[WebAssembly] Symbol changes #1, LLVM

[ncw]

Summary

First chunk split out of D41954.

Must be committed simultaneously with LLD change, D42076.

Changes:

• Get rid of DEBUG_FUNCTION_NAME symbols. When we actually debug data, maybe we'll want somewhere to put it... but having a symbol that just stores the name of another symbol seems odd. It means you have multiple Symbols with the same name, one containing the actual function and another containing the name!
• Store the names in a vector on the WasmObjectFile when reading them in. Also stash them on the WasmFunctions themselves. The names are not "symbol names" or aliases or anything, they're just the name that a debugger should show against the function body itself. NB. The WasmObjectFile stores them so that they can be exported in the YAML losslessly, and hence the tests can be precise.
• Enforce that the CODE section has been read in before reading the "names" section. Requires minor adjustment to some tests.

[sbc100]

I think dropping the debug names from the symbol table seems like a good idea.
I'm not so sure about dropping the the imports from the name section. It seems at least like a separate change.
I like added requirement on the section ordering, although I'd prefer a more explicit way to check for it.

What do you think about dropping the name section completely from the compiler output? If the compiler output is meant mainly as a linker input perhaps we don't need a names section at all (since its arguably redundant in the face of the symbol table stuff).

lib/Object/WasmObjectFile.cpp

273 ↗

(On Diff #129866)

Seems like an odd way to verify this, but I can't think of a better one of the top of my head.

[sbc100]

My proposal to drop the writing of the name section completely: https://github.com/WebAssembly/tool-conventions/issues/37. We should probably wait for @sunfish from implementing it.

[ncw]

In D42075#977374, @sbc100 wrote:

I think dropping the debug names from the symbol table seems like a good idea.
I'm not so sure about dropping the the imports from the name section. It seems at least like a separate change.
I like added requirement on the section ordering, although I'd prefer a more explicit way to check for it.

What do you think about dropping the name section completely from the compiler output? If the compiler output is meant mainly as a linker input perhaps we don't need a names section at all (since its arguably redundant in the face of the symbol table stuff).

I agree with dropping the names section completely in WasmObjectWriter. That seems to me like a separate change - could I do that as another patch, after this?

You're right I shouldn't have sneaked in the change to drop names for imports. It's there from a previous version to the patch, but actually now imports could stay. In favour of dropping their names: a) it's useless file bloat; b) neither the Chrome devtools disassembler nor binaryen/wasm-dis make use of the names for imports, although I suppose they could in future. For the time being though I've reverted it.

[ncw]

Updated:

• Reverted change to remove imports from NAME section. They are now written out as before.

[sbc100]

LGTM, I'll try to land this one now.

[ncw]

Thanks for the reviews! I created a fair amount of work for you with these.

(It's dinner-time now, but I'll try and check my work emails later tonight in case there's anything I can help with, to save a 24hr turnaround.)

[sbc100]

This comment was removed by sbc100.

llvm/trunk/include/llvm/BinaryFormat/Wasm.h

 };
 
 struct WasmFunction {
   uint32_t Index;
   std::vector<WasmLocalDecl> Locals;
   ArrayRef<uint8_t> Body;
   uint32_t CodeSectionOffset;
   uint32_t Size;
-  StringRef Comdat;
+  StringRef Name; // from the "names" section
+  StringRef Comdat; // from the "comdat info" section
 };
 
 struct WasmDataSegment {
   uint32_t MemoryIndex;
   WasmInitExpr Offset;
   ArrayRef<uint8_t> Content;
   StringRef Name;
   uint32_t Alignment;
   uint32_t Flags;
-  StringRef Comdat;
+  StringRef Comdat; // from the "comdat info" section
 };
 
 struct WasmElemSegment {
   uint32_t TableIndex;
   WasmInitExpr Offset;
   std::vector<uint32_t> Functions;
 };
 
 struct WasmRelocation {
   uint32_t Type;   // The type of the relocation.
-  uint32_t Index;  // Index into function to global index space.
+  uint32_t Index;  // Index into function or global index space.
   uint64_t Offset; // Offset from the start of the section.
   int64_t Addend;  // A value to add to the symbol.
 };
 
 struct WasmInitFunc {
   uint32_t Priority;
   uint32_t FunctionIndex;
 };
 
+struct WasmFunctionName {
+  uint32_t Index;
+  StringRef Name;
+};
+
 struct WasmLinkingData {
   uint32_t DataSize;
   std::vector<WasmInitFunc> InitFunctions;
 };
 
 enum : unsigned {
   WASM_SEC_CUSTOM = 0,   // Custom / User-defined section
   WASM_SEC_TYPE = 1,     // Function signature declarations

llvm/trunk/include/llvm/Object/Wasm.h

 
 class WasmSymbol {
 public:
   enum class SymbolType {
     FUNCTION_IMPORT,
     FUNCTION_EXPORT,
     GLOBAL_IMPORT,
     GLOBAL_EXPORT,
-    DEBUG_FUNCTION_NAME,
   };
 
   WasmSymbol(StringRef Name, SymbolType Type, uint32_t Section,
              uint32_t ElementIndex, uint32_t FunctionType = 0)
       : Name(Name), Type(Type), Section(Section), ElementIndex(ElementIndex),
         FunctionType(FunctionType) {}
 
   StringRef Name;
public:
 
   void setAltIndex(uint32_t Index) {
     HasAltIndex = true;
     AltIndex = Index;
   }
 
   bool isFunction() const {
     return Type == WasmSymbol::SymbolType::FUNCTION_IMPORT ||
-           Type == WasmSymbol::SymbolType::FUNCTION_EXPORT ||
-           Type == WasmSymbol::SymbolType::DEBUG_FUNCTION_NAME;
+           Type == WasmSymbol::SymbolType::FUNCTION_EXPORT;
   }
 
 
   bool isWeak() const {
     return getBinding() == wasm::WASM_SYMBOL_BINDING_WEAK;
   }
 
   bool isGlobal() const {
public:
   ArrayRef<wasm::WasmGlobal> globals() const { return Globals; }
   ArrayRef<wasm::WasmExport> exports() const { return Exports; }
   const wasm::WasmLinkingData& linkingData() const { return LinkingData; }
   uint32_t getNumberOfSymbols() const { return Symbols.size(); }
   ArrayRef<wasm::WasmElemSegment> elements() const { return ElemSegments; }
   ArrayRef<WasmSegment> dataSegments() const { return DataSegments; }
   ArrayRef<wasm::WasmFunction> functions() const { return Functions; }
   ArrayRef<StringRef> comdats() const { return Comdats; }
+  ArrayRef<wasm::WasmFunctionName> debugNames() const { return DebugNames; }
   uint32_t startFunction() const { return StartFunction; }
 
   void moveSymbolNext(DataRefImpl &Symb) const override;
 
   uint32_t getSymbolFlags(DataRefImpl Symb) const override;
 
   basic_symbol_iterator symbol_begin() const override;
 
private:
   std::vector<wasm::WasmGlobal> Globals;
   std::vector<wasm::WasmImport> Imports;
   std::vector<wasm::WasmExport> Exports;
   std::vector<wasm::WasmElemSegment> ElemSegments;
   std::vector<WasmSegment> DataSegments;
   std::vector<wasm::WasmFunction> Functions;
   std::vector<WasmSymbol> Symbols;
   std::vector<StringRef> Comdats;
+  std::vector<wasm::WasmFunctionName> DebugNames;
   uint32_t StartFunction = -1;
   bool HasLinkingSection = false;
   wasm::WasmLinkingData LinkingData;
   uint32_t NumImportedGlobals = 0;
   uint32_t NumImportedFunctions = 0;
   uint32_t ImportSection = 0;
   uint32_t ExportSection = 0;
 

llvm/trunk/lib/MC/WasmObjectWriter.cpp

class WasmObjectWriter : public MCObjectWriter {
   DenseMap<const MCSymbolWasm *, uint32_t> IndirectSymbolIndices;
   // Maps function/global symbols to the function/global index space.
   DenseMap<const MCSymbolWasm *, uint32_t> SymbolIndices;
 
   DenseMap<WasmFunctionType, int32_t, WasmFunctionTypeDenseMapInfo>
       FunctionTypeIndices;
   SmallVector<WasmFunctionType, 4> FunctionTypes;
   SmallVector<WasmGlobal, 4> Globals;
+  unsigned NumFunctionImports = 0;
   unsigned NumGlobalImports = 0;
 
   // TargetObjectWriter wrappers.
   bool is64Bit() const { return TargetObjectWriter->is64Bit(); }
   unsigned getRelocType(const MCValue &Target, const MCFixup &Fixup) const {
     return TargetObjectWriter->getRelocType(Target, Fixup);
   }
 
void reset() override {
     DataRelocations.clear();
     TypeIndices.clear();
     SymbolIndices.clear();
     IndirectSymbolIndices.clear();
     FunctionTypeIndices.clear();
     FunctionTypes.clear();
     Globals.clear();
     MCObjectWriter::reset();
+    NumFunctionImports = 0;
     NumGlobalImports = 0;
   }
 
   void writeHeader(const MCAssembler &Asm);
 
   void recordRelocation(MCAssembler &Asm, const MCAsmLayout &Layout,
                         const MCFragment *Fragment, const MCFixup &Fixup,
                         MCValue Target, uint64_t &FixedValue) override;
private:
   void writeFunctionSection(ArrayRef<WasmFunction> Functions);
   void writeGlobalSection();
   void writeExportSection(ArrayRef<WasmExport> Exports);
   void writeElemSection(ArrayRef<uint32_t> TableElems);
   void writeCodeSection(const MCAssembler &Asm, const MCAsmLayout &Layout,
                         ArrayRef<WasmFunction> Functions);
   void writeDataSection(ArrayRef<WasmDataSegment> Segments);
   void writeNameSection(ArrayRef<WasmFunction> Functions,
-                        ArrayRef<WasmImport> Imports,
-                        uint32_t NumFuncImports);
+                        ArrayRef<WasmImport> Imports);
   void writeCodeRelocSection();
   void writeDataRelocSection();
   void writeLinkingMetaDataSection(
       ArrayRef<WasmDataSegment> Segments, uint32_t DataSize,
       ArrayRef<std::pair<StringRef, uint32_t>> SymbolFlags,
       ArrayRef<std::pair<uint16_t, uint32_t>> InitFuncs,
       const std::map<StringRef, std::vector<WasmComdatEntry>>& Comdats);
 
void WasmObjectWriter::writeDataSection(ArrayRef<WasmDataSegment> Segments) {
   }
 
   // Apply fixups.
   applyRelocations(DataRelocations, Section.ContentsOffset);
 
   endSection(Section);
 }
 
-void WasmObjectWriter::writeNameSection(
-    ArrayRef<WasmFunction> Functions,
-    ArrayRef<WasmImport> Imports,
-    unsigned NumFuncImports) {
-  uint32_t TotalFunctions = NumFuncImports + Functions.size();
+void WasmObjectWriter::writeNameSection(ArrayRef<WasmFunction> Functions,
+                                        ArrayRef<WasmImport> Imports) {
+  uint32_t TotalFunctions = NumFunctionImports + Functions.size();
   if (TotalFunctions == 0)
     return;
 
   SectionBookkeeping Section;
   startSection(Section, wasm::WASM_SEC_CUSTOM, "name");
   SectionBookkeeping SubSection;
   startSection(SubSection, wasm::WASM_NAMES_FUNCTION);
 
void WasmObjectWriter::writeObject(MCAssembler &Asm,
   // 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<std::pair<uint16_t, uint32_t>, 2> InitFuncs;
   std::map<StringRef, std::vector<WasmComdatEntry>> Comdats;
-  unsigned NumFuncImports = 0;
   SmallVector<WasmDataSegment, 4> DataSegments;
   uint32_t DataSize = 0;
 
   // In the special .global_variables section, we've encoded global
   // variables used by the function. Translate them into the Globals
   // list.
   MCSectionWasm *GlobalVars =
       Ctx.getWasmSection(".global_variables", SectionKind::getMetadata());
void WasmObjectWriter::writeObject(MCAssembler &Asm,
   TableImport.Type = wasm::WASM_TYPE_ANYFUNC;
   Imports.push_back(TableImport);
 
   // Populate FunctionTypeIndices and Imports.
   for (const MCSymbol &S : Asm.symbols()) {
     const auto &WS = static_cast<const MCSymbolWasm &>(S);
 
     // Register types for all functions, including those with private linkage
-    // (making them
-    // because wasm always needs a type signature.
+    // (because wasm always needs a type signature).
     if (WS.isFunction())
       registerFunctionType(WS);
 
     if (WS.isTemporary())
       continue;
 
     // If the symbol is not defined in this translation unit, import it.
     if ((!WS.isDefined() && !WS.isComdat()) ||
         WS.isVariable()) {
       WasmImport Import;
       Import.ModuleName = WS.getModuleName();
       Import.FieldName = WS.getName();
 
       if (WS.isFunction()) {
         Import.Kind = wasm::WASM_EXTERNAL_FUNCTION;
         Import.Type = getFunctionType(WS);
-        SymbolIndices[&WS] = NumFuncImports;
-        ++NumFuncImports;
+        SymbolIndices[&WS] = NumFunctionImports;
+        ++NumFunctionImports;
       } else {
         Import.Kind = wasm::WASM_EXTERNAL_GLOBAL;
         Import.Type = int32_t(PtrType);
         Import.IsMutable = false;
         SymbolIndices[&WS] = NumGlobalImports;
 
         // If this global is the stack pointer, make it mutable.
         if (WS.getName() == "__stack_pointer")
if (WS.isFunction()) {
           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();
+        Index = NumFunctionImports + Functions.size();
 
         // Prepare the function.
         WasmFunction Func;
         Func.Type = getFunctionType(WS);
         Func.Sym = &WS;
         SymbolIndices[&WS] = Index;
         Functions.push_back(Func);
       } else {
void WasmObjectWriter::writeObject(MCAssembler &Asm,
   writeFunctionSection(Functions);
   // Skip the "table" section; we import the table instead.
   // Skip the "memory" section; we import the memory instead.
   writeGlobalSection();
   writeExportSection(Exports);
   writeElemSection(TableElems);
   writeCodeSection(Asm, Layout, Functions);
   writeDataSection(DataSegments);
-  writeNameSection(Functions, Imports, NumFuncImports);
+  writeNameSection(Functions, Imports);
   writeCodeRelocSection();
   writeDataRelocSection();
   writeLinkingMetaDataSection(DataSegments, DataSize, SymbolFlags,
                               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);
 }

llvm/trunk/lib/Object/WasmObjectFile.cpp

Error WasmObjectFile::parseSection(WasmSection &Sec) {
   default:
     return make_error<GenericBinaryError>("Bad section type",
                                           object_error::parse_failed);
   }
 }
 
 Error WasmObjectFile::parseNameSection(const uint8_t *Ptr, const uint8_t *End) {
   llvm::DenseSet<uint64_t> Seen;
+  if (Functions.size() != FunctionTypes.size()) {
+    return make_error<GenericBinaryError>("Names must come after code section",
+                                          object_error::parse_failed);
+  }
 
   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);
         if (!Seen.insert(Index).second)
           return make_error<GenericBinaryError>("Function named more than once",
                                                 object_error::parse_failed);
         StringRef Name = readString(Ptr);
-        if (!Name.empty())
-          Symbols.emplace_back(Name,
-                               WasmSymbol::SymbolType::DEBUG_FUNCTION_NAME,
-                               Sections.size(), Index);
+        if (!isValidFunctionIndex(Index) || Name.empty())
+          return make_error<GenericBinaryError>("Invalid name entry",
+                                                object_error::parse_failed);
+        DebugNames.push_back(wasm::WasmFunctionName{Index, Name});
+        if (Index >= NumImportedFunctions) {
+          // Override any existing name; the name specified by the "names"
+          // section is the Function's canonical name.
+          Functions[Index - NumImportedFunctions].Name = Name;
+        }
       }
       break;
     }
     // Ignore local names for now
     case wasm::WASM_NAMES_LOCAL:
     default:
       Ptr += Size;
       break;
if (Export.Kind == wasm::WASM_EXTERNAL_FUNCTION ||
         WasmSymbol NewSym(Export.Name, ExportType, ExportSection, Export.Index);
         NewSym.setAltIndex(OldSym.ElementIndex);
         Symbols[SymIndex] = NewSym;
 
         DEBUG(dbgs() << "Replacing existing symbol:  " << NewSym
                      << " sym index:" << SymIndex << "\n");
       }
     }
+    if (Export.Kind == wasm::WASM_EXTERNAL_FUNCTION) {
+      auto &Function = Functions[Export.Index - NumImportedFunctions];
+      if (Function.Name.empty()) {
+        // Use the export's name to set a name for the Function, but only if one
+        // hasn't already been set.
+        Function.Name = Export.Name;
+      }
+    }
   }
 }
 
 Error WasmObjectFile::parseLinkingSection(const uint8_t *Ptr,
                                           const uint8_t *End) {
   HasLinkingSection = true;
+  if (Functions.size() != FunctionTypes.size()) {
+    return make_error<GenericBinaryError>(
+        "Linking data must come after code section", object_error::parse_failed);
+  }
 
   // Only populate the symbol table with imports and exports if the object
   // has a linking section (i.e. its a relocatable object file). Otherwise
   // the global might not represent symbols at all.
   populateSymbolTable();
 
   while (Ptr < End) {
     uint8_t Type = readVarint7(Ptr);
uint32_t WasmObjectFile::getSymbolFlags(DataRefImpl Symb) const {
 
   switch (Sym.Type) {
   case WasmSymbol::SymbolType::FUNCTION_IMPORT:
     Result |= SymbolRef::SF_Undefined | SymbolRef::SF_Executable;
     break;
   case WasmSymbol::SymbolType::FUNCTION_EXPORT:
     Result |= 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:
     break;
   }
 
   return Result;
Expected<uint64_t> WasmObjectFile::getSymbolAddress(DataRefImpl Symb) const {
   return getSymbolValue(Symb);
 }
 
 uint64_t WasmObjectFile::getWasmSymbolValue(const WasmSymbol& Sym) const {
   switch (Sym.Type) {
   case WasmSymbol::SymbolType::FUNCTION_IMPORT:
   case WasmSymbol::SymbolType::GLOBAL_IMPORT:
   case WasmSymbol::SymbolType::FUNCTION_EXPORT:
-  case WasmSymbol::SymbolType::DEBUG_FUNCTION_NAME:
     return Sym.ElementIndex;
   case WasmSymbol::SymbolType::GLOBAL_EXPORT: {
     uint32_t GlobalIndex = Sym.ElementIndex - NumImportedGlobals;
     assert(GlobalIndex < Globals.size());
     const wasm::WasmGlobal &Global = Globals[GlobalIndex];
     // WasmSymbols correspond only to I32_CONST globals
     assert(Global.InitExpr.Opcode == wasm::WASM_OPCODE_I32_CONST);
     return Global.InitExpr.Value.Int32;

 
 Expected<SymbolRef::Type>
 WasmObjectFile::getSymbolType(DataRefImpl Symb) const {
   const WasmSymbol &Sym = getWasmSymbol(Symb);
 
   switch (Sym.Type) {
   case WasmSymbol::SymbolType::FUNCTION_IMPORT:
   case WasmSymbol::SymbolType::FUNCTION_EXPORT:
-  case WasmSymbol::SymbolType::DEBUG_FUNCTION_NAME:
     return SymbolRef::ST_Function;
   case WasmSymbol::SymbolType::GLOBAL_IMPORT:
   case WasmSymbol::SymbolType::GLOBAL_EXPORT:
     return SymbolRef::ST_Data;
   }
 
   llvm_unreachable("Unknown WasmSymbol::SymbolType");
   return SymbolRef::ST_Other;

llvm/trunk/test/MC/WebAssembly/weak-alias.ll

 ; CHECK-NEXT:         Flags:           [ ]
 ; CHECK-NEXT:       - Index:           2
 ; CHECK-NEXT:         Name:            .data.alias_address
 ; CHECK-NEXT:         Alignment:       8
 ; CHECK-NEXT:         Flags:           [ ]
 ; CHECK-NEXT: ...
 
 ; CHECK-SYMS: SYMBOL TABLE:
-; CHECK-SYMS-NEXT: 00000000 g     F name  foo_alias
-; CHECK-SYMS-NEXT: 00000001 g     F name  foo
-; CHECK-SYMS-NEXT: 00000002 g     F name  call_direct
-; CHECK-SYMS-NEXT: 00000003 g     F name  call_alias
-; CHECK-SYMS-NEXT: 00000004 g     F name  call_direct_ptr
-; CHECK-SYMS-NEXT: 00000005 g     F name  call_alias_ptr
 ; CHECK-SYMS-NEXT: 00000001 gw    F EXPORT  .hidden foo_alias
 ; CHECK-SYMS-NEXT: 00000000 gw      EXPORT  .hidden bar_alias
 ; CHECK-SYMS-NEXT: 00000001 g     F EXPORT  .hidden foo
 ; CHECK-SYMS-NEXT: 00000002 g     F EXPORT  .hidden call_direct
 ; CHECK-SYMS-NEXT: 00000003 g     F EXPORT  .hidden call_alias
 ; CHECK-SYMS-NEXT: 00000004 g     F EXPORT  .hidden call_direct_ptr
 ; CHECK-SYMS-NEXT: 00000008 g       EXPORT  direct_address
 ; CHECK-SYMS-NEXT: 00000005 g     F EXPORT  .hidden call_alias_ptr
 ; CHECK-SYMS-NEXT: 00000010 g       EXPORT  alias_address
 ; CHECK-SYMS-NEXT: 00000000 g       EXPORT  bar

llvm/trunk/test/ObjectYAML/wasm/weak_symbols.yaml

Sections:
   - Type:            EXPORT
     Exports:         
       - Name:            function_export
         Kind:            FUNCTION
         Index:           1
       - Name:            global_export
         Kind:            GLOBAL
         Index:           0
+  - Type:            CODE
+    Functions:
+      - Index:           0
+        Locals:
+        Body:            00
+      - Index:           1
+        Locals:
+        Body:            00
   - Type:            CUSTOM
     Name:            linking
     DataSize:        10
     SymbolInfo:
       - Name:            function_export
         Flags:           [ BINDING_WEAK ]
       - Name:            global_export
         Flags:           [ BINDING_WEAK ]

llvm/trunk/test/tools/llvm-nm/wasm/exports.yaml

Sections:
   - Type:            EXPORT
     Exports:
       - Name:            foo
         Kind:            FUNCTION
         Index:           0x00000004
       - Name:            bar
         Kind:            GLOBAL
         Index:           0x00000003
+  - Type:            CODE
+    Functions:
+      - Index:           1
+        Locals:
+        Body:            00
+      - Index:           2
+        Locals:
+        Body:            00
+      - Index:           3
+        Locals:
+        Body:            00
+      - Index:           4
+        Locals:
+        Body:            00
+      - Index:           5
+        Locals:
+        Body:            00
   - Type:            CUSTOM
     Name:            "linking"
     DataSize:        0
 
 # CHECK:      00000400 D bar
 # CHECK-NEXT:          U fimport
 # CHECK-NEXT: 00000004 T foo
 # CHECK-NEXT:          U gimport

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

Sections:
   - Type:            EXPORT
     Exports:
       - Name:            weak_global_func
         Kind:            FUNCTION
         Index:           0x00000004
       - Name:            weak_global_data
         Kind:            GLOBAL
         Index:           0x00000003
+  - Type:            CODE
+    Functions:
+      - Index:           1
+        Locals:
+        Body:            00
+      - Index:           2
+        Locals:
+        Body:            00
+      - Index:           3
+        Locals:
+        Body:            00
+      - Index:           4
+        Locals:
+        Body:            00
   - Type:            CUSTOM
     Name:            linking
     DataSize:        0
     SymbolInfo:
       - Name:            weak_global_func
         Flags:           [ BINDING_WEAK ]
       - Name:            weak_global_data
         Flags:           [ BINDING_WEAK ]

llvm/trunk/test/tools/llvm-objdump/WebAssembly/symbol-table.test

 RUN: llvm-objdump -t %p/../Inputs/trivial.obj.wasm | FileCheck %s
 
 CHECK:      SYMBOL TABLE:
-CHECK-NEXT: 00000000 g     F name puts
-CHECK-NEXT: 00000001 g     F name SomeOtherFunction
-CHECK-NEXT: 00000002 g     F name main
 CHECK-NEXT: 00000000 g     F IMPORT puts
 CHECK-NEXT: 00000000 g     F IMPORT SomeOtherFunction
 CHECK-NEXT: 00000002 g     F EXPORT main
 CHECK-NEXT: 00000010 g       EXPORT var
 

llvm/trunk/test/tools/llvm-readobj/symbols.test

 ELF-NEXT:     Type: Object (0x1)
 ELF-NEXT:     Other: 0
 ELF-NEXT:     Section: .rodata.str1.1 (0x5)
 ELF-NEXT:   }
 
 WASM:      Symbols [
 WASM-NEXT:   Symbol {
 WASM-NEXT:     Name: puts
-WASM-NEXT:     Type: DEBUG_FUNCTION_NAME (0x4)
-WASM-NEXT:     Flags: 0x0
-WASM-NEXT:   }
-WASM-NEXT:   Symbol {
-WASM-NEXT:     Name: SomeOtherFunction
-WASM-NEXT:     Type: DEBUG_FUNCTION_NAME (0x4)
-WASM-NEXT:     Flags: 0x0
-WASM-NEXT:   }
-WASM-NEXT:   Symbol {
-WASM-NEXT:     Name: main
-WASM-NEXT:     Type: DEBUG_FUNCTION_NAME (0x4)
-WASM-NEXT:     Flags: 0x0
-WASM-NEXT:   }
-WASM-NEXT:   Symbol {
-WASM-NEXT:     Name: puts
 WASM-NEXT:     Type: FUNCTION_IMPORT (0x0)
 WASM-NEXT:     Flags: 0x0
 WASM-NEXT:   }
 WASM-NEXT:   Symbol {
 WASM-NEXT:     Name: SomeOtherFunction
 WASM-NEXT:     Type: FUNCTION_IMPORT (0x0)
 WASM-NEXT:     Flags: 0x0
 WASM-NEXT:   }
 WASM-NEXT:   Symbol {
 WASM-NEXT:     Name: main
 WASM-NEXT:     Type: FUNCTION_EXPORT (0x1)
 WASM-NEXT:     Flags: 0x0
 WASM-NEXT:   }
 WASM-NEXT: ]

llvm/trunk/tools/llvm-readobj/WasmDumper.cpp

 namespace {
 
 static const EnumEntry<unsigned> WasmSymbolTypes[] = {
 #define ENUM_ENTRY(X) { #X, static_cast<unsigned>(WasmSymbol::SymbolType::X) }
   ENUM_ENTRY(FUNCTION_IMPORT),
   ENUM_ENTRY(FUNCTION_EXPORT),
   ENUM_ENTRY(GLOBAL_IMPORT),
   ENUM_ENTRY(GLOBAL_EXPORT),
-  ENUM_ENTRY(DEBUG_FUNCTION_NAME),
 #undef ENUM_ENTRY
 };
 
 static const EnumEntry<uint32_t> WasmSectionTypes[] = {
 #define ENUM_ENTRY(X) { #X, wasm::WASM_SEC_##X }
   ENUM_ENTRY(CUSTOM),
   ENUM_ENTRY(TYPE),
   ENUM_ENTRY(IMPORT),

llvm/trunk/tools/obj2yaml/wasm2yaml.cpp

static WasmYAML::Limits make_limits(const wasm::WasmLimits &Limits) {
   L.Maximum = Limits.Maximum;
   return L;
 }
 
 std::unique_ptr<WasmYAML::CustomSection> WasmDumper::dumpCustomSection(const WasmSection &WasmSec) {
   std::unique_ptr<WasmYAML::CustomSection> CustomSec;
   if (WasmSec.Name == "name") {
     std::unique_ptr<WasmYAML::NameSection> NameSec = make_unique<WasmYAML::NameSection>();
-    for (const object::SymbolRef& Sym: Obj.symbols()) {
-      const object::WasmSymbol Symbol = Obj.getWasmSymbol(Sym);
-      if (Symbol.Type != object::WasmSymbol::SymbolType::DEBUG_FUNCTION_NAME)
-        continue;
+    for (const llvm::wasm::WasmFunctionName &Func: Obj.debugNames()) {
       WasmYAML::NameEntry NameEntry;
-      NameEntry.Name = Symbol.Name;
-      NameEntry.Index = Sym.getValue();
+      NameEntry.Name = Func.Name;
+      NameEntry.Index = Func.Index;
       NameSec->FunctionNames.push_back(NameEntry);
     }
     CustomSec = std::move(NameSec);
   } else if (WasmSec.Name == "linking") {
     std::unique_ptr<WasmYAML::LinkingSection> LinkingSec = make_unique<WasmYAML::LinkingSection>();
     std::map<StringRef,size_t> ComdatIndexes;
     for (StringRef ComdatName : Obj.comdats()) {
       ComdatIndexes[ComdatName] = LinkingSec->Comdats.size();