shylie/llvm-project
1
0
Fork 0
Code Issues Pull Requests Actions 6 Packages Projects Releases Wiki Activity

[ELF] Move elf::symtab into Ctx

Browse Source 
Remove the global variable `symtab` and add a member variable
(`std::unique_ptr<SymbolTable>`) to `Ctx` instead.

This is one step toward eliminating global states.

Pull Request: https://github.com/llvm/llvm-project/pull/109612
This commit is contained in:
Fangrui Song 2024-09-23 10:33:43 -07:00
parent 62f3eae466
commit df0864e761
17 changed files with 127 additions and 126 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

44
lld/ELF/Arch/ARM.cpp
View File

@ -1215,7 +1215,7 @@ template <class ELFT> void ObjFile<ELFT>::importCmseSymbols() {
continue;
}
if (symtab.cmseImportLib.count(sym->getName())) {
if (ctx.symtab->cmseImportLib.count(sym->getName())) {
error("CMSE symbol '" + sym->getName() +
"' is multiply defined in import library '" + toString(this) + "'");
continue;
@ -1227,7 +1227,7 @@ template <class ELFT> void ObjFile<ELFT>::importCmseSymbols() {
Twine(ACLESESYM_SIZE) + " bytes");
}
symtab.cmseImportLib[sym->getName()] = sym;
ctx.symtab->cmseImportLib[sym->getName()] = sym;
}
}
@ -1263,9 +1263,9 @@ static std::string checkCmseSymAttributes(Symbol *acleSeSym, Symbol *sym) {
void elf::processArmCmseSymbols() {
if (!ctx.arg.cmseImplib)
return;
// Only symbols with external linkage end up in symtab, so no need to do
// Only symbols with external linkage end up in ctx.symtab, so no need to do
// linkage checks. Only check symbol type.
for (Symbol *acleSeSym : symtab.getSymbols()) {
for (Symbol *acleSeSym : ctx.symtab->getSymbols()) {
if (!acleSeSym->getName().starts_with(ACLESESYM_PREFIX))
continue;
// If input object build attributes do not support CMSE, error and disable
@ -1279,7 +1279,7 @@ void elf::processArmCmseSymbols() {
// Try to find the associated symbol definition.
// Symbol must have external linkage.
StringRef name = acleSeSym->getName().substr(std::strlen(ACLESESYM_PREFIX));
Symbol *sym = symtab.find(name);
Symbol *sym = ctx.symtab->find(name);
if (!sym) {
error(toString(acleSeSym->file) + ": cmse special symbol '" +
acleSeSym->getName() +
@ -1295,7 +1295,7 @@ void elf::processArmCmseSymbols() {
}
// <sym> may be redefined later in the link in .gnu.sgstubs
symtab.cmseSymMap[name] = {acleSeSym, sym};
ctx.symtab->cmseSymMap[name] = {acleSeSym, sym};
}
// If this is an Arm CMSE secure app, replace references to entry symbol <sym>
@ -1304,8 +1304,8 @@ void elf::processArmCmseSymbols() {
MutableArrayRef<Symbol *> syms = file->getMutableSymbols();
for (size_t i = 0, e = syms.size(); i != e; ++i) {
StringRef symName = syms[i]->getName();
if (symtab.cmseSymMap.count(symName))
syms[i] = symtab.cmseSymMap[symName].acleSeSym;
if (ctx.symtab->cmseSymMap.count(symName))
syms[i] = ctx.symtab->cmseSymMap[symName].acleSeSym;
}
});
}
@ -1332,26 +1332,26 @@ ArmCmseSGSection::ArmCmseSGSection()
/*alignment=*/32, ".gnu.sgstubs") {
entsize = ACLESESYM_SIZE;
// The range of addresses used in the CMSE import library should be fixed.
for (auto &[_, sym] : symtab.cmseImportLib) {
for (auto &[_, sym] : ctx.symtab->cmseImportLib) {
if (impLibMaxAddr <= sym->value)
impLibMaxAddr = sym->value + sym->size;
}
if (symtab.cmseSymMap.empty())
if (ctx.symtab->cmseSymMap.empty())
return;
addMappingSymbol();
for (auto &[_, entryFunc] : symtab.cmseSymMap)
for (auto &[_, entryFunc] : ctx.symtab->cmseSymMap)
addSGVeneer(cast<Defined>(entryFunc.acleSeSym),
cast<Defined>(entryFunc.sym));
for (auto &[_, sym] : symtab.cmseImportLib) {
if (!symtab.inCMSEOutImpLib.count(sym->getName()))
for (auto &[_, sym] : ctx.symtab->cmseImportLib) {
if (!ctx.symtab->inCMSEOutImpLib.count(sym->getName()))
warn("entry function '" + sym->getName() +
"' from CMSE import library is not present in secure application");
}
if (!symtab.cmseImportLib.empty() && ctx.arg.cmseOutputLib.empty()) {
for (auto &[_, entryFunc] : symtab.cmseSymMap) {
if (!ctx.symtab->cmseImportLib.empty() && ctx.arg.cmseOutputLib.empty()) {
for (auto &[_, entryFunc] : ctx.symtab->cmseSymMap) {
Symbol *sym = entryFunc.sym;
if (!symtab.inCMSEOutImpLib.count(sym->getName()))
if (!ctx.symtab->inCMSEOutImpLib.count(sym->getName()))
warn("new entry function '" + sym->getName() +
"' introduced but no output import library specified");
}
@ -1360,8 +1360,8 @@ ArmCmseSGSection::ArmCmseSGSection()
void ArmCmseSGSection::addSGVeneer(Symbol *acleSeSym, Symbol *sym) {
entries.emplace_back(acleSeSym, sym);
if (symtab.cmseImportLib.count(sym->getName()))
symtab.inCMSEOutImpLib[sym->getName()] = true;
if (ctx.symtab->cmseImportLib.count(sym->getName()))
ctx.symtab->inCMSEOutImpLib[sym->getName()] = true;
// Symbol addresses different, nothing to do.
if (acleSeSym->file != sym->file ||
cast<Defined>(*acleSeSym).value != cast<Defined>(*sym).value)
@ -1369,8 +1369,8 @@ void ArmCmseSGSection::addSGVeneer(Symbol *acleSeSym, Symbol *sym) {
// Only secure symbols with values equal to that of it's non-secure
// counterpart needs to be in the .gnu.sgstubs section.
ArmCmseSGVeneer *ss = nullptr;
if (symtab.cmseImportLib.count(sym->getName())) {
Defined *impSym = symtab.cmseImportLib[sym->getName()];
if (ctx.symtab->cmseImportLib.count(sym->getName())) {
Defined *impSym = ctx.symtab->cmseImportLib[sym->getName()];
ss = make<ArmCmseSGVeneer>(sym, acleSeSym, impSym->value);
} else {
ss = make<ArmCmseSGVeneer>(sym, acleSeSym);
@ -1451,12 +1451,12 @@ template <typename ELFT> void elf::writeARMCmseImportLib() {
osIsPairs.emplace_back(make<OutputSection>(impSymTab->name, 0, 0), impSymTab);
osIsPairs.emplace_back(make<OutputSection>(shstrtab->name, 0, 0), shstrtab);
std::sort(symtab.cmseSymMap.begin(), symtab.cmseSymMap.end(),
std::sort(ctx.symtab->cmseSymMap.begin(), ctx.symtab->cmseSymMap.end(),
[](const auto &a, const auto &b) -> bool {
return a.second.sym->getVA() < b.second.sym->getVA();
});
// Copy the secure gateway entry symbols to the import library symbol table.
for (auto &p : symtab.cmseSymMap) {
for (auto &p : ctx.symtab->cmseSymMap) {
Defined *d = cast<Defined>(p.second.sym);
impSymTab->addSymbol(makeDefined(
ctx.internalFile, d->getName(), d->computeBinding(),

2
lld/ELF/Arch/PPC64.cpp
View File

@ -251,7 +251,7 @@ void elf::writePrefixedInstruction(uint8_t *loc, uint64_t insn) {
static bool addOptional(StringRef name, uint64_t value,
std::vector<Defined *> &defined) {
Symbol *sym = symtab.find(name);
Symbol *sym = ctx.symtab->find(name);
if (!sym || sym->isDefined())
return false;
sym->resolve(Defined{ctx.internalFile, StringRef(), STB_GLOBAL, STV_HIDDEN,

2
lld/ELF/Config.h
View File

@ -44,6 +44,7 @@ class InputSectionBase;
class EhInputSection;
class Defined;
class Symbol;
class SymbolTable;
class BitcodeCompiler;
class OutputSection;
class LinkerScript;
@ -600,6 +601,7 @@ struct Ctx {
Defined *tlsModuleBase;
};
ElfSym sym;
std::unique_ptr<SymbolTable> symtab;
SmallVector<std::unique_ptr<MemoryBuffer>> memoryBuffers;
SmallVector<ELFFileBase *, 0> objectFiles;

43
lld/ELF/Driver.cpp
View File

@ -109,6 +109,7 @@ void Ctx::reset() {
in.reset();
sym = ElfSym{};
symtab = std::make_unique<SymbolTable>();
memoryBuffers.clear();
objectFiles.clear();
@ -155,7 +156,6 @@ bool link(ArrayRef<const char *> args, llvm::raw_ostream &stdoutOS,
context->e.cleanupCallback = []() {
elf::ctx.reset();
elf::ctx.partitions.emplace_back();
symtab = SymbolTable();
SharedFile::vernauxNum = 0;
};
@ -167,6 +167,7 @@ bool link(ArrayRef<const char *> args, llvm::raw_ostream &stdoutOS,
LinkerScript script(ctx);
ctx.script = &script;
ctx.symAux.emplace_back();
ctx.symtab = std::make_unique<SymbolTable>();
ctx.partitions.clear();
ctx.partitions.emplace_back();
@ -2194,7 +2195,7 @@ static void handleUndefinedGlob(Ctx &ctx, StringRef arg) {
// Calling sym->extract() in the loop is not safe because it may add new
// symbols to the symbol table, invalidating the current iterator.
SmallVector<Symbol *, 0> syms;
for (Symbol *sym : symtab.getSymbols())
for (Symbol *sym : ctx.symtab->getSymbols())
if (!sym->isPlaceholder() && pat->match(sym->getName()))
syms.push_back(sym);
@ -2203,7 +2204,7 @@ static void handleUndefinedGlob(Ctx &ctx, StringRef arg) {
}
static void handleLibcall(Ctx &ctx, StringRef name) {
Symbol *sym = symtab.find(name);
Symbol *sym = ctx.symtab->find(name);
if (sym && sym->isLazy() && isa<BitcodeFile>(sym->file)) {
if (!ctx.arg.whyExtract.empty())
ctx.whyExtractRecords.emplace_back("<libcall>", sym->file, *sym);
@ -2390,7 +2391,7 @@ template <class ELFT>
static void findKeepUniqueSections(Ctx &ctx, opt::InputArgList &args) {
for (auto *arg : args.filtered(OPT_keep_unique)) {
StringRef name = arg->getValue();
auto *d = dyn_cast_or_null<Defined>(symtab.find(name));
auto *d = dyn_cast_or_null<Defined>(ctx.symtab->find(name));
if (!d || !d->section) {
warn("could not find symbol " + name + " to keep unique");
continue;
@ -2405,7 +2406,7 @@ static void findKeepUniqueSections(Ctx &ctx, opt::InputArgList &args) {
// Symbols in the dynsym could be address-significant in other executables
// or DSOs, so we conservatively mark them as address-significant.
for (Symbol *sym : symtab.getSymbols())
for (Symbol *sym : ctx.symtab->getSymbols())
if (sym->includeInDynsym())
markAddrsig(sym);
@ -2574,24 +2575,24 @@ static std::vector<WrappedSymbol> addWrappedSymbols(opt::InputArgList &args) {
if (!seen.insert(name).second)
continue;
Symbol *sym = symtab.find(name);
Symbol *sym = ctx.symtab->find(name);
if (!sym)
continue;
Symbol *wrap =
symtab.addUnusedUndefined(saver().save("__wrap_" + name), sym->binding);
Symbol *wrap = ctx.symtab->addUnusedUndefined(
saver().save("__wrap_" + name), sym->binding);
// If __real_ is referenced, pull in the symbol if it is lazy. Do this after
// processing __wrap_ as that may have referenced __real_.
StringRef realName = saver().save("__real_" + name);
if (Symbol *real = symtab.find(realName)) {
symtab.addUnusedUndefined(name, sym->binding);
if (Symbol *real = ctx.symtab->find(realName)) {
ctx.symtab->addUnusedUndefined(name, sym->binding);
// Update sym's binding, which will replace real's later in
// SymbolTable::wrap.
sym->binding = real->binding;
}
Symbol *real = symtab.addUnusedUndefined(realName);
Symbol *real = ctx.symtab->addUnusedUndefined(realName);
v.push_back({sym, real, wrap});
// We want to tell LTO not to inline symbols to be overwritten
@ -2626,7 +2627,7 @@ static void combineVersionedSymbol(Symbol &sym,
//
// * There is a definition of foo@v1 and foo@@v1.
// * There is a definition of foo@v1 and foo.
Defined *sym2 = dyn_cast_or_null<Defined>(symtab.find(sym.getName()));
Defined *sym2 = dyn_cast_or_null<Defined>(ctx.symtab->find(sym.getName()));
if (!sym2)
return;
const char *suffix2 = sym2->getVersionSuffix();
@ -2681,7 +2682,7 @@ static void redirectSymbols(Ctx &ctx, ArrayRef<WrappedSymbol> wrapped) {
// symbols with a non-default version (foo@v1) and check whether it should be
// combined with foo or foo@@v1.
if (ctx.arg.versionDefinitions.size() > 2)
for (Symbol *sym : symtab.getSymbols())
for (Symbol *sym : ctx.symtab->getSymbols())
if (sym->hasVersionSuffix)
combineVersionedSymbol(*sym, map);
@ -2697,7 +2698,7 @@ static void redirectSymbols(Ctx &ctx, ArrayRef<WrappedSymbol> wrapped) {
// Update pointers in the symbol table.
for (const WrappedSymbol &w : wrapped)
symtab.wrap(w.sym, w.real, w.wrap);
ctx.symtab->wrap(w.sym, w.real, w.wrap);
}
static void reportMissingFeature(StringRef config, const Twine &report) {
@ -2861,14 +2862,14 @@ template <class ELFT> void LinkerDriver::link(opt::InputArgList &args) {
// Handle --trace-symbol.
for (auto *arg : args.filtered(OPT_trace_symbol))
symtab.insert(arg->getValue())->traced = true;
ctx.symtab->insert(arg->getValue())->traced = true;
ctx.internalFile = createInternalFile("<internal>");
// Handle -u/--undefined before input files. If both a.a and b.so define foo,
// -u foo a.a b.so will extract a.a.
for (StringRef name : ctx.arg.undefined)
symtab.addUnusedUndefined(name)->referenced = true;
ctx.symtab->addUnusedUndefined(name)->referenced = true;
parseFiles(files, armCmseImpLib);
@ -2876,7 +2877,7 @@ template <class ELFT> void LinkerDriver::link(opt::InputArgList &args) {
ctx.arg.hasDynSymTab = !ctx.sharedFiles.empty() || ctx.arg.isPic;
// If an entry symbol is in a static archive, pull out that file now.
if (Symbol *sym = symtab.find(ctx.arg.entry))
if (Symbol *sym = ctx.symtab->find(ctx.arg.entry))
handleUndefined(ctx, sym, "--entry");
// Handle the `--undefined-glob <pattern>` options.
@ -2890,13 +2891,13 @@ template <class ELFT> void LinkerDriver::link(opt::InputArgList &args) {
// Prevent LTO from removing any definition referenced by -u.
for (StringRef name : ctx.arg.undefined)
if (Defined *sym = dyn_cast_or_null<Defined>(symtab.find(name)))
if (Defined *sym = dyn_cast_or_null<Defined>(ctx.symtab->find(name)))
sym->isUsedInRegularObj = true;
// Mark -init and -fini symbols so that the LTO doesn't eliminate them.
if (Symbol *sym = dyn_cast_or_null<Defined>(symtab.find(ctx.arg.init)))
if (Symbol *sym = dyn_cast_or_null<Defined>(ctx.symtab->find(ctx.arg.init)))
sym->isUsedInRegularObj = true;
if (Symbol *sym = dyn_cast_or_null<Defined>(symtab.find(ctx.arg.fini)))
if (Symbol *sym = dyn_cast_or_null<Defined>(ctx.symtab->find(ctx.arg.fini)))
sym->isUsedInRegularObj = true;
// If any of our inputs are bitcode files, the LTO code generator may create
@ -2977,7 +2978,7 @@ template <class ELFT> void LinkerDriver::link(opt::InputArgList &args) {
// name "foo@ver1") rather do harm, so we don't call this if -r is given.
if (!ctx.arg.relocatable) {
llvm::TimeTraceScope timeScope("Process symbol versions");
symtab.scanVersionScript();
ctx.symtab->scanVersionScript();
}
// Skip the normal linked output if some LTO options are specified.

4
lld/ELF/ICF.cpp
View File

@ -468,7 +468,7 @@ template <class ELFT> void ICF<ELFT>::run() {
// cannot be merged with the later computeIsPreemptible() pass which is used
// by scanRelocations().
if (ctx.arg.hasDynSymTab)
for (Symbol *sym : symtab.getSymbols())
for (Symbol *sym : ctx.symtab->getSymbols())
sym->isPreemptible = computeIsPreemptible(*sym);
// Two text sections may have identical content and relocations but different
@ -568,7 +568,7 @@ template <class ELFT> void ICF<ELFT>::run() {
d->folded = true;
}
};
for (Symbol *sym : symtab.getSymbols())
for (Symbol *sym : ctx.symtab->getSymbols())
fold(sym);
parallelForEach(ctx.objectFiles, [&](ELFFileBase *file) {
for (Symbol *sym : file->getLocalSymbols())

49
lld/ELF/InputFiles.cpp
View File

@ -667,10 +667,10 @@ template <class ELFT> void ObjFile<ELFT>::parse(bool ignoreComdats) {
if (flag && flag != GRP_COMDAT)
fatal(toString(this) + ": unsupported SHT_GROUP format");
bool keepGroup =
(flag & GRP_COMDAT) == 0 || ignoreComdats ||
symtab.comdatGroups.try_emplace(CachedHashStringRef(signature), this)
.second;
bool keepGroup = (flag & GRP_COMDAT) == 0 || ignoreComdats ||
ctx.symtab->comdatGroups
.try_emplace(CachedHashStringRef(signature), this)
.second;
if (keepGroup) {
if (!ctx.arg.resolveGroups)
this->sections[i] = createInputSection(
@ -817,8 +817,8 @@ void ObjFile<ELFT>::initializeSections(bool ignoreComdats,
ArrayRef<Elf_Word> entries =
cantFail(obj.template getSectionContentsAsArray<Elf_Word>(sec));
if ((entries[0] & GRP_COMDAT) == 0 || ignoreComdats ||
symtab.comdatGroups.find(CachedHashStringRef(signature))->second ==
this)
ctx.symtab->comdatGroups.find(CachedHashStringRef(signature))
->second == this)
selectedGroups.push_back(entries);
break;
}
@ -1130,7 +1130,8 @@ void ObjFile<ELFT>::initializeSymbols(const object::ELFFile<ELFT> &obj) {
// Some entries have been filled by LazyObjFile.
for (size_t i = firstGlobal, end = eSyms.size(); i != end; ++i)
if (!symbols[i])
symbols[i] = symtab.insert(CHECK(eSyms[i].getName(stringTable), this));
symbols[i] =
ctx.symtab->insert(CHECK(eSyms[i].getName(stringTable), this));
// Perform symbol resolution on non-local symbols.
SmallVector<unsigned, 32> undefineds;
@ -1508,7 +1509,7 @@ template <class ELFT> void SharedFile::parse() {
DenseMap<CachedHashStringRef, SharedFile *>::iterator it;
bool wasInserted;
std::tie(it, wasInserted) =
symtab.soNames.try_emplace(CachedHashStringRef(soName), this);
ctx.symtab->soNames.try_emplace(CachedHashStringRef(soName), this);
// If a DSO appears more than once on the command line with and without
// --as-needed, --no-as-needed takes precedence over --as-needed because a
@ -1574,7 +1575,7 @@ template <class ELFT> void SharedFile::parse() {
name = saver().save(
(name + "@" + verName).toStringRef(versionedNameBuffer));
}
Symbol *s = symtab.addSymbol(
Symbol *s = ctx.symtab->addSymbol(
Undefined{this, name, sym.getBinding(), sym.st_other, sym.getType()});
s->exportDynamic = true;
if (sym.getBinding() != STB_WEAK &&
@ -1598,7 +1599,7 @@ template <class ELFT> void SharedFile::parse() {
uint32_t alignment = getAlignment<ELFT>(sections, sym);
if (ver == idx) {
auto *s = symtab.addSymbol(
auto *s = ctx.symtab->addSymbol(
SharedSymbol{*this, name, sym.getBinding(), sym.st_other,
sym.getType(), sym.st_value, sym.st_size, alignment});
s->dsoDefined = true;
@ -1616,7 +1617,7 @@ template <class ELFT> void SharedFile::parse() {
reinterpret_cast<const Elf_Verdef *>(verdefs[idx])->getAux()->vda_name;
versionedNameBuffer.clear();
name = (name + "@" + verName).toStringRef(versionedNameBuffer);
auto *s = symtab.addSymbol(
auto *s = ctx.symtab->addSymbol(
SharedSymbol{*this, saver().save(name), sym.getBinding(), sym.st_other,
sym.getType(), sym.st_value, sym.st_size, alignment});
s->dsoDefined = true;
@ -1751,7 +1752,7 @@ createBitcodeSymbol(Symbol *&sym, const std::vector<bool> &keptComdats,
// this way LTO can reference the same string saver's copy rather than
// keeping copies of its own.
objSym.Name = uniqueSaver().save(objSym.getName());
sym = symtab.insert(objSym.getName());
sym = ctx.symtab->insert(objSym.getName());
}
int c = objSym.getComdatIndex();
@ -1778,7 +1779,7 @@ void BitcodeFile::parse() {
for (std::pair<StringRef, Comdat::SelectionKind> s : obj->getComdatTable()) {
keptComdats.push_back(
s.second == Comdat::NoDeduplicate ||
symtab.comdatGroups.try_emplace(CachedHashStringRef(s.first), this)
ctx.symtab->comdatGroups.try_emplace(CachedHashStringRef(s.first), this)
.second);
}
@ -1810,7 +1811,7 @@ void BitcodeFile::parseLazy() {
// keeping copies of its own.
irSym.Name = uniqueSaver().save(irSym.getName());
if (!irSym.isUndefined()) {
auto *sym = symtab.insert(irSym.getName());
auto *sym = ctx.symtab->insert(irSym.getName());
sym->resolve(LazySymbol{*this});
symbols[i] = sym;
}
@ -1847,15 +1848,15 @@ void BinaryFile::parse() {
llvm::StringSaver &saver = lld::saver();
symtab.addAndCheckDuplicate(Defined{this, saver.save(s + "_start"),
STB_GLOBAL, STV_DEFAULT, STT_OBJECT, 0, 0,
section});
symtab.addAndCheckDuplicate(Defined{this, saver.save(s + "_end"), STB_GLOBAL,
STV_DEFAULT, STT_OBJECT, data.size(), 0,
section});
symtab.addAndCheckDuplicate(Defined{this, saver.save(s + "_size"), STB_GLOBAL,
STV_DEFAULT, STT_OBJECT, data.size(), 0,
nullptr});
ctx.symtab->addAndCheckDuplicate(Defined{this, saver.save(s + "_start"),
STB_GLOBAL, STV_DEFAULT, STT_OBJECT,
0, 0, section});
ctx.symtab->addAndCheckDuplicate(Defined{this, saver.save(s + "_end"),
STB_GLOBAL, STV_DEFAULT, STT_OBJECT,
data.size(), 0, section});
ctx.symtab->addAndCheckDuplicate(Defined{this, saver.save(s + "_size"),
STB_GLOBAL, STV_DEFAULT, STT_OBJECT,
data.size(), 0, nullptr});
}
InputFile *elf::createInternalFile(StringRef name) {
@ -1902,7 +1903,7 @@ template <class ELFT> void ObjFile<ELFT>::parseLazy() {
for (size_t i = firstGlobal, end = eSyms.size(); i != end; ++i) {
if (eSyms[i].st_shndx == SHN_UNDEF)
continue;
symbols[i] = symtab.insert(CHECK(eSyms[i].getName(stringTable), this));
symbols[i] = ctx.symtab->insert(CHECK(eSyms[i].getName(stringTable), this));
symbols[i]->resolve(LazySymbol{*this});
if (!lazy)
break;

2
lld/ELF/InputSection.cpp
View File

@ -1129,7 +1129,7 @@ static void switchMorestackCallsToMorestackNonSplit(
// If the target adjusted a function's prologue, all calls to
// __morestack inside that function should be switched to
// __morestack_non_split.
Symbol *moreStackNonSplit = symtab.find("__morestack_non_split");
Symbol *moreStackNonSplit = ctx.symtab->find("__morestack_non_split");
if (!moreStackNonSplit) {
error("mixing split-stack objects requires a definition of "
"__morestack_non_split");

2
lld/ELF/LTO.cpp
View File

@ -200,7 +200,7 @@ BitcodeCompiler::BitcodeCompiler(Ctx &ctx) : ctx(ctx) {
// Initialize usedStartStop.
if (ctx.bitcodeFiles.empty())
return;
for (Symbol *sym : symtab.getSymbols()) {
for (Symbol *sym : ctx.symtab->getSymbols()) {
if (sym->isPlaceholder())
continue;
StringRef s = sym->getName();

12
lld/ELF/LinkerScript.cpp
View File

@ -230,7 +230,7 @@ void LinkerScript::addSymbol(SymbolAssignment *cmd) {
Defined newSym(createInternalFile(cmd->location), cmd->name, STB_GLOBAL,
visibility, value.type, symValue, 0, sec);
Symbol *sym = symtab.insert(cmd->name);
Symbol *sym = ctx.symtab->insert(cmd->name);
sym->mergeProperties(newSym);
newSym.overwrite(*sym);
sym->isUsedInRegularObj = true;
@ -249,7 +249,7 @@ static void declareSymbol(SymbolAssignment *cmd) {
// If the symbol is already defined, its order is 0 (with absence indicating
// 0); otherwise it's assigned the order of the SymbolAssignment.
Symbol *sym = symtab.insert(cmd->name);
Symbol *sym = ctx.symtab->insert(cmd->name);
if (!sym->isDefined())
ctx.scriptSymOrder.insert({sym, cmd->symOrder});
@ -1682,7 +1682,7 @@ ExprValue LinkerScript::getSymbolValue(StringRef name, const Twine &loc) {
return 0;
}
if (Symbol *sym = symtab.find(name)) {
if (Symbol *sym = ctx.symtab->find(name)) {
if (auto *ds = dyn_cast<Defined>(sym)) {
ExprValue v{ds->section, false, ds->value, loc};
// Retain the original st_type, so that the alias will get the same
@ -1781,8 +1781,8 @@ void LinkerScript::checkFinalScriptConditions() const {
void LinkerScript::addScriptReferencedSymbolsToSymTable() {
// Some symbols (such as __ehdr_start) are defined lazily only when there
// are undefined symbols for them, so we add these to trigger that logic.
auto reference = [](StringRef name) {
Symbol *sym = symtab.addUnusedUndefined(name);
auto reference = [&ctx = ctx](StringRef name) {
Symbol *sym = ctx.symtab->addUnusedUndefined(name);
sym->isUsedInRegularObj = true;
sym->referenced = true;
};
@ -1811,6 +1811,6 @@ void LinkerScript::addScriptReferencedSymbolsToSymTable() {
}
bool LinkerScript::shouldAddProvideSym(StringRef symName) {
Symbol *sym = symtab.find(symName);
Symbol *sym = elf::ctx.symtab->find(symName);
return sym && !sym->isDefined() && !sym->isCommon();
}

24
lld/ELF/MarkLive.cpp
View File

@ -219,7 +219,7 @@ template <class ELFT> void MarkLive<ELFT>::run() {
// Preserve externally-visible symbols if the symbols defined by this
// file can interpose other ELF file's symbols at runtime.
for (Symbol *sym : symtab.getSymbols())
for (Symbol *sym : ctx.symtab->getSymbols())
if (sym->includeInDynsym() && sym->partition == partition)
markSymbol(sym);
@ -229,16 +229,16 @@ template <class ELFT> void MarkLive<ELFT>::run() {
return;
}
markSymbol(symtab.find(ctx.arg.entry));
markSymbol(symtab.find(ctx.arg.init));
markSymbol(symtab.find(ctx.arg.fini));
markSymbol(ctx.symtab->find(ctx.arg.entry));
markSymbol(ctx.symtab->find(ctx.arg.init));
markSymbol(ctx.symtab->find(ctx.arg.fini));
for (StringRef s : ctx.arg.undefined)
markSymbol(symtab.find(s));
markSymbol(ctx.symtab->find(s));
for (StringRef s : ctx.script->referencedSymbols)
markSymbol(symtab.find(s));
for (auto [symName, _] : symtab.cmseSymMap) {
markSymbol(symtab.cmseSymMap[symName].sym);
markSymbol(symtab.cmseSymMap[symName].acleSeSym);
markSymbol(ctx.symtab->find(s));
for (auto [symName, _] : ctx.symtab->cmseSymMap) {
markSymbol(ctx.symtab->cmseSymMap[symName].sym);
markSymbol(ctx.symtab->cmseSymMap[symName].acleSeSym);
}
// Mark .eh_frame sections as live because there are usually no relocations
@ -350,8 +350,8 @@ template <class ELFT> void MarkLive<ELFT>::moveToMain() {
for (InputSectionBase *sec : ctx.inputSections) {
if (!sec->isLive() || !isValidCIdentifier(sec->name))
continue;
if (symtab.find(("__start_" + sec->name).str()) ||
symtab.find(("__stop_" + sec->name).str()))
if (ctx.symtab->find(("__start_" + sec->name).str()) ||
ctx.symtab->find(("__stop_" + sec->name).str()))
enqueue(sec, 0);
}
@ -366,7 +366,7 @@ template <class ELFT> void elf::markLive() {
// If --gc-sections is not given, retain all input sections.
if (!ctx.arg.gcSections) {
// If a DSO defines a symbol referenced in a regular object, it is needed.
for (Symbol *sym : symtab.getSymbols())
for (Symbol *sym : ctx.symtab->getSymbols())
if (auto *s = dyn_cast<SharedSymbol>(sym))
if (s->isUsedInRegularObj && !s->isWeak())
cast<SharedFile>(s->file)->isNeeded = true;

14
lld/ELF/Relocations.cpp
View File

@ -295,7 +295,7 @@ static SmallSet<SharedSymbol *, 4> getSymbolsAt(SharedSymbol &ss) {
s.getType() == STT_TLS || s.st_value != ss.value)
continue;
StringRef name = check(s.getName(file.getStringTable()));
Symbol *sym = symtab.find(name);
Symbol *sym = ctx.symtab->find(name);
if (auto *alias = dyn_cast_or_null<SharedSymbol>(sym))
ret.insert(alias);
}
@ -545,7 +545,7 @@ static std::string maybeReportDiscarded(Undefined &sym) {
// If the discarded section is a COMDAT.
StringRef signature = file->getShtGroupSignature(objSections, elfSec);
if (const InputFile *prevailing =
symtab.comdatGroups.lookup(CachedHashStringRef(signature))) {
ctx.symtab->comdatGroups.lookup(CachedHashStringRef(signature))) {
msg += "\n>>> section group signature: " + signature.str() +
"\n>>> prevailing definition is in " + toString(prevailing);
if (sym.nonPrevailing) {
@ -618,7 +618,7 @@ static const Symbol *getAlternativeSpelling(const Undefined &sym,
return s;
// If in the symbol table and not undefined.
if (const Symbol *s = symtab.find(newName))
if (const Symbol *s = ctx.symtab->find(newName))
if (!s->isUndefined())
return s;
@ -667,7 +667,7 @@ static const Symbol *getAlternativeSpelling(const Undefined &sym,
for (auto &it : map)
if (name.equals_insensitive(it.first))
return it.second;
for (Symbol *sym : symtab.getSymbols())
for (Symbol *sym : ctx.symtab->getSymbols())
if (!sym->isUndefined() && name.equals_insensitive(sym->getName()))
return sym;
@ -693,7 +693,7 @@ static const Symbol *getAlternativeSpelling(const Undefined &sym,
break;
}
if (!s)
for (Symbol *sym : symtab.getSymbols())
for (Symbol *sym : ctx.symtab->getSymbols())
if (canSuggestExternCForCXX(name, sym->getName())) {
s = sym;
break;
@ -1870,7 +1870,7 @@ void elf::postScanRelocations() {
}
assert(ctx.symAux.size() == 1);
for (Symbol *sym : symtab.getSymbols())
for (Symbol *sym : ctx.symtab->getSymbols())
fn(*sym);
// Local symbols may need the aforementioned non-preemptible ifunc and GOT
@ -2384,7 +2384,7 @@ bool elf::hexagonNeedsTLSSymbol(ArrayRef<OutputSection *> outputSections) {
}
void elf::hexagonTLSSymbolUpdate(ArrayRef<OutputSection *> outputSections) {
Symbol *sym = symtab.find("__tls_get_addr");
Symbol *sym = ctx.symtab->find("__tls_get_addr");
if (!sym)
return;
bool needEntry = true;

2
lld/ELF/ScriptParser.cpp
View File

@ -1581,7 +1581,7 @@ Expr ScriptParser::readPrimary() {
// script, it must happen before this DEFINED.
auto order = ctx.scriptSymOrderCounter++;
return [=, &ctx = this->ctx] {
Symbol *s = symtab.find(name);
Symbol *s = ctx.symtab->find(name);
return s && s->isDefined() && ctx.scriptSymOrder.lookup(s) < order ? 1
: 0;
};

2
lld/ELF/SymbolTable.cpp
View File

@ -29,8 +29,6 @@ using namespace llvm::ELF;
using namespace lld;
using namespace lld::elf;
SymbolTable elf::symtab;
void SymbolTable::wrap(Symbol *sym, Symbol *real, Symbol *wrap) {
// Redirect __real_foo to the original foo and foo to the original __wrap_foo.
int &idx1 = symMap[CachedHashStringRef(sym->getName())];

2
lld/ELF/SymbolTable.h
View File

@ -104,8 +104,6 @@ private:
std::optional<llvm::StringMap<SmallVector<Symbol *, 0>>> demangledSyms;
};
LLVM_LIBRARY_VISIBILITY extern SymbolTable symtab;
} // namespace lld::elf
#endif

15
lld/ELF/SyntheticSections.cpp
View File

@ -1509,10 +1509,10 @@ DynamicSection<ELFT>::computeContents() {
addInt(DT_FINI_ARRAYSZ, ctx.out.finiArray->size);
}
if (Symbol *b = symtab.find(ctx.arg.init))
if (Symbol *b = ctx.symtab->find(ctx.arg.init))
if (b->isDefined())
addInt(DT_INIT, b->getVA());
if (Symbol *b = symtab.find(ctx.arg.fini))
if (Symbol *b = ctx.symtab->find(ctx.arg.fini))
if (b->isDefined())
addInt(DT_FINI, b->getVA());
}
@ -1692,9 +1692,9 @@ void RelocationBaseSection::finalizeContents() {
}
}
void DynamicReloc::computeRaw(SymbolTableBaseSection *symtab) {
void DynamicReloc::computeRaw(SymbolTableBaseSection *symt) {
r_offset = getOffset();
r_sym = getSymIndex(symtab);
r_sym = getSymIndex(symt);
addend = computeAddend();
kind = AddendOnly; // Catch errors
}
@ -2327,8 +2327,9 @@ SymtabShndxSection::SymtabShndxSection()
void SymtabShndxSection::writeTo(uint8_t *buf) {
// We write an array of 32 bit values, where each value has 1:1 association
// with an entry in .symtab. If the corresponding entry contains SHN_XINDEX,
// we need to write actual index, otherwise, we must write SHN_UNDEF(0).
// with an entry in ctx.in.symTab if the corresponding entry contains
// SHN_XINDEX, we need to write actual index, otherwise, we must write
// SHN_UNDEF(0).
buf += 4; // Ignore .symtab[0] entry.
for (const SymbolTableEntry &entry : ctx.in.symTab->getSymbols()) {
if (!getCommonSec(entry.sym) && getSymSectionIndex(entry.sym) == SHN_XINDEX)
@ -4640,7 +4641,7 @@ static OutputSection *findSection(StringRef name) {
static Defined *addOptionalRegular(StringRef name, SectionBase *sec,
uint64_t val, uint8_t stOther = STV_HIDDEN) {
Symbol *s = symtab.find(name);
Symbol *s = ctx.symtab->find(name);
if (!s || s->isDefined() || s->isCommon())
return nullptr;

2
lld/ELF/SyntheticSections.h
View File

@ -459,7 +459,7 @@ public:
/// address/the address of the corresponding GOT entry/etc.
int64_t computeAddend() const;
void computeRaw(SymbolTableBaseSection *symtab);
void computeRaw(SymbolTableBaseSection *symt);
Symbol *sym;
const OutputSection *outputSec = nullptr;

32
lld/ELF/Writer.cpp
View File

@ -141,7 +141,7 @@ void elf::copySectionsIntoPartitions() {
static Defined *addOptionalRegular(StringRef name, SectionBase *sec,
uint64_t val, uint8_t stOther = STV_HIDDEN) {
Symbol *s = symtab.find(name);
Symbol *s = ctx.symtab->find(name);
if (!s || s->isDefined() || s->isCommon())
return nullptr;
@ -158,8 +158,8 @@ void elf::addReservedSymbols() {
if (ctx.arg.emachine == EM_MIPS) {
auto addAbsolute = [](StringRef name) {
Symbol *sym =
symtab.addSymbol(Defined{ctx.internalFile, name, STB_GLOBAL,
STV_HIDDEN, STT_NOTYPE, 0, 0, nullptr});
ctx.symtab->addSymbol(Defined{ctx.internalFile, name, STB_GLOBAL,
STV_HIDDEN, STT_NOTYPE, 0, 0, nullptr});
sym->isUsedInRegularObj = true;
return cast<Defined>(sym);
};
@ -172,14 +172,14 @@ void elf::addReservedSymbols() {
// On MIPS O32 ABI, _gp_disp is a magic symbol designates offset between
// start of function and 'gp' pointer into GOT.
if (symtab.find("_gp_disp"))
if (ctx.symtab->find("_gp_disp"))
ctx.sym.mipsGpDisp = addAbsolute("_gp_disp");
// The __gnu_local_gp is a magic symbol equal to the current value of 'gp'
// pointer. This symbol is used in the code generated by .cpload pseudo-op
// in case of using -mno-shared option.
// https://sourceware.org/ml/binutils/2004-12/msg00094.html
if (symtab.find("__gnu_local_gp"))
if (ctx.symtab->find("__gnu_local_gp"))
ctx.sym.mipsLocalGp = addAbsolute("__gnu_local_gp");
} else if (ctx.arg.emachine == EM_PPC) {
// glibc *crt1.o has a undefined reference to _SDA_BASE_. Since we don't
@ -200,7 +200,7 @@ void elf::addReservedSymbols() {
StringRef gotSymName =
(ctx.arg.emachine == EM_PPC64) ? ".TOC." : "_GLOBAL_OFFSET_TABLE_";
if (Symbol *s = symtab.find(gotSymName)) {
if (Symbol *s = ctx.symtab->find(gotSymName)) {
if (s->isDefined()) {
error(toString(s->file) + " cannot redefine linker defined symbol '" +
gotSymName + "'");
@ -273,7 +273,7 @@ static void demoteDefined(Defined &sym, DenseMap<SectionBase *, size_t> &map) {
static void demoteSymbolsAndComputeIsPreemptible() {
llvm::TimeTraceScope timeScope("Demote symbols");
DenseMap<InputFile *, DenseMap<SectionBase *, size_t>> sectionIndexMap;
for (Symbol *sym : symtab.getSymbols()) {
for (Symbol *sym : ctx.symtab->getSymbols()) {
if (auto *d = dyn_cast<Defined>(sym)) {
if (d->section && !d->section->isLive())
demoteDefined(*d, sectionIndexMap[d->file]);
@ -1106,7 +1106,7 @@ static DenseMap<const InputSectionBase *, int> buildSectionOrder() {
// We want both global and local symbols. We get the global ones from the
// symbol table and iterate the object files for the local ones.
for (Symbol *sym : symtab.getSymbols())
for (Symbol *sym : ctx.symtab->getSymbols())
addSym(*sym);
for (ELFFileBase *file : ctx.objectFiles)
@ -1724,7 +1724,7 @@ template <class ELFT> void Writer<ELFT>::finalizeSections() {
// Even the author of gold doesn't remember why gold behaves that way.
// https://sourceware.org/ml/binutils/2002-03/msg00360.html
if (ctx.mainPart->dynamic->parent) {
Symbol *s = symtab.addSymbol(Defined{
Symbol *s = ctx.symtab->addSymbol(Defined{
ctx.internalFile, "_DYNAMIC", STB_WEAK, STV_HIDDEN, STT_NOTYPE,
/*value=*/0, /*size=*/0, ctx.mainPart->dynamic.get()});
s->isUsedInRegularObj = true;
@ -1745,7 +1745,7 @@ template <class ELFT> void Writer<ELFT>::finalizeSections() {
// Set riscvGlobalPointer to be used by the optional global pointer
// relaxation.
if (ctx.arg.relaxGP) {
Symbol *s = symtab.find("__global_pointer$");
Symbol *s = ctx.symtab->find("__global_pointer$");
if (s && s->isDefined())
ctx.sym.riscvGlobalPointer = cast<Defined>(s);
}
@ -1764,7 +1764,7 @@ template <class ELFT> void Writer<ELFT>::finalizeSections() {
// 2) is special cased in @tpoff computation. To satisfy 1), we define it
// as an absolute symbol of zero. This is different from GNU linkers which
// define _TLS_MODULE_BASE_ relative to the first TLS section.
Symbol *s = symtab.find("_TLS_MODULE_BASE_");
Symbol *s = ctx.symtab->find("_TLS_MODULE_BASE_");
if (s && s->isUndefined()) {
s->resolve(Defined{ctx.internalFile, StringRef(), STB_GLOBAL,
STV_HIDDEN, STT_TLS, /*value=*/0, 0,
@ -1832,7 +1832,7 @@ template <class ELFT> void Writer<ELFT>::finalizeSections() {
for (SharedFile *file : ctx.sharedFiles) {
bool allNeededIsKnown =
llvm::all_of(file->dtNeeded, [&](StringRef needed) {
return symtab.soNames.count(CachedHashStringRef(needed));
return ctx.symtab->soNames.count(CachedHashStringRef(needed));
});
if (!allNeededIsKnown)
continue;
@ -1857,7 +1857,7 @@ template <class ELFT> void Writer<ELFT>::finalizeSections() {
llvm::TimeTraceScope timeScope("Add symbols to symtabs");
// Now that we have defined all possible global symbols including linker-
// synthesized ones. Visit all symbols to give the finishing touches.
for (Symbol *sym : symtab.getSymbols()) {
for (Symbol *sym : ctx.symtab->getSymbols()) {
if (!sym->isUsedInRegularObj || !includeInSymtab(*sym))
continue;
if (!ctx.arg.relocatable)
@ -1922,8 +1922,8 @@ template <class ELFT> void Writer<ELFT>::finalizeSections() {
if (ctx.arg.emachine == EM_HEXAGON &&
hexagonNeedsTLSSymbol(ctx.outputSections)) {
Symbol *sym =
symtab.addSymbol(Undefined{ctx.internalFile, "__tls_get_addr",
STB_GLOBAL, STV_DEFAULT, STT_NOTYPE});
ctx.symtab->addSymbol(Undefined{ctx.internalFile, "__tls_get_addr",
STB_GLOBAL, STV_DEFAULT, STT_NOTYPE});
sym->isPreemptible = true;
ctx.partitions[0].dynSymTab->addSymbol(sym);
}
@ -2701,7 +2701,7 @@ template <class ELFT> void Writer<ELFT>::checkSections() {
// 5. the address 0.
static uint64_t getEntryAddr() {
// Case 1, 2 or 3
if (Symbol *b = symtab.find(ctx.arg.entry))
if (Symbol *b = ctx.symtab->find(ctx.arg.entry))
return b->getVA();
// Case 4