[lld] [ELF] Move elf::symtab into Ctx (PR #109612)
via llvm-commits
llvm-commits at lists.llvm.org
Sun Sep 22 22:52:08 PDT 2024
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-lld-elf
Author: Fangrui Song (MaskRay)
<details>
<summary>Changes</summary>
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.
---
Patch is 40.74 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/109612.diff
17 Files Affected:
- (modified) lld/ELF/Arch/ARM.cpp (+21-21)
- (modified) lld/ELF/Arch/PPC64.cpp (+1-1)
- (modified) lld/ELF/Config.h (+2)
- (modified) lld/ELF/Driver.cpp (+22-21)
- (modified) lld/ELF/ICF.cpp (+2-2)
- (modified) lld/ELF/InputFiles.cpp (+25-24)
- (modified) lld/ELF/InputSection.cpp (+1-1)
- (modified) lld/ELF/LTO.cpp (+1-1)
- (modified) lld/ELF/LinkerScript.cpp (+6-6)
- (modified) lld/ELF/MarkLive.cpp (+12-12)
- (modified) lld/ELF/Relocations.cpp (+7-7)
- (modified) lld/ELF/ScriptParser.cpp (+1-1)
- (modified) lld/ELF/SymbolTable.cpp (-2)
- (modified) lld/ELF/SymbolTable.h (-2)
- (modified) lld/ELF/SyntheticSections.cpp (+8-7)
- (modified) lld/ELF/SyntheticSections.h (+1-1)
- (modified) lld/ELF/Writer.cpp (+16-16)
``````````diff
diff --git a/lld/ELF/Arch/ARM.cpp b/lld/ELF/Arch/ARM.cpp
index 3484e66d2b1d4d..cc6275c76a3f4c 100644
--- a/lld/ELF/Arch/ARM.cpp
+++ b/lld/ELF/Arch/ARM.cpp
@@ -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;
}
}
@@ -1265,7 +1265,7 @@ void elf::processArmCmseSymbols() {
return;
// Only symbols with external linkage end up in 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(),
diff --git a/lld/ELF/Arch/PPC64.cpp b/lld/ELF/Arch/PPC64.cpp
index 803cc5402dda3c..fdf3d07b98bca1 100644
--- a/lld/ELF/Arch/PPC64.cpp
+++ b/lld/ELF/Arch/PPC64.cpp
@@ -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,
diff --git a/lld/ELF/Config.h b/lld/ELF/Config.h
index 875463da056474..71802cc58e95da 100644
--- a/lld/ELF/Config.h
+++ b/lld/ELF/Config.h
@@ -71,6 +71,7 @@ class StringTableSection;
class SymbolTableBaseSection;
class SymtabShndxSection;
class SyntheticSection;
+class SymbolTable;
enum ELFKind : uint8_t {
ELFNoneKind,
@@ -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;
diff --git a/lld/ELF/Driver.cpp b/lld/ELF/Driver.cpp
index 14188f98cfef33..63c0b994b89dfe 100644
--- a/lld/ELF/Driver.cpp
+++ b/lld/ELF/Driver.cpp
@@ -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();
@@ -2195,7 +2196,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);
@@ -2204,7 +2205,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);
@@ -2391,7 +2392,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;
@@ -2406,7 +2407,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);
@@ -2575,24 +2576,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
@@ -2627,7 +2628,7 @@ static void combineVersionedSymbol(Symbol &sym,
//
// * There is a definition of foo at v1 and foo@@v1.
// * There is a definition of foo at 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();
@@ -2682,7 +2683,7 @@ static void redirectSymbols(Ctx &ctx, ArrayRef<WrappedSymbol> wrapped) {
// symbols with a non-default version (foo at 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);
@@ -2698,7 +2699,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) {
@@ -2862,14 +2863,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);
@@ -2877,7 +2878,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.
@@ -2891,13 +2892,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
@@ -2978,7 +2979,7 @@ template <class ELFT> void LinkerDriver::link(opt::InputArgList &args) {
// name "foo at 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.
diff --git a/lld/ELF/ICF.cpp b/lld/ELF/ICF.cpp
index 9caff0bbe2b630..3f4f479785fd92 100644
--- a/lld/ELF/ICF.cpp
+++ b/lld/ELF/ICF.cpp
@@ -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())
diff --git a/lld/ELF/InputFiles.cpp b/lld/ELF/InputFiles.cpp
index 07a32a5ccea436..8dc6811045b3cb 100644
--- a/lld/ELF/InputFiles.cpp
+++ b/lld/ELF/InputFiles.cpp
@@ -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});
...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/109612
More information about the llvm-commits
mailing list