[WebAssembly] Improve support for "needed" list in dylink section

[sbc100]

Summary

This change adds basic support for shared library dependencies
via the dylink section.

See https://github.com/WebAssembly/tool-conventions/pull/77

[sbc100]

• move to mono-repo

[ruiu]

Is this ready for review? It doesn't seem to create a valid executable though, as there's no code to emit filenames of shared object files.

[sbc100]

• add test

[sbc100]

• remove assert

[sbc100]

• clang-format

[sbc100]

This change is now ready for review. Please note that this is only the most simple support for .so file. All it does is add each library to the "needed" section, it doesn't do any symbol resolution against the shared libraries yet.

[ruiu]

lld/wasm/Writer.cpp

504

Maybe it is better to avoid auto and make it explicit as SharedFile *

505

nit: you can omit llvm::.

llvm/lib/Object/WasmObjectFile.cpp

327

Is this dead code?

[sbc100]

llvm/lib/Object/WasmObjectFile.cpp

327

Its fixing a bug that isSharedLibrary(), which is only ever used by lld, was always returning false.

I guess at least some other tool such as objdump should probably be calling that and displaying different output for shared libs.

[ruiu]

LGTM with the previous comments fixed.

llvm/lib/Object/WasmObjectFile.cpp

327

Got it. We eventually need a test, but it doesn't have to be at this time.

lld/test/wasm/shared-needed.ll

+; RUN: llc -filetype=obj %s -o %t.o
+; RUN: llc -filetype=obj %p/Inputs/ret32.ll -o %t.ret32.o
+
+; RUN: wasm-ld -shared -o %t1.so %t.o
+; RUN: obj2yaml %t1.so | FileCheck %s -check-prefix=SO1
+
+; RUN: wasm-ld -shared -o %t2.so %t1.so %t.ret32.o
+; RUN: obj2yaml %t2.so | FileCheck %s -check-prefix=SO2
+
+target triple = "wasm32-unknown-unknown"
+
+@data = global i32 2, align 4
+
+define default void @foo() {
+entry:
+  ret void
+}
+
+; SO1:      Sections:
+; SO1-NEXT:   - Type:            CUSTOM
+; SO1-NEXT:     Name:            dylink
+; SO1-NEXT:     MemorySize:      4
+; SO1-NEXT:     MemoryAlignment: 2
+; SO1-NEXT:     TableSize:       0
+; SO1-NEXT:     TableAlignment:  0
+; SO1-NEXT:     Needed:          []
+; SO1-NEXT:   - Type:            TYPE
+
+; SO2:      Sections:
+; SO2-NEXT:   - Type:            CUSTOM
+; SO2-NEXT:     Name:            dylink
+; SO2-NEXT:     MemorySize:      0
+; SO2-NEXT:     MemoryAlignment: 0
+; SO2-NEXT:     TableSize:       0
+; SO2-NEXT:     TableAlignment:  0
+; SO2-NEXT:     Needed:
+; SO2-NEXT:       - shared-needed.ll.tmp1.so
+; SO2-NEXT:   - Type:            TYPE

lld/test/wasm/shared.ll

 
 ; CHECK:      Sections:
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            dylink
 ; CHECK-NEXT:     MemorySize:      8
 ; CHECK-NEXT:     MemoryAlignment: 2
 ; CHECK-NEXT:     TableSize:       2
 ; CHECK-NEXT:     TableAlignment:  0
+; CHECK-NEXT:     Needed:          []
+; CHECK-NEXT:   - Type:            TYPE
 
 ; check for import of __table_base and __memory_base globals
 
 ; CHECK:        - Type:            IMPORT
 ; CHECK-NEXT:     Imports:
 ; CHECK-NEXT:       - Module:          env
 ; CHECK-NEXT:         Field:           __indirect_function_table
 ; CHECK-NEXT:         Kind:            TABLE

lld/wasm/InputFiles.h

 class InputGlobal;
 class InputEvent;
 class InputSection;
 
 class InputFile {
 public:
   enum Kind {
     ObjectKind,
+    SharedKind,
     ArchiveKind,
     BitcodeKind,
   };
 
   virtual ~InputFile() {}
 
   // Returns the filename.
   StringRef getName() const { return MB.getBufferIdentifier(); }
private:
   Symbol *createDefined(const WasmSymbol &Sym);
   Symbol *createUndefined(const WasmSymbol &Sym);
 
   bool isExcludedByComdat(InputChunk *Chunk) const;
 
   std::unique_ptr<WasmObjectFile> WasmObj;
 };
 
+// .so file.
+class SharedFile : public InputFile {
+public:
+  explicit SharedFile(MemoryBufferRef M) : InputFile(SharedKind, M) {}
+  static bool classof(const InputFile *F) { return F->kind() == SharedKind; }
+
+  void parse() override {}
+};
+
+// .bc file
 class BitcodeFile : public InputFile {
 public:
   explicit BitcodeFile(MemoryBufferRef M) : InputFile(BitcodeKind, M) {}
   static bool classof(const InputFile *F) { return F->kind() == BitcodeKind; }
 
   void parse() override;
   std::unique_ptr<llvm::lto::InputFile> Obj;
 };

lld/wasm/InputFiles.cpp

Optional<MemoryBufferRef> lld::wasm::readFile(StringRef Path) {
   MemoryBufferRef MBRef = MB->getMemBufferRef();
   make<std::unique_ptr<MemoryBuffer>>(std::move(MB)); // take MB ownership
 
   return MBRef;
 }
 
 InputFile *lld::wasm::createObjectFile(MemoryBufferRef MB) {
   file_magic Magic = identify_magic(MB.getBuffer());
-  if (Magic == file_magic::wasm_object)
+  if (Magic == file_magic::wasm_object) {
+    std::unique_ptr<Binary> Bin = check(createBinary(MB));
+    auto *Obj = cast<WasmObjectFile>(Bin.get());
+    if (Obj->isSharedObject())
+      return make<SharedFile>(MB);
     return make<ObjFile>(MB);
+  }
 
   if (Magic == file_magic::bitcode)
     return make<BitcodeFile>(MB);
 
   fatal("unknown file type: " + MB.getBufferIdentifier());
 }
 
 void ObjFile::dumpInfo() const {

lld/wasm/SymbolTable.h

 // add*() functions, which are called by input files as they are parsed.
 // There is one add* function per symbol type.
 class SymbolTable {
 public:
   void addFile(InputFile *File);
   void addCombinedLTOObject();
 
   std::vector<ObjFile *> ObjectFiles;
+  std::vector<InputFile *> SharedFiles;
   std::vector<BitcodeFile *> BitcodeFiles;
   std::vector<InputFunction *> SyntheticFunctions;
   std::vector<InputGlobal *> SyntheticGlobals;
 
   void reportRemainingUndefines();
 
   ArrayRef<Symbol *> getSymbols() const { return SymVector; }
 

lld/wasm/SymbolTable.cpp

if (Config->Trace)
     message(toString(File));
   File->parse();
 
   // LLVM bitcode file
   if (auto *F = dyn_cast<BitcodeFile>(File))
     BitcodeFiles.push_back(F);
   else if (auto *F = dyn_cast<ObjFile>(File))
     ObjectFiles.push_back(F);
+  else if (auto *F = dyn_cast<SharedFile>(File))
+    SharedFiles.push_back(F);
 }
 
 // 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.
 // This function compiles bitcode files into a few big native files
 // using LLVM functions and replaces bitcode symbols with the results.
 // Because all bitcode files that the program consists of are passed

lld/wasm/Writer.cpp

 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/BinaryFormat/Wasm.h"
 #include "llvm/Object/WasmTraits.h"
 #include "llvm/Support/FileOutputBuffer.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/LEB128.h"
+#include "llvm/Support/Path.h"
 
 #include <cstdarg>
 #include <map>
 
 #define DEBUG_TYPE "lld"
 
 using namespace llvm;
 using namespace llvm::wasm;

 void Writer::createDylinkSection() {
   SyntheticSection *Section = createSyntheticSection(WASM_SEC_CUSTOM, "dylink");
   raw_ostream &OS = Section->getStream();
 
   writeUleb128(OS, MemSize, "MemSize");
   writeUleb128(OS, MemAlign, "MemAlign");
   writeUleb128(OS, IndirectFunctions.size(), "TableSize");
   writeUleb128(OS, 0, "TableAlign");
-  writeUleb128(OS, 0, "Needed");  // TODO: Support "needed" shared libraries
+  writeUleb128(OS, Symtab->SharedFiles.size(), "Needed");  // TODO: Support "needed" shared libraries
+  for (auto* SO : Symtab->SharedFiles) {
+    writeStr(OS, llvm::sys::path::filename(SO->getName()), "so name");
+  }
 }
 
 // Create the custom "linking" section containing linker metadata.
 // This is only created when relocatable output is requested.
 void Writer::createLinkingSection() {
   SyntheticSection *Section =
       createSyntheticSection(WASM_SEC_CUSTOM, "linking");
   raw_ostream &OS = Section->getStream();

llvm/lib/Object/WasmObjectFile.cpp

Error WasmObjectFile::parseSection(WasmSection &Sec) {
   default:
     return make_error<GenericBinaryError>("Bad section type",
                                           object_error::parse_failed);
   }
 }
 
 Error WasmObjectFile::parseDylinkSection(ReadContext &Ctx) {
   // See https://github.com/WebAssembly/tool-conventions/blob/master/DynamicLinking.md
+  HasDylinkSection = true;
   DylinkInfo.MemorySize = readVaruint32(Ctx);
   DylinkInfo.MemoryAlignment = readVaruint32(Ctx);
   DylinkInfo.TableSize = readVaruint32(Ctx);
   DylinkInfo.TableAlignment = readVaruint32(Ctx);
   uint32_t Count = readVaruint32(Ctx);
   while (Count--) {
     DylinkInfo.Needed.push_back(readString(Ctx));
   }