D116913 will add LazyObject. Rename LazySymbol to LazyArchive to avoid confusion
and mirror ELF.
Reviewed By: #lld-macho, Jez Ng
Differential Revision: https://reviews.llvm.org/D116914
void ArchiveFile::addLazySymbols() {
for (const object::Archive::Symbol &sym : file->symbols())
- symtab->addLazy(sym.getName(), this, sym);
+ symtab->addLazyArchive(sym.getName(), this, sym);
}
static Expected<InputFile *> loadArchiveMember(MemoryBufferRef mb,
if (wasInserted)
replaceSymbol<Undefined>(s, name, file, refState);
- else if (auto *lazy = dyn_cast<LazySymbol>(s))
+ else if (auto *lazy = dyn_cast<LazyArchive>(s))
lazy->fetchArchiveMember();
else if (auto *dynsym = dyn_cast<DylibSymbol>(s))
dynsym->reference(refState);
return addDylib(name, /*file=*/nullptr, /*isWeakDef=*/false, /*isTlv=*/false);
}
-Symbol *SymbolTable::addLazy(StringRef name, ArchiveFile *file,
- const object::Archive::Symbol &sym) {
+Symbol *SymbolTable::addLazyArchive(StringRef name, ArchiveFile *file,
+ const object::Archive::Symbol &sym) {
Symbol *s;
bool wasInserted;
std::tie(s, wasInserted) = insert(name, file);
if (wasInserted) {
- replaceSymbol<LazySymbol>(s, file, sym);
+ replaceSymbol<LazyArchive>(s, file, sym);
} else if (isa<Undefined>(s)) {
file->fetch(sym);
} else if (auto *dysym = dyn_cast<DylibSymbol>(s)) {
if (dysym->getRefState() != RefState::Unreferenced)
file->fetch(sym);
else
- replaceSymbol<LazySymbol>(s, file, sym);
+ replaceSymbol<LazyArchive>(s, file, sym);
}
}
return s;
Symbol *addDylib(StringRef name, DylibFile *file, bool isWeakDef, bool isTlv);
Symbol *addDynamicLookup(StringRef name);
- Symbol *addLazy(StringRef name, ArchiveFile *file,
- const llvm::object::Archive::Symbol &sym);
+ Symbol *addLazyArchive(StringRef name, ArchiveFile *file,
+ const llvm::object::Archive::Symbol &sym);
Defined *addSynthetic(StringRef name, InputSection *, uint64_t value,
bool isPrivateExtern, bool includeInSymtab,
return isInStubs() ? getStubVA() : Symbol::getVA();
}
-void LazySymbol::fetchArchiveMember() { getFile()->fetch(sym); }
+void LazyArchive::fetchArchiveMember() { getFile()->fetch(sym); }
UndefinedKind,
CommonKind,
DylibKind,
- LazyKind,
+ LazyArchiveKind,
};
virtual ~Symbol() {}
const bool tlv : 1;
};
-class LazySymbol : public Symbol {
+class LazyArchive : public Symbol {
public:
- LazySymbol(ArchiveFile *file, const llvm::object::Archive::Symbol &sym)
- : Symbol(LazyKind, sym.getName(), file), sym(sym) {}
+ LazyArchive(ArchiveFile *file, const llvm::object::Archive::Symbol &sym)
+ : Symbol(LazyArchiveKind, sym.getName(), file), sym(sym) {}
ArchiveFile *getFile() const { return cast<ArchiveFile>(file); }
void fetchArchiveMember();
- static bool classof(const Symbol *s) { return s->kind() == LazyKind; }
+ static bool classof(const Symbol *s) { return s->kind() == LazyArchiveKind; }
private:
const llvm::object::Archive::Symbol sym;
alignas(Undefined) char b[sizeof(Undefined)];
alignas(CommonSymbol) char c[sizeof(CommonSymbol)];
alignas(DylibSymbol) char d[sizeof(DylibSymbol)];
- alignas(LazySymbol) char e[sizeof(LazySymbol)];
+ alignas(LazyArchive) char e[sizeof(LazyArchive)];
};
template <typename T, typename... ArgT>
// (See discussions/alternatives already considered on D107533)
if (!defined->isExternal())
if (Symbol *sym = symtab->find(defined->getName()))
- if (sym->kind() != Symbol::LazyKind)
+ if (sym->kind() != Symbol::LazyArchiveKind)
r.referent = s = sym;
}
if (auto *undefined = dyn_cast<Undefined>(s)) {