/build/source/lld/ELF/ScriptParser.cpp

Bug Summary

File:	build/source/lld/ELF/ScriptParser.cpp
Warning:	line 1509, column 12 Potential memory leak

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name ScriptParser.cpp -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mframe-pointer=none -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/build/source/build-llvm/tools/clang/stage2-bins -resource-dir /usr/lib/llvm-17/lib/clang/17 -D LLD_VENDOR="Debian" -D _DEBUG -D _GLIBCXX_ASSERTIONS -D _GNU_SOURCE -D _LIBCPP_ENABLE_ASSERTIONS -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I tools/lld/ELF -I /build/source/lld/ELF -I /build/source/lld/include -I tools/lld/include -I include -I /build/source/llvm/include -D _FORTIFY_SOURCE=2 -D NDEBUG -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/x86_64-linux-gnu/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/backward -internal-isystem /usr/lib/llvm-17/lib/clang/17/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -fmacro-prefix-map=/build/source/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fmacro-prefix-map=/build/source/= -fcoverage-prefix-map=/build/source/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fcoverage-prefix-map=/build/source/= -source-date-epoch 1683717183 -O2 -Wno-unused-command-line-argument -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-redundant-move -Wno-pessimizing-move -Wno-noexcept-type -Wno-comment -Wno-misleading-indentation -std=c++17 -fdeprecated-macro -fdebug-compilation-dir=/build/source/build-llvm/tools/clang/stage2-bins -fdebug-prefix-map=/build/source/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fdebug-prefix-map=/build/source/= -ferror-limit 19 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fcolor-diagnostics -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2023-05-10-133810-16478-1 -x c++ /build/source/lld/ELF/ScriptParser.cpp

/build/source/lld/ELF/ScriptParser.cpp

→

1//===- ScriptParser.cpp ---------------------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file contains a recursive-descendent parser for linker scripts.
10// Parsed results are stored to Config and Script global objects.
11//
12//===----------------------------------------------------------------------===//

14#include "ScriptParser.h"
15#include "Config.h"
16#include "Driver.h"
17#include "InputFiles.h"
18#include "LinkerScript.h"
19#include "OutputSections.h"
20#include "ScriptLexer.h"
21#include "SymbolTable.h"
22#include "Symbols.h"
23#include "Target.h"
24#include "lld/Common/CommonLinkerContext.h"
25#include "llvm/ADT/SmallString.h"
26#include "llvm/ADT/StringRef.h"
27#include "llvm/ADT/StringSet.h"
28#include "llvm/ADT/StringSwitch.h"
29#include "llvm/BinaryFormat/ELF.h"
30#include "llvm/Support/Casting.h"
31#include "llvm/Support/ErrorHandling.h"
32#include "llvm/Support/FileSystem.h"
33#include "llvm/Support/MathExtras.h"
34#include "llvm/Support/Path.h"
35#include "llvm/Support/SaveAndRestore.h"
36#include "llvm/Support/TimeProfiler.h"
37#include <cassert>
38#include <limits>
39#include <vector>

41using namespace llvm;
42using namespace llvm::ELF;
43using namespace llvm::support::endian;
44using namespace lld;
45using namespace lld::elf;

47namespace {
48class ScriptParser final : ScriptLexer {
49public:
ScriptParser(MemoryBufferRef mb) : ScriptLexer(mb) {
  // Initialize IsUnderSysroot
  if (config->sysroot == "")
    return;
  StringRef path = mb.getBufferIdentifier();
  for (; !path.empty(); path = sys::path::parent_path(path)) {
    if (!sys::fs::equivalent(config->sysroot, path))
      continue;
    isUnderSysroot = true;
    return;
  }
}

void readLinkerScript();
void readVersionScript();
void readDynamicList();
void readDefsym(StringRef name);

68private:
void addFile(StringRef path);

void readAsNeeded();
void readEntry();
void readExtern();
void readGroup();
void readInclude();
void readInput();
void readMemory();
void readOutput();
void readOutputArch();
void readOutputFormat();
void readOverwriteSections();
void readPhdrs();
void readRegionAlias();
void readSearchDir();
void readSections();
void readTarget();
void readVersion();
void readVersionScriptCommand();

SymbolAssignment *readSymbolAssignment(StringRef name);
ByteCommand *readByteCommand(StringRef tok);
std::array<uint8_t, 4> readFill();
bool readSectionDirective(OutputSection *cmd, StringRef tok1, StringRef tok2);
void readSectionAddressType(OutputSection *cmd);
OutputDesc *readOverlaySectionDescription();
OutputDesc *readOutputSectionDescription(StringRef outSec);
SmallVector<SectionCommand *, 0> readOverlay();
SmallVector<StringRef, 0> readOutputSectionPhdrs();
std::pair<uint64_t, uint64_t> readInputSectionFlags();
InputSectionDescription *readInputSectionDescription(StringRef tok);
StringMatcher readFilePatterns();
SmallVector<SectionPattern, 0> readInputSectionsList();
InputSectionDescription *readInputSectionRules(StringRef filePattern,
                                               uint64_t withFlags,
                                               uint64_t withoutFlags);
unsigned readPhdrType();
SortSectionPolicy peekSortKind();
SortSectionPolicy readSortKind();
SymbolAssignment *readProvideHidden(bool provide, bool hidden);
SymbolAssignment *readAssignment(StringRef tok);
void readSort();
Expr readAssert();
Expr readConstant();
Expr getPageSize();

Expr readMemoryAssignment(StringRef, StringRef, StringRef);
void readMemoryAttributes(uint32_t &flags, uint32_t &invFlags,
                          uint32_t &negFlags, uint32_t &negInvFlags);

Expr combine(StringRef op, Expr l, Expr r);
Expr readExpr();
Expr readExpr1(Expr lhs, int minPrec);
StringRef readParenLiteral();
Expr readPrimary();
Expr readTernary(Expr cond);
Expr readParenExpr();

// For parsing version script.
SmallVector<SymbolVersion, 0> readVersionExtern();
void readAnonymousDeclaration();
void readVersionDeclaration(StringRef verStr);

std::pair<SmallVector<SymbolVersion, 0>, SmallVector<SymbolVersion, 0>>
readSymbols();

// True if a script being read is in the --sysroot directory.
bool isUnderSysroot = false;

bool seenDataAlign = false;
bool seenRelroEnd = false;

// A set to detect an INCLUDE() cycle.
StringSet<> seen;
144};
145} // namespace

147static StringRef unquote(StringRef s) {
if (s.startswith("\""))
  return s.substr(1, s.size() - 2);
return s;
151}

153// Some operations only support one non absolute value. Move the
154// absolute one to the right hand side for convenience.
155static void moveAbsRight(ExprValue &a, ExprValue &b) {
if (a.sec == nullptr || (a.forceAbsolute && !b.isAbsolute()))
  std::swap(a, b);
if (!b.isAbsolute())
  error(a.loc + ": at least one side of the expression must be absolute");
160}

162static ExprValue add(ExprValue a, ExprValue b) {
moveAbsRight(a, b);
return {a.sec, a.forceAbsolute, a.getSectionOffset() + b.getValue(), a.loc};
165}

167static ExprValue sub(ExprValue a, ExprValue b) {
// The distance between two symbols in sections is absolute.
if (!a.isAbsolute() && !b.isAbsolute())
  return a.getValue() - b.getValue();
return {a.sec, false, a.getSectionOffset() - b.getValue(), a.loc};
172}

174static ExprValue bitAnd(ExprValue a, ExprValue b) {
moveAbsRight(a, b);
return {a.sec, a.forceAbsolute,
        (a.getValue() & b.getValue()) - a.getSecAddr(), a.loc};
178}

180static ExprValue bitOr(ExprValue a, ExprValue b) {
moveAbsRight(a, b);
return {a.sec, a.forceAbsolute,
        (a.getValue() | b.getValue()) - a.getSecAddr(), a.loc};
184}

186void ScriptParser::readDynamicList() {
expect("{");
SmallVector<SymbolVersion, 0> locals;
SmallVector<SymbolVersion, 0> globals;
std::tie(locals, globals) = readSymbols();
expect(";");

if (!atEOF()) {
  setError("EOF expected, but got " + next());
  return;
}
if (!locals.empty()) {
  setError("\"local:\" scope not supported in --dynamic-list");
  return;
}

for (SymbolVersion v : globals)
  config->dynamicList.push_back(v);
204}

206void ScriptParser::readVersionScript() {
readVersionScriptCommand();
if (!atEOF())
  setError("EOF expected, but got " + next());
210}

212void ScriptParser::readVersionScriptCommand() {
if (consume("{")) {
  readAnonymousDeclaration();
  return;
}

while (!atEOF() && !errorCount() && peek() != "}") {
  StringRef verStr = next();
  if (verStr == "{") {
    setError("anonymous version definition is used in "
             "combination with other version definitions");
    return;
  }
  expect("{");
  readVersionDeclaration(verStr);
}
228}

230void ScriptParser::readVersion() {
expect("{");
readVersionScriptCommand();
expect("}");
234}

236void ScriptParser::readLinkerScript() {
while (!atEOF()) {
  StringRef tok = next();
  if (tok == ";")
    continue;

  if (tok == "ENTRY") {
    readEntry();
  } else if (tok == "EXTERN") {
    readExtern();
  } else if (tok == "GROUP") {
    readGroup();
  } else if (tok == "INCLUDE") {
    readInclude();
  } else if (tok == "INPUT") {
    readInput();
  } else if (tok == "MEMORY") {
    readMemory();
  } else if (tok == "OUTPUT") {
    readOutput();
  } else if (tok == "OUTPUT_ARCH") {
    readOutputArch();
  } else if (tok == "OUTPUT_FORMAT") {
    readOutputFormat();
  } else if (tok == "OVERWRITE_SECTIONS") {
    readOverwriteSections();
  } else if (tok == "PHDRS") {
    readPhdrs();
  } else if (tok == "REGION_ALIAS") {
    readRegionAlias();
  } else if (tok == "SEARCH_DIR") {
    readSearchDir();
  } else if (tok == "SECTIONS") {
    readSections();
  } else if (tok == "TARGET") {
    readTarget();
  } else if (tok == "VERSION") {
    readVersion();
  } else if (SymbolAssignment *cmd = readAssignment(tok)) {
    script->sectionCommands.push_back(cmd);
  } else {
    setError("unknown directive: " + tok);
  }
}
280}

282void ScriptParser::readDefsym(StringRef name) {
if (errorCount())
2
←
Assuming the condition is false→
3
←
Taking false branch→
  return;
Expr e = readExpr();
4
←
Calling 'ScriptParser::readExpr'→
if (!atEOF())
  setError("EOF expected, but got " + next());
SymbolAssignment *cmd = make<SymbolAssignment>(name, e, getCurrentLocation());
script->sectionCommands.push_back(cmd);
290}

292void ScriptParser::addFile(StringRef s) {
if (isUnderSysroot && s.startswith("/")) {
  SmallString<128> pathData;
  StringRef path = (config->sysroot + s).toStringRef(pathData);
  if (sys::fs::exists(path))
    ctx.driver.addFile(saver().save(path), /*withLOption=*/false);
  else
    setError("cannot find " + s + " inside " + config->sysroot);
  return;
}

if (s.startswith("/")) {
  // Case 1: s is an absolute path. Just open it.
  ctx.driver.addFile(s, /*withLOption=*/false);
} else if (s.startswith("=")) {
  // Case 2: relative to the sysroot.
  if (config->sysroot.empty())
    ctx.driver.addFile(s.substr(1), /*withLOption=*/false);
  else
    ctx.driver.addFile(saver().save(config->sysroot + "/" + s.substr(1)),
                       /*withLOption=*/false);
} else if (s.startswith("-l")) {
  // Case 3: search in the list of library paths.
  ctx.driver.addLibrary(s.substr(2));
} else {
  // Case 4: s is a relative path. Search in the directory of the script file.
  std::string filename = std::string(getCurrentMB().getBufferIdentifier());
  StringRef directory = sys::path::parent_path(filename);
  if (!directory.empty()) {
    SmallString<0> path(directory);
    sys::path::append(path, s);
    if (sys::fs::exists(path)) {
      ctx.driver.addFile(path, /*withLOption=*/false);
      return;
    }
  }
  // Then search in the current working directory.
  if (sys::fs::exists(s)) {
    ctx.driver.addFile(s, /*withLOption=*/false);
  } else {
    // Finally, search in the list of library paths.
    if (std::optional<std::string> path = findFromSearchPaths(s))
      ctx.driver.addFile(saver().save(*path), /*withLOption=*/true);
    else
      setError("unable to find " + s);
  }
}
339}

341void ScriptParser::readAsNeeded() {
expect("(");
bool orig = config->asNeeded;
config->asNeeded = true;
while (!errorCount() && !consume(")"))
  addFile(unquote(next()));
config->asNeeded = orig;
348}

350void ScriptParser::readEntry() {
// -e <symbol> takes predecence over ENTRY(<symbol>).
expect("(");
StringRef tok = next();
if (config->entry.empty())
  config->entry = unquote(tok);
expect(")");
357}

359void ScriptParser::readExtern() {
expect("(");
while (!errorCount() && !consume(")"))
  config->undefined.push_back(unquote(next()));
363}

365void ScriptParser::readGroup() {
bool orig = InputFile::isInGroup;
InputFile::isInGroup = true;
readInput();
InputFile::isInGroup = orig;
if (!orig)
  ++InputFile::nextGroupId;
372}

374void ScriptParser::readInclude() {
StringRef tok = unquote(next());

if (!seen.insert(tok).second) {
  setError("there is a cycle in linker script INCLUDEs");
  return;
}

if (std::optional<std::string> path = searchScript(tok)) {
  if (std::optional<MemoryBufferRef> mb = readFile(*path))
    tokenize(*mb);
  return;
}
setError("cannot find linker script " + tok);
388}

390void ScriptParser::readInput() {
expect("(");
while (!errorCount() && !consume(")")) {
  if (consume("AS_NEEDED"))
    readAsNeeded();
  else
    addFile(unquote(next()));
}
398}

400void ScriptParser::readOutput() {
// -o <file> takes predecence over OUTPUT(<file>).
expect("(");
StringRef tok = next();
if (config->outputFile.empty())
  config->outputFile = unquote(tok);
expect(")");
407}

409void ScriptParser::readOutputArch() {
// OUTPUT_ARCH is ignored for now.
expect("(");
while (!errorCount() && !consume(")"))
  skip();
414}

416static std::pair<ELFKind, uint16_t> parseBfdName(StringRef s) {
return StringSwitch<std::pair<ELFKind, uint16_t>>(s)
    .Case("elf32-i386", {ELF32LEKind, EM_386})
    .Case("elf32-avr", {ELF32LEKind, EM_AVR})
    .Case("elf32-iamcu", {ELF32LEKind, EM_IAMCU})
    .Case("elf32-littlearm", {ELF32LEKind, EM_ARM})
    .Case("elf32-bigarm", {ELF32BEKind, EM_ARM})
    .Case("elf32-x86-64", {ELF32LEKind, EM_X86_64})
    .Case("elf64-aarch64", {ELF64LEKind, EM_AARCH64})
    .Case("elf64-littleaarch64", {ELF64LEKind, EM_AARCH64})
    .Case("elf64-bigaarch64", {ELF64BEKind, EM_AARCH64})
    .Case("elf32-powerpc", {ELF32BEKind, EM_PPC})
    .Case("elf32-powerpcle", {ELF32LEKind, EM_PPC})
    .Case("elf64-powerpc", {ELF64BEKind, EM_PPC64})
    .Case("elf64-powerpcle", {ELF64LEKind, EM_PPC64})
    .Case("elf64-x86-64", {ELF64LEKind, EM_X86_64})
    .Cases("elf32-tradbigmips", "elf32-bigmips", {ELF32BEKind, EM_MIPS})
    .Case("elf32-ntradbigmips", {ELF32BEKind, EM_MIPS})
    .Case("elf32-tradlittlemips", {ELF32LEKind, EM_MIPS})
    .Case("elf32-ntradlittlemips", {ELF32LEKind, EM_MIPS})
    .Case("elf64-tradbigmips", {ELF64BEKind, EM_MIPS})
    .Case("elf64-tradlittlemips", {ELF64LEKind, EM_MIPS})
    .Case("elf32-littleriscv", {ELF32LEKind, EM_RISCV})
    .Case("elf64-littleriscv", {ELF64LEKind, EM_RISCV})
    .Case("elf64-sparc", {ELF64BEKind, EM_SPARCV9})
    .Case("elf32-msp430", {ELF32LEKind, EM_MSP430})
    .Default({ELFNoneKind, EM_NONE});
443}

445// Parse OUTPUT_FORMAT(bfdname) or OUTPUT_FORMAT(default, big, little). Choose
446// big if -EB is specified, little if -EL is specified, or default if neither is
447// specified.
448void ScriptParser::readOutputFormat() {
expect("(");

StringRef s;
config->bfdname = unquote(next());
if (!consume(")")) {
  expect(",");
  s = unquote(next());
  if (config->optEB)
    config->bfdname = s;
  expect(",");
  s = unquote(next());
  if (config->optEL)
    config->bfdname = s;
  consume(")");
}
s = config->bfdname;
if (s.consume_back("-freebsd"))
  config->osabi = ELFOSABI_FREEBSD;

std::tie(config->ekind, config->emachine) = parseBfdName(s);
if (config->emachine == EM_NONE)
  setError("unknown output format name: " + config->bfdname);
if (s == "elf32-ntradlittlemips" || s == "elf32-ntradbigmips")
  config->mipsN32Abi = true;
if (config->emachine == EM_MSP430)
  config->osabi = ELFOSABI_STANDALONE;
475}

477void ScriptParser::readPhdrs() {
expect("{");

while (!errorCount() && !consume("}")) {
  PhdrsCommand cmd;
  cmd.name = next();
  cmd.type = readPhdrType();

  while (!errorCount() && !consume(";")) {
    if (consume("FILEHDR"))
      cmd.hasFilehdr = true;
    else if (consume("PHDRS"))
      cmd.hasPhdrs = true;
    else if (consume("AT"))
      cmd.lmaExpr = readParenExpr();
    else if (consume("FLAGS"))
      cmd.flags = readParenExpr()().getValue();
    else
      setError("unexpected header attribute: " + next());
  }

  script->phdrsCommands.push_back(cmd);
}
500}

502void ScriptParser::readRegionAlias() {
expect("(");
StringRef alias = unquote(next());
expect(",");
StringRef name = next();
expect(")");

if (script->memoryRegions.count(alias))
  setError("redefinition of memory region '" + alias + "'");
if (!script->memoryRegions.count(name))
  setError("memory region '" + name + "' is not defined");
script->memoryRegions.insert({alias, script->memoryRegions[name]});
514}

516void ScriptParser::readSearchDir() {
expect("(");
StringRef tok = next();
if (!config->nostdlib)
  config->searchPaths.push_back(unquote(tok));
expect(")");
522}

524// This reads an overlay description. Overlays are used to describe output
525// sections that use the same virtual memory range and normally would trigger
526// linker's sections sanity check failures.
527// https://sourceware.org/binutils/docs/ld/Overlay-Description.html#Overlay-Description
528SmallVector<SectionCommand *, 0> ScriptParser::readOverlay() {
// VA and LMA expressions are optional, though for simplicity of
// implementation we assume they are not. That is what OVERLAY was designed
// for first of all: to allow sections with overlapping VAs at different LMAs.
Expr addrExpr = readExpr();
expect(":");
expect("AT");
Expr lmaExpr = readParenExpr();
expect("{");

SmallVector<SectionCommand *, 0> v;
OutputSection *prev = nullptr;
while (!errorCount() && !consume("}")) {
  // VA is the same for all sections. The LMAs are consecutive in memory
  // starting from the base load address specified.
  OutputDesc *osd = readOverlaySectionDescription();
  osd->osec.addrExpr = addrExpr;
  if (prev)
    osd->osec.lmaExpr = [=] { return prev->getLMA() + prev->size; };
  else
    osd->osec.lmaExpr = lmaExpr;
  v.push_back(osd);
  prev = &osd->osec;
}

// According to the specification, at the end of the overlay, the location
// counter should be equal to the overlay base address plus size of the
// largest section seen in the overlay.
// Here we want to create the Dot assignment command to achieve that.
Expr moveDot = [=] {
  uint64_t max = 0;
  for (SectionCommand *cmd : v)
    max = std::max(max, cast<OutputDesc>(cmd)->osec.size);
  return addrExpr().getValue() + max;
};
v.push_back(make<SymbolAssignment>(".", moveDot, getCurrentLocation()));
return v;
565}

567void ScriptParser::readOverwriteSections() {
expect("{");
while (!errorCount() && !consume("}"))
  script->overwriteSections.push_back(readOutputSectionDescription(next()));
571}

573void ScriptParser::readSections() {
expect("{");
SmallVector<SectionCommand *, 0> v;
while (!errorCount() && !consume("}")) {
  StringRef tok = next();
  if (tok == "OVERLAY") {
    for (SectionCommand *cmd : readOverlay())
      v.push_back(cmd);
    continue;
  } else if (tok == "INCLUDE") {
    readInclude();
    continue;
  }

  if (SectionCommand *cmd = readAssignment(tok))
    v.push_back(cmd);
  else
    v.push_back(readOutputSectionDescription(tok));
}

// If DATA_SEGMENT_RELRO_END is absent, for sections after DATA_SEGMENT_ALIGN,
// the relro fields should be cleared.
if (!seenRelroEnd)
  for (SectionCommand *cmd : v)
    if (auto *osd = dyn_cast<OutputDesc>(cmd))
      osd->osec.relro = false;

script->sectionCommands.insert(script->sectionCommands.end(), v.begin(),
                               v.end());

if (atEOF() || !consume("INSERT")) {
  script->hasSectionsCommand = true;
  return;
}

bool isAfter = false;
if (consume("AFTER"))
  isAfter = true;
else if (!consume("BEFORE"))
  setError("expected AFTER/BEFORE, but got '" + next() + "'");
StringRef where = next();
SmallVector<StringRef, 0> names;
for (SectionCommand *cmd : v)
  if (auto *os = dyn_cast<OutputDesc>(cmd))
    names.push_back(os->osec.name);
if (!names.empty())
  script->insertCommands.push_back({std::move(names), isAfter, where});
620}

622void ScriptParser::readTarget() {
// TARGET(foo) is an alias for "--format foo". Unlike GNU linkers,
// we accept only a limited set of BFD names (i.e. "elf" or "binary")
// for --format. We recognize only /^elf/ and "binary" in the linker
// script as well.
expect("(");
StringRef tok = unquote(next());
expect(")");

if (tok.startswith("elf"))
  config->formatBinary = false;
else if (tok == "binary")
  config->formatBinary = true;
else
  setError("unknown target: " + tok);
637}

639static int precedence(StringRef op) {
return StringSwitch<int>(op)
    .Cases("*", "/", "%", 10)
    .Cases("+", "-", 9)
    .Cases("<<", ">>", 8)
    .Cases("<", "<=", ">", ">=", 7)
    .Cases("==", "!=", 6)
    .Case("&", 5)
    .Case("|", 4)
    .Case("&&", 3)
    .Case("||", 2)
    .Case("?", 1)
    .Default(-1);
652}

654StringMatcher ScriptParser::readFilePatterns() {
StringMatcher Matcher;

while (!errorCount() && !consume(")"))
  Matcher.addPattern(SingleStringMatcher(next()));
return Matcher;
660}

662SortSectionPolicy ScriptParser::peekSortKind() {
return StringSwitch<SortSectionPolicy>(peek())
    .Case("REVERSE", SortSectionPolicy::Reverse)
    .Cases("SORT", "SORT_BY_NAME", SortSectionPolicy::Name)
    .Case("SORT_BY_ALIGNMENT", SortSectionPolicy::Alignment)
    .Case("SORT_BY_INIT_PRIORITY", SortSectionPolicy::Priority)
    .Case("SORT_NONE", SortSectionPolicy::None)
    .Default(SortSectionPolicy::Default);
670}

672SortSectionPolicy ScriptParser::readSortKind() {
SortSectionPolicy ret = peekSortKind();
if (ret != SortSectionPolicy::Default)
  skip();
return ret;
677}

679// Reads SECTIONS command contents in the following form:
680//
681// <contents> ::= <elem>*
682// <elem>     ::= <exclude>? <glob-pattern>
683// <exclude>  ::= "EXCLUDE_FILE" "(" <glob-pattern>+ ")"
684//
685// For example,
686//
687// *(.foo EXCLUDE_FILE (a.o) .bar EXCLUDE_FILE (b.o) .baz)
688//
689// is parsed as ".foo", ".bar" with "a.o", and ".baz" with "b.o".
690// The semantics of that is section .foo in any file, section .bar in
691// any file but a.o, and section .baz in any file but b.o.
692SmallVector<SectionPattern, 0> ScriptParser::readInputSectionsList() {
SmallVector<SectionPattern, 0> ret;
while (!errorCount() && peek() != ")") {
  StringMatcher excludeFilePat;
  if (consume("EXCLUDE_FILE")) {
    expect("(");
    excludeFilePat = readFilePatterns();
  }

  StringMatcher SectionMatcher;
  // Break if the next token is ), EXCLUDE_FILE, or SORT*.
  while (!errorCount() && peek() != ")" && peek() != "EXCLUDE_FILE" &&
         peekSortKind() == SortSectionPolicy::Default)
    SectionMatcher.addPattern(unquote(next()));

  if (!SectionMatcher.empty())
    ret.push_back({std::move(excludeFilePat), std::move(SectionMatcher)});
  else if (excludeFilePat.empty())
    break;
  else
    setError("section pattern is expected");
}
return ret;
715}

717// Reads contents of "SECTIONS" directive. That directive contains a
718// list of glob patterns for input sections. The grammar is as follows.
719//
720// <patterns> ::= <section-list>
721//              | <sort> "(" <section-list> ")"
722//              | <sort> "(" <sort> "(" <section-list> ")" ")"
723//
724// <sort>     ::= "SORT" | "SORT_BY_NAME" | "SORT_BY_ALIGNMENT"
725//              | "SORT_BY_INIT_PRIORITY" | "SORT_NONE"
726//
727// <section-list> is parsed by readInputSectionsList().
728InputSectionDescription *
729ScriptParser::readInputSectionRules(StringRef filePattern, uint64_t withFlags,
                                  uint64_t withoutFlags) {
auto *cmd =
    make<InputSectionDescription>(filePattern, withFlags, withoutFlags);
expect("(");

while (!errorCount() && !consume(")")) {
  SortSectionPolicy outer = readSortKind();
  SortSectionPolicy inner = SortSectionPolicy::Default;
  SmallVector<SectionPattern, 0> v;
  if (outer != SortSectionPolicy::Default) {
    expect("(");
    inner = readSortKind();
    if (inner != SortSectionPolicy::Default) {
      expect("(");
      v = readInputSectionsList();
      expect(")");
    } else {
      v = readInputSectionsList();
    }
    expect(")");
  } else {
    v = readInputSectionsList();
  }

  for (SectionPattern &pat : v) {
    pat.sortInner = inner;
    pat.sortOuter = outer;
  }

  std::move(v.begin(), v.end(), std::back_inserter(cmd->sectionPatterns));
}
return cmd;
762}

764InputSectionDescription *
765ScriptParser::readInputSectionDescription(StringRef tok) {
// Input section wildcard can be surrounded by KEEP.
// https://sourceware.org/binutils/docs/ld/Input-Section-Keep.html#Input-Section-Keep
uint64_t withFlags = 0;
uint64_t withoutFlags = 0;
if (tok == "KEEP") {
  expect("(");
  if (consume("INPUT_SECTION_FLAGS"))
    std::tie(withFlags, withoutFlags) = readInputSectionFlags();
  InputSectionDescription *cmd =
      readInputSectionRules(next(), withFlags, withoutFlags);
  expect(")");
  script->keptSections.push_back(cmd);
  return cmd;
}
if (tok == "INPUT_SECTION_FLAGS") {
  std::tie(withFlags, withoutFlags) = readInputSectionFlags();
  tok = next();
}
return readInputSectionRules(tok, withFlags, withoutFlags);
785}

787void ScriptParser::readSort() {
expect("(");
expect("CONSTRUCTORS");
expect(")");
791}

793Expr ScriptParser::readAssert() {
expect("(");
Expr e = readExpr();
expect(",");
StringRef msg = unquote(next());
expect(")");

return [=] {
  if (!e().getValue())
    errorOrWarn(msg);
  return script->getDot();
};
805}

807#define ECase(X)                                                               \
{ #X, X }
809constexpr std::pair<const char *, unsigned> typeMap[] = {
  ECase(SHT_PROGBITS),   ECase(SHT_NOTE),       ECase(SHT_NOBITS),
  ECase(SHT_INIT_ARRAY), ECase(SHT_FINI_ARRAY), ECase(SHT_PREINIT_ARRAY),
812};
813#undef ECase

815// Tries to read the special directive for an output section definition which
816// can be one of following: "(NOLOAD)", "(COPY)", "(INFO)", "(OVERLAY)", and
817// "(TYPE=<value>)".
818// Tok1 and Tok2 are next 2 tokens peeked. See comment for
819// readSectionAddressType below.
820bool ScriptParser::readSectionDirective(OutputSection *cmd, StringRef tok1, StringRef tok2) {
if (tok1 != "(")
  return false;
if (tok2 != "NOLOAD" && tok2 != "COPY" && tok2 != "INFO" &&
    tok2 != "OVERLAY" && tok2 != "TYPE")
  return false;

expect("(");
if (consume("NOLOAD")) {
  cmd->type = SHT_NOBITS;
  cmd->typeIsSet = true;
} else if (consume("TYPE")) {
  expect("=");
  StringRef value = peek();
  auto it = llvm::find_if(typeMap, [=](auto e) { return e.first == value; });
  if (it != std::end(typeMap)) {
    // The value is a recognized literal SHT_*.
    cmd->type = it->second;
    skip();
  } else if (value.startswith("SHT_")) {
    setError("unknown section type " + value);
  } else {
    // Otherwise, read an expression.
    cmd->type = readExpr()().getValue();
  }
  cmd->typeIsSet = true;
} else {
  skip(); // This is "COPY", "INFO" or "OVERLAY".
  cmd->nonAlloc = true;
}
expect(")");
return true;
852}

854// Reads an expression and/or the special directive for an output
855// section definition. Directive is one of following: "(NOLOAD)",
856// "(COPY)", "(INFO)" or "(OVERLAY)".
857//
858// An output section name can be followed by an address expression
859// and/or directive. This grammar is not LL(1) because "(" can be
860// interpreted as either the beginning of some expression or beginning
861// of directive.
862//
863// https://sourceware.org/binutils/docs/ld/Output-Section-Address.html
864// https://sourceware.org/binutils/docs/ld/Output-Section-Type.html
865void ScriptParser::readSectionAddressType(OutputSection *cmd) {
// Temporarily set inExpr to support TYPE=<value> without spaces.
bool saved = std::exchange(inExpr, true);
bool isDirective = readSectionDirective(cmd, peek(), peek2());
inExpr = saved;
if (isDirective)
  return;

cmd->addrExpr = readExpr();
if (peek() == "(" && !readSectionDirective(cmd, "(", peek2()))
  setError("unknown section directive: " + peek2());
876}

878static Expr checkAlignment(Expr e, std::string &loc) {
return [=] {
  uint64_t alignment = std::max((uint64_t)1, e().getValue());
  if (!isPowerOf2_64(alignment)) {
    error(loc + ": alignment must be power of 2");
    return (uint64_t)1; // Return a dummy value.
  }
  return alignment;
};
887}

889OutputDesc *ScriptParser::readOverlaySectionDescription() {
OutputDesc *osd = script->createOutputSection(next(), getCurrentLocation());
osd->osec.inOverlay = true;
expect("{");
while (!errorCount() && !consume("}")) {
  uint64_t withFlags = 0;
  uint64_t withoutFlags = 0;
  if (consume("INPUT_SECTION_FLAGS"))
    std::tie(withFlags, withoutFlags) = readInputSectionFlags();
  osd->osec.commands.push_back(
      readInputSectionRules(next(), withFlags, withoutFlags));
}
return osd;
902}

904OutputDesc *ScriptParser::readOutputSectionDescription(StringRef outSec) {
OutputDesc *cmd =
    script->createOutputSection(unquote(outSec), getCurrentLocation());
OutputSection *osec = &cmd->osec;
// Maybe relro. Will reset to false if DATA_SEGMENT_RELRO_END is absent.
osec->relro = seenDataAlign && !seenRelroEnd;

size_t symbolsReferenced = script->referencedSymbols.size();

if (peek() != ":")
  readSectionAddressType(osec);
expect(":");

std::string location = getCurrentLocation();
if (consume("AT"))
  osec->lmaExpr = readParenExpr();
if (consume("ALIGN"))
  osec->alignExpr = checkAlignment(readParenExpr(), location);
if (consume("SUBALIGN"))
  osec->subalignExpr = checkAlignment(readParenExpr(), location);

// Parse constraints.
if (consume("ONLY_IF_RO"))
  osec->constraint = ConstraintKind::ReadOnly;
if (consume("ONLY_IF_RW"))
  osec->constraint = ConstraintKind::ReadWrite;
expect("{");

while (!errorCount() && !consume("}")) {
  StringRef tok = next();
  if (tok == ";") {
    // Empty commands are allowed. Do nothing here.
  } else if (SymbolAssignment *assign = readAssignment(tok)) {
    osec->commands.push_back(assign);
  } else if (ByteCommand *data = readByteCommand(tok)) {
    osec->commands.push_back(data);
  } else if (tok == "CONSTRUCTORS") {
    // CONSTRUCTORS is a keyword to make the linker recognize C++ ctors/dtors
    // by name. This is for very old file formats such as ECOFF/XCOFF.
    // For ELF, we should ignore.
  } else if (tok == "FILL") {
    // We handle the FILL command as an alias for =fillexp section attribute,
    // which is different from what GNU linkers do.
    // https://sourceware.org/binutils/docs/ld/Output-Section-Data.html
    if (peek() != "(")
      setError("( expected, but got " + peek());
    osec->filler = readFill();
  } else if (tok == "SORT") {
    readSort();
  } else if (tok == "INCLUDE") {
    readInclude();
  } else if (tok == "(" || tok == ")") {
    setError("expected filename pattern");
  } else if (peek() == "(") {
    osec->commands.push_back(readInputSectionDescription(tok));
  } else {
    // We have a file name and no input sections description. It is not a
    // commonly used syntax, but still acceptable. In that case, all sections
    // from the file will be included.
    // FIXME: GNU ld permits INPUT_SECTION_FLAGS to be used here. We do not
    // handle this case here as it will already have been matched by the
    // case above.
    auto *isd = make<InputSectionDescription>(tok);
    isd->sectionPatterns.push_back({{}, StringMatcher("*")});
    osec->commands.push_back(isd);
  }
}

if (consume(">"))
  osec->memoryRegionName = std::string(next());

if (consume("AT")) {
  expect(">");
  osec->lmaRegionName = std::string(next());
}

if (osec->lmaExpr && !osec->lmaRegionName.empty())
  error("section can't have both LMA and a load region");

osec->phdrs = readOutputSectionPhdrs();

if (peek() == "=" || peek().startswith("=")) {
  inExpr = true;
  consume("=");
  osec->filler = readFill();
  inExpr = false;
}

// Consume optional comma following output section command.
consume(",");

if (script->referencedSymbols.size() > symbolsReferenced)
  osec->expressionsUseSymbols = true;
return cmd;
998}

1000// Reads a `=<fillexp>` expression and returns its value as a big-endian number.
1001// https://sourceware.org/binutils/docs/ld/Output-Section-Fill.html
1002// We do not support using symbols in such expressions.
1003//
1004// When reading a hexstring, ld.bfd handles it as a blob of arbitrary
1005// size, while ld.gold always handles it as a 32-bit big-endian number.
1006// We are compatible with ld.gold because it's easier to implement.
1007// Also, we require that expressions with operators must be wrapped into
1008// round brackets. We did it to resolve the ambiguity when parsing scripts like:
1009// SECTIONS { .foo : { ... } =120+3 /DISCARD/ : { ... } }
1010std::array<uint8_t, 4> ScriptParser::readFill() {
uint64_t value = readPrimary()().val;
if (value > UINT32_MAX(4294967295U))
  setError("filler expression result does not fit 32-bit: 0x" +
           Twine::utohexstr(value));

std::array<uint8_t, 4> buf;
write32be(buf.data(), (uint32_t)value);
return buf;
1019}

1021SymbolAssignment *ScriptParser::readProvideHidden(bool provide, bool hidden) {
expect("(");
StringRef name = next(), eq = peek();
if (eq != "=") {
  setError("= expected, but got " + next());
  while (!atEOF() && next() != ")")
    ;
  return nullptr;
}
SymbolAssignment *cmd = readSymbolAssignment(name);
cmd->provide = provide;
cmd->hidden = hidden;
expect(")");
return cmd;
1035}

1037SymbolAssignment *ScriptParser::readAssignment(StringRef tok) {
// Assert expression returns Dot, so this is equal to ".=."
if (tok == "ASSERT")
  return make<SymbolAssignment>(".", readAssert(), getCurrentLocation());

size_t oldPos = pos;
SymbolAssignment *cmd = nullptr;
const StringRef op = peek();
if (op.startswith("=")) {
  // Support = followed by an expression without whitespace.
  SaveAndRestore saved(inExpr, true);
  cmd = readSymbolAssignment(tok);
} else if ((op.size() == 2 && op[1] == '=' && strchr("*/+-&|", op[0])) ||
           op == "<<=" || op == ">>=") {
  cmd = readSymbolAssignment(tok);
} else if (tok == "PROVIDE") {
  SaveAndRestore saved(inExpr, true);
  cmd = readProvideHidden(true, false);
} else if (tok == "HIDDEN") {
  SaveAndRestore saved(inExpr, true);
  cmd = readProvideHidden(false, true);
} else if (tok == "PROVIDE_HIDDEN") {
  SaveAndRestore saved(inExpr, true);
  cmd = readProvideHidden(true, true);
}

if (cmd) {
  cmd->commandString =
      tok.str() + " " +
      llvm::join(tokens.begin() + oldPos, tokens.begin() + pos, " ");
  expect(";");
}
return cmd;
1070}

1072SymbolAssignment *ScriptParser::readSymbolAssignment(StringRef name) {
name = unquote(name);
StringRef op = next();
assert(op == "=" || op == "*=" || op == "/=" || op == "+=" || op == "-=" ||(static_cast <bool> (op == "=" || op == "*=" || op == "/="
 || op == "+=" || op == "-=" || op == "&=" || op == "|=" ||
 op == "<<=" || op == ">>=") ? void (0) : __assert_fail
 ("op == \"=\" || op == \"*=\" || op == \"/=\" || op == \"+=\" || op == \"-=\" || op == \"&=\" || op == \"|=\" || op == \"<<=\" || op == \">>=\""
, "lld/ELF/ScriptParser.cpp", 1076, __extension__ __PRETTY_FUNCTION__
))
       op == "&=" || op == "|=" || op == "<<=" || op == ">>=")(static_cast <bool> (op == "=" || op == "*=" || op == "/="
 || op == "+=" || op == "-=" || op == "&=" || op == "|=" ||
 op == "<<=" || op == ">>=") ? void (0) : __assert_fail
 ("op == \"=\" || op == \"*=\" || op == \"/=\" || op == \"+=\" || op == \"-=\" || op == \"&=\" || op == \"|=\" || op == \"<<=\" || op == \">>=\""
, "lld/ELF/ScriptParser.cpp", 1076, __extension__ __PRETTY_FUNCTION__
));
// Note: GNU ld does not support %= or ^=.
Expr e = readExpr();
if (op != "=") {
  std::string loc = getCurrentLocation();
  e = [=, c = op[0]]() -> ExprValue {
    ExprValue lhs = script->getSymbolValue(name, loc);
    switch (c) {
    case '*':
      return lhs.getValue() * e().getValue();
    case '/':
      if (uint64_t rv = e().getValue())
        return lhs.getValue() / rv;
      error(loc + ": division by zero");
      return 0;
    case '+':
      return add(lhs, e());
    case '-':
      return sub(lhs, e());
    case '<':
      return lhs.getValue() << e().getValue();
    case '>':
      return lhs.getValue() >> e().getValue();
    case '&':
      return lhs.getValue() & e().getValue();
    case '|':
      return lhs.getValue() | e().getValue();
    default:
      llvm_unreachable("")::llvm::llvm_unreachable_internal("", "lld/ELF/ScriptParser.cpp"
, 1104);
    }
  };
}
return make<SymbolAssignment>(name, e, getCurrentLocation());
1109}

1111// This is an operator-precedence parser to parse a linker
1112// script expression.
1113Expr ScriptParser::readExpr() {
// Our lexer is context-aware. Set the in-expression bit so that
// they apply different tokenization rules.
bool orig = inExpr;
inExpr = true;
Expr e = readExpr1(readPrimary(), 0);
5
←
Calling 'ScriptParser::readPrimary'→
inExpr = orig;
return e;
1121}

1123Expr ScriptParser::combine(StringRef op, Expr l, Expr r) {
if (op == "+")
  return [=] { return add(l(), r()); };
if (op == "-")
  return [=] { return sub(l(), r()); };
if (op == "*")
  return [=] { return l().getValue() * r().getValue(); };
if (op == "/") {
  std::string loc = getCurrentLocation();
  return [=]() -> uint64_t {
    if (uint64_t rv = r().getValue())
      return l().getValue() / rv;
    error(loc + ": division by zero");
    return 0;
  };
}
if (op == "%") {
  std::string loc = getCurrentLocation();
  return [=]() -> uint64_t {
    if (uint64_t rv = r().getValue())
      return l().getValue() % rv;
    error(loc + ": modulo by zero");
    return 0;
  };
}
if (op == "<<")
  return [=] { return l().getValue() << r().getValue(); };
if (op == ">>")
  return [=] { return l().getValue() >> r().getValue(); };
if (op == "<")
  return [=] { return l().getValue() < r().getValue(); };
if (op == ">")
  return [=] { return l().getValue() > r().getValue(); };
if (op == ">=")
  return [=] { return l().getValue() >= r().getValue(); };
if (op == "<=")
  return [=] { return l().getValue() <= r().getValue(); };
if (op == "==")
  return [=] { return l().getValue() == r().getValue(); };
if (op == "!=")
  return [=] { return l().getValue() != r().getValue(); };
if (op == "||")
  return [=] { return l().getValue() || r().getValue(); };
if (op == "&&")
  return [=] { return l().getValue() && r().getValue(); };
if (op == "&")
  return [=] { return bitAnd(l(), r()); };
if (op == "|")
  return [=] { return bitOr(l(), r()); };
llvm_unreachable("invalid operator")::llvm::llvm_unreachable_internal("invalid operator", "lld/ELF/ScriptParser.cpp"
, 1172);
1173}

1175// This is a part of the operator-precedence parser. This function
1176// assumes that the remaining token stream starts with an operator.
1177Expr ScriptParser::readExpr1(Expr lhs, int minPrec) {
while (!atEOF() && !errorCount()) {
  // Read an operator and an expression.
  StringRef op1 = peek();
  if (precedence(op1) < minPrec)
    break;
  if (consume("?"))
    return readTernary(lhs);
  skip();
  Expr rhs = readPrimary();

  // Evaluate the remaining part of the expression first if the
  // next operator has greater precedence than the previous one.
  // For example, if we have read "+" and "3", and if the next
  // operator is "*", then we'll evaluate 3 * ... part first.
  while (!atEOF()) {
    StringRef op2 = peek();
    if (precedence(op2) <= precedence(op1))
      break;
    rhs = readExpr1(rhs, precedence(op2));
  }

  lhs = combine(op1, lhs, rhs);
}
return lhs;
1202}

1204Expr ScriptParser::getPageSize() {
std::string location = getCurrentLocation();
return [=]() -> uint64_t {
  if (target)
    return config->commonPageSize;
  error(location + ": unable to calculate page size");
  return 4096; // Return a dummy value.
};
1212}

1214Expr ScriptParser::readConstant() {
StringRef s = readParenLiteral();
if (s == "COMMONPAGESIZE")
  return getPageSize();
if (s == "MAXPAGESIZE")
  return [] { return config->maxPageSize; };
setError("unknown constant: " + s);
return [] { return 0; };
1222}

1224// Parses Tok as an integer. It recognizes hexadecimal (prefixed with
1225// "0x" or suffixed with "H") and decimal numbers. Decimal numbers may
1226// have "K" (Ki) or "M" (Mi) suffixes.
1227static std::optional<uint64_t> parseInt(StringRef tok) {
// Hexadecimal
uint64_t val;
if (tok.startswith_insensitive("0x")) {
  if (!to_integer(tok.substr(2), val, 16))
    return std::nullopt;
  return val;
}
if (tok.endswith_insensitive("H")) {
  if (!to_integer(tok.drop_back(), val, 16))
    return std::nullopt;
  return val;
}

// Decimal
if (tok.endswith_insensitive("K")) {
  if (!to_integer(tok.drop_back(), val, 10))
    return std::nullopt;
  return val * 1024;
}
if (tok.endswith_insensitive("M")) {
  if (!to_integer(tok.drop_back(), val, 10))
    return std::nullopt;
  return val * 1024 * 1024;
}
if (!to_integer(tok, val, 10))
  return std::nullopt;
return val;
1255}

1257ByteCommand *ScriptParser::readByteCommand(StringRef tok) {
int size = StringSwitch<int>(tok)
               .Case("BYTE", 1)
               .Case("SHORT", 2)
               .Case("LONG", 4)
               .Case("QUAD", 8)
               .Default(-1);
if (size == -1)
  return nullptr;

size_t oldPos = pos;
Expr e = readParenExpr();
std::string commandString =
    tok.str() + " " +
    llvm::join(tokens.begin() + oldPos, tokens.begin() + pos, " ");
return make<ByteCommand>(e, size, commandString);
1273}

1275static std::optional<uint64_t> parseFlag(StringRef tok) {
if (std::optional<uint64_t> asInt = parseInt(tok))
  return asInt;
1278#define CASE_ENT(enum) #enum, ELF::enum
return StringSwitch<std::optional<uint64_t>>(tok)
    .Case(CASE_ENT(SHF_WRITE))
    .Case(CASE_ENT(SHF_ALLOC))
    .Case(CASE_ENT(SHF_EXECINSTR))
    .Case(CASE_ENT(SHF_MERGE))
    .Case(CASE_ENT(SHF_STRINGS))
    .Case(CASE_ENT(SHF_INFO_LINK))
    .Case(CASE_ENT(SHF_LINK_ORDER))
    .Case(CASE_ENT(SHF_OS_NONCONFORMING))
    .Case(CASE_ENT(SHF_GROUP))
    .Case(CASE_ENT(SHF_TLS))
    .Case(CASE_ENT(SHF_COMPRESSED))
    .Case(CASE_ENT(SHF_EXCLUDE))
    .Case(CASE_ENT(SHF_ARM_PURECODE))
    .Default(std::nullopt);
1294#undef CASE_ENT
1295}

1297// Reads the '(' <flags> ')' list of section flags in
1298// INPUT_SECTION_FLAGS '(' <flags> ')' in the
1299// following form:
1300// <flags> ::= <flag>
1301//           | <flags> & flag
1302// <flag>  ::= Recognized Flag Name, or Integer value of flag.
1303// If the first character of <flag> is a ! then this means without flag,
1304// otherwise with flag.
1305// Example: SHF_EXECINSTR & !SHF_WRITE means with flag SHF_EXECINSTR and
1306// without flag SHF_WRITE.
1307std::pair<uint64_t, uint64_t> ScriptParser::readInputSectionFlags() {
 uint64_t withFlags = 0;
 uint64_t withoutFlags = 0;
 expect("(");
 while (!errorCount()) {
  StringRef tok = unquote(next());
  bool without = tok.consume_front("!");
  if (std::optional<uint64_t> flag = parseFlag(tok)) {
    if (without)
      withoutFlags |= *flag;
    else
      withFlags |= *flag;
  } else {
    setError("unrecognised flag: " + tok);
  }
  if (consume(")"))
    break;
  if (!consume("&")) {
    next();
    setError("expected & or )");
  }
}
return std::make_pair(withFlags, withoutFlags);
1330}

1332StringRef ScriptParser::readParenLiteral() {
expect("(");
bool orig = inExpr;
inExpr = false;
StringRef tok = next();
inExpr = orig;
expect(")");
return tok;
1340}

1342static void checkIfExists(const OutputSection &osec, StringRef location) {
if (osec.location.empty() && script->errorOnMissingSection)
  error(location + ": undefined section " + osec.name);
1345}

1347static bool isValidSymbolName(StringRef s) {
auto valid = [](char c) {
  return isAlnum(c) || c == '$' || c == '.' || c == '_';
};
return !s.empty() && !isDigit(s[0]) && llvm::all_of(s, valid);
1352}

1354Expr ScriptParser::readPrimary() {
if (peek() == "(")
6
←
Assuming the condition is false→
7
←
Taking false branch→
  return readParenExpr();

if (consume("~")) {
8
←
Assuming the condition is false→
9
←
Taking false branch→
  Expr e = readPrimary();
  return [=] { return ~e().getValue(); };
}
if (consume("!")) {
10
←
Assuming the condition is false→
11
←
Taking false branch→
  Expr e = readPrimary();
  return [=] { return !e().getValue(); };
}
if (consume("-")) {
12
←
Assuming the condition is false→
13
←
Taking false branch→
  Expr e = readPrimary();
  return [=] { return -e().getValue(); };
}

StringRef tok = next();
std::string location = getCurrentLocation();

// Built-in functions are parsed here.
// https://sourceware.org/binutils/docs/ld/Builtin-Functions.html.
if (tok == "ABSOLUTE") {
14
←
Assuming the condition is false→
15
←
Taking false branch→
  Expr inner = readParenExpr();
  return [=] {
    ExprValue i = inner();
    i.forceAbsolute = true;
    return i;
  };
}
if (tok == "ADDR") {
16
←
Assuming the condition is false→
17
←
Taking false branch→
  StringRef name = readParenLiteral();
  OutputSection *osec = &script->getOrCreateOutputSection(name)->osec;
  osec->usedInExpression = true;
  return [=]() -> ExprValue {
    checkIfExists(*osec, location);
    return {osec, false, 0, location};
  };
}
if (tok == "ALIGN") {
18
←
Assuming the condition is false→
19
←
Taking false branch→
  expect("(");
  Expr e = readExpr();
  if (consume(")")) {
    e = checkAlignment(e, location);
    return [=] { return alignToPowerOf2(script->getDot(), e().getValue()); };
  }
  expect(",");
  Expr e2 = checkAlignment(readExpr(), location);
  expect(")");
  return [=] {
    ExprValue v = e();
    v.alignment = e2().getValue();
    return v;
  };
}
if (tok == "ALIGNOF") {
20
←
Assuming the condition is false→
21
←
Taking false branch→
  StringRef name = readParenLiteral();
  OutputSection *osec = &script->getOrCreateOutputSection(name)->osec;
  return [=] {
    checkIfExists(*osec, location);
    return osec->addralign;
  };
}
if (tok == "ASSERT")
22
←
Assuming the condition is false→
23
←
Taking false branch→
  return readAssert();
if (tok == "CONSTANT")
24
←
Assuming the condition is false→
25
←
Taking false branch→
  return readConstant();
if (tok == "DATA_SEGMENT_ALIGN") {
26
←
Assuming the condition is false→
27
←
Taking false branch→
  expect("(");
  Expr e = readExpr();
  expect(",");
  readExpr();
  expect(")");
  seenDataAlign = true;
  return [=] {
    uint64_t align = std::max(uint64_t(1), e().getValue());
    return (script->getDot() + align - 1) & -align;
  };
}
if (tok == "DATA_SEGMENT_END") {
28
←
Assuming the condition is false→
29
←
Taking false branch→
  expect("(");
  expect(".");
  expect(")");
  return [] { return script->getDot(); };
}
if (tok == "DATA_SEGMENT_RELRO_END") {
30
←
Assuming the condition is false→
31
←
Taking false branch→
  // GNU linkers implements more complicated logic to handle
  // DATA_SEGMENT_RELRO_END. We instead ignore the arguments and
  // just align to the next page boundary for simplicity.
  expect("(");
  readExpr();
  expect(",");
  readExpr();
  expect(")");
  seenRelroEnd = true;
  Expr e = getPageSize();
  return [=] { return alignToPowerOf2(script->getDot(), e().getValue()); };
}
if (tok == "DEFINED") {
32
←
Assuming the condition is false→
33
←
Taking false branch→
  StringRef name = unquote(readParenLiteral());
  return [=] {
    Symbol *b = symtab.find(name);
    return (b && b->isDefined()) ? 1 : 0;
  };
}
if (tok == "LENGTH") {
34
←
Assuming the condition is false→
35
←
Taking false branch→
  StringRef name = readParenLiteral();
  if (script->memoryRegions.count(name) == 0) {
    setError("memory region not defined: " + name);
    return [] { return 0; };
  }
  return script->memoryRegions[name]->length;
}
if (tok == "LOADADDR") {
36
←
Assuming the condition is false→
37
←
Taking false branch→
  StringRef name = readParenLiteral();
  OutputSection *osec = &script->getOrCreateOutputSection(name)->osec;
  osec->usedInExpression = true;
  return [=] {
    checkIfExists(*osec, location);
    return osec->getLMA();
  };
}
if (tok == "LOG2CEIL") {
38
←
Assuming the condition is false→
  expect("(");
  Expr a = readExpr();
  expect(")");
  return [=] {
    // LOG2CEIL(0) is defined to be 0.
    return llvm::Log2_64_Ceil(std::max(a().getValue(), UINT64_C(1)1UL));
  };
}
if (tok == "MAX" || tok == "MIN") {
39
←
Assuming the condition is false→
40
←
Assuming the condition is false→
41
←
Taking false branch→
  expect("(");
  Expr a = readExpr();
  expect(",");
  Expr b = readExpr();
  expect(")");
  if (tok == "MIN")
    return [=] { return std::min(a().getValue(), b().getValue()); };
  return [=] { return std::max(a().getValue(), b().getValue()); };
}
if (tok == "ORIGIN") {
42
←
Assuming the condition is false→
43
←
Taking false branch→
  StringRef name = readParenLiteral();
  if (script->memoryRegions.count(name) == 0) {
    setError("memory region not defined: " + name);
    return [] { return 0; };
  }
  return script->memoryRegions[name]->origin;
}
if (tok == "SEGMENT_START") {
44
←
Assuming the condition is true→
45
←
Taking true branch→
  expect("(");
  skip();
  expect(",");
  Expr e = readExpr();
  expect(")");
  return [=] { return e(); };
46
←
Calling copy constructor for 'function<lld::elf::ExprValue ()>'→
58
←
Returning from copy constructor for 'function<lld::elf::ExprValue ()>'→
59
←
Potential memory leak
}
if (tok == "SIZEOF") {
  StringRef name = readParenLiteral();
  OutputSection *cmd = &script->getOrCreateOutputSection(name)->osec;
  // Linker script does not create an output section if its content is empty.
  // We want to allow SIZEOF(.foo) where .foo is a section which happened to
  // be empty.
  return [=] { return cmd->size; };
}
if (tok == "SIZEOF_HEADERS")
  return [=] { return elf::getHeaderSize(); };

// Tok is the dot.
if (tok == ".")
  return [=] { return script->getSymbolValue(tok, location); };

// Tok is a literal number.
if (std::optional<uint64_t> val = parseInt(tok))
  return [=] { return *val; };

// Tok is a symbol name.
if (tok.startswith("\""))
  tok = unquote(tok);
else if (!isValidSymbolName(tok))
  setError("malformed number: " + tok);
script->referencedSymbols.push_back(tok);
return [=] { return script->getSymbolValue(tok, location); };
1537}

1539Expr ScriptParser::readTernary(Expr cond) {
Expr l = readExpr();
expect(":");
Expr r = readExpr();
return [=] { return cond().getValue() ? l() : r(); };
1544}

1546Expr ScriptParser::readParenExpr() {
expect("(");
Expr e = readExpr();
expect(")");
return e;
1551}

1553SmallVector<StringRef, 0> ScriptParser::readOutputSectionPhdrs() {
SmallVector<StringRef, 0> phdrs;
while (!errorCount() && peek().startswith(":")) {
  StringRef tok = next();
  phdrs.push_back((tok.size() == 1) ? next() : tok.substr(1));
}
return phdrs;
1560}

1562// Read a program header type name. The next token must be a
1563// name of a program header type or a constant (e.g. "0x3").
1564unsigned ScriptParser::readPhdrType() {
StringRef tok = next();
if (std::optional<uint64_t> val = parseInt(tok))
  return *val;

unsigned ret = StringSwitch<unsigned>(tok)
                   .Case("PT_NULL", PT_NULL)
                   .Case("PT_LOAD", PT_LOAD)
                   .Case("PT_DYNAMIC", PT_DYNAMIC)
                   .Case("PT_INTERP", PT_INTERP)
                   .Case("PT_NOTE", PT_NOTE)
                   .Case("PT_SHLIB", PT_SHLIB)
                   .Case("PT_PHDR", PT_PHDR)
                   .Case("PT_TLS", PT_TLS)
                   .Case("PT_GNU_EH_FRAME", PT_GNU_EH_FRAME)
                   .Case("PT_GNU_STACK", PT_GNU_STACK)
                   .Case("PT_GNU_RELRO", PT_GNU_RELRO)
                   .Case("PT_OPENBSD_RANDOMIZE", PT_OPENBSD_RANDOMIZE)
                   .Case("PT_OPENBSD_WXNEEDED", PT_OPENBSD_WXNEEDED)
                   .Case("PT_OPENBSD_BOOTDATA", PT_OPENBSD_BOOTDATA)
                   .Default(-1);

if (ret == (unsigned)-1) {
  setError("invalid program header type: " + tok);
  return PT_NULL;
}
return ret;
1591}

1593// Reads an anonymous version declaration.
1594void ScriptParser::readAnonymousDeclaration() {
SmallVector<SymbolVersion, 0> locals;
SmallVector<SymbolVersion, 0> globals;
std::tie(locals, globals) = readSymbols();
for (const SymbolVersion &pat : locals)
  config->versionDefinitions[VER_NDX_LOCAL].localPatterns.push_back(pat);
for (const SymbolVersion &pat : globals)
  config->versionDefinitions[VER_NDX_GLOBAL].nonLocalPatterns.push_back(pat);

expect(";");
1604}

1606// Reads a non-anonymous version definition,
1607// e.g. "VerStr { global: foo; bar; local: *; };".
1608void ScriptParser::readVersionDeclaration(StringRef verStr) {
// Read a symbol list.
SmallVector<SymbolVersion, 0> locals;
SmallVector<SymbolVersion, 0> globals;
std::tie(locals, globals) = readSymbols();

// Create a new version definition and add that to the global symbols.
VersionDefinition ver;
ver.name = verStr;
ver.nonLocalPatterns = std::move(globals);
ver.localPatterns = std::move(locals);
ver.id = config->versionDefinitions.size();
config->versionDefinitions.push_back(ver);

// Each version may have a parent version. For example, "Ver2"
// defined as "Ver2 { global: foo; local: *; } Ver1;" has "Ver1"
// as a parent. This version hierarchy is, probably against your
// instinct, purely for hint; the runtime doesn't care about it
// at all. In LLD, we simply ignore it.
if (next() != ";")
  expect(";");
1629}

1631bool elf::hasWildcard(StringRef s) {
return s.find_first_of("?*[") != StringRef::npos;
1633}

1635// Reads a list of symbols, e.g. "{ global: foo; bar; local: *; };".
1636std::pair<SmallVector<SymbolVersion, 0>, SmallVector<SymbolVersion, 0>>
1637ScriptParser::readSymbols() {
SmallVector<SymbolVersion, 0> locals;
SmallVector<SymbolVersion, 0> globals;
SmallVector<SymbolVersion, 0> *v = &globals;

while (!errorCount()) {
  if (consume("}"))
    break;
  if (consumeLabel("local")) {
    v = &locals;
    continue;
  }
  if (consumeLabel("global")) {
    v = &globals;
    continue;
  }

  if (consume("extern")) {
    SmallVector<SymbolVersion, 0> ext = readVersionExtern();
    v->insert(v->end(), ext.begin(), ext.end());
  } else {
    StringRef tok = next();
    v->push_back({unquote(tok), false, hasWildcard(tok)});
  }
  expect(";");
}
return {locals, globals};
1664}

1666// Reads an "extern C++" directive, e.g.,
1667// "extern "C++" { ns::*; "f(int, double)"; };"
1668//
1669// The last semicolon is optional. E.g. this is OK:
1670// "extern "C++" { ns::*; "f(int, double)" };"
1671SmallVector<SymbolVersion, 0> ScriptParser::readVersionExtern() {
StringRef tok = next();
bool isCXX = tok == "\"C++\"";
if (!isCXX && tok != "\"C\"")
  setError("Unknown language");
expect("{");

SmallVector<SymbolVersion, 0> ret;
while (!errorCount() && peek() != "}") {
  StringRef tok = next();
  ret.push_back(
      {unquote(tok), isCXX, !tok.startswith("\"") && hasWildcard(tok)});
  if (consume("}"))
    return ret;
  expect(";");
}

expect("}");
return ret;
1690}

1692Expr ScriptParser::readMemoryAssignment(StringRef s1, StringRef s2,
                                      StringRef s3) {
if (!consume(s1) && !consume(s2) && !consume(s3)) {
  setError("expected one of: " + s1 + ", " + s2 + ", or " + s3);
  return [] { return 0; };
}
expect("=");
return readExpr();
1700}

1702// Parse the MEMORY command as specified in:
1703// https://sourceware.org/binutils/docs/ld/MEMORY.html
1704//
1705// MEMORY { name [(attr)] : ORIGIN = origin, LENGTH = len ... }
1706void ScriptParser::readMemory() {
expect("{");
while (!errorCount() && !consume("}")) {
  StringRef tok = next();
  if (tok == "INCLUDE") {
    readInclude();
    continue;
  }

  uint32_t flags = 0;
  uint32_t invFlags = 0;
  uint32_t negFlags = 0;
  uint32_t negInvFlags = 0;
  if (consume("(")) {
    readMemoryAttributes(flags, invFlags, negFlags, negInvFlags);
    expect(")");
  }
  expect(":");

  Expr origin = readMemoryAssignment("ORIGIN", "org", "o");
  expect(",");
  Expr length = readMemoryAssignment("LENGTH", "len", "l");

  // Add the memory region to the region map.
  MemoryRegion *mr = make<MemoryRegion>(tok, origin, length, flags, invFlags,
                                        negFlags, negInvFlags);
  if (!script->memoryRegions.insert({tok, mr}).second)
    setError("region '" + tok + "' already defined");
}
1735}

1737// This function parses the attributes used to match against section
1738// flags when placing output sections in a memory region. These flags
1739// are only used when an explicit memory region name is not used.
1740void ScriptParser::readMemoryAttributes(uint32_t &flags, uint32_t &invFlags,
                                      uint32_t &negFlags,
                                      uint32_t &negInvFlags) {
bool invert = false;

for (char c : next().lower()) {
  if (c == '!') {
    invert = !invert;
    std::swap(flags, negFlags);
    std::swap(invFlags, negInvFlags);
    continue;
  }
  if (c == 'w')
    flags |= SHF_WRITE;
  else if (c == 'x')
    flags |= SHF_EXECINSTR;
  else if (c == 'a')
    flags |= SHF_ALLOC;
  else if (c == 'r')
    invFlags |= SHF_WRITE;
  else
    setError("invalid memory region attribute");
}

if (invert) {
  std::swap(flags, negFlags);
  std::swap(invFlags, negInvFlags);
}
1768}

1770void elf::readLinkerScript(MemoryBufferRef mb) {
llvm::TimeTraceScope timeScope("Read linker script",
                               mb.getBufferIdentifier());
ScriptParser(mb).readLinkerScript();
1774}

1776void elf::readVersionScript(MemoryBufferRef mb) {
llvm::TimeTraceScope timeScope("Read version script",
                               mb.getBufferIdentifier());
ScriptParser(mb).readVersionScript();
1780}

1782void elf::readDynamicList(MemoryBufferRef mb) {
llvm::TimeTraceScope timeScope("Read dynamic list", mb.getBufferIdentifier());
ScriptParser(mb).readDynamicList();
1785}

1787void elf::readDefsym(StringRef name, MemoryBufferRef mb) {
llvm::TimeTraceScope timeScope("Read defsym input", name);
ScriptParser(mb).readDefsym(name);
1
Calling 'ScriptParser::readDefsym'→
1790}

←

/usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/std_function.h

1// Implementation of std::function -*- C++ -*-

3// Copyright (C) 2004-2020 Free Software Foundation, Inc.
4//
5// This file is part of the GNU ISO C++ Library.  This library is free
6// software; you can redistribute it and/or modify it under the
7// terms of the GNU General Public License as published by the
8// Free Software Foundation; either version 3, or (at your option)
9// any later version.

11// This library is distributed in the hope that it will be useful,
12// but WITHOUT ANY WARRANTY; without even the implied warranty of
13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14// GNU General Public License for more details.

16// Under Section 7 of GPL version 3, you are granted additional
17// permissions described in the GCC Runtime Library Exception, version
18// 3.1, as published by the Free Software Foundation.

20// You should have received a copy of the GNU General Public License and
21// a copy of the GCC Runtime Library Exception along with this program;
22// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
23// <http://www.gnu.org/licenses/>.

25/** @file include/bits/std_function.h
*  This is an internal header file, included by other library headers.
*  Do not attempt to use it directly. @headername{functional}
*/

30#ifndef _GLIBCXX_STD_FUNCTION_H1
31#define _GLIBCXX_STD_FUNCTION_H1 1

33#pragma GCC system_header

35#if __cplusplus201703L < 201103L
36# include <bits/c++0x_warning.h>
37#else

39#if __cpp_rtti199711L
40# include <typeinfo>
41#endif
42#include <bits/stl_function.h>
43#include <bits/invoke.h>
44#include <bits/refwrap.h>
45#include <bits/functexcept.h>

47namespace std _GLIBCXX_VISIBILITY(default)__attribute__ ((__visibility__ ("default")))
48{
49_GLIBCXX_BEGIN_NAMESPACE_VERSION

/**
 *  @brief Exception class thrown when class template function's
 *  operator() is called with an empty target.
 *  @ingroup exceptions
 */
class bad_function_call : public std::exception
{
public:
  virtual ~bad_function_call() noexcept;

  const char* what() const noexcept;
};

/**
 *  Trait identifying "location-invariant" types, meaning that the
 *  address of the object (or any of its members) will not escape.
 *  Trivially copyable types are location-invariant and users can
 *  specialize this trait for other types.
 */
template<typename _Tp>
  struct __is_location_invariant
  : is_trivially_copyable<_Tp>::type
  { };

class _Undefined_class;

union _Nocopy_types
{
  void*       _M_object;
  const void* _M_const_object;
  void (*_M_function_pointer)();
  void (_Undefined_class::*_M_member_pointer)();
};

union [[gnu::may_alias]] _Any_data
{
  void*       _M_access()       { return &_M_pod_data[0]; }
  const void* _M_access() const { return &_M_pod_data[0]; }

  template<typename _Tp>
    _Tp&
    _M_access()
    { return *static_cast<_Tp*>(_M_access()); }

  template<typename _Tp>
    const _Tp&
    _M_access() const
    { return *static_cast<const _Tp*>(_M_access()); }

  _Nocopy_types _M_unused;
  char _M_pod_data[sizeof(_Nocopy_types)];
};

enum _Manager_operation
{
  __get_type_info,
  __get_functor_ptr,
  __clone_functor,
  __destroy_functor
};

template<typename _Signature>
  class function;

/// Base class of all polymorphic function object wrappers.
class _Function_base
{
public:
  static const size_t _M_max_size = sizeof(_Nocopy_types);
  static const size_t _M_max_align = __alignof__(_Nocopy_types);

  template<typename _Functor>
    class _Base_manager
    {
    protected:
static const bool __stored_locally =
(__is_location_invariant<_Functor>::value
&& sizeof(_Functor) <= _M_max_size
&& __alignof__(_Functor) <= _M_max_align
&& (_M_max_align % __alignof__(_Functor) == 0));

typedef integral_constant<bool, __stored_locally> _Local_storage;

// Retrieve a pointer to the function object
static _Functor*
_M_get_pointer(const _Any_data& __source)
{
 if _GLIBCXX17_CONSTEXPRconstexpr (__stored_locally)
   {
     const _Functor& __f = __source._M_access<_Functor>();
     return const_cast<_Functor*>(std::__addressof(__f));
   }
 else // have stored a pointer
   return __source._M_access<_Functor*>();
}

// Clone a location-invariant function object that fits within
// an _Any_data structure.
static void
_M_clone(_Any_data& __dest, const _Any_data& __source, true_type)
{
 ::new (__dest._M_access()) _Functor(__source._M_access<_Functor>());
}

// Clone a function object that is not location-invariant or
// that cannot fit into an _Any_data structure.
static void
_M_clone(_Any_data& __dest, const _Any_data& __source, false_type)
{
 __dest._M_access<_Functor*>() =
   new _Functor(*__source._M_access<const _Functor*>());
53
←
Memory is allocated→
}

// Destroying a location-invariant object may still require
// destruction.
static void
_M_destroy(_Any_data& __victim, true_type)
{
 __victim._M_access<_Functor>().~_Functor();
}

// Destroying an object located on the heap.
static void
_M_destroy(_Any_data& __victim, false_type)
{
 delete __victim._M_access<_Functor*>();
}

    public:
static bool
_M_manager(_Any_data& __dest, const _Any_data& __source,
   _Manager_operation __op)
{
 switch (__op)
51
←
Control jumps to 'case __clone_functor:'  at line 195→
   {
186#if __cpp_rtti199711L
   case __get_type_info:
     __dest._M_access<const type_info*>() = &typeid(_Functor);
     break;
190#endif
   case __get_functor_ptr:
     __dest._M_access<_Functor*>() = _M_get_pointer(__source);
     break;

   case __clone_functor:
     _M_clone(__dest, __source, _Local_storage());
52
←
Calling '_Base_manager::_M_clone'→
54
←
Returned allocated memory→
     break;

   case __destroy_functor:
     _M_destroy(__dest, _Local_storage());
     break;
   }
 return false;
55
←
 Execution continues on line 203→
}

static void
_M_init_functor(_Any_data& __functor, _Functor&& __f)
{ _M_init_functor(__functor, std::move(__f), _Local_storage()); }

template<typename _Signature>
 static bool
 _M_not_empty_function(const function<_Signature>& __f)
 { return static_cast<bool>(__f); }

template<typename _Tp>
 static bool
 _M_not_empty_function(_Tp* __fp)
 { return __fp != nullptr; }

template<typename _Class, typename _Tp>
 static bool
 _M_not_empty_function(_Tp _Class::* __mp)
 { return __mp != nullptr; }

template<typename _Tp>
 static bool
 _M_not_empty_function(const _Tp&)
 { return true; }

    private:
static void
_M_init_functor(_Any_data& __functor, _Functor&& __f, true_type)
{ ::new (__functor._M_access()) _Functor(std::move(__f)); }

static void
_M_init_functor(_Any_data& __functor, _Functor&& __f, false_type)
{ __functor._M_access<_Functor*>() = new _Functor(std::move(__f)); }
    };

  _Function_base() : _M_manager(nullptr) { }

  ~_Function_base()
  {
    if (_M_manager)
_M_manager(_M_functor, _M_functor, __destroy_functor);
  }

  bool _M_empty() const { return !_M_manager; }

  typedef bool (*_Manager_type)(_Any_data&, const _Any_data&,
		  _Manager_operation);

  _Any_data     _M_functor;
  _Manager_type _M_manager;
};

template<typename _Signature, typename _Functor>
  class _Function_handler;

template<typename _Res, typename _Functor, typename... _ArgTypes>
  class _Function_handler<_Res(_ArgTypes...), _Functor>
  : public _Function_base::_Base_manager<_Functor>
  {
    typedef _Function_base::_Base_manager<_Functor> _Base;

  public:
    static bool
    _M_manager(_Any_data& __dest, const _Any_data& __source,
 _Manager_operation __op)
    {
switch (__op)
49
←
Control jumps to the 'default' case at line 282→
 {
273#if __cpp_rtti199711L
 case __get_type_info:
   __dest._M_access<const type_info*>() = &typeid(_Functor);
   break;
277#endif
 case __get_functor_ptr:
   __dest._M_access<_Functor*>() = _Base::_M_get_pointer(__source);
   break;

 default:
   _Base::_M_manager(__dest, __source, __op);
50
←
Calling '_Base_manager::_M_manager'→
56
←
Returned allocated memory→
 }
return false;
    }

    static _Res
    _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args)
    {
return std::__invoke_r<_Res>(*_Base::_M_get_pointer(__functor),
		     std::forward<_ArgTypes>(__args)...);
    }
  };

/**
 *  @brief Primary class template for std::function.
 *  @ingroup functors
 *
 *  Polymorphic function wrapper.
 */
template<typename _Res, typename... _ArgTypes>
  class function<_Res(_ArgTypes...)>
  : public _Maybe_unary_or_binary_function<_Res, _ArgTypes...>,
    private _Function_base
  {
    template<typename _Func,
      typename _Res2 = __invoke_result<_Func&, _ArgTypes...>>
struct _Callable
: __is_invocable_impl<_Res2, _Res>::type
{ };

    // Used so the return type convertibility checks aren't done when
    // performing overload resolution for copy construction/assignment.
    template<typename _Tp>
struct _Callable<function, _Tp> : false_type { };

    template<typename _Cond, typename _Tp>
using _Requires = typename enable_if<_Cond::value, _Tp>::type;

  public:
    typedef _Res result_type;

    // [3.7.2.1] construct/copy/destroy

    /**
     *  @brief Default construct creates an empty function call wrapper.
     *  @post @c !(bool)*this
     */
    function() noexcept
    : _Function_base() { }

    /**
     *  @brief Creates an empty function call wrapper.
     *  @post @c !(bool)*this
     */
    function(nullptr_t) noexcept
    : _Function_base() { }

    /**
     *  @brief %Function copy constructor.
     *  @param __x A %function object with identical call signature.
     *  @post @c bool(*this) == bool(__x)
     *
     *  The newly-created %function contains a copy of the target of @a
     *  __x (if it has one).
     */
    function(const function& __x);

    /**
     *  @brief %Function move constructor.
     *  @param __x A %function object rvalue with identical call signature.
     *
     *  The newly-created %function contains the target of @a __x
     *  (if it has one).
     */
    function(function&& __x) noexcept : _Function_base()
    {
__x.swap(*this);
    }

    /**
     *  @brief Builds a %function that targets a copy of the incoming
     *  function object.
     *  @param __f A %function object that is callable with parameters of
     *  type @c T1, @c T2, ..., @c TN and returns a value convertible
     *  to @c Res.
     *
     *  The newly-created %function object will target a copy of
     *  @a __f. If @a __f is @c reference_wrapper<F>, then this function
     *  object will contain a reference to the function object @c
     *  __f.get(). If @a __f is a NULL function pointer or NULL
     *  pointer-to-member, the newly-created object will be empty.
     *
     *  If @a __f is a non-NULL function pointer or an object of type @c
     *  reference_wrapper<F>, this function will not throw.
     */
    template<typename _Functor,
      typename = _Requires<__not_<is_same<_Functor, function>>, void>,
      typename = _Requires<_Callable<_Functor>, void>>
function(_Functor);

    /**
     *  @brief %Function assignment operator.
     *  @param __x A %function with identical call signature.
     *  @post @c (bool)*this == (bool)x
     *  @returns @c *this
     *
     *  The target of @a __x is copied to @c *this. If @a __x has no
     *  target, then @c *this will be empty.
     *
     *  If @a __x targets a function pointer or a reference to a function
     *  object, then this operation will not throw an %exception.
     */
    function&
    operator=(const function& __x)
    {
function(__x).swap(*this);
return *this;
    }

    /**
     *  @brief %Function move-assignment operator.
     *  @param __x A %function rvalue with identical call signature.
     *  @returns @c *this
     *
     *  The target of @a __x is moved to @c *this. If @a __x has no
     *  target, then @c *this will be empty.
     *
     *  If @a __x targets a function pointer or a reference to a function
     *  object, then this operation will not throw an %exception.
     */
    function&
    operator=(function&& __x) noexcept
    {
function(std::move(__x)).swap(*this);
return *this;
    }

    /**
     *  @brief %Function assignment to zero.
     *  @post @c !(bool)*this
     *  @returns @c *this
     *
     *  The target of @c *this is deallocated, leaving it empty.
     */
    function&
    operator=(nullptr_t) noexcept
    {
if (_M_manager)
 {
   _M_manager(_M_functor, _M_functor, __destroy_functor);
   _M_manager = nullptr;
   _M_invoker = nullptr;
 }
return *this;
    }

    /**
     *  @brief %Function assignment to a new target.
     *  @param __f A %function object that is callable with parameters of
     *  type @c T1, @c T2, ..., @c TN and returns a value convertible
     *  to @c Res.
     *  @return @c *this
     *
     *  This  %function object wrapper will target a copy of @a
     *  __f. If @a __f is @c reference_wrapper<F>, then this function
     *  object will contain a reference to the function object @c
     *  __f.get(). If @a __f is a NULL function pointer or NULL
     *  pointer-to-member, @c this object will be empty.
     *
     *  If @a __f is a non-NULL function pointer or an object of type @c
     *  reference_wrapper<F>, this function will not throw.
     */
    template<typename _Functor>
_Requires<_Callable<typename decay<_Functor>::type>, function&>
operator=(_Functor&& __f)
{
 function(std::forward<_Functor>(__f)).swap(*this);
 return *this;
}

    /// @overload
    template<typename _Functor>
function&
operator=(reference_wrapper<_Functor> __f) noexcept
{
 function(__f).swap(*this);
 return *this;
}

    // [3.7.2.2] function modifiers

    /**
     *  @brief Swap the targets of two %function objects.
     *  @param __x A %function with identical call signature.
     *
     *  Swap the targets of @c this function object and @a __f. This
     *  function will not throw an %exception.
     */
    void swap(function& __x) noexcept
    {
std::swap(_M_functor, __x._M_functor);
std::swap(_M_manager, __x._M_manager);
std::swap(_M_invoker, __x._M_invoker);
    }

    // [3.7.2.3] function capacity

    /**
     *  @brief Determine if the %function wrapper has a target.
     *
     *  @return @c true when this %function object contains a target,
     *  or @c false when it is empty.
     *
     *  This function will not throw an %exception.
     */
    explicit operator bool() const noexcept
    { return !_M_empty(); }

    // [3.7.2.4] function invocation

    /**
     *  @brief Invokes the function targeted by @c *this.
     *  @returns the result of the target.
     *  @throws bad_function_call when @c !(bool)*this
     *
     *  The function call operator invokes the target function object
     *  stored by @c this.
     */
    _Res operator()(_ArgTypes... __args) const;

513#if __cpp_rtti199711L
    // [3.7.2.5] function target access
    /**
     *  @brief Determine the type of the target of this function object
     *  wrapper.
     *
     *  @returns the type identifier of the target function object, or
     *  @c typeid(void) if @c !(bool)*this.
     *
     *  This function will not throw an %exception.
     */
    const type_info& target_type() const noexcept;

    /**
     *  @brief Access the stored target function object.
     *
     *  @return Returns a pointer to the stored target function object,
     *  if @c typeid(_Functor).equals(target_type()); otherwise, a NULL
     *  pointer.
     *
     * This function does not throw exceptions.
     *
     * @{
     */
    template<typename _Functor>       _Functor* target() noexcept;

    template<typename _Functor> const _Functor* target() const noexcept;
    // @}
541#endif

  private:
    using _Invoker_type = _Res (*)(const _Any_data&, _ArgTypes&&...);
    _Invoker_type _M_invoker;
};

548#if __cpp_deduction_guides201703L >= 201606
template<typename>
  struct __function_guide_helper
  { };

template<typename _Res, typename _Tp, bool _Nx, typename... _Args>
  struct __function_guide_helper<
    _Res (_Tp::*) (_Args...) noexcept(_Nx)
  >
  { using type = _Res(_Args...); };

template<typename _Res, typename _Tp, bool _Nx, typename... _Args>
  struct __function_guide_helper<
    _Res (_Tp::*) (_Args...) & noexcept(_Nx)
  >
  { using type = _Res(_Args...); };

template<typename _Res, typename _Tp, bool _Nx, typename... _Args>
  struct __function_guide_helper<
    _Res (_Tp::*) (_Args...) const noexcept(_Nx)
  >
  { using type = _Res(_Args...); };

template<typename _Res, typename _Tp, bool _Nx, typename... _Args>
  struct __function_guide_helper<
    _Res (_Tp::*) (_Args...) const & noexcept(_Nx)
  >
  { using type = _Res(_Args...); };

template<typename _Res, typename... _ArgTypes>
  function(_Res(*)(_ArgTypes...)) -> function<_Res(_ArgTypes...)>;

template<typename _Functor, typename _Signature = typename
  __function_guide_helper<decltype(&_Functor::operator())>::type>
  function(_Functor) -> function<_Signature>;
583#endif

// Out-of-line member definitions.
template<typename _Res, typename... _ArgTypes>
  function<_Res(_ArgTypes...)>::
  function(const function& __x)
  : _Function_base()
  {
    if (static_cast<bool>(__x))
47
←
Taking true branch→
{
 __x._M_manager(_M_functor, __x._M_functor, __clone_functor);
48
←
Calling '_Function_handler::_M_manager'→
57
←
Returned allocated memory→
 _M_invoker = __x._M_invoker;
 _M_manager = __x._M_manager;
}
  }

template<typename _Res, typename... _ArgTypes>
  template<typename _Functor, typename, typename>
    function<_Res(_ArgTypes...)>::
    function(_Functor __f)
    : _Function_base()
    {
typedef _Function_handler<_Res(_ArgTypes...), _Functor> _My_handler;

if (_My_handler::_M_not_empty_function(__f))
 {
   _My_handler::_M_init_functor(_M_functor, std::move(__f));
   _M_invoker = &_My_handler::_M_invoke;
   _M_manager = &_My_handler::_M_manager;
 }
    }

template<typename _Res, typename... _ArgTypes>
  _Res
  function<_Res(_ArgTypes...)>::
  operator()(_ArgTypes... __args) const
  {
    if (_M_empty())
__throw_bad_function_call();
    return _M_invoker(_M_functor, std::forward<_ArgTypes>(__args)...);
  }

625#if __cpp_rtti199711L
template<typename _Res, typename... _ArgTypes>
  const type_info&
  function<_Res(_ArgTypes...)>::
  target_type() const noexcept
  {
    if (_M_manager)
{
 _Any_data __typeinfo_result;
 _M_manager(__typeinfo_result, _M_functor, __get_type_info);
 return *__typeinfo_result._M_access<const type_info*>();
}
    else
return typeid(void);
  }

template<typename _Res, typename... _ArgTypes>
  template<typename _Functor>
    _Functor*
    function<_Res(_ArgTypes...)>::
    target() noexcept
    {
const function* __const_this = this;
const _Functor* __func = __const_this->template target<_Functor>();
return const_cast<_Functor*>(__func);
    }

template<typename _Res, typename... _ArgTypes>
  template<typename _Functor>
    const _Functor*
    function<_Res(_ArgTypes...)>::
    target() const noexcept
    {
if (typeid(_Functor) == target_type() && _M_manager)
 {
   _Any_data __ptr;
   _M_manager(__ptr, _M_functor, __get_functor_ptr);
   return __ptr._M_access<const _Functor*>();
 }
else
 return nullptr;
    }
667#endif

// [20.7.15.2.6] null pointer comparisons

/**
 *  @brief Compares a polymorphic function object wrapper against 0
 *  (the NULL pointer).
 *  @returns @c true if the wrapper has no target, @c false otherwise
 *
 *  This function will not throw an %exception.
 */
template<typename _Res, typename... _Args>
  inline bool
  operator==(const function<_Res(_Args...)>& __f, nullptr_t) noexcept
  { return !static_cast<bool>(__f); }

683#if __cpp_impl_three_way_comparison < 201907L
/// @overload
template<typename _Res, typename... _Args>
  inline bool
  operator==(nullptr_t, const function<_Res(_Args...)>& __f) noexcept
  { return !static_cast<bool>(__f); }

/**
 *  @brief Compares a polymorphic function object wrapper against 0
 *  (the NULL pointer).
 *  @returns @c false if the wrapper has no target, @c true otherwise
 *
 *  This function will not throw an %exception.
 */
template<typename _Res, typename... _Args>
  inline bool
  operator!=(const function<_Res(_Args...)>& __f, nullptr_t) noexcept
  { return static_cast<bool>(__f); }

/// @overload
template<typename _Res, typename... _Args>
  inline bool
  operator!=(nullptr_t, const function<_Res(_Args...)>& __f) noexcept
  { return static_cast<bool>(__f); }
707#endif

// [20.7.15.2.7] specialized algorithms

/**
 *  @brief Swap the targets of two polymorphic function object wrappers.
 *
 *  This function will not throw an %exception.
 */
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 2062. Effect contradictions w/o no-throw guarantee of std::function swaps
template<typename _Res, typename... _Args>
  inline void
  swap(function<_Res(_Args...)>& __x, function<_Res(_Args...)>& __y) noexcept
  { __x.swap(__y); }

723#if __cplusplus201703L >= 201703L
namespace __detail::__variant
{
  template<typename> struct _Never_valueless_alt; // see <variant>

  // Provide the strong exception-safety guarantee when emplacing a
  // function into a variant.
  template<typename _Signature>
    struct _Never_valueless_alt<std::function<_Signature>>
    : std::true_type
    { };
}  // namespace __detail::__variant
735#endif // C++17

737_GLIBCXX_END_NAMESPACE_VERSION
738} // namespace std

740#endif // C++11
741#endif // _GLIBCXX_STD_FUNCTION_H