[ELF2] Initial support for local symbols.
Symbol table is now populated correctly, but some fields are missing,
they'll be added in the future. This patch also adds --discard-all
flag, which was the default behavior until now.
Differential Revision: http://reviews.llvm.org/D12874
llvm-svn: 247849
diff --git a/lld/ELF/Config.h b/lld/ELF/Config.h
index b4faef70..7af0fa7 100644
--- a/lld/ELF/Config.h
+++ b/lld/ELF/Config.h
@@ -20,6 +20,7 @@
llvm::StringRef DynamicLinker;
std::string RPath;
bool Shared = false;
+ bool DiscardAll = false;
};
extern Configuration *Config;
diff --git a/lld/ELF/Driver.cpp b/lld/ELF/Driver.cpp
index d1b6326..8328ba5 100644
--- a/lld/ELF/Driver.cpp
+++ b/lld/ELF/Driver.cpp
@@ -82,6 +82,9 @@
if (Args.hasArg(OPT_shared))
Config->Shared = true;
+ if (Args.hasArg(OPT_discard_all))
+ Config->DiscardAll = true;
+
// Create a list of input files.
std::vector<MemoryBufferRef> Inputs;
diff --git a/lld/ELF/InputFiles.cpp b/lld/ELF/InputFiles.cpp
index fc13501..5d9e92d 100644
--- a/lld/ELF/InputFiles.cpp
+++ b/lld/ELF/InputFiles.cpp
@@ -55,21 +55,36 @@
}
template <class ELFT>
-typename ELFData<ELFT>::Elf_Sym_Range ELFData<ELFT>::getNonLocalSymbols() {
+typename ELFData<ELFT>::Elf_Sym_Range
+ELFData<ELFT>::getSymbolsHelper(bool Local) {
if (!Symtab)
return Elf_Sym_Range(nullptr, nullptr);
-
- ErrorOr<StringRef> StringTableOrErr =
- ELFObj->getStringTableForSymtab(*Symtab);
- error(StringTableOrErr.getError());
- StringTable = *StringTableOrErr;
-
Elf_Sym_Range Syms = ELFObj->symbols(Symtab);
uint32_t NumSymbols = std::distance(Syms.begin(), Syms.end());
uint32_t FirstNonLocal = Symtab->sh_info;
if (FirstNonLocal > NumSymbols)
error("Invalid sh_info in symbol table");
- return llvm::make_range(Syms.begin() + FirstNonLocal, Syms.end());
+ if (!Local)
+ return llvm::make_range(Syms.begin() + FirstNonLocal, Syms.end());
+ else
+ // Skip over dummy symbol.
+ return llvm::make_range(Syms.begin() + 1, Syms.begin() + FirstNonLocal);
+}
+
+template <class ELFT>
+typename ELFData<ELFT>::Elf_Sym_Range ELFData<ELFT>::getNonLocalSymbols() {
+ if (!Symtab)
+ return Elf_Sym_Range(nullptr, nullptr);
+ ErrorOr<StringRef> StringTableOrErr =
+ ELFObj->getStringTableForSymtab(*Symtab);
+ error(StringTableOrErr.getError());
+ StringTable = *StringTableOrErr;
+ return getSymbolsHelper(false);
+}
+
+template <class ELFT>
+typename ObjectFile<ELFT>::Elf_Sym_Range ObjectFile<ELFT>::getLocalSymbols() {
+ return this->getSymbolsHelper(true);
}
template <class ELFT> void elf2::ObjectFile<ELFT>::parse() {
@@ -217,6 +232,7 @@
namespace lld {
namespace elf2 {
+
template class elf2::ObjectFile<llvm::object::ELF32LE>;
template class elf2::ObjectFile<llvm::object::ELF32BE>;
template class elf2::ObjectFile<llvm::object::ELF64LE>;
diff --git a/lld/ELF/InputFiles.h b/lld/ELF/InputFiles.h
index 4577de6..d336b2b 100644
--- a/lld/ELF/InputFiles.h
+++ b/lld/ELF/InputFiles.h
@@ -102,11 +102,14 @@
uint16_t getEMachine() const { return getObj()->getHeader()->e_machine; }
+ StringRef getStringTable() const { return StringTable; }
+
protected:
std::unique_ptr<llvm::object::ELFFile<ELFT>> ELFObj;
const Elf_Shdr *Symtab = nullptr;
StringRef StringTable;
Elf_Sym_Range getNonLocalSymbols();
+ Elf_Sym_Range getSymbolsHelper(bool);
void openELF(MemoryBufferRef MB);
};
@@ -138,6 +141,8 @@
return SymbolBodies[SymbolIndex - FirstNonLocal]->getReplacement();
}
+ Elf_Sym_Range getLocalSymbols();
+
private:
void initializeChunks();
void initializeSymbols();
diff --git a/lld/ELF/Options.td b/lld/ELF/Options.td
index b3c244b..fed2e99 100644
--- a/lld/ELF/Options.td
+++ b/lld/ELF/Options.td
@@ -15,3 +15,6 @@
def shared : Flag<["-"], "shared">,
HelpText<"Build a shared object">;
+
+def discard_all : Flag<["-"], "discard-all">,
+ HelpText<"Delete all local symbols">;
diff --git a/lld/ELF/Writer.cpp b/lld/ELF/Writer.cpp
index bb5f5a2..6161eb8 100644
--- a/lld/ELF/Writer.cpp
+++ b/lld/ELF/Writer.cpp
@@ -210,6 +210,7 @@
class SymbolTableSection final : public OutputSectionBase<ELFT::Is64Bits> {
public:
typedef typename ELFFile<ELFT>::Elf_Sym Elf_Sym;
+ typedef typename ELFFile<ELFT>::Elf_Sym_Range Elf_Sym_Range;
typedef typename OutputSectionBase<ELFT::Is64Bits>::uintX_t uintX_t;
SymbolTableSection(Writer<ELFT> &W, SymbolTable &Table,
StringTableSection<ELFT::Is64Bits> &StrTabSec)
@@ -221,9 +222,6 @@
typedef OutputSectionBase<ELFT::Is64Bits> Base;
typename Base::HeaderT &Header = this->Header;
- // For now the only local symbol is going to be the one at index 0
- Header.sh_info = 1;
-
Header.sh_entsize = sizeof(Elf_Sym);
Header.sh_addralign = ELFT::Is64Bits ? 8 : 4;
}
@@ -231,15 +229,18 @@
void finalize() override {
this->Header.sh_size = getNumSymbols() * sizeof(Elf_Sym);
this->Header.sh_link = StrTabSec.getSectionIndex();
+ this->Header.sh_info = NumLocals + 1;
}
void writeTo(uint8_t *Buf) override;
const SymbolTable &getSymTable() const { return Table; }
- void addSymbol(StringRef Name) {
+ void addSymbol(StringRef Name, bool isLocal = false) {
StrTabSec.add(Name);
++NumVisible;
+ if (isLocal)
+ ++NumLocals;
}
StringTableSection<ELFT::Is64Bits> &getStrTabSec() { return StrTabSec; }
@@ -249,6 +250,7 @@
SymbolTable &Table;
StringTableSection<ELFT::Is64Bits> &StrTabSec;
unsigned NumVisible = 0;
+ unsigned NumLocals = 0;
const Writer<ELFT> &W;
};
@@ -434,6 +436,7 @@
typedef typename ELFFile<ELFT>::Elf_Ehdr Elf_Ehdr;
typedef typename ELFFile<ELFT>::Elf_Phdr Elf_Phdr;
typedef typename ELFFile<ELFT>::Elf_Sym Elf_Sym;
+ typedef typename ELFFile<ELFT>::Elf_Sym_Range Elf_Sym_Range;
typedef typename ELFFile<ELFT>::Elf_Rela Elf_Rela;
Writer(SymbolTable *T)
: SymTabSec(*this, *T, StrTabSec), DynSymSec(*this, *T, DynStrSec),
@@ -623,9 +626,28 @@
}
template <class ELFT> void SymbolTableSection<ELFT>::writeTo(uint8_t *Buf) {
- uint8_t *BufStart = Buf;
-
Buf += sizeof(Elf_Sym);
+
+ // All symbols with STB_LOCAL binding precede the weak and global symbols.
+ // .dynsym only contains global symbols.
+ if (!Config->DiscardAll && !StrTabSec.isDynamic()) {
+ for (const std::unique_ptr<ObjectFileBase> &FileB :
+ Table.getObjectFiles()) {
+ auto &File = cast<ObjectFile<ELFT>>(*FileB);
+ Elf_Sym_Range Syms = File.getLocalSymbols();
+ for (const Elf_Sym &Sym : Syms) {
+ auto *ESym = reinterpret_cast<Elf_Sym *>(Buf);
+ ErrorOr<StringRef> SymName = Sym.getName(File.getStringTable());
+ ESym->st_name = (SymName) ? StrTabSec.getFileOff(*SymName) : 0;
+ ESym->st_value = Sym.st_value;
+ ESym->st_size = Sym.st_size;
+ Buf += sizeof(Elf_Sym);
+ }
+ }
+ }
+
+ uint8_t *GlobalStart = Buf;
+
for (auto &P : Table.getSymbols()) {
StringRef Name = P.first;
Symbol *Sym = P.second;
@@ -686,9 +708,8 @@
// The default hashing of StringRef produces different results on 32 and 64
// bit systems so we sort by st_name. That is arbitrary but deterministic.
// FIXME: Experiment with passing in a custom hashing instead.
- auto *Syms = reinterpret_cast<Elf_Sym *>(BufStart);
- ++Syms;
- array_pod_sort(Syms, Syms + NumVisible, compareSym<ELFT>);
+ auto *Syms = reinterpret_cast<Elf_Sym *>(GlobalStart);
+ array_pod_sort(Syms, Syms + NumVisible - NumLocals, compareSym<ELFT>);
}
template <bool Is64Bits>
@@ -819,6 +840,14 @@
for (const std::unique_ptr<ObjectFileBase> &FileB : Symtab.getObjectFiles()) {
auto &File = cast<ObjectFile<ELFT>>(*FileB);
+ if (!Config->DiscardAll) {
+ Elf_Sym_Range Syms = File.getLocalSymbols();
+ for (const Elf_Sym &Sym : Syms) {
+ ErrorOr<StringRef> SymName = Sym.getName(File.getStringTable());
+ if (SymName)
+ SymTabSec.addSymbol(*SymName, true);
+ }
+ }
for (SectionChunk<ELFT> *C : File.getChunks()) {
if (!C)
continue;