Re-implement --just-symbols as a regular object file.

[ruiu]

Summary

I tried a few different designs to find a way to implement it without
too much hassle and settled down with this. Unlike before, object files
given as arguments for --just-symbols are handled as object files, with
an exception that their section tables are handled as if they were all
null.

[• espindola]

lld/ELF/InputFiles.cpp

1178

This should reject non ET_EXEC.

lld/ELF/InputFiles.h

338

These typedefs are not used here. Please move to where they are needed.

[ruiu]

• address Rafael's comments

[ruiu]

• move typedefs

[• espindola]

Please rebase on top of trunk.

I like the idea of using --cref to show a benefit of having a regular object. Please copy it from D44516.

[• espindola]

In D42025#1039747, @espindola wrote:

Please rebase on top of trunk.

I like the idea of using --cref to show a benefit of having a regular object. Please copy it from D44516.

ping

[ruiu]

• re-implement the feature

[• espindola]

Nice idea!

lld/ELF/Driver.cpp

case OPT_Bdynamic:
       Config->Static = false;
       break;
     case OPT_whole_archive:
       InWholeArchive = true;
       break;
     case OPT_no_whole_archive:
       InWholeArchive = false;
       break;
+    case OPT_just_symbols:
+      if (Optional<MemoryBufferRef> MB = readFile(Arg->getValue()))
+        Files.push_back(createJustSymbolsFile(*MB));
+      break;
     case OPT_start_lib:
       InLib = true;
       break;
     case OPT_end_lib:
       InLib = false;
       break;
     }
   }

lld/ELF/InputFiles.h

 public:
   enum Kind {
     ObjKind,
     SharedKind,
     LazyObjKind,
     ArchiveKind,
     BitcodeKind,
     BinaryKind,
+    JustSymbolsKind,
   };
 
   Kind kind() const { return FileKind; }
 
   bool isElf() const {
     Kind K = kind();
-    return K == ObjKind || K == SharedKind;
+    return K == ObjKind || K == SharedKind || K == JustSymbolsKind;
   }
 
   StringRef getName() const { return MB.getBufferIdentifier(); }
   MemoryBufferRef MB;
 
   // Returns sections. It is a runtime error to call this function
   // on files that don't have the notion of sections.
   ArrayRef<InputSectionBase *> getSections() const {

 
 class BinaryFile : public InputFile {
 public:
   explicit BinaryFile(MemoryBufferRef M) : InputFile(BinaryKind, M) {}
   static bool classof(const InputFile *F) { return F->kind() == BinaryKind; }
   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

lld/ELF/InputFiles.cpp

case ELF64LEKind:
     return getElfSymbols<ELF64LE>();
   case ELF64BEKind:
     return getElfSymbols<ELF64BE>();
   default:
     llvm_unreachable("getELFKind");
   }
 }
 
+// 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.
+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->MB.getBufferIdentifier();
+  ELFFile<ELFT> Obj = check(ELFFile<ELFT>::create(this->MB.getBuffer()));
+  ArrayRef<Elf_Shdr> Sections = CHECK(Obj.sections(), ObjName);
+
+  if (Obj.getHeader()->e_type == ET_DYN)
+    error(ObjName +
+          ": --just-symbols does not make sense with a shared object");
+
+  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;
+  }
+}
+
+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");
+  }
+}
+
 template void ArchiveFile::parse<ELF32LE>();
 template void ArchiveFile::parse<ELF32BE>();
 template void ArchiveFile::parse<ELF64LE>();
 template void ArchiveFile::parse<ELF64BE>();
 
 template void BitcodeFile::parse<ELF32LE>(DenseSet<CachedHashStringRef> &);
 template void BitcodeFile::parse<ELF32BE>(DenseSet<CachedHashStringRef> &);
 template void BitcodeFile::parse<ELF64LE>(DenseSet<CachedHashStringRef> &);

 template class elf::ObjFile<ELF32BE>;
 template class elf::ObjFile<ELF64LE>;
 template class elf::ObjFile<ELF64BE>;
 
 template class elf::SharedFile<ELF32LE>;
 template class elf::SharedFile<ELF32BE>;
 template class elf::SharedFile<ELF64LE>;
 template class elf::SharedFile<ELF64BE>;
+
+template class elf::JustSymbolsFile<ELF32LE>;
+template class elf::JustSymbolsFile<ELF32BE>;
+template class elf::JustSymbolsFile<ELF64LE>;
+template class elf::JustSymbolsFile<ELF64BE>;

lld/ELF/Options.td

 def ignore_data_address_equality: F<"ignore-data-address-equality">,
   HelpText<"lld can break the address equality of data">;
 
 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">;
 

lld/ELF/SymbolTable.cpp

template <class ELFT> void SymbolTable::addFile(InputFile *File) {
 
   // LLVM bitcode file
   if (auto *F = dyn_cast<BitcodeFile>(File)) {
     BitcodeFiles.push_back(F);
     F->parse<ELFT>(ComdatGroups);
     return;
   }
 
+  // --just-symbols argument
+  if (auto *F = dyn_cast<JustSymbolsFile<ELFT>>(File)) {
+    F->parse();
+    return;
+  }
+
   // Regular object file
   ObjectFiles.push_back(File);
   cast<ObjFile<ELFT>>(File)->parse(ComdatGroups);
 }
 
 // This function is where all the optimizations of link-time
 // optimization happens. When LTO is in use, some input files are
 // not in native object file format but in the LLVM bitcode format.

lld/test/ELF/Inputs/just-symbols.s

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

lld/test/ELF/just-symbols.s

+# REQUIRES: x86
+
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %S/Inputs/just-symbols.s -o %t1.o
+# RUN: ld.lld %t1.o -o %t1.exe -Ttext=0x10000
+
+# RUN: ld.lld -just-symbols=%t1.exe -o %t2.exe
+# RUN: llvm-readelf -symbols %t2.exe | FileCheck %s
+
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t3.o
+# RUN: ld.lld %t3.o -just-symbols=%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: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %S/Inputs/just-symbols.s -o %t4.o
+# RUN: ld.lld -shared -o %t4.so %t4.o
+# RUN: not ld.lld -just-symbols=%t4.so 2>&1 | FileCheck -check-prefix=ERR %s
+
+# ERR: --just-symbols does not make sense with a shared object
+
+.globl _start
+_start:
+  call foo
+  call bar
+  ret