Implement --just-symbols

[PkmX]

Summary

This is based on D39348, but adds a new kind of input file JustSymbolsFile which is derived from ELFFileBase. The argument is treated as a normal input file so the case where it is the sole input works and we get to reuse some of code from ELFFileBase.

[ruiu]

Sorry I missed this one.

ELF/Driver.cpp

183

You can just call Files.push_back(createJustSymbolsFile(MBRef)) instead of calling addFile.

ELF/Driver.h

30 ↗

(On Diff #127076)

I don't like an optional argument in general. Please avoid using it in lld.

ELF/InputFiles.h

337

Remove InputFile::.

ELF/SymbolTable.cpp

77

Obviously you need a comment just like other code blocks.

[PkmX]

ELF/Driver.cpp

183

You are right. In retrospect I should've just call that instead of adding an extra argument to addFile.

ELF/InputFiles.h

337

The InputFile:: is required due to the rules of two-phase lookup in C++.

[PkmX]

• Copy symbol type, size, binding, etc, like D39348.
• Update test cases.

[PkmX]

Added a check to only allow ET_EXEC and the corresponding test.

On Tue, Dec 19, 2017 at 9:54 AM, Rafael Avila de Espindola <[e-mail]> wrote:

This patch allows --just-symbols to be a ET_DYN, ET_REL or ET_EXEC. Do
you need all 3? ET_REL in particular seems problematic since st_value
has a different meaning in relocatable files.

If you don't need ET_DYN or ET_REL, please reject them. If you need
them, please add a test.

ld.bfd accepts ET_EXEC and ET_REL but not ET_DYN. However I don't think this option makes much sense for ET_REL inputs so I'm restricting it to ET_EXEC for now.

[PkmX]

Implement the -R option as an alias to either --rpath or --just-symbols. It is treated as latter if the argument file exists and is not a directory.

[mcgrathr]

This works fine for me. Perhaps Rui should land D39348 first and then you can rebase this in terms of that to discuss the remaining features (-R alias, no input files case).

[PkmX]

Abandoning as this has been implemented by another commit.

ELF/Driver.cpp

if (!Buffer.hasValue())
     return;
   MemoryBufferRef MBRef = *Buffer;
 
   if (InBinary) {
     Files.push_back(make<BinaryFile>(MBRef));
     return;
   }
 
   switch (identify_magic(MBRef.getBuffer())) {
   case file_magic::unknown:
     readLinkerScript(MBRef);
     return;
   case file_magic::archive: {
     // Handle -whole-archive.
     if (InWholeArchive) {
       for (const auto &P : getArchiveMembers(MBRef))
         Files.push_back(createObjectFile(P.first, Path, P.second));
void LinkerDriver::main(ArrayRef<const char *> ArgsArr, bool CanExitEarly) {
   case ELF64BEKind:
     link<ELF64BE>(Args);
     return;
   default:
     llvm_unreachable("unknown Config->EKind");
   }
 }
 
+static bool isJustSymbols(const Twine &Path) {
+  using namespace llvm::sys::fs;
+  return exists(Path) && !is_directory(Path);
+}
+
 static std::string getRpath(opt::InputArgList &Args) {
-  std::vector<StringRef> V = args::getStrings(Args, OPT_rpath);
+  std::vector<StringRef> V;
+  for (auto *Arg : Args) {
+    switch (Arg->getOption().getID()) {
+    case OPT_R:
+      if (isJustSymbols(Arg->getValue()))
+        break;
+      LLVM_FALLTHROUGH;
+    case OPT_rpath:
+      V.push_back(Arg->getValue());
+      break;
+    }
+  }
   return llvm::join(V.begin(), V.end(), ":");
 }
 
 // Determines what we should do if there are remaining unresolved
 // symbols after the name resolution.
 static UnresolvedPolicy getUnresolvedSymbolPolicy(opt::InputArgList &Args) {
   if (Args.hasArg(OPT_relocatable))
     return UnresolvedPolicy::IgnoreAll;
for (auto *Arg : Args) {
     case OPT_script:
       if (Optional<std::string> Path = searchLinkerScript(Arg->getValue())) {
         if (Optional<MemoryBufferRef> MB = readFile(*Path))
           readLinkerScript(*MB);
         break;
       }
       error(Twine("cannot find linker script ") + Arg->getValue());
       break;
+    case OPT_R:
+      if (!isJustSymbols(Arg->getValue()))
+        break;
+      LLVM_FALLTHROUGH;
+    // Handle a rarely-used, --just-symbols option.
+    //
+    // This option allows you to link your output against other existing
+    // program, so that if you load both the other program and your
+    // output to memory, your output can refer other program's symbols.
+    //
+    // What we are doing here is to read defined symbols from given ELF
+    // files and add them as absolute symbols.
+    case OPT_just_symbols: {
+      Optional<MemoryBufferRef> Buffer = readFile(Arg->getValue());
+      if (Buffer.hasValue())
+        Files.push_back(createJustSymbolsFile(*Buffer));
+      break;
+    }
     case OPT_as_needed:
       Config->AsNeeded = true;
       break;
     case OPT_format:
       InBinary = getBinaryOption(Arg->getValue());
       break;
     case OPT_no_as_needed:
       Config->AsNeeded = false;

ELF/InputFiles.h

 public:
   enum Kind {
     ObjKind,
     SharedKind,
     LazyObjKind,
     ArchiveKind,
     BitcodeKind,
     BinaryKind,
+    JustSymbolsKind,
   };
 
   Kind kind() const { return FileKind; }
 
   StringRef getName() const { return MB.getBufferIdentifier(); }
   MemoryBufferRef MB;
 
   // Returns sections. It is a runtime error to call this function
public:
   typedef typename ELFT::Shdr Elf_Shdr;
   typedef typename ELFT::Sym Elf_Sym;
   typedef typename ELFT::Word Elf_Word;
   typedef typename ELFT::SymRange Elf_Sym_Range;
 
   ELFFileBase(Kind K, MemoryBufferRef M);
   static bool classof(const InputFile *F) {
     Kind K = F->kind();
-    return K == ObjKind || K == SharedKind;
+    return K == ObjKind || K == SharedKind || K == JustSymbolsKind;
   }
 
   llvm::object::ELFFile<ELFT> getObj() const {
     return check(llvm::object::ELFFile<ELFT>::create(MB.getBuffer()));
   }
 
   StringRef getStringTable() const { return StringTable; }
 

 
 class BinaryFile : public InputFile {
 public:
   explicit BinaryFile(MemoryBufferRef M) : InputFile(BinaryKind, M) {}
   static bool classof(const InputFile *F) { return F->kind() == BinaryKind; }
   template <class ELFT> void parse();
 };
 
+template <class ELFT> class JustSymbolsFile : public ELFFileBase<ELFT> {
+public:
+  explicit JustSymbolsFile(MemoryBufferRef M)
+      : ELFFileBase<ELFT>(InputFile::JustSymbolsKind, M) {}
+  static bool classof(const InputFile *F) {
+    return F->kind() == InputFile::JustSymbolsKind;
+  }
+  void parse();
+};
+
 InputFile *createObjectFile(MemoryBufferRef MB, StringRef ArchiveName = "",
                             uint64_t OffsetInArchive = 0);
 InputFile *createSharedFile(MemoryBufferRef MB, StringRef DefaultSoName);
+InputFile *createJustSymbolsFile(MemoryBufferRef MB);
 
 extern std::vector<BinaryFile *> BinaryFiles;
 extern std::vector<BitcodeFile *> BitcodeFiles;
 extern std::vector<InputFile *> ObjectFiles;
 extern std::vector<InputFile *> SharedFiles;
 
 } // namespace elf
 } // namespace lld
 
 #endif

ELF/InputFiles.cpp

template <class ELFT> void BinaryFile::parse() {
   Symtab->addRegular<ELFT>(Saver.save(S + "_start"), STV_DEFAULT, STT_OBJECT,
                            0, 0, STB_GLOBAL, Section, nullptr);
   Symtab->addRegular<ELFT>(Saver.save(S + "_end"), STV_DEFAULT, STT_OBJECT,
                            Data.size(), 0, STB_GLOBAL, Section, nullptr);
   Symtab->addRegular<ELFT>(Saver.save(S + "_size"), STV_DEFAULT, STT_OBJECT,
                            Data.size(), 0, STB_GLOBAL, nullptr, nullptr);
 }
 
+template <class ELFT> void JustSymbolsFile<ELFT>::parse() {
+  typedef typename ELFT::Shdr Elf_Shdr;
+  typedef typename ELFT::Sym Elf_Sym;
+  typedef typename ELFT::SymRange Elf_Sym_Range;
+
+  StringRef ObjName = this->getName();
+  ELFFile<ELFT> Obj = this->getObj();
+
+  if (Obj.getHeader()->e_type != ET_EXEC)
+    error(toString(this) + ": --just-symbols only accepts ET_EXEC files");
+
+  ArrayRef<Elf_Shdr> Sections = CHECK(Obj.sections(), ObjName);
+
+  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);
+
+    for (const Elf_Sym &Sym : Syms.slice(FirstNonLocal))
+      if (Sym.st_shndx != SHN_UNDEF) {
+        StringRef SymName = CHECK(Sym.getName(StringTable), ObjName);
+        Symtab->addRegular<ELFT>(SymName, Sym.st_other, Sym.getType(),
+                                 Sym.st_value, Sym.st_size, Sym.getBinding(),
+                                 nullptr, nullptr);
+      }
+  }
+}
+
 static bool isBitcode(MemoryBufferRef MB) {
   using namespace sys::fs;
   return identify_magic(MB.getBuffer()) == file_magic::bitcode;
 }
 
 InputFile *elf::createObjectFile(MemoryBufferRef MB, StringRef ArchiveName,
                                  uint64_t OffsetInArchive) {
   if (isBitcode(MB))
case ELF64LEKind:
     return make<SharedFile<ELF64LE>>(MB, DefaultSoName);
   case ELF64BEKind:
     return make<SharedFile<ELF64BE>>(MB, DefaultSoName);
   default:
     llvm_unreachable("getELFKind");
   }
 }
 
+InputFile *elf::createJustSymbolsFile(MemoryBufferRef MB) {
+  switch (getELFKind(MB)) {
+  case ELF32LEKind:
+    return make<JustSymbolsFile<ELF32LE>>(MB);
+  case ELF32BEKind:
+    return make<JustSymbolsFile<ELF32BE>>(MB);
+  case ELF64LEKind:
+    return make<JustSymbolsFile<ELF64LE>>(MB);
+  case ELF64BEKind:
+    return make<JustSymbolsFile<ELF64BE>>(MB);
+  default:
+    llvm_unreachable("getELFKind");
+  }
+}
+
 MemoryBufferRef LazyObjFile::getBuffer() {
   if (Seen)
     return MemoryBufferRef();
   Seen = true;
   return MB;
 }
 
 InputFile *LazyObjFile::fetch() {

 template class elf::SharedFile<ELF32BE>;
 template class elf::SharedFile<ELF64LE>;
 template class elf::SharedFile<ELF64BE>;
 
 template void BinaryFile::parse<ELF32LE>();
 template void BinaryFile::parse<ELF32BE>();
 template void BinaryFile::parse<ELF64LE>();
 template void BinaryFile::parse<ELF64BE>();
+
+template class elf::JustSymbolsFile<ELF32LE>;
+template class elf::JustSymbolsFile<ELF32BE>;
+template class elf::JustSymbolsFile<ELF64LE>;
+template class elf::JustSymbolsFile<ELF64BE>;

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<"Just link symbols">;
+
 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">;
 

 def pie: F<"pie">, HelpText<"Create a position independent executable">;
 
 def print_gc_sections: F<"print-gc-sections">,
   HelpText<"List removed unused sections">;
 
 def print_map: F<"print-map">,
   HelpText<"Print a link map to the standard output">;
 
+def R: JoinedOrSeparate<["-"], "R">, HelpText<"Alias to --rpath or --just-symbols">;
+
 defm reproduce: Eq<"reproduce">,
   HelpText<"Dump linker invocation and input files for debugging">;
 
 defm rpath: Eq<"rpath">, HelpText<"Add a DT_RUNPATH to the output">;
 
 def relocatable: F<"relocatable">, HelpText<"Create relocatable object file">;
 
 defm retain_symbols_file: Eq<"retain-symbols-file">,

 def alias_library: JoinedOrSeparate<["-"], "l">, Alias<library>;
 def alias_library_path: JoinedOrSeparate<["-"], "L">, Alias<library_path>;
 def alias_omagic: Flag<["-"], "N">, Alias<omagic>;
 def alias_o_output: Joined<["--"], "output=">, Alias<o>;
 def alias_o_output2 : Separate<["--"], "output">, Alias<o>;
 def alias_pie_pic_executable: F<"pic-executable">, Alias<pie>;
 def alias_print_map_M: Flag<["-"], "M">, Alias<print_map>;
 def alias_relocatable_r: Flag<["-"], "r">, Alias<relocatable>;
-def alias_rpath_R: JoinedOrSeparate<["-"], "R">, Alias<rpath>;
 def alias_script_T: JoinedOrSeparate<["-"], "T">, Alias<script>;
 def alias_shared_Bshareable: F<"Bshareable">, Alias<shared>;
 def alias_soname_h: JoinedOrSeparate<["-"], "h">, Alias<soname>;
 def alias_strip_all: Flag<["-"], "s">, Alias<strip_all>;
 def alias_strip_debug_S: Flag<["-"], "S">, Alias<strip_debug>;
 def alias_trace: Flag<["-"], "t">, Alias<trace>;
 def alias_trace_symbol_y : JoinedOrSeparate<["-"], "y">, Alias<trace_symbol>;
 def alias_Ttext_segment: S<"Ttext-segment">, Alias<Ttext>;

ELF/SymbolTable.cpp

template <class ELFT> void SymbolTable::addFile(InputFile *File) {
 
   // Binary file
   if (auto *F = dyn_cast<BinaryFile>(File)) {
     BinaryFiles.push_back(F);
     F->parse<ELFT>();
     return;
   }
 
+  // --just-symbols file
+  if (auto *F = dyn_cast<JustSymbolsFile<ELFT>>(File)) {
+    F->parse();
+    return;
+  }
+
   // .a file
   if (auto *F = dyn_cast<ArchiveFile>(File)) {
     F->parse<ELFT>();
     return;
   }
 
   // Lazy object file
   if (auto *F = dyn_cast<LazyObjFile>(File)) {

test/ELF/Inputs/just-symbols.s

+.globl foo, bar
+foo:
+  ret
+
+.section .data
+.type bar, @object
+.size bar, 40
+bar:
+  .zero 40

test/ELF/just-symbols.s

+# REQUIRES: x86
+
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %S/Inputs/just-symbols.s -o %t1
+# RUN: ld.lld %t1 -o %t1.exe -Ttext=0x10000 -Tdata=0x11000
+
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t2
+# RUN: ld.lld %t2 -just-symbols=%t1.exe -o %t2.exe
+# RUN: llvm-readelf -symbols %t2.exe | FileCheck %s
+#
+# RUN: ld.lld -R %t1.exe -o %t3.exe
+# RUN: llvm-readelf -symbols %t3.exe | FileCheck %s
+
+# CHECK: 0000000000011000    40 OBJECT  GLOBAL DEFAULT  ABS bar
+# CHECK: 0000000000010000     0 NOTYPE  GLOBAL DEFAULT  ABS foo
+
+# RUN: not ld.lld -just-symbols=%t1 2>&1 | FileCheck %s --check-prefix CHECK-REL
+# CHECK-REL: error: {{.*}}: --just-symbols only accepts ET_EXEC files
+
+.globl _start
+_start:
+  call foo
+  call bar
+  ret