BitcodeCompiler::~BitcodeCompiler() = default;
-static void undefine(Symbol *S) { replaceBody<Undefined>(S, S->getName()); }
+static void undefine(Symbol *S) { replaceSymbol<Undefined>(S, S->getName()); }
void BitcodeCompiler::add(BitcodeFile &F) {
lto::InputFile &Obj = *F.Obj;
Symbol *Imp = find(Name.substr(strlen("__imp_")));
if (Imp && isa<Defined>(Imp)) {
auto *D = cast<Defined>(Imp);
- replaceBody<DefinedLocalImport>(Sym, Name, D);
+ replaceSymbol<DefinedLocalImport>(Sym, Name, D);
LocalImportChunks.push_back(cast<DefinedLocalImport>(Sym)->getChunk());
continue;
}
// Remaining undefined symbols are not fatal if /force is specified.
// They are replaced with dummy defined symbols.
if (Config->Force)
- replaceBody<DefinedAbsolute>(Sym, Name, 0);
+ replaceSymbol<DefinedAbsolute>(Sym, Name, 0);
Undefs.insert(Sym);
}
if (!F || !isa<BitcodeFile>(F))
S->IsUsedInRegularObj = true;
if (WasInserted || (isa<Lazy>(S) && IsWeakAlias)) {
- replaceBody<Undefined>(S, Name);
+ replaceSymbol<Undefined>(S, Name);
return S;
}
if (auto *L = dyn_cast<Lazy>(S)) {
bool WasInserted;
std::tie(S, WasInserted) = insert(Name);
if (WasInserted) {
- replaceBody<Lazy>(S, F, Sym);
+ replaceSymbol<Lazy>(S, F, Sym);
return;
}
auto *U = dyn_cast<Undefined>(S);
std::tie(S, WasInserted) = insert(N);
S->IsUsedInRegularObj = true;
if (WasInserted || isa<Undefined>(S) || isa<Lazy>(S))
- replaceBody<DefinedAbsolute>(S, N, Sym);
+ replaceSymbol<DefinedAbsolute>(S, N, Sym);
else if (!isa<DefinedCOFF>(S))
reportDuplicate(S, nullptr);
return S;
std::tie(S, WasInserted) = insert(N);
S->IsUsedInRegularObj = true;
if (WasInserted || isa<Undefined>(S) || isa<Lazy>(S))
- replaceBody<DefinedAbsolute>(S, N, VA);
+ replaceSymbol<DefinedAbsolute>(S, N, VA);
else if (!isa<DefinedCOFF>(S))
reportDuplicate(S, nullptr);
return S;
std::tie(S, WasInserted) = insert(N);
S->IsUsedInRegularObj = true;
if (WasInserted || isa<Undefined>(S) || isa<Lazy>(S))
- replaceBody<DefinedSynthetic>(S, N, C);
+ replaceSymbol<DefinedSynthetic>(S, N, C);
else if (!isa<DefinedCOFF>(S))
reportDuplicate(S, nullptr);
return S;
if (SP == SP_CONFLICT) {
reportDuplicate(S, F);
} else if (SP == SP_NEW) {
- replaceBody<DefinedRegular>(S, F, N, IsCOMDAT, /*IsExternal*/ true, Sym, C);
+ replaceSymbol<DefinedRegular>(S, F, N, IsCOMDAT, /*IsExternal*/ true, Sym,
+ C);
} else if (SP == SP_EXISTING && IsCOMDAT && C) {
C->markDiscarded();
// Discard associative chunks that we've parsed so far. No need to recurse
if (!isa<BitcodeFile>(F))
S->IsUsedInRegularObj = true;
if (WasInserted || !isa<DefinedCOFF>(S))
- replaceBody<DefinedCommon>(S, F, N, Size, Sym, C);
+ replaceSymbol<DefinedCommon>(S, F, N, Size, Sym, C);
else if (auto *DC = dyn_cast<DefinedCommon>(S))
if (Size > DC->getSize())
- replaceBody<DefinedCommon>(S, F, N, Size, Sym, C);
+ replaceSymbol<DefinedCommon>(S, F, N, Size, Sym, C);
return S;
}
std::tie(S, WasInserted) = insert(N);
S->IsUsedInRegularObj = true;
if (WasInserted || isa<Undefined>(S) || isa<Lazy>(S)) {
- replaceBody<DefinedImportData>(S, N, F);
+ replaceSymbol<DefinedImportData>(S, N, F);
return cast<DefinedImportData>(S);
}
std::tie(S, WasInserted) = insert(Name);
S->IsUsedInRegularObj = true;
if (WasInserted || isa<Undefined>(S) || isa<Lazy>(S)) {
- replaceBody<DefinedImportThunk>(S, Name, ID, Machine);
+ replaceSymbol<DefinedImportThunk>(S, Name, ID, Machine);
return cast<DefinedImportThunk>(S);
}
};
template <typename T, typename... ArgT>
-void replaceBody(Symbol *S, ArgT &&... Arg) {
+void replaceSymbol(Symbol *S, ArgT &&... Arg) {
static_assert(sizeof(T) <= sizeof(SymbolUnion), "Symbol too small");
static_assert(alignof(T) <= alignof(SymbolUnion),
"SymbolUnion not aligned enough");
// section relative relocations.
Symbol *T = Symtab->find("___safe_se_handler_table");
Symbol *C = Symtab->find("___safe_se_handler_count");
- replaceBody<DefinedSynthetic>(T, T->getName(), SEHTable);
+ replaceSymbol<DefinedSynthetic>(T, T->getName(), SEHTable);
cast<DefinedAbsolute>(C)->setVA(SEHTable->getSize() / 4);
}
BitcodeCompiler::~BitcodeCompiler() = default;
static void undefine(Symbol *S) {
- replaceBody<Undefined>(S, nullptr, S->getName(), /*IsLocal=*/false,
- STV_DEFAULT, S->Type);
+ replaceSymbol<Undefined>(S, nullptr, S->getName(), /*IsLocal=*/false,
+ STV_DEFAULT, S->Type);
}
void BitcodeCompiler::add(BitcodeFile &F) {
// write expressions like this: `alignment = 16; . = ALIGN(., alignment)`.
uint64_t SymValue = Value.Sec ? 0 : Value.getValue();
- replaceBody<DefinedRegular>(Sym, nullptr, Cmd->Name, /*IsLocal=*/false,
- Visibility, STT_NOTYPE, SymValue, 0, Sec);
+ replaceSymbol<DefinedRegular>(Sym, nullptr, Cmd->Name, /*IsLocal=*/false,
+ Visibility, STT_NOTYPE, SymValue, 0, Sec);
Cmd->Sym = cast<DefinedRegular>(Sym);
}
// in the same DSO.
if (WasInserted || (isa<SharedSymbol>(S) && Visibility != STV_DEFAULT)) {
S->Binding = Binding;
- replaceBody<Undefined>(S, File, Name, IsLocal, StOther, Type);
+ replaceSymbol<Undefined>(S, File, Name, IsLocal, StOther, Type);
return S;
}
if (Binding != STB_WEAK) {
int Cmp = compareDefined(S, WasInserted, Binding, N);
if (Cmp > 0) {
S->Binding = Binding;
- replaceBody<DefinedCommon>(S, File, N, Size, Alignment, StOther, Type);
+ replaceSymbol<DefinedCommon>(S, File, N, Size, Alignment, StOther, Type);
} else if (Cmp == 0) {
auto *C = dyn_cast<DefinedCommon>(S);
if (!C) {
Alignment = C->Alignment = std::max(C->Alignment, Alignment);
if (Size > C->Size)
- replaceBody<DefinedCommon>(S, File, N, Size, Alignment, StOther, Type);
+ replaceSymbol<DefinedCommon>(S, File, N, Size, Alignment, StOther, Type);
}
return S;
}
int Cmp = compareDefinedNonCommon(S, WasInserted, Binding, Section == nullptr,
Value, Name);
if (Cmp > 0)
- replaceBody<DefinedRegular>(S, File, Name, /*IsLocal=*/false, StOther, Type,
- Value, Size, Section);
+ replaceSymbol<DefinedRegular>(S, File, Name, /*IsLocal=*/false, StOther,
+ Type, Value, Size, Section);
else if (Cmp == 0)
reportDuplicate<ELFT>(S, dyn_cast_or_null<InputSectionBase>(Section),
Value);
// in the same DSO.
if (WasInserted || ((S->isUndefined() || S->isLazy()) &&
S->getVisibility() == STV_DEFAULT)) {
- replaceBody<SharedSymbol>(S, File, Name, Sym.st_other, Sym.getType(),
- Sym.st_value, Sym.st_size, Alignment, Verdef);
+ replaceSymbol<SharedSymbol>(S, File, Name, Sym.st_other, Sym.getType(),
+ Sym.st_value, Sym.st_size, Alignment, Verdef);
if (!S->isWeak())
File->IsUsed = true;
}
int Cmp = compareDefinedNonCommon(S, WasInserted, Binding,
/*IsAbs*/ false, /*Value*/ 0, Name);
if (Cmp > 0)
- replaceBody<DefinedRegular>(S, F, Name, /*IsLocal=*/false, StOther, Type, 0,
- 0, nullptr);
+ replaceSymbol<DefinedRegular>(S, F, Name, /*IsLocal=*/false, StOther, Type,
+ 0, 0, nullptr);
else if (Cmp == 0)
reportDuplicate(S, F);
return S;
bool WasInserted;
std::tie(S, WasInserted) = insert(Name);
if (WasInserted) {
- replaceBody<LazyArchive>(S, F, Sym, Symbol::UnknownType);
+ replaceSymbol<LazyArchive>(S, F, Sym, Symbol::UnknownType);
return S;
}
if (!S->isUndefined())
// An undefined weak will not fetch archive members. See comment on Lazy in
// Symbols.h for the details.
if (S->isWeak()) {
- replaceBody<LazyArchive>(S, F, Sym, S->Type);
+ replaceSymbol<LazyArchive>(S, F, Sym, S->Type);
return S;
}
std::pair<MemoryBufferRef, uint64_t> MBInfo = F->getMember(&Sym);
bool WasInserted;
std::tie(S, WasInserted) = insert(Name);
if (WasInserted) {
- replaceBody<LazyObject>(S, &Obj, Name, Symbol::UnknownType);
+ replaceSymbol<LazyObject>(S, &Obj, Name, Symbol::UnknownType);
return;
}
if (!S->isUndefined())
// See comment for addLazyArchive above.
if (S->isWeak())
- replaceBody<LazyObject>(S, &Obj, Name, S->Type);
+ replaceSymbol<LazyObject>(S, &Obj, Name, S->Type);
else if (InputFile *F = Obj.fetch())
addFile<ELFT>(F);
}
void printTraceSymbol(Symbol *Sym);
template <typename T, typename... ArgT>
-void replaceBody(Symbol *S, InputFile *File, ArgT &&... Arg) {
+void replaceSymbol(Symbol *S, InputFile *File, ArgT &&... Arg) {
static_assert(sizeof(T) <= sizeof(SymbolUnion), "SymbolUnion too small");
static_assert(alignof(T) <= alignof(SymbolUnion),
"SymbolUnion not aligned enough");
// Replace all DefinedCommon symbols with DefinedRegular symbols so that we
// don't have to care about DefinedCommon symbols beyond this point.
- replaceBody<DefinedRegular>(S, Sym->getFile(), Sym->getName(),
- static_cast<bool>(Sym->isLocal()), Sym->StOther,
- Sym->Type, 0, Sym->getSize(), Section);
+ replaceSymbol<DefinedRegular>(
+ S, Sym->getFile(), Sym->getName(), static_cast<bool>(Sym->isLocal()),
+ Sym->StOther, Sym->Type, 0, Sym->getSize(), Section);
}
}