[WebAssembly] Add support for -emit-reloc

[sbc100]

Summary

This can be useful for post-link tools and for testing. Sometimes
it can be useful to produces a regular executable but with relocations
preserved.

[sbc100]

• cleanup

[sbc100]

• only include live syms

[ruiu]

LGTM

But I wonder what kind of tools need this flag in the wasm ecosystem. As far as I know, in the ELF world, Linux kernel is using this, but that is not an ordinary program.

[sbc100]

My motivation is mostly for testing purposes. I want to be able to include reloc information in the output without going for --relocatable .. mostly so objdump can tell me a little more about the output file. If you think thats not a good enough motivation I could reconsider.

[sbc100]

Specifically I want to use in https://reviews.llvm.org/D62380.

Once we have better objdump -d support this might not be necessary.

[ruiu]

All the existing use cases of the feature is somewhat tricky. But if you already have --relocatable, implementing --emit-relocs is pretty easy as you demonstrated. So, it's up to you, but I'd perhaps just submit this.

lld/ELF/Driver.cpp

 // Some Config members do not directly correspond to any particular
 // command line options, but computed based on other Config values.
 // This function initialize such members. See Config.h for the details
 // of these values.
 static void setConfigs(opt::InputArgList &Args) {
   ELFKind K = Config->EKind;
   uint16_t M = Config->EMachine;
 
-  Config->CopyRelocs = (Config->Relocatable || Config->EmitRelocs);
+  Config->CopyRelocs = Config->Relocatable || Config->EmitRelocs;
   Config->Is64 = (K == ELF64LEKind || K == ELF64BEKind);
   Config->IsLE = (K == ELF32LEKind || K == ELF64LEKind);
   Config->Endianness = Config->IsLE ? endianness::little : endianness::big;
   Config->IsMips64EL = (K == ELF64LEKind && M == EM_MIPS);
   Config->Pic = Config->Pie || Config->Shared;
   Config->PicThunk = Args.hasArg(OPT_pic_veneer, Config->Pic);
   Config->Wordsize = Config->Is64 ? 8 : 4;
 

lld/test/wasm/emit-relocs.ll

+; RUN: llc -filetype=obj %s -o %t.o
+; RUN: llc -filetype=obj %p/Inputs/ret32.ll -o %t.ret32.o
+; RUN: wasm-ld --emit-relocs -o %t.wasm %t.o %t.ret32.o
+; RUN: obj2yaml %t.wasm | FileCheck %s
+
+target triple = "wasm32-unknown-unknown"
+
+declare i32 @ret32(float)
+
+define hidden void @_start() local_unnamed_addr #0 {
+entry:
+  call i32 @ret32(float 0.0)
+  ret void
+}
+
+; CHECK:        - Type:            CODE
+; CHECK-NEXT:     Relocations:
+; CHECK-NEXT:       - Type:            R_WASM_FUNCTION_INDEX_LEB
+; CHECK-NEXT:         Index:           1
+; CHECK-NEXT:         Offset:          0x00000009
+
+; CHECK:        - Type:            CUSTOM
+; CHECK-NEXT:     Name:            linking
+; CHECK-NEXT:     Version:         2
+; CHECK-NEXT:     SymbolTable:
+; CHECK-NEXT:       - Index:           0
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            _start
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         Function:        0
+; CHECK-NEXT:       - Index:           1
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            ret32
+; CHECK-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
+; CHECK-NEXT:         Function:        1

lld/wasm/Config.h

 // and such fields have the same name as the corresponding options.
 // Most fields are initialized by the driver.
 struct Configuration {
   bool AllowUndefined;
   bool CheckFeatures;
   bool CompressRelocations;
   bool Demangle;
   bool DisableVerify;
+  bool EmitRelocs;
   bool ExportAll;
   bool ExportDynamic;
   bool ExportTable;
   bool GcSections;
   bool ImportMemory;
   bool SharedMemory;
   bool ImportTable;
   bool MergeDataSegments;
struct Configuration {
   llvm::StringSet<> AllowUndefinedSymbols;
   std::vector<llvm::StringRef> SearchPaths;
   llvm::CachePruningPolicy ThinLTOCachePolicy;
   llvm::Optional<std::vector<std::string>> Features;
 
   // The following config options do not directly correspond to any
   // particualr command line options.
 
+  // True if we need to pass through relocations in input files to the
+  // output file. Usually false because we consume relocations.
+  bool CopyRelocs;
+
   // True if we are creating position-independent code.
   bool Pic;
 };
 
 // The only instance of Configuration struct.
 extern Configuration *Config;
 
 } // namespace wasm
 } // namespace lld
 
 #endif

lld/wasm/Driver.cpp

 // Initializes Config members by the command line options.
 static void readConfigs(opt::InputArgList &Args) {
   Config->AllowUndefined = Args.hasArg(OPT_allow_undefined);
   Config->CheckFeatures =
       Args.hasFlag(OPT_check_features, OPT_no_check_features, true);
   Config->CompressRelocations = Args.hasArg(OPT_compress_relocations);
   Config->Demangle = Args.hasFlag(OPT_demangle, OPT_no_demangle, true);
   Config->DisableVerify = Args.hasArg(OPT_disable_verify);
+  Config->EmitRelocs = Args.hasArg(OPT_emit_relocs);
   Config->Entry = getEntry(Args);
   Config->ExportAll = Args.hasArg(OPT_export_all);
   Config->ExportDynamic = Args.hasFlag(OPT_export_dynamic,
       OPT_no_export_dynamic, false);
   Config->ExportTable = Args.hasArg(OPT_export_table);
   errorHandler().FatalWarnings =
       Args.hasFlag(OPT_fatal_warnings, OPT_no_fatal_warnings, false);
   Config->ImportMemory = Args.hasArg(OPT_import_memory);
static void readConfigs(opt::InputArgList &Args) {
   }
 }
 
 // Some Config members do not directly correspond to any particular
 // command line options, but computed based on other Config values.
 // This function initialize such members. See Config.h for the details
 // of these values.
 static void setConfigs() {
+  Config->CopyRelocs = Config->Relocatable || Config->EmitRelocs;
   Config->Pic = Config->Pie || Config->Shared;
 
   if (Config->Pic) {
     if (Config->ExportTable)
       error("-shared/-pie is incompatible with --export-table");
     Config->ImportTable = true;
   }
 

lld/wasm/Options.td

 
 def compress_relocations: F<"compress-relocations">,
   HelpText<"Compress the relocation targets in the code section.">;
 
 defm demangle: B<"demangle",
     "Demangle symbol names",
     "Do not demangle symbol names">;
 
+def emit_relocs: F<"emit-relocs">, HelpText<"Generate relocations in output">;
+
 defm export_dynamic: B<"export-dynamic",
     "Put symbols in the dynamic symbol table",
     "Do not put symbols in the dynamic symbol table (default)">;
 
 def entry: S<"entry">, MetaVarName<"<entry>">,
   HelpText<"Name of entry point symbol">;
 
 def error_limit: J<"error-limit=">,

lld/wasm/SyntheticSections.h

 // Create the custom "linking" section containing linker metadata.
 // This is only created when relocatable output is requested.
 class LinkingSection : public SyntheticSection {
 public:
   LinkingSection(const std::vector<WasmInitEntry> &InitFunctions,
                  const std::vector<OutputSegment *> &DataSegments)
       : SyntheticSection(llvm::wasm::WASM_SEC_CUSTOM, "linking"),
         InitFunctions(InitFunctions), DataSegments(DataSegments) {}
-  bool isNeeded() const override { return Config->Relocatable; }
+  bool isNeeded() const override {
+    return Config->Relocatable || Config->EmitRelocs;
+  }
   void writeBody() override;
   void addToSymtab(Symbol *Sym);
 
 protected:
   std::vector<const Symbol *> SymtabEntries;
   llvm::StringMap<uint32_t> SectionSymbolIndices;
   const std::vector<WasmInitEntry> &InitFunctions;
   const std::vector<OutputSegment *> &DataSegments;

lld/wasm/Writer.cpp

 
 void Writer::createCustomSections() {
   log("createCustomSections");
   for (auto &Pair : CustomSectionMapping) {
     StringRef Name = Pair.first();
     LLVM_DEBUG(dbgs() << "createCustomSection: " << Name << "\n");
 
     OutputSection *Sec = make<CustomSection>(Name, Pair.second);
-    if (Config->Relocatable) {
+    if (Config->CopyRelocs) {
       auto *Sym = make<OutputSectionSymbol>(Sec);
       Out.LinkingSec->addToSymtab(Sym);
       Sec->SectionSym = Sym;
     }
     addSection(Sec);
   }
 }
 
void Writer::addSections() {
   addSection(Out.DataCountSec);
 
   addSection(make<CodeSection>(Out.FunctionSec->InputFunctions));
   addSection(make<DataSection>(Segments));
 
   createCustomSections();
 
   addSection(Out.LinkingSec);
-  if (Config->Relocatable) {
+  if (Config->CopyRelocs) {
     createRelocSections();
   }
 
   addSection(Out.NameSec);
   addSection(Out.ProducersSec);
   addSection(Out.TargetFeaturesSec);
 }
 
for (Symbol *Sym : Symtab->getSymbols()) {
     }
 
     LLVM_DEBUG(dbgs() << "Export: " << Name << "\n");
     Out.ExportSec->Exports.push_back(Export);
   }
 }
 
 void Writer::populateSymtab() {
-  if (!Config->Relocatable)
+  if (!Config->CopyRelocs)
     return;
 
   for (Symbol *Sym : Symtab->getSymbols())
     if (Sym->IsUsedInRegularObj)
       Out.LinkingSec->addToSymtab(Sym);
 
   for (ObjFile *File : Symtab->ObjectFiles) {
     LLVM_DEBUG(dbgs() << "Local symtab entries: " << File->getName() << "\n");