[WebAssembly] Symbol changes #6: syminfo index, LLVM

[ncw]

Summary

Sixth chunk split out of D41954.

Must be committed simultaneously with LLD change, D42118.

Fixes: https://github.com/WebAssembly/tool-conventions/issues/30

Changes:

• Change the WASM_SYMBOL_INFO linking metadata to refer to symbols by index rather than by string name
• This should reduce the size of the Wasm object files. Hopefully uncontroversial?

[sbc100]

I'd like to land this stand-alone if possible? i.e. not as part of this chain of commits, but directly on HEAD as it stands today. It seems like it might require a bit of rebase work to make it happen which I'm happy to do if you like?

[sbc100]

I refactored this to sit on top of current HEAD so we can land before the other patchsets: D42279. I removed the stable_sort call since it didn't seem to be needed, or at least it didn't seem to effect the test output (Maybe the yaml dump is destroying the order?)

[sbc100]

And the LLD-side change re-based very cleanly: D42282.

[ncw]

(On a side-note: yes, the sort doesn't do much, but I think it might make a difference if you have a lot of globals and functions? It should make it less likely that the tests will need to be updated in future due to reordering of the output.)

[ncw]

Updates:

• Rebased
• Removed std::sort() of the symbol flags, that wasn't actually doing anything useful since obj2yaml reorders them anyway

[sbc100]

In D42117#982103, @ncw wrote:

Updates:

• Rebased
• Removed std::sort() of the symbol flags, that wasn't actually doing anything useful since obj2yaml reorders them anyway

Hmm.. obj2yaml is sorting stuff ? I don't think it should since its supposed to mirror the binary directly.

[ncw]

In D42117#982151, @sbc100 wrote:

In D42117#982103, @ncw wrote:

Updates:

• Rebased
• Removed std::sort() of the symbol flags, that wasn't actually doing anything useful since obj2yaml reorders them anyway

Hmm.. obj2yaml is sorting stuff ? I don't think it should since its supposed to mirror the binary directly.

Not exactly - obj2yaml is using the canonical order from the Wasm file, but it's using the order the symbol are declared in (via imports/exports) rather than the order the symbol flags happen to be stored in. It's basically normalising the order of the flags section, which isn't a disaster.

[ncw]

Abandoning - symtab changes take precedence.

I reckon the symtab work is something I can work on towards the end of the week (maybe) and something done towards the start of next week.

#2 and #3 are OK to merge now. #5 will be modified a bit in the symtab work, and I'll create a new changeset on top of the (updated) #5 that does the actual modifications to the symtab format on disk.

include/llvm/Object/Wasm.h

private:
   bool HasLinkingSection = false;
   wasm::WasmLinkingData LinkingData;
   uint32_t NumImportedGlobals = 0;
   uint32_t NumImportedFunctions = 0;
   uint32_t NumExportedGlobals = 0;
   uint32_t NumExportedFunctions = 0;
   uint32_t ImportSection = 0;
   uint32_t ExportSection = 0;
-
-  // TODO: will get rid of this map in next commit
-  StringMap<std::pair<uint32_t,uint32_t>> SymbolMap; // name to pair(kind,index)
 };
 
 } // 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

include/llvm/ObjectYAML/WasmYAML.h

 struct Signature {
   uint32_t Index;
   SignatureForm Form = wasm::WASM_TYPE_FUNC;
   std::vector<ValueType> ParamTypes;
   ValueType ReturnType;
 };
 
 struct SymbolInfo {
-  StringRef Name;
+  ExportKind Kind;
+  uint32_t Index;
   SymbolFlags Flags;
 };
 
 struct InitFunction {
   uint32_t Priority;
   uint32_t FunctionIndex;
 };
 

lib/MC/WasmObjectWriter.cpp

 #include "llvm/MC/MCSymbolWasm.h"
 #include "llvm/MC/MCValue.h"
 #include "llvm/MC/MCWasmObjectWriter.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/StringSaver.h"
+#include <algorithm>
 #include <vector>
 
 using namespace llvm;
 
 #define DEBUG_TYPE "mc"
 
 namespace {
 

 // Information about a single item which is part of a COMDAT.  For each data
 // segment or function which is in the COMDAT, there is a corresponding
 // WasmComdatEntry.
 struct WasmComdatEntry {
   unsigned Kind;
   uint32_t Index;
 };
 
+// Information about a single symbol to be written into the linking metadata
+struct WasmSymEntry {
+  uint32_t Kind;
+  uint32_t Index;
+  uint32_t Flags;
+};
+
 // Information about a single relocation.
 struct WasmRelocationEntry {
   uint64_t Offset;                  // Where is the relocation.
   const MCSymbolWasm *Symbol;       // The symbol to relocate with.
   int64_t Addend;                   // A value to add to the symbol.
   unsigned Type;                    // The type of the relocation.
   const MCSectionWasm *FixupSection;// The section the relocation is targeting.
 
void writeCodeSection(const MCAssembler &Asm, const MCAsmLayout &Layout,
                         ArrayRef<WasmFunction> Functions);
   void writeDataSection(ArrayRef<WasmDataSegment> Segments);
   void writeNameSection(ArrayRef<WasmFunction> Functions,
                         ArrayRef<WasmImport> Imports);
   void writeCodeRelocSection();
   void writeDataRelocSection();
   void writeLinkingMetaDataSection(
       ArrayRef<WasmDataSegment> Segments, uint32_t DataSize,
-      ArrayRef<std::pair<StringRef, uint32_t>> SymbolFlags,
+      ArrayRef<WasmSymEntry> SymbolInfo,
       ArrayRef<std::pair<uint16_t, uint32_t>> InitFuncs,
       const std::map<StringRef, std::vector<WasmComdatEntry>>& Comdats);
 
   uint32_t getProvisionalValue(const WasmRelocationEntry &RelEntry);
   uint32_t getProvisionalTableIndex(const WasmRelocationEntry &RelEntry);
   void applyRelocations(ArrayRef<WasmRelocationEntry> Relocations,
                         uint64_t ContentsOffset);
 
void WasmObjectWriter::writeDataRelocSection() {
 
   writeRelocations(DataRelocations);
 
   endSection(Section);
 }
 
 void WasmObjectWriter::writeLinkingMetaDataSection(
     ArrayRef<WasmDataSegment> Segments, uint32_t DataSize,
-    ArrayRef<std::pair<StringRef, uint32_t>> SymbolFlags,
+    ArrayRef<WasmSymEntry> SymbolInfo,
     ArrayRef<std::pair<uint16_t, uint32_t>> InitFuncs,
     const std::map<StringRef, std::vector<WasmComdatEntry>>& Comdats) {
   SectionBookkeeping Section;
   startSection(Section, wasm::WASM_SEC_CUSTOM, "linking");
   SectionBookkeeping SubSection;
 
-  if (SymbolFlags.size() != 0) {
+  if (!SymbolInfo.empty()) {
     startSection(SubSection, wasm::WASM_SYMBOL_INFO);
-    encodeULEB128(SymbolFlags.size(), getStream());
-    for (auto Pair: SymbolFlags) {
-      writeString(Pair.first);
-      encodeULEB128(Pair.second, getStream());
+    encodeULEB128(SymbolInfo.size(), getStream());
+    for (const auto &SI : SymbolInfo) {
+      encodeULEB128(SI.Kind, getStream());
+      encodeULEB128(SI.Index, getStream());
+      encodeULEB128(SI.Flags, getStream());
     }
     endSection(SubSection);
   }
 
   if (DataSize > 0) {
     startSection(SubSection, wasm::WASM_DATA_SIZE);
     encodeULEB128(DataSize, getStream());
     endSection(SubSection);
if (Pair.second)
     FunctionTypes.push_back(F);
   TypeIndices[&Symbol] = Pair.first->second;
 
   DEBUG(dbgs() << "registerFunctionType: " << Symbol << " new:" << Pair.second << "\n");
   DEBUG(dbgs() << "  -> type index: " << Pair.first->second << "\n");
   return Pair.first->second;
 }
 
-static void addFlags(SmallVector<std::pair<StringRef, uint32_t>, 4> &SymbolFlags,
-                     const MCSymbolWasm &WS) {
+static void addFlags(SmallVector<WasmSymEntry, 4> &SymbolInfo,
+                     uint32_t SymbolIndex, const MCSymbolWasm &WS) {
   uint32_t Flags = (WS.isWeak() ? wasm::WASM_SYMBOL_BINDING_WEAK : 0) |
       (WS.isHidden() ? wasm::WASM_SYMBOL_VISIBILITY_HIDDEN : 0) |
       (!WS.isExternal() && WS.isDefined() ? wasm::WASM_SYMBOL_BINDING_LOCAL : 0);
   if (Flags != 0) {
-    SymbolFlags.emplace_back(WS.getName(), Flags);
+    uint32_t Kind = WS.isFunction() ? wasm::WASM_EXTERNAL_FUNCTION
+                                    : wasm::WASM_EXTERNAL_GLOBAL;
+    SymbolInfo.emplace_back(WasmSymEntry{Kind, SymbolIndex, Flags});
   }
 }
 
 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<WasmFunction, 4> Functions;
   SmallVector<uint32_t, 4> TableElems;
   SmallVector<WasmImport, 4> Imports;
   SmallVector<WasmExport, 4> Exports;
-  SmallVector<std::pair<StringRef, uint32_t>, 4> SymbolFlags;
+  SmallVector<WasmSymEntry, 4> SymbolInfo;
   SmallVector<std::pair<uint16_t, uint32_t>, 2> InitFuncs;
   std::map<StringRef, std::vector<WasmComdatEntry>> Comdats;
   unsigned NumFuncExports = 0;
   unsigned NumGlobalExports = 0;
   SmallVector<WasmDataSegment, 4> DataSegments;
   uint32_t DataSize = 0;
 
   // In the special .global_variables section, we've encoded global
if (!WS.isDefined() && !WS.isComdat()) {
         WasmIndices[&WS] = SymbolIndices[&WS] = SymbolIndex;
 
         // If this global is the stack pointer, make it mutable.
         if (WS.getName() == "__stack_pointer")
           Import.IsMutable = true;
 
         ++NumGlobalImports;
 
-        addFlags(SymbolFlags, WS);
+        addFlags(SymbolInfo, SymbolIndex, WS);
       }
 
       Imports.push_back(Import);
     }
   }
 
   for (MCSection &Sec : Asm) {
     auto &Section = static_cast<MCSectionWasm &>(Sec);
if (WS.isFunction()) {
       Global.InitialValue = DataSection.getMemoryOffset() + Layout.getSymbolOffset(WS);
       Global.ImportIndex = 0;
       SymbolIndices[&WS] = SymbolIndex;
       WasmIndices[&WS] = WasmIndex;
       DEBUG(dbgs() << "  -> global index: " << WasmIndex << "\n");
       Globals.push_back(Global);
     }
 
-    addFlags(SymbolFlags, WS);
+    addFlags(SymbolInfo, SymbolIndex, WS);
 
     // If the symbol is visible outside this translation unit, export it.
     if (WS.isDefined()) {
       WasmExport Export;
       Export.FieldName = WS.getName();
       Export.Index = WasmIndex;
       if (WS.isFunction())
         Export.Kind = wasm::WASM_EXTERNAL_FUNCTION;
if (WS.isFunction()) {
       ++NumFuncExports;
     } else {
       SymbolIndex = NumGlobalImports + NumGlobalExports;
       ++NumGlobalExports;
     }
     SymbolIndices[&WS] = SymbolIndex;
     WasmIndices[&WS] = WasmIndex;
 
-    addFlags(SymbolFlags, WS);
+    addFlags(SymbolInfo, SymbolIndex, WS);
 
     WasmExport Export;
     Export.FieldName = WS.getName();
     Export.Index = WasmIndex;
     if (WS.isFunction())
       Export.Kind = wasm::WASM_EXTERNAL_FUNCTION;
     else
       Export.Kind = wasm::WASM_EXTERNAL_GLOBAL;
void WasmObjectWriter::writeObject(MCAssembler &Asm,
   writeGlobalSection();
   writeExportSection(Exports);
   writeElemSection(TableElems);
   writeCodeSection(Asm, Layout, Functions);
   writeDataSection(DataSegments);
   writeNameSection(Functions, Imports);
   writeCodeRelocSection();
   writeDataRelocSection();
-  writeLinkingMetaDataSection(DataSegments, DataSize, SymbolFlags,
+  writeLinkingMetaDataSection(DataSegments, DataSize, SymbolInfo,
                               InitFuncs, Comdats);
 
   // TODO: Translate the .comment section to the output.
   // TODO: Translate debug sections to the output.
 }
 
 std::unique_ptr<MCObjectWriter>
 llvm::createWasmObjectWriter(std::unique_ptr<MCWasmObjectTargetWriter> MOTW,
                              raw_pwrite_stream &OS) {
   return llvm::make_unique<WasmObjectWriter>(std::move(MOTW), OS);
 }

lib/Object/WasmObjectFile.cpp

if (Ptr != End)
     return make_error<GenericBinaryError>("Name section ended prematurely",
                                           object_error::parse_failed);
   return Error::success();
 }
 
 Error WasmObjectFile::populateSymbolTable() {
   FunctionSymbols.reserve(NumImportedFunctions + NumExportedFunctions);
   GlobalSymbols.reserve(NumImportedGlobals + NumExportedGlobals);
+  StringSet<> SymbolNames;
 
   // Add imports to symbol table
   for (const wasm::WasmImport& Import : Imports) {
     WasmSymbol::SymbolType ImportType;
     std::vector<WasmSymbol> *Symbols;
     unsigned FunctionType = 0;
     switch (Import.Kind) {
     case wasm::WASM_EXTERNAL_GLOBAL:
       assert(Import.Global.Type == wasm::WASM_TYPE_I32);
       Symbols = &GlobalSymbols;
       ImportType = WasmSymbol::SymbolType::GLOBAL_IMPORT;
       break;
     case wasm::WASM_EXTERNAL_FUNCTION:
       Symbols = &FunctionSymbols;
       ImportType = WasmSymbol::SymbolType::FUNCTION_IMPORT;
       FunctionType = Import.SigIndex;
       break;
     default:
       continue;
     }
-    if (!SymbolMap.try_emplace(Import.Field, Import.Kind, Symbols->size()).second)
+    if (!SymbolNames.insert(Import.Field).second)
       return make_error<GenericBinaryError>(
           "Duplicate symbol name " + Import.Field,
           object_error::parse_failed);
     unsigned SymbolIndex = Symbols->size();
     unsigned WasmIndex = SymbolIndex;
     Symbols->emplace_back(Import.Field, ImportType, ImportSection, SymbolIndex,
                           WasmIndex, FunctionType);
     DEBUG(dbgs() << "Adding import: " << Symbols->back()
case wasm::WASM_EXTERNAL_FUNCTION: {
         // hasn't already been set.
         Function.Name = Export.Name;
       }
       break;
     }
     default:
       continue;
     }
-    if (!SymbolMap.try_emplace(Export.Name, Export.Kind, Symbols->size()).second)
+    if (!SymbolNames.insert(Export.Name).second)
       return make_error<GenericBinaryError>(
           "Duplicate symbol name " + Export.Name,
           object_error::parse_failed);
     unsigned SymbolIndex = Symbols->size();
     unsigned WasmIndex = Export.Index;
     Symbols->emplace_back(Export.Name, ExportType, ExportSection, SymbolIndex,
                           WasmIndex, FunctionType);
     DEBUG(dbgs() << "Adding export: " << Symbols->back()
Error WasmObjectFile::parseLinkingSection(const uint8_t *Ptr,
   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--) {
-        StringRef Symbol = readString(Ptr);
-        uint32_t Flags = readVaruint32(Ptr);
-        auto iter = SymbolMap.find(Symbol);
-        if (iter == SymbolMap.end()) {
-          return make_error<GenericBinaryError>(
-              "Invalid symbol name in linking section: " + Symbol,
+        uint32_t Kind = readVaruint32(Ptr);
+        std::vector<WasmSymbol> *Symbols;
+        switch (Kind) {
+        case wasm::WASM_EXTERNAL_GLOBAL:
+          Symbols = &GlobalSymbols;
+          break;
+        case wasm::WASM_EXTERNAL_FUNCTION:
+          Symbols = &FunctionSymbols;
+          break;
+        default:
+          return make_error<GenericBinaryError>("Unexpected syminfo kind",
                                                 object_error::parse_failed);
         }
-        uint32_t Kind = iter->second.first;
-        uint32_t SymIndex = iter->second.second;
-        std::vector<WasmSymbol> &Symbols =
-            Kind == wasm::WASM_EXTERNAL_FUNCTION ? FunctionSymbols : GlobalSymbols;
-        assert(SymIndex < Symbols.size());
-        Symbols[SymIndex].Flags = Flags;
-        DEBUG(dbgs() << "Set symbol flags index:"
-                     << SymIndex << " name:"
-                     << Symbols[SymIndex].Name << " expected:"
-                     << Symbol << " flags: " << Flags << "\n");
+        uint32_t SymIndex = readVaruint32(Ptr);
+        if (SymIndex >= Symbols->size())
+          return make_error<GenericBinaryError>("Invalid syminfo index",
+                                                object_error::parse_failed);
+        uint32_t Flags = readVaruint32(Ptr);
+        (*Symbols)[SymIndex].Flags = Flags;
+        DEBUG(dbgs() << "Set symbol flags index:" << SymIndex
+                     << " name:" << (*Symbols)[SymIndex].Name
+                     << " flags: " << Flags << "\n");
       }
       break;
     }
     case wasm::WASM_DATA_SIZE:
       LinkingData.DataSize = readVaruint32(Ptr);
       break;
     case wasm::WASM_SEGMENT_INFO: {
       uint32_t Count = readVaruint32(Ptr);

lib/ObjectYAML/WasmYAML.cpp

 void MappingTraits<WasmYAML::Comdat>::mapping(
     IO &IO, WasmYAML::Comdat &Comdat) {
   IO.mapRequired("Name", Comdat.Name);
   IO.mapRequired("Entries", Comdat.Entries);
 }
 
 void MappingTraits<WasmYAML::SymbolInfo>::mapping(IO &IO,
                                                   WasmYAML::SymbolInfo &Info) {
-  IO.mapRequired("Name", Info.Name);
+  IO.mapRequired("Kind", Info.Kind);
+  IO.mapRequired("Index", Info.Index);
   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);
 #undef BCase

test/MC/WebAssembly/array-fill.ll

 
 ; CHECK:        - Type:            DATA
 ; CHECK:              Content:         '0102'
 
 ; CHECK:        - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            linking
 ; CHECK-NEXT:     DataSize:        2
 ; CHECK-NEXT:     SymbolInfo:      
-; CHECK-NEXT:       - Name:            gBd
+; CHECK-NEXT:       - Kind:            GLOBAL
+; CHECK-NEXT:         Index:           0
 ; CHECK-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
 ; CHECK-NEXT:     SegmentInfo:    
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Name:            .data
 ; CHECK-NEXT:         Alignment:       1
 ; CHECK-NEXT:         Flags:           [ ]
 ; CHECK-NEXT: ...

test/MC/WebAssembly/comdat.ll

 ; CHECK-NEXT:      - Index:           2
 ; CHECK-NEXT:        Name:            basicInlineFn
 ; CHECK-NEXT:      - Index:           3
 ; CHECK-NEXT:        Name:            sharedFn
 ; CHECK-NEXT:  - Type:            CUSTOM
 ; CHECK-NEXT:    Name:            linking
 ; CHECK-NEXT:    DataSize:        3
 ; CHECK-NEXT:    SymbolInfo:
-; CHECK-NEXT:      - Name:            basicInlineFn
+; CHECK-NEXT:      - Kind:            FUNCTION
+; CHECK-NEXT:        Index:           2
 ; CHECK-NEXT:        Flags:           [ BINDING_WEAK ]
-; CHECK-NEXT:      - Name:            sharedFn
+; CHECK-NEXT:      - Kind:            FUNCTION
+; CHECK-NEXT:        Index:           3
 ; CHECK-NEXT:        Flags:           [ BINDING_WEAK ]
-; CHECK-NEXT:      - Name:            constantData
+; CHECK-NEXT:      - Kind:            GLOBAL
+; CHECK-NEXT:        Index:           0
 ; CHECK-NEXT:        Flags:           [ BINDING_WEAK ]
 ; CHECK-NEXT:    SegmentInfo:
 ; CHECK-NEXT:      - Index:           0
 ; CHECK-NEXT:        Name:            .rodata.constantData
 ; CHECK-NEXT:        Alignment:       1
 ; CHECK-NEXT:        Flags:           [  ]
 ; CHECK-NEXT:    Comdats:
 ; CHECK-NEXT:      - Name:            basicInlineFn

test/MC/WebAssembly/global-ctor-dtor.ll

 ; CHECK-NEXT:       - Index:           7
 ; CHECK-NEXT:         Name:            .Lcall_dtors
 ; CHECK-NEXT:       - Index:           8
 ; CHECK-NEXT:         Name:            .Lregister_call_dtors
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            linking
 ; CHECK-NEXT:     DataSize:        4
 ; CHECK-NEXT:     SymbolInfo:      
-; CHECK-NEXT:       - Name:            .Lcall_dtors.42
+; CHECK-NEXT:       - Kind:            FUNCTION
+; CHECK-NEXT:         Index:           5
 ; CHECK-NEXT:         Flags:           [ BINDING_LOCAL ]
-; CHECK-NEXT:       - Name:            .Lregister_call_dtors.42
+; CHECK-NEXT:       - Kind:            FUNCTION
+; CHECK-NEXT:         Index:           6
 ; CHECK-NEXT:         Flags:           [ BINDING_LOCAL ]
-; CHECK-NEXT:       - Name:            .Lcall_dtors
+; CHECK-NEXT:       - Kind:            FUNCTION
+; CHECK-NEXT:         Index:           7
 ; CHECK-NEXT:         Flags:           [ BINDING_LOCAL ]
-; CHECK-NEXT:       - Name:            .Lregister_call_dtors
+; CHECK-NEXT:       - Kind:            FUNCTION
+; CHECK-NEXT:         Index:           8
 ; CHECK-NEXT:         Flags:           [ BINDING_LOCAL ]
-; CHECK-NEXT:       - Name:            __dso_handle
+; CHECK-NEXT:       - Kind:            GLOBAL
+; CHECK-NEXT:         Index:           0
 ; CHECK-NEXT:         Flags:           [ BINDING_WEAK, VISIBILITY_HIDDEN ]
 ; CHECK-NEXT:     SegmentInfo:     
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Name:            .data.global1
 ; CHECK-NEXT:         Alignment:       8
 ; CHECK-NEXT:         Flags:           [ ]
 ; CHECK-NEXT:     InitFunctions:     
 ; CHECK-NEXT:       - Priority: 42
 ; CHECK-NEXT:         FunctionIndex: 3
 ; CHECK-NEXT:       - Priority: 42
 ; CHECK-NEXT:         FunctionIndex: 6
 ; CHECK-NEXT:       - Priority: 65535
 ; CHECK-NEXT:         FunctionIndex: 4
 ; CHECK-NEXT:       - Priority: 65535
 ; CHECK-NEXT:         FunctionIndex: 8
 ; CHECK-NEXT: ...

test/MC/WebAssembly/unnamed-data.ll

 ; CHECK-NEXT:         Offset:          
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           24
 ; CHECK-NEXT:         Content:         '06000000'
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            linking
 ; CHECK-NEXT:     DataSize:        28
 ; CHECK-NEXT:     SymbolInfo:      
-; CHECK-NEXT:       - Name:            .L.str1
+; CHECK-NEXT:       - Kind:            GLOBAL
+; CHECK-NEXT:         Index:           0
 ; CHECK-NEXT:         Flags:           [ BINDING_LOCAL ]
-; CHECK-NEXT:       - Name:            .L.str2
+; CHECK-NEXT:       - Kind:            GLOBAL
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Flags:           [ BINDING_LOCAL ]
 ; CHECK-NEXT:     SegmentInfo:    
 ; CHECK-NEXT:       - Index:       0
 ; CHECK-NEXT:         Name:        .rodata..L.str1
 ; CHECK-NEXT:         Alignment:   1
 ; CHECK-NEXT:         Flags:       [ ]
 ; CHECK-NEXT:       - Index:       1
 ; CHECK-NEXT:         Name:        .rodata..L.str2

test/MC/WebAssembly/visibility.ll

 }
 
 ; CHECK:        - Type:            CUSTOM
 
 ; CHECK:        - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            linking
 ; CHECK-NEXT:     DataSize:        0
 ; CHECK-NEXT:     SymbolInfo:
-; CHECK-NEXT:       - Name:            hiddenVis
+; CHECK-NEXT:       - Kind:            FUNCTION
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
 ; CHECK-NEXT: ...

test/MC/WebAssembly/weak-alias.ll

 ; CHECK-NEXT:         Name:            call_alias
 ; CHECK-NEXT:       - Index:           3
 ; CHECK-NEXT:         Name:            call_direct_ptr
 ; CHECK-NEXT:       - Index:           4
 ; CHECK-NEXT:         Name:            call_alias_ptr
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            linking
 ; CHECK-NEXT:     DataSize:        20
-; CHECK-NEXT:     SymbolInfo:      
-; CHECK-NEXT:       - Name:            foo
+; CHECK-NEXT:     SymbolInfo:
+; CHECK-NEXT:       - Kind:            FUNCTION
+; CHECK-NEXT:         Index:           0
 ; CHECK-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
-; CHECK-NEXT:       - Name:            call_direct
+; CHECK-NEXT:       - Kind:            FUNCTION
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
-; CHECK-NEXT:       - Name:            call_alias
+; CHECK-NEXT:       - Kind:            FUNCTION
+; CHECK-NEXT:         Index:           2
 ; CHECK-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
-; CHECK-NEXT:       - Name:            call_direct_ptr
+; CHECK-NEXT:       - Kind:            FUNCTION
+; CHECK-NEXT:         Index:           3
 ; CHECK-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
-; CHECK-NEXT:       - Name:            call_alias_ptr
+; CHECK-NEXT:       - Kind:            FUNCTION
+; CHECK-NEXT:         Index:           4
 ; CHECK-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
-; CHECK-NEXT:       - Name:            foo_alias
+; CHECK-NEXT:       - Kind:            FUNCTION
+; CHECK-NEXT:         Index:           5
 ; CHECK-NEXT:         Flags:           [ BINDING_WEAK, VISIBILITY_HIDDEN ]
-; CHECK-NEXT:       - Name:            bar_alias
+; CHECK-NEXT:       - Kind:            GLOBAL
+; CHECK-NEXT:         Index:           3
 ; CHECK-NEXT:         Flags:           [ BINDING_WEAK, VISIBILITY_HIDDEN ]
 ; CHECK-NEXT:     SegmentInfo:    
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Name:            .data.bar
 ; CHECK-NEXT:         Alignment:       8
 ; CHECK-NEXT:         Flags:           [ ]
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Name:            .data.direct_address

test/MC/WebAssembly/weak.ll

 ; CHECK-NEXT:     Name:            name
 ; CHECK-NEXT:     FunctionNames:   
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Name:            weak_function
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            linking
 ; CHECK-NEXT:     DataSize:        0
 ; CHECK-NEXT:     SymbolInfo:      
-; CHECK-NEXT:       - Name:            weak_function
+; CHECK-NEXT:       - Kind:            FUNCTION
+; CHECK-NEXT:         Index:           0
 ; CHECK-NEXT:         Flags:           [ BINDING_WEAK, VISIBILITY_HIDDEN ]
-; CHECK-NEXT:       - Name:            weak_external_data
+; CHECK-NEXT:       - Kind:            GLOBAL
+; CHECK-NEXT:         Index:           0
 ; CHECK-NEXT:         Flags:           [ BINDING_WEAK ]
 ; CHECK-NEXT: ...

test/ObjectYAML/wasm/linking_section.yaml

Segments:
         Offset:
           Opcode:          I32_CONST
           Value:           8
         Content:         '11110000'
   - Type:            CUSTOM
     Name:            linking
     DataSize:        999
     SymbolInfo:
-      - Name:            bar
+      - Kind:            FUNCTION
+        Index:           0
         Flags:           [ BINDING_WEAK ]
     SegmentInfo:
       - Index:       0
         Alignment:   4
         Flags:       [ ]
         Name:        mydata
       - Index:       1
         Alignment:   2
         Flags:       [ ]
         Name:        moredata
     InitFunctions:
       - Priority:      1
         FunctionIndex: 0
 ...
 # CHECK:       - Type:            CUSTOM
 # CHECK-NEXT:    Name:            linking
 # CHECK-NEXT:    DataSize:        999
 # CHECK-NEXT:    SymbolInfo:
-# CHECK-NEXT:      - Name:            bar
+# CHECK-NEXT:      - Kind:            FUNCTION
+# CHECK-NEXT:        Index:           0
 # CHECK-NEXT:        Flags:           [ BINDING_WEAK ]
 # CHECK-NEXT:    SegmentInfo:
 # CHECK-NEXT:      - Index:           0
 # CHECK-NEXT:        Name:            mydata
 # CHECK-NEXT:        Alignment:       4
 # CHECK-NEXT:        Flags:           [ ]
 # CHECK-NEXT:      - Index:           1
 # CHECK-NEXT:        Name:            moredata
 # CHECK-NEXT:        Alignment:       2
 # CHECK-NEXT:        Flags:           [ ]
 # CHECK-NEXT:    InitFunctions:
 # CHECK-NEXT:       - Priority:       1
 # CHECK-NEXT:         FunctionIndex:  0
 # CHECK-NEXT: ...

test/ObjectYAML/wasm/weak_symbols.yaml

Functions:
         Body:            00
       - Index:           1
         Locals:
         Body:            00
   - Type:            CUSTOM
     Name:            linking
     DataSize:        10
     SymbolInfo:
-      - Name:            function_export
+      - Kind:            FUNCTION
+        Index:           0
         Flags:           [ BINDING_WEAK ]
-      - Name:            global_export
+      - Kind:            GLOBAL
+        Index:           0
         Flags:           [ BINDING_WEAK ]
 ...
 # CHECK: --- !WASM
 # CHECK: FileHeader:
 # CHECK:   Version:           0x00000001
 # CHECK: Sections:
 # CHECK:   - Type:            EXPORT
 # CHECK:     Exports:         
 # CHECK:       - Name:            function_export
 # CHECK:         Kind:            FUNCTION
 # CHECK:         Index:           1
 # CHECK:       - Name:            global_export
 # CHECK:         Kind:            GLOBAL
 # CHECK:         Index:           0
 # CHECK:   - Type:            CUSTOM
 # CHECK:     Name:            linking
 # CHECK:     DataSize:        10
 # CHECK:     SymbolInfo:
-# CHECK:       - Name:            function_export
+# CHECK:       - Kind:            FUNCTION
+# CHECK:         Index:           0
 # CHECK:         Flags:           [ BINDING_WEAK ]
-# CHECK:       - Name:            global_export
+# CHECK:       - Kind:            GLOBAL
+# CHECK:         Index:           0
 # CHECK:         Flags:           [ BINDING_WEAK ]

test/tools/llvm-nm/wasm/weak-symbols.yaml

Functions:
         Body:            00
       - Index:           4
         Locals:
         Body:            00
   - Type:            CUSTOM
     Name:            linking
     DataSize:        0
     SymbolInfo:
-      - Name:            weak_global_func
+      - Kind:            FUNCTION
+        Index:           1
         Flags:           [ BINDING_WEAK ]
-      - Name:            weak_global_data
+      - Kind:            GLOBAL
+        Index:           1
         Flags:           [ BINDING_WEAK ]
-      - Name:            weak_import_func
+      - Kind:            FUNCTION
+        Index:           0
         Flags:           [ BINDING_WEAK ]
-      - Name:            weak_import_data
+      - Kind:            GLOBAL
+        Index:           0
         Flags:           [ BINDING_WEAK ]
 
 # CHECK: 00000400 W weak_global_data
 # CHECK: 00000004 W weak_global_func
 # CHECK:          w weak_import_data
 # CHECK:          w weak_import_func

tools/obj2yaml/wasm2yaml.cpp

for (const object::WasmSegment &Segment : Obj.dataSegments()) {
         Comdat.Entries.emplace_back(
             WasmYAML::ComdatEntry{wasm::WASM_COMDAT_DATA, SegmentIndex});
       }
       SegmentIndex++;
     }
     for (const object::SymbolRef& Sym: Obj.symbols()) {
       const object::WasmSymbol Symbol = Obj.getWasmSymbol(Sym);
       if (Symbol.Flags != 0) {
-        WasmYAML::SymbolInfo Info{Symbol.Name, Symbol.Flags};
+        WasmYAML::SymbolInfo Info{Symbol.isFunction() ? wasm::WASM_EXTERNAL_FUNCTION
+                                                      : wasm::WASM_EXTERNAL_GLOBAL,
+                                  Symbol.SymbolIndex, Symbol.Flags};
         LinkingSec->SymbolInfos.emplace_back(Info);
       }
     }
     LinkingSec->DataSize = Obj.linkingData().DataSize;
     for (const wasm::WasmInitFunc &Func : Obj.linkingData().InitFunctions) {
       WasmYAML::InitFunction F{Func.Priority, Func.FunctionIndex};
       LinkingSec->InitFunctions.emplace_back(F);
     }

tools/yaml2obj/yaml2wasm.cpp

int WasmWriter::writeSectionContent(raw_ostream &OS, WasmYAML::LinkingSection &Section) {
   SubSection.Done();
 
   // SYMBOL_INFO subsection
   if (Section.SymbolInfos.size()) {
     encodeULEB128(wasm::WASM_SYMBOL_INFO, OS);
 
     encodeULEB128(Section.SymbolInfos.size(), SubSection.GetStream());
     for (const WasmYAML::SymbolInfo &Info : Section.SymbolInfos) {
-      writeStringRef(Info.Name, SubSection.GetStream());
+      encodeULEB128(Info.Kind, SubSection.GetStream());
+      encodeULEB128(Info.Index, SubSection.GetStream());
       encodeULEB128(Info.Flags, SubSection.GetStream());
     }
 
     SubSection.Done();
   }
 
   // SEGMENT_NAMES subsection
   if (Section.SegmentInfos.size()) {