[ELF] - Add support for --just-symbols flag.

[grimar]

Summary

This is "Bug 35067 - support --just-symbols (-R)" (https://bugs.llvm.org//show_bug.cgi?id=35067)

Description of feature:
--just-symbols=filename
Read symbol names and their addresses from filename, but do not relocate it or include it in the output.
This allows your output file to refer symbolically to absolute locations of memory defined in other programs.
You may use this option more than once.
(ftp://ftp.gnu.org/old-gnu/Manuals/ld-2.9.1/html_node/ld_3.html)

Patch implements --just-symbols flag. Behavior is to read symbols from file and
add all of them as absolute symbols except undefined symbols, which are kept as undefined.

Only executable and relocatable files are supported as arguments. Both gnu linkers does not support
adding DSO files. Behavior of GNU linkers restricting DSO inputs is probably reasonable, though that looks
like artifical limitation. I can imagine DSO with absolute symbols and see no problems to extract
and use such symbols. This implementation follows GNU linkers behavior mostly for simplicity and consistency
of our implementation.

[phosek]

FYI @ruiu has already wrote a similar patch in D39348.

[grimar]

In D40549#937993, @phosek wrote:

FYI @ruiu has already wrote a similar patch in D39348.

I did not see it :( Thanks.

[grimar]

Abdndoned in favor of D39348.

ELF/Config.h

struct Configuration {
   std::vector<llvm::StringRef> FilterList;
   std::vector<llvm::StringRef> SearchPaths;
   std::vector<llvm::StringRef> SymbolOrderingFile;
   std::vector<llvm::StringRef> Undefined;
   std::vector<SymbolVersion> DynamicList;
   std::vector<SymbolVersion> VersionScriptGlobals;
   std::vector<SymbolVersion> VersionScriptLocals;
   std::vector<uint8_t> BuildIdVector;
+  std::vector<InputFile *> JustSymbols;
   bool AllowMultipleDefinition;
   bool AndroidPackDynRelocs = false;
   bool AsNeeded = false;
   bool Bsymbolic;
   bool BsymbolicFunctions;
   bool CompressDebugSections;
   bool DefineCommon;
   bool Demangle = true;

ELF/Driver.cpp

if (S == "binary")
     return true;
   if (S == "elf" || S == "default")
     return false;
   error("unknown -format value: " + S +
         " (supported formats: elf, default, binary)");
   return false;
 }
 
+// Used for --just-symbol. Adds file from Path.
+static void addJustSymbolsFile(StringRef Path) {
+  Optional<MemoryBufferRef> Buffer = readFile(Path);
+  if (!Buffer)
+    return;
+
+  file_magic Type = identify_magic(Buffer->getBuffer());
+  if (Type != file_magic::elf_relocatable &&
+      Type != file_magic::elf_executable) {
+    error("--just-symbols: unknown format of file " + Path +
+          " (supported formats: ELF executable, ELF relocatable)");
+    return;
+  }
+
+  Config->JustSymbols.push_back(createObjectFile(*Buffer));
+}
+
 void LinkerDriver::createFiles(opt::InputArgList &Args) {
   for (auto *Arg : Args) {
     switch (Arg->getOption().getUnaliasedOption().getID()) {
+    case OPT_just_symbols:
+      addJustSymbolsFile(Arg->getValue());
+      break;
     case OPT_library:
       addLibrary(Arg->getValue());
       break;
     case OPT_INPUT:
       addFile(Arg->getValue(), /*WithLOption=*/false);
       break;
     case OPT_script:
       if (Optional<std::string> Path = searchLinkerScript(Arg->getValue())) {
template <class ELFT> void LinkerDriver::link(opt::InputArgList &Args) {
   // Handle --trace-symbol.
   for (auto *Arg : Args.filtered(OPT_trace_symbol))
     Symtab->trace(Arg->getValue());
 
   // Add all files to the symbol table. This will add almost all
   // symbols that we need to the symbol table.
   for (InputFile *F : Files)
     Symtab->addFile<ELFT>(F);
+  for (InputFile *F : Config->JustSymbols)
+    cast<ObjFile<ELFT>>(F)->parseJustSymbols();
 
   // Process -defsym option.
   for (auto *Arg : Args.filtered(OPT_defsym)) {
     StringRef From;
     StringRef To;
     std::tie(From, To) = StringRef(Arg->getValue()).split('=');
     readDefsym(From, MemoryBufferRef(To, "-defsym"));
   }

ELF/InputFiles.h

 public:
   static bool classof(const InputFile *F) { return F->kind() == Base::ObjKind; }
 
   ArrayRef<Symbol *> getLocalSymbols();
 
   ObjFile(MemoryBufferRef M, StringRef ArchiveName);
   void parse(llvm::DenseSet<llvm::CachedHashStringRef> &ComdatGroups);
 
+  // For --just-symbols implementation.
+  void parseJustSymbols();
+
   InputSectionBase *getSection(uint32_t Index) const;
 
   Symbol &getSymbol(uint32_t SymbolIndex) const {
     if (SymbolIndex >= this->Symbols.size())
       fatal(toString(this) + ": invalid symbol index");
     return *this->Symbols[SymbolIndex];
   }
 

ELF/InputFiles.cpp

 
 template <class ELFT>
 void ObjFile<ELFT>::parse(DenseSet<CachedHashStringRef> &ComdatGroups) {
   // Read section and symbol tables.
   initializeSections(ComdatGroups);
   initializeSymbols();
 }
 
+// Used for --just-symbol=filename implementation, here we scan
+// and add symbols from object file.
+template <class ELFT> void ObjFile<ELFT>::parseJustSymbols() {
+  ArrayRef<Elf_Shdr> ObjSections =
+      check(this->getObj().sections(), toString(this));
+
+  // Initialize symbol and string tables.
+  for (const Elf_Shdr &Hdr : ObjSections) {
+    if (Hdr.sh_type != SHT_SYMTAB)
+      continue;
+    this->initSymtab(ObjSections, &Hdr);
+    break;
+  }
+
+  // Scan over all symbols.
+  for (const Elf_Sym &Sym : this->ELFSyms) {
+    // Skip all local symbols.
+    if (Sym.getBinding() == STB_LOCAL)
+      continue;
+
+    StringRef Name = check(Sym.getName(this->StringTable), toString(this));
+    // We do not want to automatically resolve undefined symbols here, so
+    // leaving them as is, assuming they must be defined somewhere else.
+    if (Sym.st_shndx == SHN_UNDEF) {
+      this->Symbols.push_back(Symtab->addUndefined<ELFT>(
+          Name, Sym.getBinding(), Sym.st_other, Sym.getType(),
+          /*CanOmitFromDynSym=*/false, this));
+      continue;
+    }
+
+    // All other symbols are added as absolute ones.
+    this->Symbols.push_back(Symtab->addRegular<ELFT>(
+        Name, Sym.st_other, Sym.getType(), Sym.st_value, Sym.st_size,
+        Sym.getBinding(), nullptr /*Sec*/, this));
+  }
+}
+
 // Sections with SHT_GROUP and comdat bits define comdat section groups.
 // They are identified and deduplicated by group name. This function
 // returns a group name.
 template <class ELFT>
 StringRef ObjFile<ELFT>::getShtGroupSignature(ArrayRef<Elf_Shdr> Sections,
                                               const Elf_Shdr &Sec) {
   // Group signatures are stored as symbol names in object files.
   // sh_info contains a symbol index, so we fetch a symbol and read its name.

ELF/Options.td

 
 def icf_none: F<"icf=none">, HelpText<"Disable identical code folding">;
 
 defm image_base : Eq<"image-base">, HelpText<"Set the base address">;
 
 defm init: Eq<"init">, HelpText<"Specify an initializer function">,
   MetaVarName<"<symbol>">;
 
+defm just_symbols: Eq<"just-symbols">, HelpText<"Add symbols from file">;
+
 defm library: Eq<"library">, HelpText<"Root name of library to use">,
   MetaVarName<"<libName>">;
 
 def lto_O: J<"lto-O">, MetaVarName<"<opt-level>">,
   HelpText<"Optimization level for LTO">;
 
 def m: JoinedOrSeparate<["-"], "m">, HelpText<"Set target emulation">;
 

test/ELF/just-symbols.s

+# REQUIRES: x86
+
+# RUN: echo "_start:" > %t.s
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %t.s -o %t.o
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %tsymbols.o
+# RUN: ld.lld -o %t.exe %t.o --just-symbols=%tsymbols.o
+# RUN: llvm-readobj -symbols %t.exe | FileCheck %s
+
+# CHECK:       Symbol {
+# CHECK:         Name: hiddenFoo
+# CHECK-NEXT:    Value: 0x5
+# CHECK-NEXT:    Size: 0
+# CHECK-NEXT:    Binding: Local
+# CHECK-NEXT:    Type: None
+# CHECK-NEXT:    Other [
+# CHECK-NEXT:      STV_HIDDEN
+# CHECK-NEXT:    ]
+# CHECK-NEXT:    Section: Absolute
+# CHECK-NEXT:  }
+# CHECK-NEXT:  Symbol {
+# CHECK-NEXT:    Name: absoluteFoo
+# CHECK-NEXT:    Value: 0x123
+# CHECK-NEXT:    Size: 0
+# CHECK-NEXT:    Binding: Global
+# CHECK-NEXT:    Type: None
+# CHECK-NEXT:    Other: 0
+# CHECK-NEXT:    Section: Absolute
+# CHECK-NEXT:  }
+# CHECK-NEXT:  Symbol {
+# CHECK-NEXT:    Name: commonFoo
+# CHECK-NEXT:    Value: 0x4
+# CHECK-NEXT:    Size: 4
+# CHECK-NEXT:    Binding: Global
+# CHECK-NEXT:    Type: Object
+# CHECK-NEXT:    Other: 0
+# CHECK-NEXT:    Section: Absolute
+# CHECK-NEXT:  }
+# CHECK-NEXT:  Symbol {
+# CHECK-NEXT:    Name: foo
+# CHECK-NEXT:    Value: 0x0
+# CHECK-NEXT:    Size: 0
+# CHECK-NEXT:    Binding: Global
+# CHECK-NEXT:    Type: None
+# CHECK-NEXT:    Other: 0
+# CHECK-NEXT:    Section: Absolute
+# CHECK-NEXT:  }
+# CHECK-NEXT:  Symbol {
+# CHECK-NEXT:    Name: undefFoo
+# CHECK-NEXT:    Value: 0x0
+# CHECK-NEXT:    Size: 0
+# CHECK-NEXT:    Binding: Global
+# CHECK-NEXT:    Type: None
+# CHECK-NEXT:    Other: 0
+# CHECK-NEXT:    Section: Undefined
+# CHECK-NEXT:  }
+# CHECK-NEXT:  Symbol {
+# CHECK-NEXT:    Name: weakFoo
+# CHECK-NEXT:    Value: 0x5
+# CHECK-NEXT:    Size: 0
+# CHECK-NEXT:    Binding: Weak
+# CHECK-NEXT:    Type: None
+# CHECK-NEXT:    Other: 0
+# CHECK-NEXT:    Section: Absolute
+# CHECK-NEXT:  }
+
+.section .foo, "a"
+.global foo
+foo:
+ callq undefFoo@PLT
+
+.global absoluteFoo
+absoluteFoo = 0x123
+
+.weak weakFoo
+weakFoo:
+
+.local localFoo
+localFoo:
+
+.globl hiddenFoo
+.hidden hiddenFoo
+hiddenFoo:
+
+.comm commonFoo,4,4