[WebAssembly] Add support for weak symbols in the binary format

[sbc100]

Summary

Still needs test code

[sbc100]

Rebase

[sunfish]

LGTM

include/llvm/ObjectYAML/WasmYAML.h

124 ↗

(On Diff #102408)

This constructor can be marked explicit.

[sbc100]

• Reference symbols by name in linking section

[sbc100]

• Explicit constructors

[chapuni]

llvm/trunk/lib/MC/WasmObjectWriter.cpp

1095 ↗

(On Diff #103143)

Could we avoid leaving such a line, possibly snippet?

include/llvm/BinaryFormat/Wasm.h

enum class ValType {
   I64 = WASM_TYPE_I64,
   F32 = WASM_TYPE_F32,
   F64 = WASM_TYPE_F64,
 };
 
 // Linking metadata kinds.
 enum : unsigned {
   WASM_STACK_POINTER = 0x1,
+  WASM_SYMBOL_INFO  = 0x2,
+};
+
+enum : unsigned {
+  WASM_SYMBOL_FLAG_WEAK = 0x1,
 };
 
 #define WASM_RELOC(name, value) name = value,
 
 enum : unsigned {
 #include "WasmRelocs/WebAssembly.def"
 };
 

include/llvm/MC/MCWasmObjectWriter.h

 //===-- llvm/MC/MCWasmObjectWriter.h - Wasm Object Writer -------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_MC_MCWASMOBJECTWRITER_H
 #define LLVM_MC_MCWASMOBJECTWRITER_H
 
 #include "llvm/ADT/Triple.h"
 #include "llvm/BinaryFormat/Wasm.h"
 #include "llvm/MC/MCValue.h"
+#include "llvm/MC/MCSymbolWasm.h"
 #include "llvm/Support/DataTypes.h"
 #include "llvm/Support/raw_ostream.h"
 #include <vector>
 
 namespace llvm {
 class MCAssembler;
 class MCContext;
 class MCFixup;

include/llvm/Object/Wasm.h

public:
 
   WasmSymbol(StringRef Name, SymbolType Type, uint32_t Section,
              uint32_t ElementIndex)
       : Name(Name), Type(Type), Section(Section), ElementIndex(ElementIndex) {}
 
   StringRef Name;
   SymbolType Type;
   uint32_t Section;
+  uint32_t Flags = 0;
 
   // For imports, this is an import index
   // For exports, this is an export index
   // For debug names, this is a function index
   uint32_t ElementIndex;
+
+  void print(raw_ostream &Out) const {
+    Out << "Name=" << Name << ", Type=" << static_cast<int>(Type) << ", Flags=" << Flags;
+  }
+
+  #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+  LLVM_DUMP_METHOD void dump() const { print(dbgs()); }
+  #endif
 };
 
 class WasmSection {
 public:
   WasmSection() = default;
 
   uint32_t Type = 0; // Section type (See below)
   uint32_t Offset = 0; // Offset with in the file
   StringRef Name; // Section name (User-defined sections only)
   ArrayRef<uint8_t> Content; // Section content
   std::vector<wasm::WasmRelocation> Relocations; // Relocations for this section
 };
 
+struct WasmExportSym {
+  wasm::WasmExport Export;
+  uint32_t Symbol;
+};
+
+struct WasmImportSym {
+  wasm::WasmImport Import;
+  uint32_t Symbol;
+};
+
 class WasmObjectFile : public ObjectFile {
+
 public:
   WasmObjectFile(MemoryBufferRef Object, Error &Err);
 
   const wasm::WasmObjectHeader &getHeader() const;
   const WasmSymbol &getWasmSymbol(const DataRefImpl &Symb) const;
   const WasmSymbol &getWasmSymbol(const SymbolRef &Symbol) const;
   const WasmSection &getWasmSection(const SectionRef &Section) const;
   const wasm::WasmRelocation &getWasmRelocation(const RelocationRef& Ref) const;
 
   static bool classof(const Binary *v) { return v->isWasm(); }
 
   const std::vector<wasm::WasmSignature>& types() const { return Signatures; }
   const std::vector<uint32_t>& functionTypes() const { return FunctionTypes; }
-  const std::vector<wasm::WasmImport>& imports() const { return Imports; }
+  const std::vector<WasmImportSym>& imports() const { return Imports; }
   const std::vector<wasm::WasmTable>& tables() const { return Tables; }
   const std::vector<wasm::WasmLimits>& memories() const { return Memories; }
   const std::vector<wasm::WasmGlobal>& globals() const { return Globals; }
-  const std::vector<wasm::WasmExport>& exports() const { return Exports; }
+  const std::vector<WasmExportSym>& exports() const { return Exports; }
 
   uint32_t getNumberOfSymbols() const {
     return Symbols.size();
   }
 
   const std::vector<wasm::WasmElemSegment>& elements() const {
     return ElemSegments;
   }
public:
   bool isRelocatableObject() const override;
 
 private:
   const WasmSection &getWasmSection(DataRefImpl Ref) const;
   const wasm::WasmRelocation &getWasmRelocation(DataRefImpl Ref) const;
 
   WasmSection* findCustomSectionByName(StringRef Name);
   WasmSection* findSectionByType(uint32_t Type);
+  BasicSymbolRef makeSymbolRef(uint32_t Index) const;
 
   const uint8_t *getPtr(size_t Offset) const;
   Error parseSection(WasmSection &Sec);
   Error parseCustomSection(WasmSection &Sec, const uint8_t *Ptr,
                            const uint8_t *End);
 
   // Standard section types
   Error parseTypeSection(const uint8_t *Ptr, const uint8_t *End);
   Error parseImportSection(const uint8_t *Ptr, const uint8_t *End);
   Error parseFunctionSection(const uint8_t *Ptr, const uint8_t *End);
   Error parseTableSection(const uint8_t *Ptr, const uint8_t *End);
   Error parseMemorySection(const uint8_t *Ptr, const uint8_t *End);
   Error parseGlobalSection(const uint8_t *Ptr, const uint8_t *End);
   Error parseExportSection(const uint8_t *Ptr, const uint8_t *End);
   Error parseStartSection(const uint8_t *Ptr, const uint8_t *End);
   Error parseElemSection(const uint8_t *Ptr, const uint8_t *End);
   Error parseCodeSection(const uint8_t *Ptr, const uint8_t *End);
   Error parseDataSection(const uint8_t *Ptr, const uint8_t *End);
 
   // Custom section types
   Error parseNameSection(const uint8_t *Ptr, const uint8_t *End);
+  Error parseLinkingSection(const uint8_t *Ptr, const uint8_t *End);
   Error parseRelocSection(StringRef Name, const uint8_t *Ptr,
                           const uint8_t *End);
 
   wasm::WasmObjectHeader Header;
   std::vector<WasmSection> Sections;
   std::vector<wasm::WasmSignature> Signatures;
   std::vector<uint32_t> FunctionTypes;
   std::vector<wasm::WasmTable> Tables;
   std::vector<wasm::WasmLimits> Memories;
   std::vector<wasm::WasmGlobal> Globals;
-  std::vector<wasm::WasmImport> Imports;
-  std::vector<wasm::WasmExport> Exports;
+  std::vector<WasmImportSym> Imports;
+  std::vector<WasmExportSym> Exports;
   std::vector<wasm::WasmElemSegment> ElemSegments;
   std::vector<wasm::WasmDataSegment> DataSegments;
   std::vector<WasmSymbol> Symbols;
   std::vector<wasm::WasmFunction> Functions;
   ArrayRef<uint8_t> CodeSection;
   uint32_t StartFunction = -1;
 };
 
 } // end namespace object
+
+inline raw_ostream &operator<<(raw_ostream &OS,
+                               const object::WasmSymbol &Sym) {
+  Sym.print(OS);
+  return OS;
+}
+
 } // end namespace llvm
 
 #endif // LLVM_OBJECT_WASM_H

lib/MC/MCWasmStreamer.cpp

bool MCWasmStreamer::EmitSymbolAttribute(MCSymbol *S, MCSymbolAttr Attribute) {
   case MCSA_Reference:
   case MCSA_SymbolResolver:
   case MCSA_PrivateExtern:
   case MCSA_WeakDefinition:
   case MCSA_WeakDefAutoPrivate:
   case MCSA_Invalid:
   case MCSA_IndirectSymbol:
     return false;
+
+  case MCSA_WeakReference:
+  case MCSA_Weak:
+    Symbol->setExternal(true);
+    break;
+
   case MCSA_Global:
     Symbol->setExternal(true);
     break;
+
   case MCSA_ELF_TypeFunction:
     Symbol->setIsFunction(true);
     break;
+
   case MCSA_ELF_TypeObject:
     Symbol->setIsFunction(false);
     break;
+
   default:
     // unrecognized directive
     return false;
   }
 
   return true;
 }
 

lib/MC/WasmObjectWriter.cpp

case wasm::R_WEBASSEMBLY_GLOBAL_ADDR_I32:
       return true;
     default:
       return false;
     }
   }
 
   void print(raw_ostream &Out) const {
     Out << "Off=" << Offset << ", Sym=" << Symbol->getName() << ", Addend=" << Addend
-        << ", Type=" << Type << ", FixupSection=" << FixupSection << "\n";
+        << ", Type=" << Type << ", FixupSection=" << FixupSection;
   }
-  void dump() const { print(errs()); }
+
+#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+  LLVM_DUMP_METHOD void dump() const { print(dbgs()); }
+#endif
 };
 
+inline raw_ostream &operator<<(raw_ostream &OS,
+                               const WasmRelocationEntry &Rel) {
+  Rel.print(OS);
+  return OS;
+}
+
 class WasmObjectWriter : public MCObjectWriter {
   /// Helper struct for containing some precomputed information on symbols.
   struct WasmSymbolData {
     const MCSymbolWasm *Symbol;
     StringRef Name;
 
     // Support lexicographic sorting.
     bool operator<(const WasmSymbolData &RHS) const { return Name < RHS.Name; }
void writeCodeSection(const MCAssembler &Asm, const MCAsmLayout &Layout,
                         const SmallVector<WasmFunction, 4> &Functions);
   uint64_t
   writeDataSection(const SmallVector<char, 0> &DataBytes);
   void writeNameSection(const SmallVector<WasmFunction, 4> &Functions,
                         const SmallVector<WasmImport, 4> &Imports,
                         uint32_t NumFuncImports);
   void writeCodeRelocSection();
   void writeDataRelocSection(uint64_t DataSectionHeaderSize);
-  void writeLinkingMetaDataSection(bool HasStackPointer,
+  void writeLinkingMetaDataSection(ArrayRef<uint32_t> WeakExports,
+                                   bool HasStackPointer,
                                    uint32_t StackPointerGlobal);
 
   void applyRelocations(ArrayRef<WasmRelocationEntry> Relocations,
                         uint64_t ContentsOffset);
 
   void writeRelocations(ArrayRef<WasmRelocationEntry> Relocations,
                         uint64_t HeaderSize);
   uint32_t getRelocationIndexValue(const WasmRelocationEntry &RelEntry);

 
 // Write out a section header and a patchable section size field.
 void WasmObjectWriter::startSection(SectionBookkeeping &Section,
                                     unsigned SectionId,
                                     const char *Name) {
   assert((Name != nullptr) == (SectionId == wasm::WASM_SEC_CUSTOM) &&
          "Only custom sections can have names");
 
+  DEBUG(dbgs() << "startSection " << SectionId << ": " << Name << "\n");
   encodeULEB128(SectionId, getStream());
 
   Section.SizeOffset = getStream().tell();
 
   // The section size. We don't know the size yet, so reserve enough space
   // for any 32-bit value; we'll patch it later.
   encodeULEB128(UINT32_MAX, getStream());
 

 
 // Now that the section is complete and we know how big it is, patch up the
 // section size field at the start of the section.
 void WasmObjectWriter::endSection(SectionBookkeeping &Section) {
   uint64_t Size = getStream().tell() - Section.ContentsOffset;
   if (uint32_t(Size) != Size)
     report_fatal_error("section size does not fit in a uint32_t");
 
+  DEBUG(dbgs() << "endSection size=" << Size << "\n");
   unsigned Padding = PaddingFor5ByteULEB128(Size);
 
   // Write the final section size to the payload_len field, which follows
   // the section id byte.
   uint8_t Buffer[16];
   unsigned SizeLen = encodeULEB128(Size, Buffer, Padding);
   assert(SizeLen == 5);
   getStream().pwrite((char *)Buffer, SizeLen, Section.SizeOffset);
if (SymA) {
     else
       SymA->setUsedInReloc();
   }
 
   unsigned Type = getRelocType(Ctx, Target, Fixup, IsPCRel);
 
   assert(SymA);
   WasmRelocationEntry Rec(FixupOffset, SymA, C, Type, &FixupSection);
+  DEBUG(dbgs() << "WasmReloc: " << Rec << "\n");
 
   if (FixupSection.hasInstructions())
     CodeRelocations.push_back(Rec);
   else
     DataRelocations.push_back(Rec);
 }
 
 // Write X as an (unsigned) LEB value at offset Offset in Stream, padded

 // Compute a value to write into the code at the location covered
 // by RelEntry. This value isn't used by the static linker, since
 // we have addends; it just serves to make the code more readable
 // and to make standalone wasm modules directly usable.
 static uint32_t ProvisionalValue(const WasmRelocationEntry &RelEntry) {
   const MCSymbolWasm *Sym = RelEntry.Symbol;
 
   // For undefined symbols, use a hopefully invalid value.
-  if (!Sym->isDefined(false))
+  if (!Sym->isDefined(/*SetUsed=*/false))
     return UINT32_MAX;
 
   MCSectionWasm &Section =
     cast<MCSectionWasm>(RelEntry.Symbol->getSection(false));
   uint64_t Address = Section.getSectionOffset() + RelEntry.Addend;
 
   // Ignore overflow. LLVM allows address arithmetic to silently wrap.
   uint32_t Value = Address;
void WasmObjectWriter::writeCodeSection(
   startSection(Section, wasm::WASM_SEC_CODE);
 
   encodeULEB128(Functions.size(), getStream());
 
   for (const WasmFunction &Func : Functions) {
     MCSectionWasm &FuncSection =
         static_cast<MCSectionWasm &>(Func.Sym->getSection());
 
-    if (Func.Sym->isVariable())
-      report_fatal_error("weak symbols not supported yet");
-
-    if (Func.Sym->getOffset() != 0)
-      report_fatal_error("function sections must contain one function each");
-
-    if (!Func.Sym->getSize())
-      report_fatal_error("function symbols must have a size set with .size");
-
     int64_t Size = 0;
     if (!Func.Sym->getSize()->evaluateAsAbsolute(Size, Layout))
       report_fatal_error(".size expression must be evaluatable");
 
     encodeULEB128(Size, getStream());
 
     FuncSection.setSectionOffset(getStream().tell() -
                                  Section.ContentsOffset);
void WasmObjectWriter::writeDataRelocSection(uint64_t DataSectionHeaderSize) {
   encodeULEB128(DataRelocations.size(), getStream());
 
   writeRelocations(DataRelocations, DataSectionHeaderSize);
 
   endSection(Section);
 }
 
 void WasmObjectWriter::writeLinkingMetaDataSection(
-    bool HasStackPointer, uint32_t StackPointerGlobal) {
-  if (!HasStackPointer)
+    ArrayRef<uint32_t> WeakExports, bool HasStackPointer,
+    uint32_t StackPointerGlobal) {
+  if (!HasStackPointer && WeakExports.empty())
     return;
+
   SectionBookkeeping Section;
   startSection(Section, wasm::WASM_SEC_CUSTOM, "linking");
+  SectionBookkeeping SubSection;
 
-  encodeULEB128(1, getStream()); // count
-
-  encodeULEB128(wasm::WASM_STACK_POINTER, getStream()); // type
+  if (HasStackPointer) {
+    startSection(SubSection, wasm::WASM_STACK_POINTER);
     encodeULEB128(StackPointerGlobal, getStream()); // id
+    endSection(SubSection);
+  }
+
+  if (WeakExports.size() != 0) {
+    startSection(SubSection, wasm::WASM_SYMBOL_INFO);
+    encodeULEB128(WeakExports.size(), getStream());
+    for (uint32_t Export: WeakExports) {
+      write8(0); // 1 - Import, 0 = Export
+      encodeULEB128(Export, getStream()); // Import or Export index
+      encodeULEB128(wasm::WASM_SYMBOL_FLAG_WEAK, getStream());
+    }
+    endSection(SubSection);
+  }
 
   endSection(Section);
 }
 
 void WasmObjectWriter::writeObject(MCAssembler &Asm,
                                    const MCAsmLayout &Layout) {
+  DEBUG(dbgs() << "WasmObjectWriter::writeObject\n");
   MCContext &Ctx = Asm.getContext();
   wasm::ValType PtrType = is64Bit() ? wasm::ValType::I64 : wasm::ValType::I32;
 
   // Collect information from the available symbols.
   SmallVector<WasmFunctionType, 4> FunctionTypes;
   SmallVector<WasmFunction, 4> Functions;
   SmallVector<uint32_t, 4> TableElems;
   SmallVector<WasmGlobal, 4> Globals;
   SmallVector<WasmImport, 4> Imports;
   SmallVector<WasmExport, 4> Exports;
+  SmallVector<uint32_t, 4> WeakExports;
   SmallPtrSet<const MCSymbolWasm *, 4> IsAddressTaken;
   unsigned NumFuncImports = 0;
   unsigned NumGlobalImports = 0;
   SmallVector<char, 0> DataBytes;
   uint32_t StackPointerGlobal = 0;
   bool HasStackPointer = false;
 
   // Populate the IsAddressTaken set.
-  for (WasmRelocationEntry RelEntry : CodeRelocations) {
+  for (const WasmRelocationEntry &RelEntry : CodeRelocations) {
     switch (RelEntry.Type) {
     case wasm::R_WEBASSEMBLY_TABLE_INDEX_SLEB:
     case wasm::R_WEBASSEMBLY_GLOBAL_ADDR_SLEB:
       IsAddressTaken.insert(RelEntry.Symbol);
       break;
     default:
       break;
     }
   }
-  for (WasmRelocationEntry RelEntry : DataRelocations) {
+  for (const WasmRelocationEntry &RelEntry : DataRelocations) {
     switch (RelEntry.Type) {
     case wasm::R_WEBASSEMBLY_TABLE_INDEX_I32:
     case wasm::R_WEBASSEMBLY_GLOBAL_ADDR_I32:
       IsAddressTaken.insert(RelEntry.Symbol);
       break;
     default:
       break;
     }
void WasmObjectWriter::writeObject(MCAssembler &Asm,
   // Handle defined symbols.
   for (const MCSymbol &S : Asm.symbols()) {
     // Ignore unnamed temporary symbols, which aren't ever exported, imported,
     // or used in relocations.
     if (S.isTemporary() && S.getName().empty())
       continue;
     const auto &WS = static_cast<const MCSymbolWasm &>(S);
     unsigned Index;
+    DEBUG(dbgs() << "MCSymbolWasm: " << WS << "\n");
+
     if (WS.isFunction()) {
       // Prepare the function's type, if we haven't seen it yet.
       WasmFunctionType F;
       F.Returns = WS.getReturns();
       F.Params = WS.getParams();
       auto Pair =
           FunctionTypeIndices.insert(std::make_pair(F, FunctionTypes.size()));
       if (Pair.second)
         FunctionTypes.push_back(F);
 
       int32_t Type = Pair.first->second;
 
       if (WS.isDefined(/*SetUsed=*/false)) {
+        if (WS.isVariable()) {
+          // A weak reference to another symbol.
+          const MCExpr *Expr = WS.getVariableValue();
+          auto *Inner = dyn_cast<MCSymbolRefExpr>(Expr);
+          const MCSymbolWasm *ResolvedSym = cast<MCSymbolWasm>(&Inner->getSymbol());
+          Index = SymbolIndices.find(ResolvedSym)->second;
+          DEBUG(dbgs() << "Resolved weak symbol: " << WS << " -> " << Index
+                       << "\n");
+        } else {
+          if (WS.getOffset() != 0)
+            report_fatal_error(
+                "function sections must contain one function each");
+
+          if (WS.getSize() == 0)
+            report_fatal_error(
+                "function symbols must have a size set with .size");
+
           // A definition. Take the next available index.
           Index = NumFuncImports + Functions.size();
 
           // Prepare the function.
           WasmFunction Func;
           Func.Type = Type;
           Func.Sym = &WS;
           SymbolIndices[&WS] = Index;
           Functions.push_back(Func);
+        }
       } else {
+        // Should be no such thing as weak undefined symbol
+        assert(!WS.isVariable());
         // An import; the index was assigned above.
         Index = SymbolIndices.find(&WS)->second;
       }
 
       // If needed, prepare the function to be called indirectly.
       if (IsAddressTaken.count(&WS)) {
         IndirectSymbolIndices[&WS] = TableElems.size();
         TableElems.push_back(Index);
       }
     } else {
       if (WS.isTemporary() && !WS.getSize())
         continue;
 
-      if (WS.isDefined(false)) {
+      if (WS.isVariable())
+        report_fatal_error("weak data symbols not supported yet: " + WS.getName());
+
+      if (WS.isDefined(/*SetUsed=*/false)) {
         if (WS.getOffset() != 0)
           report_fatal_error("data sections must contain one variable each: " +
                              WS.getName());
         if (!WS.getSize())
           report_fatal_error("data symbols must have a size set with .size: " +
                              WS.getName());
 
         int64_t Size = 0;
if (WS.isFunction()) {
         Global.ImportIndex = 0;
         SymbolIndices[&WS] = Index;
         Globals.push_back(Global);
       }
     }
 
     // If the symbol is visible outside this translation unit, export it.
     if (WS.isExternal()) {
-      assert(WS.isDefined(false));
+      DEBUG(dbgs() << "Exporting: " << WS << " -> " << Index << "\n");
+      assert(WS.isDefined(/*SetUsed=*/false));
       WasmExport Export;
       Export.FieldName = WS.getName();
       Export.Index = Index;
 
       if (WS.isFunction())
         Export.Kind = wasm::WASM_EXTERNAL_FUNCTION;
       else
         Export.Kind = wasm::WASM_EXTERNAL_GLOBAL;
 
+      if (WS.isVariable()) {
+        DEBUG(dbgs() << "Weak Export: " << WS << "\n");
+        WeakExports.push_back(Exports.size());
+      }
       Exports.push_back(Export);
     }
   }
 
   // Add types for indirect function calls.
   for (const WasmRelocationEntry &Fixup : CodeRelocations) {
     if (Fixup.Type != wasm::R_WEBASSEMBLY_TYPE_INDEX_LEB)
       continue;
void WasmObjectWriter::writeObject(MCAssembler &Asm,
   writeExportSection(Exports);
   // TODO: Start Section
   writeElemSection(TableElems);
   writeCodeSection(Asm, Layout, Functions);
   uint64_t DataSectionHeaderSize = writeDataSection(DataBytes);
   writeNameSection(Functions, Imports, NumFuncImports);
   writeCodeRelocSection();
   writeDataRelocSection(DataSectionHeaderSize);
-  writeLinkingMetaDataSection(HasStackPointer, StackPointerGlobal);
+  writeLinkingMetaDataSection(WeakExports, HasStackPointer, StackPointerGlobal);
 
   // TODO: Translate the .comment section to the output.
   // TODO: Translate debug sections to the output.
 }
 
 MCObjectWriter *llvm::createWasmObjectWriter(MCWasmObjectTargetWriter *MOTW,
                                              raw_pwrite_stream &OS) {
   return new WasmObjectWriter(MOTW, OS);
 }

lib/Object/WasmObjectFile.cpp

 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/LEB128.h"
 #include <algorithm>
 #include <cassert>
 #include <cstdint>
 #include <cstring>
 #include <system_error>
 
+#define DEBUG_TYPE "wasm-object"
+
 using namespace llvm;
 using namespace object;
 
 Expected<std::unique_ptr<WasmObjectFile>>
 ObjectFile::createWasmObjectFile(MemoryBufferRef Buffer) {
   Error Err = Error::success();
   auto ObjectFile = llvm::make_unique<WasmObjectFile>(Buffer, Err);
   if (Err)
return make_error<GenericBinaryError>("Bad section type",
                                           object_error::parse_failed);
   }
 }
 
 Error WasmObjectFile::parseNameSection(const uint8_t *Ptr, const uint8_t *End) {
   while (Ptr < End) {
     uint8_t Type = readVarint7(Ptr);
     uint32_t Size = readVaruint32(Ptr);
+    const uint8_t *SubSectionEnd = Ptr + Size;
     switch (Type) {
     case wasm::WASM_NAMES_FUNCTION: {
       uint32_t Count = readVaruint32(Ptr);
       while (Count--) {
         uint32_t Index = readVaruint32(Ptr);
         StringRef Name = readString(Ptr);
         if (!Name.empty())
           Symbols.emplace_back(Name,
                                WasmSymbol::SymbolType::DEBUG_FUNCTION_NAME,
                                Sections.size(), Index);
       }
       break;
     }
     // Ignore local names for now
     case wasm::WASM_NAMES_LOCAL:
     default:
       Ptr += Size;
       break;
     }
+    if (Ptr != SubSectionEnd)
+      return make_error<GenericBinaryError>("Name sub-section ended prematurely",
+                                            object_error::parse_failed);
   }
 
   if (Ptr != End)
     return make_error<GenericBinaryError>("Name section ended prematurely",
                                           object_error::parse_failed);
   return Error::success();
 }
 
+Error WasmObjectFile::parseLinkingSection(const uint8_t *Ptr,
+                                          const uint8_t *End) {
+  while (Ptr < End) {
+    uint8_t Type = readVarint7(Ptr);
+    uint32_t Size = readVaruint32(Ptr);
+    const uint8_t *SubSectionEnd = Ptr + Size;
+    switch (Type) {
+    case wasm::WASM_SYMBOL_INFO: {
+      uint32_t Count = readVaruint32(Ptr);
+      while (Count--) {
+        uint8_t Import = readVaruint1(Ptr);
+        uint32_t Index = readVaruint32(Ptr);
+        if ((Import && Index >= Imports.size()) ||
+            (!Import && Index >= Exports.size())) {
+          return make_error<GenericBinaryError>("Invalid symbol index",
+                                                object_error::parse_failed);
+        }
+        uint32_t Flags = readVaruint32(Ptr);
+        if (Import) {
+          Symbols[Imports[Index].Symbol].Flags = Flags;
+          DEBUG(dbgs() << "Set symbol flags: "
+                       << Symbols[Imports[Index].Symbol] << "\n");
+        } else {
+          Symbols[Exports[Index].Symbol].Flags = Flags;
+          DEBUG(dbgs() << "Set symbol flags: "
+                       << Symbols[Exports[Index].Symbol] << "\n");
+        }
+      }
+      break;
+    }
+    case wasm::WASM_STACK_POINTER:
+    default:
+      Ptr += Size;
+      break;
+    }
+    if (Ptr != SubSectionEnd)
+      return make_error<GenericBinaryError>(
+          "Linking sub-section ended prematurely", object_error::parse_failed);
+  }
+  if (Ptr != End)
+    return make_error<GenericBinaryError>("Linking section ended prematurely",
+                                          object_error::parse_failed);
+  return Error::success();
+}
+
 WasmSection* WasmObjectFile::findCustomSectionByName(StringRef Name) {
   for (WasmSection& Section : Sections) {
     if (Section.Type == wasm::WASM_SEC_CUSTOM && Section.Name == Name)
       return &Section;
   }
   return nullptr;
 }
 

 }
 
 Error WasmObjectFile::parseCustomSection(WasmSection &Sec,
                                          const uint8_t *Ptr, const uint8_t *End) {
   Sec.Name = readString(Ptr);
   if (Sec.Name == "name") {
     if (Error Err = parseNameSection(Ptr, End))
       return Err;
+  } else if (Sec.Name == "linking") {
+    if (Error Err = parseLinkingSection(Ptr, End))
+      return Err;
   } else if (Sec.Name.startswith("reloc.")) {
     if (Error Err = parseRelocSection(Sec.Name, Ptr, End))
       return Err;
   }
   return Error::success();
 }
 
 Error WasmObjectFile::parseTypeSection(const uint8_t *Ptr, const uint8_t *End) {
return make_error<GenericBinaryError>("Type section ended prematurely",
                                           object_error::parse_failed);
   return Error::success();
 }
 
 Error WasmObjectFile::parseImportSection(const uint8_t *Ptr, const uint8_t *End) {
   uint32_t Count = readVaruint32(Ptr);
   Imports.reserve(Count);
   for (uint32_t i = 0; i < Count; i++) {
-    wasm::WasmImport Im;
-    Im.Module = readString(Ptr);
-    Im.Field = readString(Ptr);
-    Im.Kind = readUint8(Ptr);
-    switch (Im.Kind) {
+    WasmImportSym Im;
+    Im.Import.Module = readString(Ptr);
+    Im.Import.Field = readString(Ptr);
+    Im.Import.Kind = readUint8(Ptr);
+    switch (Im.Import.Kind) {
     case wasm::WASM_EXTERNAL_FUNCTION:
-      Im.SigIndex = readVaruint32(Ptr);
-      Symbols.emplace_back(Im.Field, WasmSymbol::SymbolType::FUNCTION_IMPORT,
+      Im.Import.SigIndex = readVaruint32(Ptr);
+      Symbols.emplace_back(Im.Import.Field, WasmSymbol::SymbolType::FUNCTION_IMPORT,
                            Sections.size(), i);
+      Im.Symbol = Symbols.size() - 1;
       break;
     case wasm::WASM_EXTERNAL_GLOBAL:
-      Im.Global.Type = readVarint7(Ptr);
-      Im.Global.Mutable = readVaruint1(Ptr);
-      Symbols.emplace_back(Im.Field, WasmSymbol::SymbolType::GLOBAL_IMPORT,
+      Im.Import.Global.Type = readVarint7(Ptr);
+      Im.Import.Global.Mutable = readVaruint1(Ptr);
+      Symbols.emplace_back(Im.Import.Field, WasmSymbol::SymbolType::GLOBAL_IMPORT,
                            Sections.size(), i);
+      Im.Symbol = Symbols.size() - 1;
       break;
     case wasm::WASM_EXTERNAL_MEMORY:
-      Im.Memory = readLimits(Ptr);
+      Im.Import.Memory = readLimits(Ptr);
       break;
     case wasm::WASM_EXTERNAL_TABLE:
-      Im.Table = readTable(Ptr);
-      if (Im.Table.ElemType != wasm::WASM_TYPE_ANYFUNC) {
+      Im.Import.Table = readTable(Ptr);
+      if (Im.Import.Table.ElemType != wasm::WASM_TYPE_ANYFUNC) {
         return make_error<GenericBinaryError>("Invalid table element type",
                                               object_error::parse_failed);
       }
       break;
     default:
       return make_error<GenericBinaryError>(
           "Unexpected import kind", object_error::parse_failed);
     }
return make_error<GenericBinaryError>("Global section ended prematurely",
                                           object_error::parse_failed);
   return Error::success();
 }
 
 Error WasmObjectFile::parseExportSection(const uint8_t *Ptr, const uint8_t *End) {
   uint32_t Count = readVaruint32(Ptr);
   Exports.reserve(Count);
   for (uint32_t i = 0; i < Count; i++) {
-    wasm::WasmExport Ex;
-    Ex.Name = readString(Ptr);
-    Ex.Kind = readUint8(Ptr);
-    Ex.Index = readVaruint32(Ptr);
-    Exports.push_back(Ex);
-    switch (Ex.Kind) {
+    WasmExportSym Ex;
+    Ex.Export.Name = readString(Ptr);
+    Ex.Export.Kind = readUint8(Ptr);
+    Ex.Export.Index = readVaruint32(Ptr);
+    switch (Ex.Export.Kind) {
     case wasm::WASM_EXTERNAL_FUNCTION:
-      Symbols.emplace_back(Ex.Name, WasmSymbol::SymbolType::FUNCTION_EXPORT,
+      Symbols.emplace_back(Ex.Export.Name, WasmSymbol::SymbolType::FUNCTION_EXPORT,
                            Sections.size(), i);
+      Ex.Symbol = Symbols.size() - 1;
+      DEBUG(dbgs() << "Adding export with sym: " << Symbols[Ex.Symbol] << "\n");
       break;
     case wasm::WASM_EXTERNAL_GLOBAL:
-      Symbols.emplace_back(Ex.Name, WasmSymbol::SymbolType::GLOBAL_EXPORT,
+      Symbols.emplace_back(Ex.Export.Name, WasmSymbol::SymbolType::GLOBAL_EXPORT,
                            Sections.size(), i);
+      Ex.Symbol = Symbols.size() - 1;
       break;
     case wasm::WASM_EXTERNAL_MEMORY:
     case wasm::WASM_EXTERNAL_TABLE:
       break;
     default:
       return make_error<GenericBinaryError>(
           "Unexpected export kind", object_error::parse_failed);
     }
+    Exports.push_back(Ex);
   }
   if (Ptr != End)
     return make_error<GenericBinaryError>("Export section ended prematurely",
                                           object_error::parse_failed);
   return Error::success();
 }
 
 Error WasmObjectFile::parseStartSection(const uint8_t *Ptr, const uint8_t *End) {

 }
 
 void WasmObjectFile::moveSymbolNext(DataRefImpl &Symb) const { Symb.d.a++; }
 
 uint32_t WasmObjectFile::getSymbolFlags(DataRefImpl Symb) const {
   uint32_t Result = SymbolRef::SF_None;
   const WasmSymbol &Sym = getWasmSymbol(Symb);
 
+  DEBUG(dbgs() << "getSymbolFlags: ptr=" << &Sym << " " << Sym << "\n");
+  if (Sym.Flags & wasm::WASM_SYMBOL_FLAG_WEAK)
+    Result |= SymbolRef::SF_Weak;
+
+
   switch (Sym.Type) {
   case WasmSymbol::SymbolType::FUNCTION_IMPORT:
     Result |= SymbolRef::SF_Undefined | SymbolRef::SF_Executable;
     break;
   case WasmSymbol::SymbolType::FUNCTION_EXPORT:
     Result |= SymbolRef::SF_Global | SymbolRef::SF_Executable;
     break;
   case WasmSymbol::SymbolType::DEBUG_FUNCTION_NAME:
     Result |= SymbolRef::SF_Executable;
+    Result |= SymbolRef::SF_FormatSpecific;
     break;
   case WasmSymbol::SymbolType::GLOBAL_IMPORT:
     Result |= SymbolRef::SF_Undefined;
     break;
   case WasmSymbol::SymbolType::GLOBAL_EXPORT:
     Result |= SymbolRef::SF_Global;
     break;
   }
 
   return Result;
 }
 
-basic_symbol_iterator WasmObjectFile::symbol_begin() const {
+BasicSymbolRef WasmObjectFile::makeSymbolRef(uint32_t Index) const {
   DataRefImpl Ref;
-  Ref.d.a = 0;
+  Ref.d.a = Index;
   return BasicSymbolRef(Ref, this);
 }
 
+basic_symbol_iterator WasmObjectFile::symbol_begin() const {
+  return makeSymbolRef(0);
+}
+
 basic_symbol_iterator WasmObjectFile::symbol_end() const {
-  DataRefImpl Ref;
-  Ref.d.a = Symbols.size();
-  return BasicSymbolRef(Ref, this);
+  return makeSymbolRef(Symbols.size());
 }
 
 const WasmSymbol &WasmObjectFile::getWasmSymbol(const DataRefImpl &Symb) const {
   return Symbols[Symb.d.a];
 }
 
 const WasmSymbol &WasmObjectFile::getWasmSymbol(const SymbolRef &Symb) const {
   return getWasmSymbol(Symb.getRawDataRefImpl());
 }
 
 Expected<StringRef> WasmObjectFile::getSymbolName(DataRefImpl Symb) const {
-  const WasmSymbol &Sym = getWasmSymbol(Symb);
-  return Sym.Name;
+  return getWasmSymbol(Symb).Name;
 }
 
 Expected<uint64_t> WasmObjectFile::getSymbolAddress(DataRefImpl Symb) const {
   return getSymbolValue(Symb);
 }
 
 uint64_t WasmObjectFile::getSymbolValueImpl(DataRefImpl Symb) const {
-  const WasmSymbol &Sym = getWasmSymbol(Symb);
-  return Sym.ElementIndex;
+  return getWasmSymbol(Symb).ElementIndex;
 }
 
 uint32_t WasmObjectFile::getSymbolAlignment(DataRefImpl Symb) const {
   llvm_unreachable("not yet implemented");
   return 0;
 }
 
 uint64_t WasmObjectFile::getCommonSymbolSizeImpl(DataRefImpl Symb) const {

tools/obj2yaml/wasm2yaml.cpp

case wasm::WASM_SEC_TYPE: {
       }
       S = std::move(TypeSec);
       break;
     }
     case wasm::WASM_SEC_IMPORT: {
       auto ImportSec = make_unique<WasmYAML::ImportSection>();
       for (auto &Import : Obj.imports()) {
         WasmYAML::Import Im;
-        Im.Module = Import.Module;
-        Im.Field = Import.Field;
-        Im.Kind = Import.Kind;
+        Im.Module = Import.Import.Module;
+        Im.Field = Import.Import.Field;
+        Im.Kind = Import.Import.Kind;
         switch (Im.Kind) {
         case wasm::WASM_EXTERNAL_FUNCTION:
-          Im.SigIndex = Import.SigIndex;
+          Im.SigIndex = Import.Import.SigIndex;
           break;
         case wasm::WASM_EXTERNAL_GLOBAL:
-          Im.GlobalImport.Type = Import.Global.Type;
-          Im.GlobalImport.Mutable = Import.Global.Mutable;
+          Im.GlobalImport.Type = Import.Import.Global.Type;
+          Im.GlobalImport.Mutable = Import.Import.Global.Mutable;
           break;
         case wasm::WASM_EXTERNAL_TABLE:
-          Im.TableImport = make_table(Import.Table);
+          Im.TableImport = make_table(Import.Import.Table);
           break;
         case wasm::WASM_EXTERNAL_MEMORY:
-          Im.Memory = make_limits(Import.Memory);
+          Im.Memory = make_limits(Import.Import.Memory);
           break;
         }
         ImportSec->Imports.push_back(Im);
       }
       S = std::move(ImportSec);
       break;
     }
     case wasm::WASM_SEC_FUNCTION: {
case wasm::WASM_SEC_START: {
       StartSec->StartFunction = Obj.startFunction();
       S = std::move(StartSec);
       break;
     }
     case wasm::WASM_SEC_EXPORT: {
       auto ExportSec = make_unique<WasmYAML::ExportSection>();
       for (auto &Export : Obj.exports()) {
         WasmYAML::Export Ex;
-        Ex.Name = Export.Name;
-        Ex.Kind = Export.Kind;
-        Ex.Index = Export.Index;
+        Ex.Name = Export.Export.Name;
+        Ex.Kind = Export.Export.Kind;
+        Ex.Index = Export.Export.Index;
         ExportSec->Exports.push_back(Ex);
       }
       S = std::move(ExportSec);
       break;
     }
     case wasm::WASM_SEC_ELEM: {
       auto ElemSec = make_unique<WasmYAML::ElemSection>();
       for (auto &Segment : Obj.elements()) {