/build/llvm-toolchain-snapshot-8~svn345461/tools/lld/ELF/ScriptParser.cpp

Bug Summary

File:	tools/lld/ELF/ScriptParser.cpp
Warning:	line 885, column 3 Undefined or garbage value returned to caller

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-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-8/lib/clang/8.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-8~svn345461/build-llvm/tools/lld/ELF -I /build/llvm-toolchain-snapshot-8~svn345461/tools/lld/ELF -I /build/llvm-toolchain-snapshot-8~svn345461/tools/lld/include -I /build/llvm-toolchain-snapshot-8~svn345461/build-llvm/tools/lld/include -I /build/llvm-toolchain-snapshot-8~svn345461/build-llvm/include -I /build/llvm-toolchain-snapshot-8~svn345461/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0/backward -internal-isystem /usr/include/clang/8.0.0/include/ -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-8/lib/clang/8.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-8~svn345461/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-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2018-10-27-211344-32123-1 -x c++ /build/llvm-toolchain-snapshot-8~svn345461/tools/lld/ELF/ScriptParser.cpp -faddrsig

/build/llvm-toolchain-snapshot-8~svn345461/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 readTarget();
void readVersion();
void readVersionScriptCommand();

SymbolAssignment *readSymbolAssignment(StringRef Name);
ByteCommand *readByteCommand(StringRef Tok);
uint32_t readFill();
uint32_t parseFill(StringRef Tok);
bool readSectionDirective(OutputSection *Cmd, StringRef Tok1, StringRef Tok2);
void readSectionAddressType(OutputSection *Cmd);
OutputSection *readOverlaySectionDescription();
OutputSection *readOutputSectionDescription(StringRef OutSec);
std::vector<BaseCommand *> readOverlay();
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 *readAssignment(StringRef Tok);
std::pair<ELFKind, uint16_t> readBfdName();
void readSort();
Expr readAssert();
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;
127};
128} // namespace

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

136static 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;
143}

145// Some operations only support one non absolute value. Move the
146// absolute one to the right hand side for convenience.
147static 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");
152}

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

159static 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};
164}

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

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

178void 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);
197}

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

205void 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);
}
221}

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

229void 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 == "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);
  }
}
271}

273void 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);
279}

281void 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);
}
309}

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

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

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

335void ScriptParser::readGroup() {
bool Orig = InputFile::IsInGroup;
InputFile::IsInGroup = true;
readInput();
InputFile::IsInGroup = Orig;
if (!Orig)
  ++InputFile::NextGroupId;
342}

344void 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 = searchScript(Tok)) {
  if (Optional<MemoryBufferRef> MB = readFile(*Path))
    tokenize(*MB);
  return;
}
setError("cannot find linker script " + Tok);
358}

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

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

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

386std::pair<ELFKind, uint16_t> ScriptParser::readBfdName() {
StringRef S = next();
if (S == "elf32-i386")
  return {ELF32LEKind, EM_386};
if (S == "elf32-iamcu")
  return {ELF32LEKind, EM_IAMCU};
if (S == "elf32-littlearm")
  return {ELF32LEKind, EM_ARM};
if (S == "elf32-x86-64")
  return {ELF32LEKind, EM_X86_64};
if (S == "elf64-littleaarch64")
  return {ELF64LEKind, EM_AARCH64};
if (S == "elf64-x86-64")
  return {ELF64LEKind, EM_X86_64};

setError("unknown output format name: " + S);
return {ELFNoneKind, EM_NONE};
403}

405// Parse OUTPUT_FORMAT(bfdname) or OUTPUT_FORMAT(bfdname, big, little).
406// Currently we ignore big and little parameters.
407void ScriptParser::readOutputFormat() {
expect("(");

std::pair<ELFKind, uint16_t> P = readBfdName();
if (Config->EKind == ELFNoneKind) {
  Config->EKind = P.first;
  Config->EMachine = P.second;
}

if (consume(")"))
  return;
expect(",");
skip();
expect(",");
skip();
expect(")");
423}

425void 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);
}
448}

450void 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]});
462}

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

472// This reads an overlay description. Overlays are used to describe output
473// sections that use the same virtual memory range and normally would trigger
474// linker's sections sanity check failures.
475// https://sourceware.org/binutils/docs/ld/Overlay-Description.html#Overlay-Description
476std::vector<BaseCommand *> 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("{");

std::vector<BaseCommand *> 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.
  OutputSection *OS = readOverlaySectionDescription();
  OS->AddrExpr = AddrExpr;
  if (Prev)
    OS->LMAExpr = [=] { return Prev->getLMA() + Prev->Size; };
  else
    OS->LMAExpr = LMAExpr;
  V.push_back(OS);
  Prev = OS;
}

// 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 (BaseCommand *Cmd : V)
    Max = std::max(Max, cast<OutputSection>(Cmd)->Size);
  return AddrExpr().getValue() + Max;
};
V.push_back(make<SymbolAssignment>(".", MoveDot, getCurrentLocation()));
return V;
513}

515void 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();
  if (Tok == "OVERLAY") {
    for (BaseCommand *Cmd : readOverlay())
      V.push_back(Cmd);
    continue;
  } else if (Tok == "INCLUDE") {
    readInclude();
    continue;
  }

  if (BaseCommand *Cmd = readAssignment(Tok))
    V.push_back(Cmd);
  else
    V.push_back(readOutputSectionDescription(Tok));
}

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());
557}

559void 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 = next();
expect(")");

if (Tok.startswith("elf"))
  Config->FormatBinary = false;
else if (Tok == "binary")
  Config->FormatBinary = true;
else
  setError("unknown target: " + Tok);
574}

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

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

596SortSectionPolicy 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;
606}

608// Reads SECTIONS command contents in the following form:
609//
610// <contents> ::= <elem>*
611// <elem>     ::= <exclude>? <glob-pattern>
612// <exclude>  ::= "EXCLUDE_FILE" "(" <glob-pattern>+ ")"
613//
614// For example,
615//
616// *(.foo EXCLUDE_FILE (a.o) .bar EXCLUDE_FILE (b.o) .baz)
617//
618// is parsed as ".foo", ".bar" with "a.o", and ".baz" with "b.o".
619// The semantics of that is section .foo in any file, section .bar in
620// any file but a.o, and section .baz in any file but b.o.
621std::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;
640}

642// Reads contents of "SECTIONS" directive. That directive contains a
643// list of glob patterns for input sections. The grammar is as follows.
644//
645// <patterns> ::= <section-list>
646//              | <sort> "(" <section-list> ")"
647//              | <sort> "(" <sort> "(" <section-list> ")" ")"
648//
649// <sort>     ::= "SORT" | "SORT_BY_NAME" | "SORT_BY_ALIGNMENT"
650//              | "SORT_BY_INIT_PRIORITY" | "SORT_NONE"
651//
652// <section-list> is parsed by readInputSectionsList().
653InputSectionDescription *
654ScriptParser::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;
685}

687InputSectionDescription *
688ScriptParser::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);
700}

702void ScriptParser::readSort() {
expect("(");
expect("CONSTRUCTORS");
expect(")");
706}

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

return [=] {
  if (!E().getValue())
    error(Msg);
  return Script->getDot();
};
720}

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

733// Tries to read the special directive for an output section definition which
734// can be one of following: "(NOLOAD)", "(COPY)", "(INFO)" or "(OVERLAY)".
735// Tok1 and Tok2 are next 2 tokens peeked. See comment for readSectionAddressType below.
736bool ScriptParser::readSectionDirective(OutputSection *Cmd, StringRef Tok1, StringRef Tok2) {
if (Tok1 != "(")
  return false;
if (Tok2 != "NOLOAD" && Tok2 != "COPY" && Tok2 != "INFO" && Tok2 != "OVERLAY")
  return false;

expect("(");
if (consume("NOLOAD")) {
  Cmd->Noload = true;
} else {
  skip(); // This is "COPY", "INFO" or "OVERLAY".
  Cmd->NonAlloc = true;
}
expect(")");
return true;
751}

753// Reads an expression and/or the special directive for an output
754// section definition. Directive is one of following: "(NOLOAD)",
755// "(COPY)", "(INFO)" or "(OVERLAY)".
756//
757// An output section name can be followed by an address expression
758// and/or directive. This grammar is not LL(1) because "(" can be
759// interpreted as either the beginning of some expression or beginning
760// of directive.
761//
762// https://sourceware.org/binutils/docs/ld/Output-Section-Address.html
763// https://sourceware.org/binutils/docs/ld/Output-Section-Type.html
764void ScriptParser::readSectionAddressType(OutputSection *Cmd) {
if (readSectionDirective(Cmd, peek(), peek2()))
  return;

Cmd->AddrExpr = readExpr();
if (peek() == "(" && !readSectionDirective(Cmd, "(", peek2()))
  setError("unknown section directive: " + peek2());
771}

773static 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;
};
782}

784OutputSection *ScriptParser::readOverlaySectionDescription() {
OutputSection *Cmd =
    Script->createOutputSection(next(), getCurrentLocation());
Cmd->InOverlay = true;
expect("{");
while (!errorCount() && !consume("}"))
  Cmd->SectionCommands.push_back(readInputSectionRules(next()));
Cmd->Phdrs = readOutputSectionPhdrs();
return Cmd;
793}

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

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

if (peek() != ":")
1
Taking false branch→
  readSectionAddressType(Cmd);
expect(":");

std::string Location = getCurrentLocation();
if (consume("AT"))
2
←
Assuming the condition is false→
3
←
Taking false branch→
  Cmd->LMAExpr = readParenExpr();
if (consume("ALIGN"))
4
←
Assuming the condition is false→
5
←
Taking false branch→
  Cmd->AlignExpr = checkAlignment(readParenExpr(), Location);
if (consume("SUBALIGN"))
6
←
Assuming the condition is false→
7
←
Taking false branch→
  Cmd->SubalignExpr = checkAlignment(readParenExpr(), Location);

// Parse constraints.
if (consume("ONLY_IF_RO"))
8
←
Assuming the condition is false→
9
←
Taking false branch→
  Cmd->Constraint = ConstraintKind::ReadOnly;
if (consume("ONLY_IF_RW"))
10
←
Assuming the condition is false→
11
←
Taking false branch→
  Cmd->Constraint = ConstraintKind::ReadWrite;
expect("{");

while (!errorCount() && !consume("}")) {
12
←
Assuming the condition is false→
13
←
Loop condition is false. Execution continues on line 845→
  StringRef Tok = next();
  if (Tok == ";") {
    // Empty commands are allowed. Do nothing here.
  } else if (SymbolAssignment *Assign = readAssignment(Tok)) {
    Cmd->SectionCommands.push_back(Assign);
  } else if (ByteCommand *Data = readByteCommand(Tok)) {
    Cmd->SectionCommands.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") {
    Cmd->Filler = readFill();
  } else if (Tok == "SORT") {
    readSort();
  } else if (Tok == "INCLUDE") {
    readInclude();
  } else if (peek() == "(") {
    Cmd->SectionCommands.push_back(readInputSectionDescription(Tok));
  } else {
    setError("unknown command " + Tok);
  }
}

if (consume(">"))
14
←
Assuming the condition is false→
15
←
Taking false branch→
  Cmd->MemoryRegionName = next();

if (consume("AT")) {
16
←
Assuming the condition is false→
17
←
Taking false branch→
  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("="))
18
←
Assuming the condition is true→
19
←
Taking true branch→
  Cmd->Filler = parseFill(next());
20
←
Calling 'ScriptParser::parseFill'→
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;
869}

871// Parses a given string as a octal/decimal/hexadecimal number and
872// returns it as a big-endian number. Used for `=<fillexp>`.
873// https://sourceware.org/binutils/docs/ld/Output-Section-Fill.html
874//
875// When reading a hexstring, ld.bfd handles it as a blob of arbitrary
876// size, while ld.gold always handles it as a 32-bit big-endian number.
877// We are compatible with ld.gold because it's easier to implement.
878uint32_t ScriptParser::parseFill(StringRef Tok) {
uint32_t V = 0;
if (!to_integer(Tok, V))
21
←
Taking false branch→
  setError("invalid filler expression: " + Tok);

uint32_t Buf;
22
←
'Buf' declared without an initial value→
write32be(&Buf, V);
23
←
Calling 'write32be'→
31
←
Returning from 'write32be'→
return Buf;
32
←
Undefined or garbage value returned to caller
886}

888SymbolAssignment *ScriptParser::readProvideHidden(bool Provide, bool Hidden) {
expect("(");
SymbolAssignment *Cmd = readSymbolAssignment(next());
Cmd->Provide = Provide;
Cmd->Hidden = Hidden;
expect(")");
return Cmd;
895}

897SymbolAssignment *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;
if (peek() == "=" || peek() == "+=")
  Cmd = readSymbolAssignment(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;
920}

922SymbolAssignment *ScriptParser::readSymbolAssignment(StringRef Name) {
StringRef Op = next();
assert(Op == "=" || Op == "+=")((Op == "=" || Op == "+=") ? static_cast<void> (0) : __assert_fail
 ("Op == \"=\" || Op == \"+=\"", "/build/llvm-toolchain-snapshot-8~svn345461/tools/lld/ELF/ScriptParser.cpp"
, 924, __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());
931}

933// This is an operator-precedence parser to parse a linker
934// script expression.
935Expr 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;
943}

945Expr 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", "/build/llvm-toolchain-snapshot-8~svn345461/tools/lld/ELF/ScriptParser.cpp"
, 994);
995}

997// This is a part of the operator-precedence parser. This function
998// assumes that the remaining token stream starts with an operator.
999Expr 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;
1024}

1026Expr 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.
};
1034}

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

1046// Parses Tok as an integer. It recognizes hexadecimal (prefixed with
1047// "0x" or suffixed with "H") and decimal numbers. Decimal numbers may
1048// have "K" (Ki) or "M" (Mi) suffixes.
1049static 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;
1077}

1079ByteCommand *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);
1095}

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

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

1112Expr 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 readAssert();
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); };
1276}

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

1285Expr ScriptParser::readParenExpr() {
expect("(");
Expr E = readExpr();
expect(")");
return E;
1290}

1292std::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;
1299}

1301// Read a program header type name. The next token must be a
1302// name of a program header type or a constant (e.g. "0x3").
1303unsigned 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;
1330}

1332// Reads an anonymous version declaration.
1333void 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(";");
1349}

1351// Reads a non-anonymous version definition,
1352// e.g. "VerStr { global: foo; bar; local: *; };".
1353void 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(";");
1384}

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

1390// Reads a list of symbols, e.g. "{ global: foo; bar; local: *; };".
1391std::pair<std::vector<SymbolVersion>, std::vector<SymbolVersion>>
1392ScriptParser::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};
1419}

1421// Reads an "extern C++" directive, e.g.,
1422// "extern "C++" { ns::*; "f(int, double)"; };"
1423//
1424// The last semicolon is optional. E.g. this is OK:
1425// "extern "C++" { ns::*; "f(int, double)" };"
1426std::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;
1445}

1447uint64_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();
1455}

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

  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>(Tok, Origin, Length, Flags, NegFlags);
  if (!Script->MemoryRegions.insert({Tok, MR}).second)
    setError("region '" + Tok + "' already defined");
}
1487}

1489// This function parses the attributes used to match against section
1490// flags when placing output sections in a memory region. These flags
1491// are only used when an explicit memory region name is not used.
1492std::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};
1516}

1518void elf::readLinkerScript(MemoryBufferRef MB) {
ScriptParser(MB).readLinkerScript();
1520}

1522void elf::readVersionScript(MemoryBufferRef MB) {
ScriptParser(MB).readVersionScript();
1524}

1526void elf::readDynamicList(MemoryBufferRef MB) {
ScriptParser(MB).readDynamicList();
1528}

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

←

/build/llvm-toolchain-snapshot-8~svn345461/include/llvm/Support/Endian.h

1//===- Endian.h - Utilities for IO with endian specific data ----*- C++ -*-===//
2//
3//                     The LLVM Compiler Infrastructure
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 declares generic functions to read and write endian specific data.
11//
12//===----------------------------------------------------------------------===//
13 
14#ifndef LLVM_SUPPORT_ENDIAN_H
15#define LLVM_SUPPORT_ENDIAN_H
16 
17#include "llvm/Support/AlignOf.h"
18#include "llvm/Support/Compiler.h"
19#include "llvm/Support/Host.h"
20#include "llvm/Support/SwapByteOrder.h"
21#include <cassert>
22#include <cstddef>
23#include <cstdint>
24#include <cstring>
25#include <type_traits>
26 
27namespace llvm {
28namespace support {
29 
30enum endianness {big, little, native};
31 
32// These are named values for common alignments.
33enum {aligned = 0, unaligned = 1};
34 
35namespace detail {
36 
37/// ::value is either alignment, or alignof(T) if alignment is 0.
38template<class T, int alignment>
39struct PickAlignment {
40 enum { value = alignment == 0 ? alignof(T) : alignment };
41};
42 
43} // end namespace detail
44 
45namespace endian {
46 
47constexpr endianness system_endianness() {
48  return sys::IsBigEndianHost ? big : little;
49}
50 
51template <typename value_type>
52inline value_type byte_swap(value_type value, endianness endian) {
53  if ((endian != native) && (endian != system_endianness()))
54    sys::swapByteOrder(value);
55  return value;
56}
57 
58/// Swap the bytes of value to match the given endianness.
59template<typename value_type, endianness endian>
60inline value_type byte_swap(value_type value) {
61  return byte_swap(value, endian);
62}
63 
64/// Read a value of a particular endianness from memory.
65template <typename value_type, std::size_t alignment>
66inline value_type read(const void *memory, endianness endian) {
67  value_type ret;
68 
69  memcpy(&ret,
70         LLVM_ASSUME_ALIGNED(__builtin_assume_aligned(memory, (detail::PickAlignment<value_type
, alignment>::value))
71             memory, (detail::PickAlignment<value_type, alignment>::value))__builtin_assume_aligned(memory, (detail::PickAlignment<value_type
, alignment>::value)),
72         sizeof(value_type));
73  return byte_swap<value_type>(ret, endian);
74}
75 
76template<typename value_type,
77         endianness endian,
78         std::size_t alignment>
79inline value_type read(const void *memory) {
80  return read<value_type, alignment>(memory, endian);
81}
82 
83/// Read a value of a particular endianness from a buffer, and increment the
84/// buffer past that value.
85template <typename value_type, std::size_t alignment, typename CharT>
86inline value_type readNext(const CharT *&memory, endianness endian) {
87  value_type ret = read<value_type, alignment>(memory, endian);
88  memory += sizeof(value_type);
89  return ret;
90}
91 
92template<typename value_type, endianness endian, std::size_t alignment,
93         typename CharT>
94inline value_type readNext(const CharT *&memory) {
95  return readNext<value_type, alignment, CharT>(memory, endian);
96}
97 
98/// Write a value to memory with a particular endianness.
99template <typename value_type, std::size_t alignment>
100inline void write(void *memory, value_type value, endianness endian) {
101  value = byte_swap<value_type>(value, endian);
102  memcpy(LLVM_ASSUME_ALIGNED(__builtin_assume_aligned(memory, (detail::PickAlignment<value_type
, alignment>::value))
103             memory, (detail::PickAlignment<value_type, alignment>::value))__builtin_assume_aligned(memory, (detail::PickAlignment<value_type
, alignment>::value)),
104         &value, sizeof(value_type));
105}
106 
107template<typename value_type,
108         endianness endian,
109         std::size_t alignment>
110inline void write(void *memory, value_type value) {
111  write<value_type, alignment>(memory, value, endian);
112}
113 
114template <typename value_type>
115using make_unsigned_t = typename std::make_unsigned<value_type>::type;
116 
117/// Read a value of a particular endianness from memory, for a location
118/// that starts at the given bit offset within the first byte.
119template <typename value_type, endianness endian, std::size_t alignment>
120inline value_type readAtBitAlignment(const void *memory, uint64_t startBit) {
121  assert(startBit < 8)((startBit < 8) ? static_cast<void> (0) : __assert_fail
 ("startBit < 8", "/build/llvm-toolchain-snapshot-8~svn345461/include/llvm/Support/Endian.h"
, 121, __PRETTY_FUNCTION__));
122  if (startBit == 0)
123    return read<value_type, endian, alignment>(memory);
124  else {
125    // Read two values and compose the result from them.
126    value_type val[2];
127    memcpy(&val[0],
128           LLVM_ASSUME_ALIGNED(__builtin_assume_aligned(memory, (detail::PickAlignment<value_type
, alignment>::value))
129               memory, (detail::PickAlignment<value_type, alignment>::value))__builtin_assume_aligned(memory, (detail::PickAlignment<value_type
, alignment>::value)),
130           sizeof(value_type) * 2);
131    val[0] = byte_swap<value_type, endian>(val[0]);
132    val[1] = byte_swap<value_type, endian>(val[1]);
133 
134    // Shift bits from the lower value into place.
135    make_unsigned_t<value_type> lowerVal = val[0] >> startBit;
136    // Mask off upper bits after right shift in case of signed type.
137    make_unsigned_t<value_type> numBitsFirstVal =
138        (sizeof(value_type) * 8) - startBit;
139    lowerVal &= ((make_unsigned_t<value_type>)1 << numBitsFirstVal) - 1;
140 
141    // Get the bits from the upper value.
142    make_unsigned_t<value_type> upperVal =
143        val[1] & (((make_unsigned_t<value_type>)1 << startBit) - 1);
144    // Shift them in to place.
145    upperVal <<= numBitsFirstVal;
146 
147    return lowerVal | upperVal;
148  }
149}
150 
151/// Write a value to memory with a particular endianness, for a location
152/// that starts at the given bit offset within the first byte.
153template <typename value_type, endianness endian, std::size_t alignment>
154inline void writeAtBitAlignment(void *memory, value_type value,
155                                uint64_t startBit) {
156  assert(startBit < 8)((startBit < 8) ? static_cast<void> (0) : __assert_fail
 ("startBit < 8", "/build/llvm-toolchain-snapshot-8~svn345461/include/llvm/Support/Endian.h"
, 156, __PRETTY_FUNCTION__));
157  if (startBit == 0)
158    write<value_type, endian, alignment>(memory, value);
159  else {
160    // Read two values and shift the result into them.
161    value_type val[2];
162    memcpy(&val[0],
163           LLVM_ASSUME_ALIGNED(__builtin_assume_aligned(memory, (detail::PickAlignment<value_type
, alignment>::value))
164               memory, (detail::PickAlignment<value_type, alignment>::value))__builtin_assume_aligned(memory, (detail::PickAlignment<value_type
, alignment>::value)),
165           sizeof(value_type) * 2);
166    val[0] = byte_swap<value_type, endian>(val[0]);
167    val[1] = byte_swap<value_type, endian>(val[1]);
168 
169    // Mask off any existing bits in the upper part of the lower value that
170    // we want to replace.
171    val[0] &= ((make_unsigned_t<value_type>)1 << startBit) - 1;
172    make_unsigned_t<value_type> numBitsFirstVal =
173        (sizeof(value_type) * 8) - startBit;
174    make_unsigned_t<value_type> lowerVal = value;
175    if (startBit > 0) {
176      // Mask off the upper bits in the new value that are not going to go into
177      // the lower value. This avoids a left shift of a negative value, which
178      // is undefined behavior.
179      lowerVal &= (((make_unsigned_t<value_type>)1 << numBitsFirstVal) - 1);
180      // Now shift the new bits into place
181      lowerVal <<= startBit;
182    }
183    val[0] |= lowerVal;
184 
185    // Mask off any existing bits in the lower part of the upper value that
186    // we want to replace.
187    val[1] &= ~(((make_unsigned_t<value_type>)1 << startBit) - 1);
188    // Next shift the bits that go into the upper value into position.
189    make_unsigned_t<value_type> upperVal = value >> numBitsFirstVal;
190    // Mask off upper bits after right shift in case of signed type.
191    upperVal &= ((make_unsigned_t<value_type>)1 << startBit) - 1;
192    val[1] |= upperVal;
193 
194    // Finally, rewrite values.
195    val[0] = byte_swap<value_type, endian>(val[0]);
196    val[1] = byte_swap<value_type, endian>(val[1]);
197    memcpy(LLVM_ASSUME_ALIGNED(__builtin_assume_aligned(memory, (detail::PickAlignment<value_type
, alignment>::value))
198               memory, (detail::PickAlignment<value_type, alignment>::value))__builtin_assume_aligned(memory, (detail::PickAlignment<value_type
, alignment>::value)),
199           &val[0], sizeof(value_type) * 2);
200  }
201}
202 
203} // end namespace endian
204 
205namespace detail {
206 
207template<typename value_type,
208         endianness endian,
209         std::size_t alignment>
210struct packed_endian_specific_integral {
211  packed_endian_specific_integral() = default;
212 
213  explicit packed_endian_specific_integral(value_type val) { *this = val; }
214 
215  operator value_type() const {
216    return endian::read<value_type, endian, alignment>(
217      (const void*)Value.buffer);
218  }
219 
220  void operator=(value_type newValue) {
221    endian::write<value_type, endian, alignment>(
222      (void*)Value.buffer, newValue);
223  }
224 
225  packed_endian_specific_integral &operator+=(value_type newValue) {
226    *this = *this + newValue;
227    return *this;
228  }
229 
230  packed_endian_specific_integral &operator-=(value_type newValue) {
231    *this = *this - newValue;
232    return *this;
233  }
234 
235  packed_endian_specific_integral &operator|=(value_type newValue) {
236    *this = *this | newValue;
237    return *this;
238  }
239 
240  packed_endian_specific_integral &operator&=(value_type newValue) {
241    *this = *this & newValue;
242    return *this;
243  }
244 
245private:
246  AlignedCharArray<PickAlignment<value_type, alignment>::value,
247                   sizeof(value_type)> Value;
248 
249public:
250  struct ref {
251    explicit ref(void *Ptr) : Ptr(Ptr) {}
252 
253    operator value_type() const {
254      return endian::read<value_type, endian, alignment>(Ptr);
255    }
256 
257    void operator=(value_type NewValue) {
258      endian::write<value_type, endian, alignment>(Ptr, NewValue);
259    }
260 
261  private:
262    void *Ptr;
263  };
264};
265 
266} // end namespace detail
267 
268using ulittle16_t =
269    detail::packed_endian_specific_integral<uint16_t, little, unaligned>;
270using ulittle32_t =
271    detail::packed_endian_specific_integral<uint32_t, little, unaligned>;
272using ulittle64_t =
273    detail::packed_endian_specific_integral<uint64_t, little, unaligned>;
274 
275using little16_t =
276    detail::packed_endian_specific_integral<int16_t, little, unaligned>;
277using little32_t =
278    detail::packed_endian_specific_integral<int32_t, little, unaligned>;
279using little64_t =
280    detail::packed_endian_specific_integral<int64_t, little, unaligned>;
281 
282using aligned_ulittle16_t =
283    detail::packed_endian_specific_integral<uint16_t, little, aligned>;
284using aligned_ulittle32_t =
285    detail::packed_endian_specific_integral<uint32_t, little, aligned>;
286using aligned_ulittle64_t =
287    detail::packed_endian_specific_integral<uint64_t, little, aligned>;
288 
289using aligned_little16_t =
290    detail::packed_endian_specific_integral<int16_t, little, aligned>;
291using aligned_little32_t =
292    detail::packed_endian_specific_integral<int32_t, little, aligned>;
293using aligned_little64_t =
294    detail::packed_endian_specific_integral<int64_t, little, aligned>;
295 
296using ubig16_t =
297    detail::packed_endian_specific_integral<uint16_t, big, unaligned>;
298using ubig32_t =
299    detail::packed_endian_specific_integral<uint32_t, big, unaligned>;
300using ubig64_t =
301    detail::packed_endian_specific_integral<uint64_t, big, unaligned>;
302 
303using big16_t =
304    detail::packed_endian_specific_integral<int16_t, big, unaligned>;
305using big32_t =
306    detail::packed_endian_specific_integral<int32_t, big, unaligned>;
307using big64_t =
308    detail::packed_endian_specific_integral<int64_t, big, unaligned>;
309 
310using aligned_ubig16_t =
311    detail::packed_endian_specific_integral<uint16_t, big, aligned>;
312using aligned_ubig32_t =
313    detail::packed_endian_specific_integral<uint32_t, big, aligned>;
314using aligned_ubig64_t =
315    detail::packed_endian_specific_integral<uint64_t, big, aligned>;
316 
317using aligned_big16_t =
318    detail::packed_endian_specific_integral<int16_t, big, aligned>;
319using aligned_big32_t =
320    detail::packed_endian_specific_integral<int32_t, big, aligned>;
321using aligned_big64_t =
322    detail::packed_endian_specific_integral<int64_t, big, aligned>;
323 
324using unaligned_uint16_t =
325    detail::packed_endian_specific_integral<uint16_t, native, unaligned>;
326using unaligned_uint32_t =
327    detail::packed_endian_specific_integral<uint32_t, native, unaligned>;
328using unaligned_uint64_t =
329    detail::packed_endian_specific_integral<uint64_t, native, unaligned>;
330 
331using unaligned_int16_t =
332    detail::packed_endian_specific_integral<int16_t, native, unaligned>;
333using unaligned_int32_t =
334    detail::packed_endian_specific_integral<int32_t, native, unaligned>;
335using unaligned_int64_t =
336    detail::packed_endian_specific_integral<int64_t, native, unaligned>;
337 
338namespace endian {
339 
340template <typename T> inline T read(const void *P, endianness E) {
341  return read<T, unaligned>(P, E);
342}
343 
344template <typename T, endianness E> inline T read(const void *P) {
345  return *(const detail::packed_endian_specific_integral<T, E, unaligned> *)P;
346}
347 
348inline uint16_t read16(const void *P, endianness E) {
349  return read<uint16_t>(P, E);
350}
351inline uint32_t read32(const void *P, endianness E) {
352  return read<uint32_t>(P, E);
353}
354inline uint64_t read64(const void *P, endianness E) {
355  return read<uint64_t>(P, E);
356}
357 
358template <endianness E> inline uint16_t read16(const void *P) {
359  return read<uint16_t, E>(P);
360}
361template <endianness E> inline uint32_t read32(const void *P) {
362  return read<uint32_t, E>(P);
363}
364template <endianness E> inline uint64_t read64(const void *P) {
365  return read<uint64_t, E>(P);
366}
367 
368inline uint16_t read16le(const void *P) { return read16<little>(P); }
369inline uint32_t read32le(const void *P) { return read32<little>(P); }
370inline uint64_t read64le(const void *P) { return read64<little>(P); }
371inline uint16_t read16be(const void *P) { return read16<big>(P); }
372inline uint32_t read32be(const void *P) { return read32<big>(P); }
373inline uint64_t read64be(const void *P) { return read64<big>(P); }
374 
375template <typename T> inline void write(void *P, T V, endianness E) {
376  write<T, unaligned>(P, V, E);
377}
378 
379template <typename T, endianness E> inline void write(void *P, T V) {
380  *(detail::packed_endian_specific_integral<T, E, unaligned> *)P = V;
381}
26
←
Returning without writing to '*P'→
382 
383inline void write16(void *P, uint16_t V, endianness E) {
384  write<uint16_t>(P, V, E);
385}
386inline void write32(void *P, uint32_t V, endianness E) {
387  write<uint32_t>(P, V, E);
388}
389inline void write64(void *P, uint64_t V, endianness E) {
390  write<uint64_t>(P, V, E);
391}
392 
393template <endianness E> inline void write16(void *P, uint16_t V) {
394  write<uint16_t, E>(P, V);
395}
396template <endianness E> inline void write32(void *P, uint32_t V) {
397  write<uint32_t, E>(P, V);
25
←
Calling 'write<unsigned int, llvm::support::big>'→
27
←
Returning from 'write<unsigned int, llvm::support::big>'→
398}
28
←
Returning without writing to '*P'→
399template <endianness E> inline void write64(void *P, uint64_t V) {
400  write<uint64_t, E>(P, V);
401}
402 
403inline void write16le(void *P, uint16_t V) { write16<little>(P, V); }
404inline void write32le(void *P, uint32_t V) { write32<little>(P, V); }
405inline void write64le(void *P, uint64_t V) { write64<little>(P, V); }
406inline void write16be(void *P, uint16_t V) { write16<big>(P, V); }
407inline void write32be(void *P, uint32_t V) { write32<big>(P, V); }
24
←
Calling 'write32<llvm::support::big>'→
29
←
Returning from 'write32<llvm::support::big>'→
30
←
Returning without writing to '*P'→
408inline void write64be(void *P, uint64_t V) { write64<big>(P, V); }
409 
410} // end namespace endian
411 
412} // end namespace support
413} // end namespace llvm
414 
415#endif // LLVM_SUPPORT_ENDIAN_H