Simplify LazyobjFile and readElfSymbols.

[ruiu]

Summary

addElfSymbols and readJustSymbolsFile still has duplicate code, but
I didn't come up with a good idea to eliminate them. Since this patch
is an improvement, I'm sending this for review.

[• rafael]

Rui Ueyama via Phabricator via llvm-commits
<[e-mail]> writes:

-template <class ELFT> std::vector<StringRef> LazyObjFile::getElfSymbols() {

• typedef typename ELFT::Shdr Elf_Shdr;
• typedef typename ELFT::Sym Elf_Sym;
• typedef typename ELFT::SymRange Elf_Sym_Range;

+template <class ELFT> void LazyObjFile::addElfSymbols() {
+ StringRef ObjName = MB.getBufferIdentifier();
+ ELFFile<ELFT> Obj = check(ELFFile<ELFT>::create(MB.getBuffer()));
+ ArrayRef<typename ELFT::Shdr> Sections = CHECK(Obj.sections(), ObjName);

Why change CHECK(..., this) to CHECK(..., ObjName)?

LGTM with that.

Cheers,
Rafael

lld/trunk/ELF/InputFiles.h

public:
 
   static bool classof(const InputFile *F) { return F->kind() == LazyObjKind; }
 
   template <class ELFT> void parse();
   MemoryBufferRef getBuffer();
   InputFile *fetch();
 
 private:
-  std::vector<StringRef> getSymbolNames();
-  template <class ELFT> std::vector<StringRef> getElfSymbols();
-  std::vector<StringRef> getBitcodeSymbols();
+  template <class ELFT> void addElfSymbols();
 
   bool Seen = false;
   uint64_t OffsetInArchive;
 };
 
 // An ArchiveFile object represents a .a file.
 class ArchiveFile : public InputFile {
 public:

lld/trunk/ELF/InputFiles.cpp

 InputFile *LazyObjFile::fetch() {
   MemoryBufferRef MBRef = getBuffer();
   if (MBRef.getBuffer().empty())
     return nullptr;
   return createObjectFile(MBRef, ArchiveName, OffsetInArchive);
 }
 
 template <class ELFT> void LazyObjFile::parse() {
-  for (StringRef Sym : getSymbolNames())
-    Symtab->addLazyObject<ELFT>(Sym, *this);
-}
-
-template <class ELFT> std::vector<StringRef> LazyObjFile::getElfSymbols() {
-  typedef typename ELFT::Shdr Elf_Shdr;
-  typedef typename ELFT::Sym Elf_Sym;
-  typedef typename ELFT::SymRange Elf_Sym_Range;
-
-  ELFFile<ELFT> Obj = check(ELFFile<ELFT>::create(this->MB.getBuffer()));
-  ArrayRef<Elf_Shdr> Sections = CHECK(Obj.sections(), this);
-  for (const Elf_Shdr &Sec : Sections) {
-    if (Sec.sh_type != SHT_SYMTAB)
-      continue;
-
-    Elf_Sym_Range Syms = CHECK(Obj.symbols(&Sec), this);
-    uint32_t FirstNonLocal = Sec.sh_info;
-    StringRef StringTable =
-        CHECK(Obj.getStringTableForSymtab(Sec, Sections), this);
-    std::vector<StringRef> V;
-
-    for (const Elf_Sym &Sym : Syms.slice(FirstNonLocal))
-      if (Sym.st_shndx != SHN_UNDEF)
-        V.push_back(CHECK(Sym.getName(StringTable), this));
-    return V;
-  }
-  return {};
-}
-
-std::vector<StringRef> LazyObjFile::getBitcodeSymbols() {
+  // A lazy object file wraps either a bitcode file or an ELF file.
+  if (isBitcode(this->MB)) {
     std::unique_ptr<lto::InputFile> Obj =
         CHECK(lto::InputFile::create(this->MB), this);
-  std::vector<StringRef> V;
     for (const lto::InputFile::Symbol &Sym : Obj->symbols())
       if (!Sym.isUndefined())
-      V.push_back(Saver.save(Sym.getName()));
-  return V;
+        Symtab->addLazyObject<ELFT>(Saver.save(Sym.getName()), *this);
+    return;
   }
 
-// Returns a vector of globally-visible defined symbol names.
-std::vector<StringRef> LazyObjFile::getSymbolNames() {
-  if (isBitcode(this->MB))
-    return getBitcodeSymbols();
-
   switch (getELFKind(this->MB)) {
   case ELF32LEKind:
-    return getElfSymbols<ELF32LE>();
+    addElfSymbols<ELF32LE>();
+    return;
   case ELF32BEKind:
-    return getElfSymbols<ELF32BE>();
+    addElfSymbols<ELF32BE>();
+    return;
   case ELF64LEKind:
-    return getElfSymbols<ELF64LE>();
+    addElfSymbols<ELF64LE>();
+    return;
   case ELF64BEKind:
-    return getElfSymbols<ELF64BE>();
+    addElfSymbols<ELF64BE>();
+    return;
   default:
     llvm_unreachable("getELFKind");
   }
 }
 
+template <class ELFT> void LazyObjFile::addElfSymbols() {
+  ELFFile<ELFT> Obj = check(ELFFile<ELFT>::create(MB.getBuffer()));
+  ArrayRef<typename ELFT::Shdr> Sections = CHECK(Obj.sections(), this);
+
+  for (const typename ELFT::Shdr &Sec : Sections) {
+    if (Sec.sh_type != SHT_SYMTAB)
+      continue;
+
+    typename ELFT::SymRange Syms = CHECK(Obj.symbols(&Sec), this);
+    uint32_t FirstNonLocal = Sec.sh_info;
+    StringRef StringTable =
+        CHECK(Obj.getStringTableForSymtab(Sec, Sections), this);
+
+    for (const typename ELFT::Sym &Sym : Syms.slice(FirstNonLocal))
+      if (Sym.st_shndx != SHN_UNDEF)
+        Symtab->addLazyObject<ELFT>(CHECK(Sym.getName(StringTable), this),
+                                    *this);
+  }
+}
+
 // This is for --just-symbols.
 //
 // This option allows you to link your output against other existing
 // program, so that if you load both your program and the other program
 // into memory, your output can use program's symbols.
 //
 // What we are doing here is to read defined symbols from a given ELF
 // file and add them as absolute symbols.
for (const Elf_Shdr &Sec : Sections) {
     if (Sec.sh_type != SHT_SYMTAB)
       continue;
 
     Elf_Sym_Range Syms = CHECK(Obj.symbols(&Sec), ObjName);
     uint32_t FirstNonLocal = Sec.sh_info;
     StringRef StringTable =
         CHECK(Obj.getStringTableForSymtab(Sec, Sections), ObjName);
 
-    std::vector<std::pair<StringRef, uint64_t>> Ret;
     for (const Elf_Sym &Sym : Syms.slice(FirstNonLocal))
       if (Sym.st_shndx != SHN_UNDEF)
         Symtab->addRegular(CHECK(Sym.getName(StringTable), ObjName),
                            Sym.st_other, Sym.getType(), Sym.st_value,
                            Sym.st_size, Sym.getBinding(), nullptr, nullptr);
     return;
   }
 }