[WebAssembly] Add import info to `dylink` section of shared libraries

[sbc100]

Summary

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

[dschuff]

lld/wasm/SyntheticSections.cpp

77

out exports and/or exports?

82

87

don't need sym->IsLive() in the inner condition now

91

is it only for weak undef symbols? What about just regular strong undef symbols?

[sbc100]

feedback

[sbc100]

lld/wasm/SyntheticSections.cpp

91

We don't need to export any extra flags for that case.. i.e. strong is the default for imports.

[sbc100]

• rebase

[sbc100]

ping..

lld/test/wasm/shared-weak-undefined.s

+# RUN: llvm-mc -filetype=obj -triple=wasm32-unknown-unknown -o %t.o %s
+# RUN: wasm-ld --experimental-pic -shared -o %t.wasm %t.o
+# RUN: obj2yaml %t.wasm | FileCheck %s
+# RUN: llvm-objdump -d %t.wasm | FileCheck %s -check-prefix=ASM
+
+# Verify the weak undefined symbols are marked as such in the
+# dylink section.
+
+.weak weak_func
+.functype weak_func () -> (i32)
+
+.globl call_weak
+call_weak:
+# ASM: <call_weak>:
+  .functype call_weak () -> (i32)
+  call weak_func
+# ASM:           10 80 80 80 80 00      call  0
+  end_function
+# ASM-NEXT:      0b                     end
+
+#      CHECK: Sections:
+# CHECK-NEXT:   - Type:            CUSTOM
+# CHECK-NEXT:     Name:            dylink.0
+# CHECK-NEXT:     MemorySize:      0
+# CHECK-NEXT:     MemoryAlignment: 0
+# CHECK-NEXT:     TableSize:       0
+# CHECK-NEXT:     TableAlignment:  0
+# CHECK-NEXT:     Needed:          []
+# CHECK-NEXT:     ImportInfo:
+# CHECK-NEXT:       - Module:          env
+# CHECK-NEXT:         Field:           weak_func
+# CHECK-NEXT:         Flags:           [ BINDING_WEAK, UNDEFINED ]

lld/wasm/SyntheticSections.cpp

void DylinkSection::writeBody() {
   if (symtab->sharedFiles.size()) {
     SubSection sub(WASM_DYLINK_NEEDED);
     writeUleb128(sub.os, symtab->sharedFiles.size(), "Needed");
     for (auto *so : symtab->sharedFiles)
       writeStr(sub.os, llvm::sys::path::filename(so->getName()), "so name");
     sub.writeTo(os);
   }
 
-  // Under certain circumstances we need to include extra information about the
-  // exports we are providing to the dynamic linker.  Currently this is only the
-  // case for TLS symbols where the exported value is relative to __tls_base
-  // rather than __memory_base.
+  // Under certain circumstances we need to include extra information about out
+  // exports and/or exports to the dynamic linker.
+  // For exports we need to notify the linker when an export is TLS since the
+  // exported value is relative to __tls_base rather than __memory_base.
+  // For imports we need to notify the dynamic linker when an import is weak
+  // so that knows not to report and error for such symbols.
+  std::vector<const Symbol *> importInfo;
   std::vector<const Symbol *> exportInfo;
   for (const Symbol *sym : symtab->getSymbols()) {
+    if (sym->isLive()) {
       if (sym->isExported() && sym->isLive() && sym->isTLS() &&
           isa<DefinedData>(sym)) {
         exportInfo.push_back(sym);
       }
+      if (sym->isUndefWeak()) {
+        importInfo.push_back(sym);
+      }
+    }
   }
 
   if (!exportInfo.empty()) {
     SubSection sub(WASM_DYLINK_EXPORT_INFO);
     writeUleb128(sub.os, exportInfo.size(), "num exports");
 
     for (const Symbol *sym : exportInfo) {
       LLVM_DEBUG(llvm::dbgs() << "export info: " << toString(*sym) << "\n");
       StringRef name = sym->getName();
       if (auto *f = dyn_cast<DefinedFunction>(sym)) {
         if (Optional<StringRef> exportName = f->function->getExportName()) {
           name = *exportName;
         }
       }
       writeStr(sub.os, name, "sym name");
       writeUleb128(sub.os, sym->flags, "sym flags");
     }
 
     sub.writeTo(os);
   }
+
+  if (!importInfo.empty()) {
+    SubSection sub(WASM_DYLINK_IMPORT_INFO);
+    writeUleb128(sub.os, importInfo.size(), "num imports");
+
+    for (const Symbol *sym : importInfo) {
+      LLVM_DEBUG(llvm::dbgs() << "imports info: " << toString(*sym) << "\n");
+      StringRef module = sym->importModule.getValueOr(defaultModule);
+      StringRef name = sym->importName.getValueOr(sym->getName());
+      writeStr(sub.os, module, "import module");
+      writeStr(sub.os, name, "import name");
+      writeUleb128(sub.os, sym->flags, "sym flags");
+    }
+
+    sub.writeTo(os);
+  }
 }
 
 uint32_t TypeSection::registerType(const WasmSignature &sig) {
   auto pair = typeIndices.insert(std::make_pair(sig, types.size()));
   if (pair.second) {
     LLVM_DEBUG(llvm::dbgs() << "type " << toString(sig) << "\n");
     types.push_back(&sig);
   }

llvm/include/llvm/BinaryFormat/Wasm.h

 // Wasm uses a 64k page size
 const uint32_t WasmPageSize = 65536;
 
 struct WasmObjectHeader {
   StringRef Magic;
   uint32_t Version;
 };
 
-struct WasmDylinkExport {
+struct WasmDylinkImportInfo {
+  StringRef Module;
+  StringRef Field;
+  uint32_t Flags;
+};
+
+struct WasmDylinkExportInfo {
   StringRef Name;
   uint32_t Flags;
 };
 
 struct WasmDylinkInfo {
   uint32_t MemorySize; // Memory size in bytes
   uint32_t MemoryAlignment;  // P2 alignment of memory
   uint32_t TableSize;  // Table size in elements
   uint32_t TableAlignment;  // P2 alignment of table
   std::vector<StringRef> Needed; // Shared library dependencies
-  std::vector<WasmDylinkExport> ExportInfo; // Shared library dependencies
+  std::vector<WasmDylinkImportInfo> ImportInfo;
+  std::vector<WasmDylinkExportInfo> ExportInfo;
 };
 
 struct WasmProducerInfo {
   std::vector<std::pair<std::string, std::string>> Languages;
   std::vector<std::pair<std::string, std::string>> Tools;
   std::vector<std::pair<std::string, std::string>> SDKs;
 };
 
enum : unsigned {
   WASM_SYMBOL_TABLE = 0x8,
 };
 
 // Kind codes used in the custom "dylink" section
 enum : unsigned {
   WASM_DYLINK_MEM_INFO = 0x1,
   WASM_DYLINK_NEEDED = 0x2,
   WASM_DYLINK_EXPORT_INFO = 0x3,
+  WASM_DYLINK_IMPORT_INFO = 0x4,
 };
 
 // Kind codes used in the custom "linking" section in the WASM_COMDAT_INFO
 enum : unsigned {
   WASM_COMDAT_DATA = 0x0,
   WASM_COMDAT_FUNCTION = 0x1,
   // GLOBAL, TAG, and TABLE are in here but LLVM doesn't use them yet.
   WASM_COMDAT_SECTION = 0x5,

llvm/include/llvm/ObjectYAML/WasmYAML.h

struct CustomSection : Section {
   static bool classof(const Section *S) {
     return S->Type == wasm::WASM_SEC_CUSTOM;
   }
 
   StringRef Name;
   yaml::BinaryRef Payload;
 };
 
-struct DylinkExport {
+struct DylinkImportInfo {
+  StringRef Module;
+  StringRef Field;
+  SymbolFlags Flags;
+};
+
+struct DylinkExportInfo {
   StringRef Name;
   SymbolFlags Flags;
 };
 
 struct DylinkSection : CustomSection {
   DylinkSection() : CustomSection("dylink.0") {}
 
   static bool classof(const Section *S) {
     auto C = dyn_cast<CustomSection>(S);
     return C && C->Name == "dylink.0";
   }
 
   uint32_t MemorySize;
   uint32_t MemoryAlignment;
   uint32_t TableSize;
   uint32_t TableAlignment;
   std::vector<StringRef> Needed;
-  std::vector<DylinkExport> ExportInfo;
+  std::vector<DylinkImportInfo> ImportInfo;
+  std::vector<DylinkExportInfo> ExportInfo;
 };
 
 struct NameSection : CustomSection {
   NameSection() : CustomSection("name") {}
 
   static bool classof(const Section *S) {
     auto C = dyn_cast<CustomSection>(S);
     return C && C->Name == "name";

 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::NameEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::ProducerEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::FeatureEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::SegmentInfo)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::SymbolInfo)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::InitFunction)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::ComdatEntry)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Comdat)
-LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::DylinkExport)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::DylinkImportInfo)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::DylinkExportInfo)
 
 namespace llvm {
 namespace yaml {
 
 template <> struct MappingTraits<WasmYAML::FileHeader> {
   static void mapping(IO &IO, WasmYAML::FileHeader &FileHdr);
 };
 

 template <> struct ScalarEnumerationTraits<WasmYAML::Opcode> {
   static void enumeration(IO &IO, WasmYAML::Opcode &Opcode);
 };
 
 template <> struct ScalarEnumerationTraits<WasmYAML::RelocType> {
   static void enumeration(IO &IO, WasmYAML::RelocType &Kind);
 };
 
-template <> struct MappingTraits<WasmYAML::DylinkExport> {
-  static void mapping(IO &IO, WasmYAML::DylinkExport &Export);
+template <> struct MappingTraits<WasmYAML::DylinkImportInfo> {
+  static void mapping(IO &IO, WasmYAML::DylinkImportInfo &Info);
+};
+
+template <> struct MappingTraits<WasmYAML::DylinkExportInfo> {
+  static void mapping(IO &IO, WasmYAML::DylinkExportInfo &Info);
 };
 
 } // end namespace yaml
 } // end namespace llvm
 
 #endif // LLVM_OBJECTYAML_WASMYAML_H

llvm/lib/Object/WasmObjectFile.cpp

case wasm::WASM_DYLINK_NEEDED:
       break;
     case wasm::WASM_DYLINK_EXPORT_INFO: {
       uint32_t Count = readVaruint32(Ctx);
       while (Count--) {
         DylinkInfo.ExportInfo.push_back({readString(Ctx), readVaruint32(Ctx)});
       }
       break;
     }
+    case wasm::WASM_DYLINK_IMPORT_INFO: {
+      uint32_t Count = readVaruint32(Ctx);
+      while (Count--) {
+        DylinkInfo.ImportInfo.push_back(
+            {readString(Ctx), readString(Ctx), readVaruint32(Ctx)});
+      }
+      break;
+    }
     default:
       LLVM_DEBUG(dbgs() << "unknown dylink.0 sub-section: " << Type << "\n");
       Ctx.Ptr += Size;
       break;
     }
     if (Ctx.Ptr != Ctx.End) {
       return make_error<GenericBinaryError>(
           "dylink.0 sub-section ended prematurely", object_error::parse_failed);

llvm/lib/ObjectYAML/WasmYAML.cpp

 static void sectionMapping(IO &IO, WasmYAML::DylinkSection &Section) {
   commonSectionMapping(IO, Section);
   IO.mapRequired("Name", Section.Name);
   IO.mapRequired("MemorySize", Section.MemorySize);
   IO.mapRequired("MemoryAlignment", Section.MemoryAlignment);
   IO.mapRequired("TableSize", Section.TableSize);
   IO.mapRequired("TableAlignment", Section.TableAlignment);
   IO.mapRequired("Needed", Section.Needed);
+  IO.mapOptional("ImportInfo", Section.ImportInfo);
   IO.mapOptional("ExportInfo", Section.ExportInfo);
 }
 
 static void sectionMapping(IO &IO, WasmYAML::NameSection &Section) {
   commonSectionMapping(IO, Section);
   IO.mapRequired("Name", Section.Name);
   IO.mapOptional("FunctionNames", Section.FunctionNames);
   IO.mapOptional("GlobalNames", Section.GlobalNames);
if (Info.Kind == wasm::WASM_SYMBOL_TYPE_FUNCTION) {
     }
   } else if (Info.Kind == wasm::WASM_SYMBOL_TYPE_SECTION) {
     IO.mapRequired("Section", Info.ElementIndex);
   } else {
     llvm_unreachable("unsupported symbol kind");
   }
 }
 
-void MappingTraits<WasmYAML::DylinkExport>::mapping(
-    IO &IO, WasmYAML::DylinkExport &Export) {
-  IO.mapRequired("Name", Export.Name);
-  IO.mapRequired("Flags", Export.Flags);
+void MappingTraits<WasmYAML::DylinkImportInfo>::mapping(
+    IO &IO, WasmYAML::DylinkImportInfo &Info) {
+  IO.mapRequired("Module", Info.Module);
+  IO.mapRequired("Field", Info.Field);
+  IO.mapRequired("Flags", Info.Flags);
+}
+
+void MappingTraits<WasmYAML::DylinkExportInfo>::mapping(
+    IO &IO, WasmYAML::DylinkExportInfo &Info) {
+  IO.mapRequired("Name", Info.Name);
+  IO.mapRequired("Flags", Info.Flags);
 }
 
 void ScalarBitSetTraits<WasmYAML::LimitFlags>::bitset(
     IO &IO, WasmYAML::LimitFlags &Value) {
 #define BCase(X) IO.bitSetCase(Value, #X, wasm::WASM_LIMITS_FLAG_##X)
   BCase(HAS_MAX);
   BCase(IS_SHARED);
   BCase(IS_64);

llvm/tools/obj2yaml/wasm2yaml.cpp

if (WasmSec.Name == "dylink" || WasmSec.Name == "dylink.0") {
     std::unique_ptr<WasmYAML::DylinkSection> DylinkSec =
         std::make_unique<WasmYAML::DylinkSection>();
     const wasm::WasmDylinkInfo& Info = Obj.dylinkInfo();
     DylinkSec->MemorySize = Info.MemorySize;
     DylinkSec->MemoryAlignment = Info.MemoryAlignment;
     DylinkSec->TableSize = Info.TableSize;
     DylinkSec->TableAlignment = Info.TableAlignment;
     DylinkSec->Needed = Info.Needed;
+    for (const auto &Imp : Info.ImportInfo)
+      DylinkSec->ImportInfo.push_back({Imp.Module, Imp.Field, Imp.Flags});
     for (const auto &Exp : Info.ExportInfo)
       DylinkSec->ExportInfo.push_back({Exp.Name, Exp.Flags});
     CustomSec = std::move(DylinkSec);
   } else if (WasmSec.Name == "name") {
     std::unique_ptr<WasmYAML::NameSection> NameSec =
         std::make_unique<WasmYAML::NameSection>();
     for (const llvm::wasm::WasmDebugName &Name : Obj.debugNames()) {
       WasmYAML::NameEntry NameEntry;