/build/llvm-toolchain-snapshot-7~svn329677/tools/lld/ELF/ScriptParser.cpp

Bug Summary

File:	tools/lld/ELF/ScriptParser.cpp
Warning:	line 55, column 3 Potential memory leak

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name ScriptParser.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-eagerly-assume -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 -mrelocation-model pic -pic-level 2 -mthread-model posix -fmath-errno -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -momit-leaf-frame-pointer -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-7/lib/clang/7.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-7~svn329677/build-llvm/tools/lld/ELF -I /build/llvm-toolchain-snapshot-7~svn329677/tools/lld/ELF -I /build/llvm-toolchain-snapshot-7~svn329677/tools/lld/include -I /build/llvm-toolchain-snapshot-7~svn329677/build-llvm/tools/lld/include -I /build/llvm-toolchain-snapshot-7~svn329677/build-llvm/include -I /build/llvm-toolchain-snapshot-7~svn329677/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/x86_64-linux-gnu/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/x86_64-linux-gnu/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0/backward -internal-isystem /usr/include/clang/7.0.0/include/ -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-7/lib/clang/7.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -std=c++11 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-7~svn329677/build-llvm/tools/lld/ELF -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -fobjc-runtime=gcc -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-checker optin.performance.Padding -analyzer-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2018-04-11-031539-24776-1 -x c++ /build/llvm-toolchain-snapshot-7~svn329677/tools/lld/ELF/ScriptParser.cpp

/build/llvm-toolchain-snapshot-7~svn329677/tools/lld/ELF/ScriptParser.cpp

→

1//===- ScriptParser.cpp ---------------------------------------------------===//
2//
3//                             The LLVM Linker
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file contains a recursive-descendent parser for linker scripts.
11// Parsed results are stored to Config and Script global objects.
12//
13//===----------------------------------------------------------------------===//

15#include "ScriptParser.h"
16#include "Config.h"
17#include "Driver.h"
18#include "InputSection.h"
19#include "LinkerScript.h"
20#include "OutputSections.h"
21#include "ScriptLexer.h"
22#include "Symbols.h"
23#include "Target.h"
24#include "lld/Common/Memory.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/Path.h"
34#include <cassert>
35#include <limits>
36#include <vector>

38using namespace llvm;
39using namespace llvm::ELF;
40using namespace llvm::support::endian;
41using namespace lld;
42using namespace lld::elf;

44static bool isUnderSysroot(StringRef Path);

46namespace {
47class ScriptParser final : ScriptLexer {
48public:
ScriptParser(MemoryBufferRef MB)
    : ScriptLexer(MB),
      IsUnderSysroot(isUnderSysroot(MB.getBufferIdentifier())) {}

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

58private:
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 readPhdrs();
void readRegionAlias();
void readSearchDir();
void readSections();
void readVersion();
void readVersionScriptCommand();

SymbolAssignment *readAssignment(StringRef Name);
ByteCommand *readByteCommand(StringRef Tok);
uint32_t readFill();
uint32_t parseFill(StringRef Tok);
void readSectionAddressType(OutputSection *Cmd);
OutputSection *readOutputSectionDescription(StringRef OutSec);
std::vector<StringRef> readOutputSectionPhdrs();
InputSectionDescription *readInputSectionDescription(StringRef Tok);
StringMatcher readFilePatterns();
std::vector<SectionPattern> readInputSectionsList();
InputSectionDescription *readInputSectionRules(StringRef FilePattern);
unsigned readPhdrType();
SortSectionPolicy readSortKind();
SymbolAssignment *readProvideHidden(bool Provide, bool Hidden);
SymbolAssignment *readProvideOrAssignment(StringRef Tok);
void readSort();
AssertCommand *readAssert();
Expr readAssertExpr();
Expr readConstant();
Expr getPageSize();

uint64_t readMemoryAssignment(StringRef, StringRef, StringRef);
std::pair<uint32_t, uint32_t> readMemoryAttributes();

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.
std::vector<SymbolVersion> readVersionExtern();
void readAnonymousDeclaration();
void readVersionDeclaration(StringRef VerStr);

std::pair<std::vector<SymbolVersion>, std::vector<SymbolVersion>>
readSymbols();

// True if a script being read is in a subdirectory specified by -sysroot.
bool IsUnderSysroot;

// A set to detect an INCLUDE() cycle.
StringSet<> Seen;
123};
124} // namespace

126static StringRef unquote(StringRef S) {
if (S.startswith("\""))
  return S.substr(1, S.size() - 2);
return S;
130}

132static bool isUnderSysroot(StringRef Path) {
if (Config->Sysroot == "")
  return false;
for (; !Path.empty(); Path = sys::path::parent_path(Path))
  if (sys::fs::equivalent(Config->Sysroot, Path))
    return true;
return false;
139}

141// Some operations only support one non absolute value. Move the
142// absolute one to the right hand side for convenience.
143static 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");
148}

150static ExprValue add(ExprValue A, ExprValue B) {
moveAbsRight(A, B);
return {A.Sec, A.ForceAbsolute, A.getSectionOffset() + B.getValue(), A.Loc};
153}

155static 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};
160}

162static ExprValue bitAnd(ExprValue A, ExprValue B) {
moveAbsRight(A, B);
return {A.Sec, A.ForceAbsolute,
        (A.getValue() & B.getValue()) - A.getSecAddr(), A.Loc};
166}

168static ExprValue bitOr(ExprValue A, ExprValue B) {
moveAbsRight(A, B);
return {A.Sec, A.ForceAbsolute,
        (A.getValue() | B.getValue()) - A.getSecAddr(), A.Loc};
172}

174void ScriptParser::readDynamicList() {
Config->HasDynamicList = true;
expect("{");
std::vector<SymbolVersion> Locals;
std::vector<SymbolVersion> 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);
193}

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

201void 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);
}
217}

219void ScriptParser::readVersion() {
expect("{");
readVersionScriptCommand();
expect("}");
223}

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

  if (Tok == "ASSERT") {
    Script->SectionCommands.push_back(readAssert());
  } else 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 == "PHDRS") {
    readPhdrs();
  } else if (Tok == "REGION_ALIAS") {
    readRegionAlias();
  } else if (Tok == "SEARCH_DIR") {
    readSearchDir();
  } else if (Tok == "SECTIONS") {
    readSections();
  } else if (Tok == "VERSION") {
    readVersion();
  } else if (SymbolAssignment *Cmd = readProvideOrAssignment(Tok)) {
    Script->SectionCommands.push_back(Cmd);
  } else {
    setError("unknown directive: " + Tok);
  }
}
267}

269void ScriptParser::readDefsym(StringRef Name) {
Expr E = readExpr();
if (!atEOF())
  setError("EOF expected, but got " + next());
SymbolAssignment *Cmd = make<SymbolAssignment>(Name, E, getCurrentLocation());
Script->SectionCommands.push_back(Cmd);
275}

277void ScriptParser::addFile(StringRef S) {
if (IsUnderSysroot && S.startswith("/")) {
  SmallString<128> PathData;
  StringRef Path = (Config->Sysroot + S).toStringRef(PathData);
  if (sys::fs::exists(Path)) {
    Driver->addFile(Saver.save(Path), /*WithLOption=*/false);
    return;
  }
}

if (S.startswith("/")) {
  Driver->addFile(S, /*WithLOption=*/false);
} else if (S.startswith("=")) {
  if (Config->Sysroot.empty())
    Driver->addFile(S.substr(1), /*WithLOption=*/false);
  else
    Driver->addFile(Saver.save(Config->Sysroot + "/" + S.substr(1)),
                    /*WithLOption=*/false);
} else if (S.startswith("-l")) {
  Driver->addLibrary(S.substr(2));
} else if (sys::fs::exists(S)) {
  Driver->addFile(S, /*WithLOption=*/false);
} else {
  if (Optional<std::string> Path = findFromSearchPaths(S))
    Driver->addFile(Saver.save(*Path), /*WithLOption=*/true);
  else
    setError("unable to find " + S);
}
305}

307void ScriptParser::readAsNeeded() {
expect("(");
bool Orig = Config->AsNeeded;
Config->AsNeeded = true;
while (!errorCount() && !consume(")"))
  addFile(unquote(next()));
Config->AsNeeded = Orig;
314}

316void ScriptParser::readEntry() {
// -e <symbol> takes predecence over ENTRY(<symbol>).
expect("(");
StringRef Tok = next();
if (Config->Entry.empty())
  Config->Entry = Tok;
expect(")");
323}

325void ScriptParser::readExtern() {
expect("(");
while (!errorCount() && !consume(")"))
  Config->Undefined.push_back(next());
329}

331void ScriptParser::readGroup() {
bool Orig = InputFile::IsInGroup;
InputFile::IsInGroup = true;
readInput();
InputFile::IsInGroup = Orig;
336}

338void ScriptParser::readInclude() {
StringRef Tok = unquote(next());

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

if (Optional<std::string> Path = searchLinkerScript(Tok)) {
  if (Optional<MemoryBufferRef> MB = readFile(*Path))
    tokenize(*MB);
  return;
}
setError("cannot find linker script " + Tok);
352}

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

364void ScriptParser::readOutput() {
// -o <file> takes predecence over OUTPUT(<file>).
expect("(");
StringRef Tok = next();
if (Config->OutputFile.empty())
  Config->OutputFile = unquote(Tok);
expect(")");
371}

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

380void ScriptParser::readOutputFormat() {
// Error checking only for now.
expect("(");
skip();
if (consume(")"))
  return;
expect(",");
skip();
expect(",");
skip();
expect(")");
391}

393void 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);
}
416}

418void 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]});
430}

432void ScriptParser::readSearchDir() {
expect("(");
StringRef Tok = next();
if (!Config->Nostdlib)
  Config->SearchPaths.push_back(unquote(Tok));
expect(")");
438}

440void ScriptParser::readSections() {
Script->HasSectionsCommand = true;

// -no-rosegment is used to avoid placing read only non-executable sections in
// their own segment. We do the same if SECTIONS command is present in linker
// script. See comment for computeFlags().
Config->SingleRoRx = true;

expect("{");
std::vector<BaseCommand *> V;
while (!errorCount() && !consume("}")) {
  StringRef Tok = next();
  BaseCommand *Cmd = readProvideOrAssignment(Tok);
  if (!Cmd) {
    if (Tok == "ASSERT")
      Cmd = readAssert();
    else
      Cmd = readOutputSectionDescription(Tok);
  }
  V.push_back(Cmd);
}

if (!atEOF() && consume("INSERT")) {
  std::vector<BaseCommand *> *Dest = nullptr;
  if (consume("AFTER"))
    Dest = &Script->InsertAfterCommands[next()];
  else if (consume("BEFORE"))
    Dest = &Script->InsertBeforeCommands[next()];
  else
    setError("expected AFTER/BEFORE, but got '" + next() + "'");
  if (Dest)
    Dest->insert(Dest->end(), V.begin(), V.end());
  return;
}

Script->SectionCommands.insert(Script->SectionCommands.end(), V.begin(),
                               V.end());
477}

479static int precedence(StringRef Op) {
return StringSwitch<int>(Op)
    .Cases("*", "/", "%", 6)
    .Cases("+", "-", 5)
    .Cases("<<", ">>", 4)
    .Cases("<", "<=", ">", ">=", "==", "!=", 3)
    .Case("&", 2)
    .Case("|", 1)
    .Default(-1);
488}

490StringMatcher ScriptParser::readFilePatterns() {
std::vector<StringRef> V;
while (!errorCount() && !consume(")"))
  V.push_back(next());
return StringMatcher(V);
495}

497SortSectionPolicy ScriptParser::readSortKind() {
if (consume("SORT") || consume("SORT_BY_NAME"))
  return SortSectionPolicy::Name;
if (consume("SORT_BY_ALIGNMENT"))
  return SortSectionPolicy::Alignment;
if (consume("SORT_BY_INIT_PRIORITY"))
  return SortSectionPolicy::Priority;
if (consume("SORT_NONE"))
  return SortSectionPolicy::None;
return SortSectionPolicy::Default;
507}

509// Reads SECTIONS command contents in the following form:
510//
511// <contents> ::= <elem>*
512// <elem>     ::= <exclude>? <glob-pattern>
513// <exclude>  ::= "EXCLUDE_FILE" "(" <glob-pattern>+ ")"
514//
515// For example,
516//
517// *(.foo EXCLUDE_FILE (a.o) .bar EXCLUDE_FILE (b.o) .baz)
518//
519// is parsed as ".foo", ".bar" with "a.o", and ".baz" with "b.o".
520// The semantics of that is section .foo in any file, section .bar in
521// any file but a.o, and section .baz in any file but b.o.
522std::vector<SectionPattern> ScriptParser::readInputSectionsList() {
std::vector<SectionPattern> Ret;
while (!errorCount() && peek() != ")") {
  StringMatcher ExcludeFilePat;
  if (consume("EXCLUDE_FILE")) {
    expect("(");
    ExcludeFilePat = readFilePatterns();
  }

  std::vector<StringRef> V;
  while (!errorCount() && peek() != ")" && peek() != "EXCLUDE_FILE")
    V.push_back(next());

  if (!V.empty())
    Ret.push_back({std::move(ExcludeFilePat), StringMatcher(V)});
  else
    setError("section pattern is expected");
}
return Ret;
541}

543// Reads contents of "SECTIONS" directive. That directive contains a
544// list of glob patterns for input sections. The grammar is as follows.
545//
546// <patterns> ::= <section-list>
547//              | <sort> "(" <section-list> ")"
548//              | <sort> "(" <sort> "(" <section-list> ")" ")"
549//
550// <sort>     ::= "SORT" | "SORT_BY_NAME" | "SORT_BY_ALIGNMENT"
551//              | "SORT_BY_INIT_PRIORITY" | "SORT_NONE"
552//
553// <section-list> is parsed by readInputSectionsList().
554InputSectionDescription *
555ScriptParser::readInputSectionRules(StringRef FilePattern) {
auto *Cmd = make<InputSectionDescription>(FilePattern);
expect("(");

while (!errorCount() && !consume(")")) {
  SortSectionPolicy Outer = readSortKind();
  SortSectionPolicy Inner = SortSectionPolicy::Default;
  std::vector<SectionPattern> 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;
586}

588InputSectionDescription *
589ScriptParser::readInputSectionDescription(StringRef Tok) {
// Input section wildcard can be surrounded by KEEP.
// https://sourceware.org/binutils/docs/ld/Input-Section-Keep.html#Input-Section-Keep
if (Tok == "KEEP") {
  expect("(");
  StringRef FilePattern = next();
  InputSectionDescription *Cmd = readInputSectionRules(FilePattern);
  expect(")");
  Script->KeptSections.push_back(Cmd);
  return Cmd;
}
return readInputSectionRules(Tok);
601}

603void ScriptParser::readSort() {
expect("(");
expect("CONSTRUCTORS");
expect(")");
607}

609AssertCommand *ScriptParser::readAssert() {
return make<AssertCommand>(readAssertExpr());
1
Calling 'ScriptParser::readAssertExpr'→
10
←
Returned allocated memory→
11
←
Calling 'make'→
611}

613Expr ScriptParser::readAssertExpr() {
expect("(");
Expr E = readExpr();
expect(",");
StringRef Msg = unquote(next());
expect(")");

return [=] {
2
←
Calling constructor for 'function'→
9
←
Returning from constructor for 'function'→
  if (!E().getValue())
    error(Msg);
  return Script->getDot();
};
625}

627// Reads a FILL(expr) command. We handle the FILL command as an
628// alias for =fillexp section attribute, which is different from
629// what GNU linkers do.
630// https://sourceware.org/binutils/docs/ld/Output-Section-Data.html
631uint32_t ScriptParser::readFill() {
expect("(");
uint32_t V = parseFill(next());
expect(")");
return V;
636}

638// Reads an expression and/or the special directive for an output
639// section definition. Directive is one of following: "(NOLOAD)",
640// "(COPY)", "(INFO)" or "(OVERLAY)".
641//
642// An output section name can be followed by an address expression
643// and/or directive. This grammar is not LL(1) because "(" can be
644// interpreted as either the beginning of some expression or beginning
645// of directive.
646//
647// https://sourceware.org/binutils/docs/ld/Output-Section-Address.html
648// https://sourceware.org/binutils/docs/ld/Output-Section-Type.html
649void ScriptParser::readSectionAddressType(OutputSection *Cmd) {
if (consume("(")) {
  if (consume("NOLOAD")) {
    expect(")");
    Cmd->Noload = true;
    return;
  }
  if (consume("COPY") || consume("INFO") || consume("OVERLAY")) {
    expect(")");
    Cmd->NonAlloc = true;
    return;
  }
  Cmd->AddrExpr = readExpr();
  expect(")");
} else {
  Cmd->AddrExpr = readExpr();
}

if (consume("(")) {
  expect("NOLOAD");
  expect(")");
  Cmd->Noload = true;
}
672}

674static 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;
};
683}

685OutputSection *ScriptParser::readOutputSectionDescription(StringRef OutSec) {
OutputSection *Cmd =
    Script->createOutputSection(OutSec, getCurrentLocation());

size_t SymbolsReferenced = Script->ReferencedSymbols.size();

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

std::string Location = getCurrentLocation();
if (consume("AT"))
  Cmd->LMAExpr = readParenExpr();
if (consume("ALIGN"))
  Cmd->AlignExpr = checkAlignment(readParenExpr(), Location);
if (consume("SUBALIGN"))
  Cmd->SubalignExpr = checkAlignment(readParenExpr(), Location);

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

while (!errorCount() && !consume("}")) {
  StringRef Tok = next();
  if (Tok == ";") {
    // Empty commands are allowed. Do nothing here.
  } else if (SymbolAssignment *Assign = readProvideOrAssignment(Tok)) {
    Cmd->SectionCommands.push_back(Assign);
  } else if (ByteCommand *Data = readByteCommand(Tok)) {
    Cmd->SectionCommands.push_back(Data);
  } else if (Tok == "ASSERT") {
    Cmd->SectionCommands.push_back(readAssert());
    expect(";");
  } 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") {
    Cmd->Filler = readFill();
  } else if (Tok == "SORT") {
    readSort();
  } else if (peek() == "(") {
    Cmd->SectionCommands.push_back(readInputSectionDescription(Tok));
  } else {
    setError("unknown command " + Tok);
  }
}

if (consume(">"))
  Cmd->MemoryRegionName = next();

if (consume("AT")) {
  expect(">");
  Cmd->LMARegionName = next();
}

if (Cmd->LMAExpr && !Cmd->LMARegionName.empty())
  error("section can't have both LMA and a load region");

Cmd->Phdrs = readOutputSectionPhdrs();

if (consume("="))
  Cmd->Filler = parseFill(next());
else if (peek().startswith("="))
  Cmd->Filler = parseFill(next().drop_front());

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

if (Script->ReferencedSymbols.size() > SymbolsReferenced)
  Cmd->ExpressionsUseSymbols = true;
return Cmd;
760}

762// Parses a given string as a octal/decimal/hexadecimal number and
763// returns it as a big-endian number. Used for `=<fillexp>`.
764// https://sourceware.org/binutils/docs/ld/Output-Section-Fill.html
765//
766// When reading a hexstring, ld.bfd handles it as a blob of arbitrary
767// size, while ld.gold always handles it as a 32-bit big-endian number.
768// We are compatible with ld.gold because it's easier to implement.
769uint32_t ScriptParser::parseFill(StringRef Tok) {
uint32_t V = 0;
if (!to_integer(Tok, V))
  setError("invalid filler expression: " + Tok);

uint32_t Buf;
write32be(&Buf, V);
return Buf;
777}

779SymbolAssignment *ScriptParser::readProvideHidden(bool Provide, bool Hidden) {
expect("(");
SymbolAssignment *Cmd = readAssignment(next());
Cmd->Provide = Provide;
Cmd->Hidden = Hidden;
expect(")");
return Cmd;
786}

788SymbolAssignment *ScriptParser::readProvideOrAssignment(StringRef Tok) {
size_t OldPos = Pos;
SymbolAssignment *Cmd = nullptr;
if (peek() == "=" || peek() == "+=")
  Cmd = readAssignment(Tok);
else if (Tok == "PROVIDE")
  Cmd = readProvideHidden(true, false);
else if (Tok == "HIDDEN")
  Cmd = readProvideHidden(false, true);
else if (Tok == "PROVIDE_HIDDEN")
  Cmd = readProvideHidden(true, true);

if (Cmd) {
  Cmd->CommandString =
      Tok.str() + " " +
      llvm::join(Tokens.begin() + OldPos, Tokens.begin() + Pos, " ");
  expect(";");
}
return Cmd;
807}

809SymbolAssignment *ScriptParser::readAssignment(StringRef Name) {
StringRef Op = next();
assert(Op == "=" || Op == "+=")(static_cast <bool> (Op == "=" || Op == "+=") ? void (0
) : __assert_fail ("Op == \"=\" || Op == \"+=\"", "/build/llvm-toolchain-snapshot-7~svn329677/tools/lld/ELF/ScriptParser.cpp"
, 811, __extension__ __PRETTY_FUNCTION__));
Expr E = readExpr();
if (Op == "+=") {
  std::string Loc = getCurrentLocation();
  E = [=] { return add(Script->getSymbolValue(Name, Loc), E()); };
}
return make<SymbolAssignment>(Name, E, getCurrentLocation());
818}

820// This is an operator-precedence parser to parse a linker
821// script expression.
822Expr 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);
InExpr = Orig;
return E;
830}

832Expr 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 bitAnd(L(), R()); };
if (Op == "|")
  return [=] { return bitOr(L(), R()); };
llvm_unreachable("invalid operator")::llvm::llvm_unreachable_internal("invalid operator", "/build/llvm-toolchain-snapshot-7~svn329677/tools/lld/ELF/ScriptParser.cpp"
, 877);
878}

880// This is a part of the operator-precedence parser. This function
881// assumes that the remaining token stream starts with an operator.
882Expr ScriptParser::readExpr1(Expr Lhs, int MinPrec) {
while (!atEOF() && !errorCount()) {
  // Read an operator and an expression.
  if (consume("?"))
    return readTernary(Lhs);
  StringRef Op1 = peek();
  if (precedence(Op1) < MinPrec)
    break;
  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;
907}

909Expr ScriptParser::getPageSize() {
std::string Location = getCurrentLocation();
return [=]() -> uint64_t {
  if (Target)
    return Target->PageSize;
  error(Location + ": unable to calculate page size");
  return 4096; // Return a dummy value.
};
917}

919Expr ScriptParser::readConstant() {
StringRef S = readParenLiteral();
if (S == "COMMONPAGESIZE")
  return getPageSize();
if (S == "MAXPAGESIZE")
  return [] { return Config->MaxPageSize; };
setError("unknown constant: " + S);
return [] { return 0; };
927}

929// Parses Tok as an integer. It recognizes hexadecimal (prefixed with
930// "0x" or suffixed with "H") and decimal numbers. Decimal numbers may
931// have "K" (Ki) or "M" (Mi) suffixes.
932static Optional<uint64_t> parseInt(StringRef Tok) {
// Hexadecimal
uint64_t Val;
if (Tok.startswith_lower("0x")) {
  if (!to_integer(Tok.substr(2), Val, 16))
    return None;
  return Val;
}
if (Tok.endswith_lower("H")) {
  if (!to_integer(Tok.drop_back(), Val, 16))
    return None;
  return Val;
}

// Decimal
if (Tok.endswith_lower("K")) {
  if (!to_integer(Tok.drop_back(), Val, 10))
    return None;
  return Val * 1024;
}
if (Tok.endswith_lower("M")) {
  if (!to_integer(Tok.drop_back(), Val, 10))
    return None;
  return Val * 1024 * 1024;
}
if (!to_integer(Tok, Val, 10))
  return None;
return Val;
960}

962ByteCommand *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);
978}

980StringRef ScriptParser::readParenLiteral() {
expect("(");
bool Orig = InExpr;
InExpr = false;
StringRef Tok = next();
InExpr = Orig;
expect(")");
return Tok;
988}

990static void checkIfExists(OutputSection *Cmd, StringRef Location) {
if (Cmd->Location.empty() && Script->ErrorOnMissingSection)
  error(Location + ": undefined section " + Cmd->Name);
993}

995Expr ScriptParser::readPrimary() {
if (peek() == "(")
  return readParenExpr();

if (consume("~")) {
  Expr E = readPrimary();
  return [=] { return ~E().getValue(); };
}
if (consume("!")) {
  Expr E = readPrimary();
  return [=] { return !E().getValue(); };
}
if (consume("-")) {
  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") {
  Expr Inner = readParenExpr();
  return [=] {
    ExprValue I = Inner();
    I.ForceAbsolute = true;
    return I;
  };
}
if (Tok == "ADDR") {
  StringRef Name = readParenLiteral();
  OutputSection *Sec = Script->getOrCreateOutputSection(Name);
  return [=]() -> ExprValue {
    checkIfExists(Sec, Location);
    return {Sec, false, 0, Location};
  };
}
if (Tok == "ALIGN") {
  expect("(");
  Expr E = readExpr();
  if (consume(")")) {
    E = checkAlignment(E, Location);
    return [=] { return alignTo(Script->getDot(), E().getValue()); };
  }
  expect(",");
  Expr E2 = checkAlignment(readExpr(), Location);
  expect(")");
  return [=] {
    ExprValue V = E();
    V.Alignment = E2().getValue();
    return V;
  };
}
if (Tok == "ALIGNOF") {
  StringRef Name = readParenLiteral();
  OutputSection *Cmd = Script->getOrCreateOutputSection(Name);
  return [=] {
    checkIfExists(Cmd, Location);
    return Cmd->Alignment;
  };
}
if (Tok == "ASSERT")
  return readAssertExpr();
if (Tok == "CONSTANT")
  return readConstant();
if (Tok == "DATA_SEGMENT_ALIGN") {
  expect("(");
  Expr E = readExpr();
  expect(",");
  readExpr();
  expect(")");
  return [=] {
    return alignTo(Script->getDot(), std::max((uint64_t)1, E().getValue()));
  };
}
if (Tok == "DATA_SEGMENT_END") {
  expect("(");
  expect(".");
  expect(")");
  return [] { return Script->getDot(); };
}
if (Tok == "DATA_SEGMENT_RELRO_END") {
  // 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(")");
  Expr E = getPageSize();
  return [=] { return alignTo(Script->getDot(), E().getValue()); };
}
if (Tok == "DEFINED") {
  StringRef Name = readParenLiteral();
  return [=] { return Symtab->find(Name) ? 1 : 0; };
}
if (Tok == "LENGTH") {
  StringRef Name = readParenLiteral();
  if (Script->MemoryRegions.count(Name) == 0) {
    setError("memory region not defined: " + Name);
    return [] { return 0; };
  }
  return [=] { return Script->MemoryRegions[Name]->Length; };
}
if (Tok == "LOADADDR") {
  StringRef Name = readParenLiteral();
  OutputSection *Cmd = Script->getOrCreateOutputSection(Name);
  return [=] {
    checkIfExists(Cmd, Location);
    return Cmd->getLMA();
  };
}
if (Tok == "MAX" || Tok == "MIN") {
  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") {
  StringRef Name = readParenLiteral();
  if (Script->MemoryRegions.count(Name) == 0) {
    setError("memory region not defined: " + Name);
    return [] { return 0; };
  }
  return [=] { return Script->MemoryRegions[Name]->Origin; };
}
if (Tok == "SEGMENT_START") {
  expect("(");
  skip();
  expect(",");
  Expr E = readExpr();
  expect(")");
  return [=] { return E(); };
}
if (Tok == "SIZEOF") {
  StringRef Name = readParenLiteral();
  OutputSection *Cmd = Script->getOrCreateOutputSection(Name);
  // 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 (Optional<uint64_t> Val = parseInt(Tok))
  return [=] { return *Val; };

// Tok is a symbol name.
if (!isValidCIdentifier(Tok))
  setError("malformed number: " + Tok);
Script->ReferencedSymbols.push_back(Tok);
return [=] { return Script->getSymbolValue(Tok, Location); };
1159}

1161Expr ScriptParser::readTernary(Expr Cond) {
Expr L = readExpr();
expect(":");
Expr R = readExpr();
return [=] { return Cond().getValue() ? L() : R(); };
1166}

1168Expr ScriptParser::readParenExpr() {
expect("(");
Expr E = readExpr();
expect(")");
return E;
1173}

1175std::vector<StringRef> ScriptParser::readOutputSectionPhdrs() {
std::vector<StringRef> Phdrs;
while (!errorCount() && peek().startswith(":")) {
  StringRef Tok = next();
  Phdrs.push_back((Tok.size() == 1) ? next() : Tok.substr(1));
}
return Phdrs;
1182}

1184// Read a program header type name. The next token must be a
1185// name of a program header type or a constant (e.g. "0x3").
1186unsigned ScriptParser::readPhdrType() {
StringRef Tok = next();
if (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;
1213}

1215// Reads an anonymous version declaration.
1216void ScriptParser::readAnonymousDeclaration() {
std::vector<SymbolVersion> Locals;
std::vector<SymbolVersion> Globals;
std::tie(Locals, Globals) = readSymbols();

for (SymbolVersion V : Locals) {
  if (V.Name == "*")
    Config->DefaultSymbolVersion = VER_NDX_LOCAL;
  else
    Config->VersionScriptLocals.push_back(V);
}

for (SymbolVersion V : Globals)
  Config->VersionScriptGlobals.push_back(V);

expect(";");
1232}

1234// Reads a non-anonymous version definition,
1235// e.g. "VerStr { global: foo; bar; local: *; };".
1236void ScriptParser::readVersionDeclaration(StringRef VerStr) {
// Read a symbol list.
std::vector<SymbolVersion> Locals;
std::vector<SymbolVersion> Globals;
std::tie(Locals, Globals) = readSymbols();

for (SymbolVersion V : Locals) {
  if (V.Name == "*")
    Config->DefaultSymbolVersion = VER_NDX_LOCAL;
  else
    Config->VersionScriptLocals.push_back(V);
}

// Create a new version definition and add that to the global symbols.
VersionDefinition Ver;
Ver.Name = VerStr;
Ver.Globals = Globals;

// User-defined version number starts from 2 because 0 and 1 are
// reserved for VER_NDX_LOCAL and VER_NDX_GLOBAL, respectively.
Ver.Id = Config->VersionDefinitions.size() + 2;
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 (peek() != ";")
  skip();
expect(";");
1267}

1269static bool hasWildcard(StringRef S) {
return S.find_first_of("?*[") != StringRef::npos;
1271}

1273// Reads a list of symbols, e.g. "{ global: foo; bar; local: *; };".
1274std::pair<std::vector<SymbolVersion>, std::vector<SymbolVersion>>
1275ScriptParser::readSymbols() {
std::vector<SymbolVersion> Locals;
std::vector<SymbolVersion> Globals;
std::vector<SymbolVersion> *V = &Globals;

while (!errorCount()) {
  if (consume("}"))
    break;
  if (consumeLabel("local")) {
    V = &Locals;
    continue;
  }
  if (consumeLabel("global")) {
    V = &Globals;
    continue;
  }

  if (consume("extern")) {
    std::vector<SymbolVersion> 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};
1302}

1304// Reads an "extern C++" directive, e.g.,
1305// "extern "C++" { ns::*; "f(int, double)"; };"
1306//
1307// The last semicolon is optional. E.g. this is OK:
1308// "extern "C++" { ns::*; "f(int, double)" };"
1309std::vector<SymbolVersion> ScriptParser::readVersionExtern() {
StringRef Tok = next();
bool IsCXX = Tok == "\"C++\"";
if (!IsCXX && Tok != "\"C\"")
  setError("Unknown language");
expect("{");

std::vector<SymbolVersion> Ret;
while (!errorCount() && peek() != "}") {
  StringRef Tok = next();
  bool HasWildcard = !Tok.startswith("\"") && hasWildcard(Tok);
  Ret.push_back({unquote(Tok), IsCXX, HasWildcard});
  if (consume("}"))
    return Ret;
  expect(";");
}

expect("}");
return Ret;
1328}

1330uint64_t ScriptParser::readMemoryAssignment(StringRef S1, StringRef S2,
                                          StringRef S3) {
if (!consume(S1) && !consume(S2) && !consume(S3)) {
  setError("expected one of: " + S1 + ", " + S2 + ", or " + S3);
  return 0;
}
expect("=");
return readExpr()().getValue();
1338}

1340// Parse the MEMORY command as specified in:
1341// https://sourceware.org/binutils/docs/ld/MEMORY.html
1342//
1343// MEMORY { name [(attr)] : ORIGIN = origin, LENGTH = len ... }
1344void ScriptParser::readMemory() {
expect("{");
while (!errorCount() && !consume("}")) {
  StringRef Name = next();

  uint32_t Flags = 0;
  uint32_t NegFlags = 0;
  if (consume("(")) {
    std::tie(Flags, NegFlags) = readMemoryAttributes();
    expect(")");
  }
  expect(":");

  uint64_t Origin = readMemoryAssignment("ORIGIN", "org", "o");
  expect(",");
  uint64_t Length = readMemoryAssignment("LENGTH", "len", "l");

  // Add the memory region to the region map.
  MemoryRegion *MR =
      make<MemoryRegion>(Name, Origin, Length, Flags, NegFlags);
  if (!Script->MemoryRegions.insert({Name, MR}).second)
    setError("region '" + Name + "' already defined");
}
1367}

1369// This function parses the attributes used to match against section
1370// flags when placing output sections in a memory region. These flags
1371// are only used when an explicit memory region name is not used.
1372std::pair<uint32_t, uint32_t> ScriptParser::readMemoryAttributes() {
uint32_t Flags = 0;
uint32_t NegFlags = 0;
bool Invert = false;

for (char C : next().lower()) {
  uint32_t Flag = 0;
  if (C == '!')
    Invert = !Invert;
  else if (C == 'w')
    Flag = SHF_WRITE;
  else if (C == 'x')
    Flag = SHF_EXECINSTR;
  else if (C == 'a')
    Flag = SHF_ALLOC;
  else if (C != 'r')
    setError("invalid memory region attribute");

  if (Invert)
    NegFlags |= Flag;
  else
    Flags |= Flag;
}
return {Flags, NegFlags};
1396}

1398void elf::readLinkerScript(MemoryBufferRef MB) {
ScriptParser(MB).readLinkerScript();
1400}

1402void elf::readVersionScript(MemoryBufferRef MB) {
ScriptParser(MB).readVersionScript();
1404}

1406void elf::readDynamicList(MemoryBufferRef MB) {
ScriptParser(MB).readDynamicList();
1408}

1410void elf::readDefsym(StringRef Name, MemoryBufferRef MB) {
ScriptParser(MB).readDefsym(Name);
1412}

←

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

→

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

3// Copyright (C) 2004-2017 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/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 __cplusplus201103L < 201103L
36# include <bits/c++0x_warning.h>
37#else

39#if __cpp_rtti199711
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

/**
 * Derives from @c unary_function or @c binary_function, or perhaps
 * nothing, depending on the number of arguments provided. The
 * primary template is the basis case, which derives nothing.
 */
template<typename _Res, typename... _ArgTypes>
  struct _Maybe_unary_or_binary_function { };

/// Derives from @c unary_function, as appropriate.
template<typename _Res, typename _T1>
  struct _Maybe_unary_or_binary_function<_Res, _T1>
  : std::unary_function<_T1, _Res> { };

/// Derives from @c binary_function, as appropriate.
template<typename _Res, typename _T1, typename _T2>
  struct _Maybe_unary_or_binary_function<_Res, _T1, _T2>
  : std::binary_function<_T1, _T2, _Res> { };


/**
 *  @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
};

// Simple type wrapper that helps avoid annoying const problems
// when casting between void pointers and pointers-to-pointers.
template<typename _Tp>
  struct _Simple_type_wrapper
  {
    _Simple_type_wrapper(_Tp __value) : __value(__value) { }

    _Tp __value;
  };

template<typename _Tp>
  struct __is_location_invariant<_Simple_type_wrapper<_Tp> >
  : __is_location_invariant<_Tp>
  { };

template<typename _Signature>
  class function;

/// Base class of all polymorphic function object wrappers.
class _Function_base
{
public:
  static const std::size_t _M_max_size = sizeof(_Nocopy_types);
  static const std::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)
{
 const _Functor* __ptr =
   __stored_locally? std::__addressof(__source._M_access<_Functor>())
   /* have stored a pointer */ : __source._M_access<_Functor*>();
 return const_cast<_Functor*>(__ptr);
}

// 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<_Functor*>());
}

// 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)
   {
217#if __cpp_rtti199711
   case __get_type_info:
     __dest._M_access<const type_info*>() = &typeid(_Functor);
     break;
221#endif
   case __get_functor_ptr:
     __dest._M_access<_Functor*>() = _M_get_pointer(__source);
     break;

   case __clone_functor:
     _M_clone(__dest, __source, _Local_storage());
     break;

   case __destroy_functor:
     _M_destroy(__dest, _Local_storage());
     break;
   }
 return false;
}

static void
_M_init_functor(_Any_data& __functor, _Functor&& __f)
{ _M_init_functor(__functor, std::move(__f), _Local_storage()); }
5
←
Calling '_Base_manager::_M_init_functor'→
7
←
Returned allocated memory→

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)); }
6
←
Memory is allocated→
    };

  _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 _Res
    _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args)
    {
return (*_Base::_M_get_pointer(__functor))(
   std::forward<_ArgTypes>(__args)...);
    }
  };

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

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

template<typename _Class, typename _Member, typename _Res,
  typename... _ArgTypes>
  class _Function_handler<_Res(_ArgTypes...), _Member _Class::*>
  : public _Function_handler<void(_ArgTypes...), _Member _Class::*>
  {
    typedef _Function_handler<void(_ArgTypes...), _Member _Class::*>
_Base;

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

template<typename _Class, typename _Member, typename... _ArgTypes>
  class _Function_handler<void(_ArgTypes...), _Member _Class::*>
  : public _Function_base::_Base_manager<
 _Simple_type_wrapper< _Member _Class::* > >
  {
    typedef _Member _Class::* _Functor;
    typedef _Simple_type_wrapper<_Functor> _Wrapper;
    typedef _Function_base::_Base_manager<_Wrapper> _Base;

  public:
    static bool
    _M_manager(_Any_data& __dest, const _Any_data& __source,
 _Manager_operation __op)
    {
switch (__op)
 {
354#if __cpp_rtti199711
 case __get_type_info:
   __dest._M_access<const type_info*>() = &typeid(_Functor);
   break;
358#endif
 case __get_functor_ptr:
   __dest._M_access<_Functor*>() =
     &_Base::_M_get_pointer(__source)->__value;
   break;

 default:
   _Base::_M_manager(__dest, __source, __op);
 }
return false;
    }

    static void
    _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args)
    {
std::__invoke(_Base::_M_get_pointer(__functor)->__value,
      std::forward<_ArgTypes>(__args)...);
    }
  };

template<typename _From, typename _To>
  using __check_func_return_type
    = __or_<is_void<_To>, is_same<_From, _To>, is_convertible<_From, _To>>;

/**
 *  @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 = typename result_of<_Func&(_ArgTypes...)>::type>
struct _Callable : __check_func_return_type<_Res2, _Res> { };

    // 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;

597#if __cpp_rtti199711
    // [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;
    // @}
625#endif

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

632#if __cpp_deduction_guides >= 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>;
667#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))
{
 __x._M_manager(_M_functor, __x._M_functor, __clone_functor);
 _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))
3
←
Taking true branch→
 {
   _My_handler::_M_init_functor(_M_functor, std::move(__f));
4
←
Calling '_Base_manager::_M_init_functor'→
8
←
Returned allocated memory→
   _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)...);
  }

709#if __cpp_rtti199711
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;
    }
751#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); }

/// @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); }


// [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); }

806_GLIBCXX_END_NAMESPACE_VERSION
807} // namespace std

809#endif // C++11

811#endif // _GLIBCXX_STD_FUNCTION_H

←

/build/llvm-toolchain-snapshot-7~svn329677/tools/lld/include/lld/Common/Memory.h

1//===- Memory.h -------------------------------------------------*- C++ -*-===//
2//
3//                             The LLVM Linker
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file defines arena allocators.
11//
12// Almost all large objects, such as files, sections or symbols, are
13// used for the entire lifetime of the linker once they are created.
14// This usage characteristic makes arena allocator an attractive choice
15// where the entire linker is one arena. With an arena, newly created
16// objects belong to the arena and freed all at once when everything is done.
17// Arena allocators are efficient and easy to understand.
18// Most objects are allocated using the arena allocators defined by this file.
19//
20//===----------------------------------------------------------------------===//
21 
22#ifndef LLD_COMMON_MEMORY_H
23#define LLD_COMMON_MEMORY_H
24 
25#include "llvm/Support/Allocator.h"
26#include "llvm/Support/StringSaver.h"
27#include <vector>
28 
29namespace lld {
30 
31// Use this arena if your object doesn't have a destructor.
32extern llvm::BumpPtrAllocator BAlloc;
33extern llvm::StringSaver Saver;
34 
35void freeArena();
36 
37// These two classes are hack to keep track of all
38// SpecificBumpPtrAllocator instances.
39struct SpecificAllocBase {
40  SpecificAllocBase() { Instances.push_back(this); }
41  virtual ~SpecificAllocBase() = default;
42  virtual void reset() = 0;
43  static std::vector<SpecificAllocBase *> Instances;
44};
45 
46template <class T> struct SpecificAlloc : public SpecificAllocBase {
47  void reset() override { Alloc.DestroyAll(); }
48  llvm::SpecificBumpPtrAllocator<T> Alloc;
49};
50 
51// Use this arena if your object has a destructor.
52// Your destructor will be invoked from freeArena().
53template <typename T, typename... U> T *make(U &&... Args) {
54  static SpecificAlloc<T> Alloc;
55  return new (Alloc.Alloc.Allocate()) T(std::forward<U>(Args)...);
12
←
Potential memory leak
56}
57 
58} // namespace lld
59 
60#endif