[WebAssembly] Add symbol table to LLVM, 1/2

[ncw]

Summary

WebAssembly object files will now have an explicit symbol table. This commit is the first of two halves, adding support throughout the code for addressing symbols by index; however, the symbols are still written out using a single import/export (depending on whether defined).

This half of the symbol table work is valid on its own, and the second half doesn't need to be committed immediately after. However, the corresponding LLD change D41955 must be committed simultaneously with this.

---

Addresses: https://github.com/WebAssembly/tool-conventions/issues/34

Changes:

• For IMPORTs, go back to where we in November! Get rid of "alt index" stuff and don't generate an import for weakly-exported symbols. Now each MCSymbol generates a single import or export (never both) and each import/export generates a single LLD Symbol. Whew!
• Track both "symbol index" and "Wasm index" for each entity. A Wasm function can have more than one symbol attached. Hopefully the naming now avoids any confusion as to what index is referring to what.
• Document new scheme in the headers

[sbc100]

Looks promising!

If we are going to remove debug names from the symbol table (which seems like a reasonable idea) can you split that into a separate change?

[sbc100]

include/llvm/BinaryFormat/Wasm.h

93

How about just:

uint32_t Index;   // Function index space

There is really only one index that a function can have.

If we want to be extra clear we could also add new types for FunctionIndex and GlobalIndex I suppose.

include/llvm/Object/Wasm.h

57

Its a single index space right? How about just "Index into the symbol index space, which consists of imports and exports"

165

Do we need these new methods?

268

Do these needs to be separate? Why not just have "Symbols"?

lib/MC/WasmObjectWriter.cpp

609

I guess we can make this an if/else now since all relocations except TYPE_INDEX are now symbol-based.

It would be nice if we could unify TYPE_INDEX too but I don't think we can sadly since its used by call_indirect to call function pointers for which there is not a symbol.

824

Why this change?

947

Rename this argument to Symbolnfo?

lib/Object/WasmObjectFile.cpp

743

isValidFunctionWasmIndex?

750

Should we add isValidGlobalIndex? Maybe that plus the above can be a separate simply change?

926

Again, not sure we need to separate these do we? Seems like just makes our lives harder.

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

61

It would probably be useful to have the symbol index here too so it clear which symbol the info is for. I've been going this for other sections too: https://reviews.llvm.org/D41877

I guess you would need to rename the existing Index: field then. Perhaps to WasmIndex?

[ncw]

Thanks for the early feedback!

I hadn't quite finished work on it, and was going to add some reviewers tomorrow.

The tests aren't all passing, some more need to be updated.

Regarding the tests - the diffs are going to seem larger & more invasive than I would have liked. Sorry :( Part of the changes are due to (partially) undoing D41472 at the same time.

Splitting it up would be a fiddle, but might be possible. Changing the Symbol index space kind-of forces most of the changes to happen all at once; some of the changes though are stuffed in a bit gratuitously I admit.

include/llvm/BinaryFormat/Wasm.h

93

Oops, yes, need to rename it back! I renamed every var with "Index" in to force myself to examine/audit everywhere they were used.

(In my mind there are three possible index spaces for functions: the index into std::vector<WasmFunction> Functions, secondly the Wasm function index space, and thirdly the function Symbol index space. They're pretty clear from the context though! This one didn't need renaming.)

include/llvm/Object/Wasm.h

57

I've made functions/globals have separate Symbol index spaces, just like they have separate Wasm index spaces.

My rationale:

1. Matches Wasm index space(s)
2. Makes range checks easier in dozens of places - no need to check "is < max && is correct type" when the index spaces are separate
3. No chance of type confusion - forgetting to do a type check and then accidentally using a Symbol of the wrong type. I really feel that merging the index spaces would increase the risk of bugs.

165

They're short and simple! I find it disappointing to have at least two (redundant) instances of the following code:

int NumImportedGlobals = 0;
int NumImportedFunctions = 0;
for (auto Import : Imports) {
  switch (Import.Type) {
  case Global: ++NumImportedGlobals; break;
  case Function: ++NumImportedFunctions; break;
  }
}

How verbose! Definitely worth eliminating silly counting loops; the WasmObjectFile is an ideal place to store simple information like how many imports/exports there are, so that other code doesn't have to do the counting.

268

See above. I could be convinced (or told!) to merge them, but for the moment I think it's more robust (and shorter overall) to keep separately-typed objects separate.

include/llvm/ObjectYAML/WasmYAML.h

133

This is something I slightly regret. The need for a "Kind" field here is the one downside I can think of for keeping the function/global index space of Symbols separate.

"Index" var below needs comment.

lib/MC/WasmObjectWriter.cpp

824

Good catch. I wanted to make the intermediate object files as similar as possible to the final output files.

Why the odd differences? When making normal output, LLD started the Table from 1, but for relocatable output, LLD started it at zero, and WasmObjectWriter also started from zero. They should all just agree on what the right convention is, and use it.

I did consider not outputting a table at all from WasmObjectWriter (and for LLD's relocatable output). It's not used... so it's just dead code to generate something redundant. On the other hand, it's "nice" to have the object file mirror the behaviour of the LLD output. I'm still not 100% convinced "nice" is enough to justify dozens of lines of useless code however. Do you have any thoughts?

lib/Object/WasmObjectFile.cpp

285

I've decided actually to edit this.

Currently, I've changed it to get rid of the weird/unused DEBUG symbols, and generate a fresh+shiny "names" section in LLD for the browser to use. But, I should actually keep the original vector of names around, just for the time being, for wasm2yaml's sake.

926

Aha, you've pounced on the one line of code where it's extra...

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

61

The index here is already the symbol index (since it's symbol metadata!)

I need to make a corresponding PR in the Linking Conventions repo, to document what I've done (assuming this is eventually merged). Most of the linking metadata uses Symbol index space, just one or two bits of metadata use the wasm index space.

[ncw]

Changes:

• Responded to Sam's feedback
• Fixed all test failures

It's pretty large, I'll look into splitting up into a couple of smaller commits. That drags out the time to get the chain of patches committed which increases rebasing time... but it's probably worth doing here. I'll have to come back to it next week, I can't do any more refactoring on it this week.

I'm happy with my changes overall now.

[ncw]

Simple rebase to fix conflicts.

[ncw]

Updated: split up the big review into six smaller ones. This is the core change still, the change that motivated it all!

[ncw]

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

162 ↗

(On Diff #129977)

Updated test expectations: some benign reordering of iteration now means that globals come after functions.

test/MC/WebAssembly/weak-alias.ll

75

Updated test expectations: getting rid of these imports that duplicate the exports is exactly what we were trying to achieve!

The consequence is that all the function/global indexes below have been decremented by 1 - except for index zero (foo_alias) which is now 5. Each index change below matches my expectations.

[ncw]

Updated:

• Simple rebase to fix conflict

[ncw]

Updated:

• Simple rebase, fixing conflicts along the way

[ncw]

Updated:

• Now in line with the new symtab proposal!
• NB Doesn't actually include the symtab itself, but changes relocations to use the new symbol indexes
• The next review after this will do the actual refactor whereby global symbols are split into global/data symbols, and are written out in the linking metadata rather than in the imports/exports table

[ncw]

Updating to remove conflict, just in hope it'll be merged...

[ncw]

Updated:

• Rejigged to reduce the diff
• Makes clearer the progression to the final symbol tab implementation

I'm happy with this, awaiting review.

[ncw]

Simple update to remove conflicts (now based on top of D42750)

[sbc100]

Looks like this needs anther rebase

[sbc100]

Ok.. I think we are almost there now.

I'm still not a fan of landing this in two parts, but I'm prepared to do it if land them close together I guess.

include/llvm/Object/Wasm.h

55–73

I think "either" is not supposed to be here.

61

Can we avoid renaming this for now and continue to call it ElementIndex? Especially since the above "SymbolIndex" is removed in the followup change. We can rename it later perhaps, but I keeping it the same will reduce churn and make this change more concise.

111

Revert this change, since SymbolIndex is a temporary measure?

lib/Object/WasmObjectFile.cpp

446

So we want to INIT_FUNCS to refer to symbols rather than functions?

948

Revert this?

[ncw]

Updated, renamed WasmIndex -> ElementIndex

lib/Object/WasmObjectFile.cpp

446

I think so. An init func could perfectly well be a weak symbol like a C++ inline ctor or something - I don't think the linking conventions should force the frontend into always emitting a non-discardable thunk for init functions (rather than allowing the init declaration to link to a shared symbol).

We should add a test for this at some point I guess. I've just checked and the following really does work: void __attribute__((weak,constructor)) myFunc() {}.

[ncw]

Rebased, attended to review comments/renaming

[sbc100]

lib/MC/WasmObjectWriter.cpp

1186

Can SymbolIndices[&WS] = NumSymbols++; be moved in the AddSymbol? That would seem logical to me.

1235

I don't like the term WasmIndex here. Can we just revert this or come up with a better name? Looks like its actially used as the Export.Index below, so maybe ExportIndex? Just reverting to Index seems reasonable though.

1270

Revert this indentation change? Seems like continue; is still what we want.

[ncw]

Updated; renamed WasmIndex -> Index, folder assignment into AddSymbol helper

include/llvm/BinaryFormat/Wasm.h

 };
 
 struct WasmLocalDecl {
   int32_t Type;
   uint32_t Count;
 };
 
 struct WasmFunction {
-  uint32_t Index;
+  uint32_t WasmIndex; // index into code array + num imported fns
   std::vector<WasmLocalDecl> Locals;
   ArrayRef<uint8_t> Body;
   uint32_t CodeSectionOffset;
   uint32_t Size;
-  StringRef Comdat;
+  StringRef Name; // from the "names" or "export" section
+  StringRef Comdat; // from the "comdat info" section
 };
 
 struct WasmDataSegment {
   uint32_t MemoryIndex;
   WasmInitExpr Offset;
   ArrayRef<uint8_t> Content;
   StringRef Name;
   uint32_t Alignment;

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) {}
+             uint32_t SymbolIndex, uint32_t WasmIndex,
+             uint32_t FunctionType = 0)
+      : Name(Name), Type(Type), Section(Section), SymbolIndex(SymbolIndex),
+        WasmIndex(WasmIndex), FunctionType(FunctionType) {}
 
   StringRef Name;
   SymbolType Type;
   uint32_t Section;
   uint32_t Flags = 0;
 
-  // Index into either the function or global index space.
-  uint32_t ElementIndex;
+  // Index into either the function or global Symbol index space.  The Symbol
+  // index space consists of the imports followed by the exports (each of
+  // which creates a Symbol).
+  uint32_t SymbolIndex;
+  // Index into the the function or global Wasm index space.  This is the
+  // index space used by the Wasm format for referring to a function or
+  // global, and consists of the imports followed by the function/global
+  // definitions.
+  // To be crystal clear, the following Wasm file has three linker symbols,
+  // and two Wasm callable items:
+  //   (import "env" "externalFn" ...)
+  //   (export "exportedFn" (func $exportedFnBody))
+  //   (export "exportedFnAlias" (func $exportedFnBody))
+  //   (func $exportedFnBody ...)
+  // Symbol index space =
+  //   [ 0: import externalFn, 1: export exportedFn, 2: export exportedFnAlias ]
+  // Wasm index space =
+  //   [ 0: import externalFn, 1: definition exportedFnBody ]
+  uint32_t WasmIndex;
 
   // For function, the type index
   uint32_t FunctionType;
 
-  // Symbols can be both exported and imported (in the case of the weakly
-  // defined symbol).  In this the import index is stored as AltIndex.
-  uint32_t AltIndex = 0;
-  bool HasAltIndex = false;
-
-  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:
   }
 
   unsigned getVisibility() const {
     return Flags & wasm::WASM_SYMBOL_VISIBILITY_MASK;
   }
 
   void print(raw_ostream &Out) const {
     Out << "Name=" << Name << ", Type=" << static_cast<int>(Type)
-        << ", Flags=" << Flags << " ElemIndex=" << ElementIndex;
+        << ", Flags=" << Flags << " SymbolIndex=" << SymbolIndex
+        << ", WasmIndex=" << WasmIndex;
   }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
   LLVM_DUMP_METHOD void dump() const { print(dbgs()); }
 #endif
 };
 
 struct WasmSection {
public:
   ArrayRef<wasm::WasmSignature> types() const { return Signatures; }
   ArrayRef<uint32_t> functionTypes() const { return FunctionTypes; }
   ArrayRef<wasm::WasmImport> imports() const { return Imports; }
   ArrayRef<wasm::WasmTable> tables() const { return Tables; }
   ArrayRef<wasm::WasmLimits> memories() const { return Memories; }
   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(); }
+  uint32_t getNumberOfSymbols() const
+  { return FunctionSymbols.size() + GlobalSymbols.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; }
   uint32_t startFunction() const { return StartFunction; }
+  uint32_t getNumImportedGlobals() const { return NumImportedGlobals; }
+  uint32_t getNumImportedFunctions() const { return NumImportedFunctions; }
+  uint32_t getNumExportedGlobals() const { return NumExportedGlobals; }
+  uint32_t getNumExportedFunctions() const { return NumExportedFunctions; }
 
   void moveSymbolNext(DataRefImpl &Symb) const override;
 
   uint32_t getSymbolFlags(DataRefImpl Symb) const override;
 
   basic_symbol_iterator symbol_begin() const override;
 
   basic_symbol_iterator symbol_end() const override;
public:
   section_iterator section_end() const override;
   uint8_t getBytesInAddress() const override;
   StringRef getFileFormatName() const override;
   Triple::ArchType getArch() const override;
   SubtargetFeatures getFeatures() const override;
   bool isRelocatableObject() const override;
 
 private:
-  bool isValidFunctionIndex(uint32_t Index) const;
+  bool isValidFunctionWasmIndex(uint32_t Index) const;
+  bool isValidFunctionSymbolIndex(uint32_t Index) const;
   const WasmSection &getWasmSection(DataRefImpl Ref) const;
   const wasm::WasmRelocation &getWasmRelocation(DataRefImpl Ref) const;
 
   WasmSection* findCustomSectionByName(StringRef Name);
   WasmSection* findSectionByType(uint32_t Type);
 
   const uint8_t *getPtr(size_t Offset) const;
   Error parseSection(WasmSection &Sec);
private:
 
   // Custom section types
   Error parseNameSection(const uint8_t *Ptr, const uint8_t *End);
   Error parseLinkingSection(const uint8_t *Ptr, const uint8_t *End);
   Error parseLinkingSectionComdat(const uint8_t *&Ptr, const uint8_t *End);
   Error parseRelocSection(StringRef Name, const uint8_t *Ptr,
                           const uint8_t *End);
 
-  void populateSymbolTable();
+  Error populateSymbolTable();
 
   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<wasm::WasmElemSegment> ElemSegments;
   std::vector<WasmSegment> DataSegments;
   std::vector<wasm::WasmFunction> Functions;
-  std::vector<WasmSymbol> Symbols;
+  std::vector<WasmSymbol> FunctionSymbols;
+  std::vector<WasmSymbol> GlobalSymbols;
   std::vector<StringRef> Comdats;
   uint32_t StartFunction = -1;
   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;
-
-  StringMap<uint32_t> SymbolMap;
 };
 
 } // 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

 // 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.
 
class WasmObjectWriter : public MCObjectWriter {
   std::vector<WasmRelocationEntry> CodeRelocations;
 
   // Relocations for fixing up references in the data section.
   std::vector<WasmRelocationEntry> DataRelocations;
 
   // Index values to use for fixing up call_indirect type indices.
   // Maps function symbols to the index of the type of the function
   DenseMap<const MCSymbolWasm *, uint32_t> TypeIndices;
-  // Maps function symbols to the table element index space. Used
-  // for TABLE_INDEX relocation types (i.e. address taken functions).
-  DenseMap<const MCSymbolWasm *, uint32_t> IndirectSymbolIndices;
-  // Maps function/global symbols to the function/global index space.
+  // Maps function/global symbols to the function/global Symbol index space.
   DenseMap<const MCSymbolWasm *, uint32_t> SymbolIndices;
+  // Maps function/global symbols to the function/global Wasm index space.
+  DenseMap<const MCSymbolWasm *, uint32_t> WasmIndices;
+  // Maps function symbol indices to the table element index space. Used
+  // for TABLE_INDEX relocation types (i.e. address taken functions).
+  SmallVector<int32_t, 4> TableIndices;
 
   DenseMap<WasmFunctionType, int32_t, WasmFunctionTypeDenseMapInfo>
       FunctionTypeIndices;
   SmallVector<WasmFunctionType, 4> FunctionTypes;
   SmallVector<WasmGlobal, 4> Globals;
+  unsigned NumFunctionImports = 0;
   unsigned NumGlobalImports = 0;
+  unsigned InitialTableOffset = 1;
 
   // TargetObjectWriter wrappers.
   bool is64Bit() const { return TargetObjectWriter->is64Bit(); }
   unsigned getRelocType(const MCValue &Target, const MCFixup &Fixup) const {
     return TargetObjectWriter->getRelocType(Target, Fixup);
   }
 
   void startSection(SectionBookkeeping &Section, unsigned SectionId,

 private:
   ~WasmObjectWriter() override;
 
   void reset() override {
     CodeRelocations.clear();
     DataRelocations.clear();
     TypeIndices.clear();
     SymbolIndices.clear();
-    IndirectSymbolIndices.clear();
+    TableIndices.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;
void writeImportSection(ArrayRef<WasmImport> Imports, uint32_t DataSize,
                           uint32_t NumElements);
   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);
+  void writeNameSection(ArrayRef<WasmFunction> Functions);
   void writeCodeRelocSection();
   void writeDataRelocSection();
   void writeLinkingMetaDataSection(
       ArrayRef<WasmDataSegment> Segments, uint32_t DataSize,
-      ArrayRef<std::pair<StringRef, uint32_t>> SymbolFlags,
+      ArrayRef<WasmSymEntry> SymbolFlags,
       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 writeRelocations(ArrayRef<WasmRelocationEntry> Relocations);
   uint32_t getRelocationIndexValue(const WasmRelocationEntry &RelEntry);
   uint32_t getFunctionType(const MCSymbolWasm& Symbol);
   uint32_t registerFunctionType(const MCSymbolWasm& Symbol);
 };

 uint32_t
 WasmObjectWriter::getProvisionalValue(const WasmRelocationEntry &RelEntry) {
   const MCSymbolWasm *Sym = ResolveSymbol(*RelEntry.Symbol);
 
   // For undefined symbols, use zero
   if (!Sym->isDefined(/*SetUsed=*/false))
     return 0;
 
-  uint32_t GlobalIndex = SymbolIndices[Sym];
+  uint32_t GlobalIndex = WasmIndices[Sym];
   const WasmGlobal& Global = Globals[GlobalIndex - NumGlobalImports];
   uint64_t Address = Global.InitialValue + RelEntry.Addend;
 
   // Ignore overflow. LLVM allows address arithmetic to silently wrap.
   uint32_t Value = Address;
 
   return Value;
 }
 
+// Get a provisional table index.  For table relocations, the relocation
+// entry contains the actual function symbol index, and that's all that's
+// used by the linker. However, as a nice touch so that the object files
+// "work", we create provisional table and table indexes just for show.
+uint32_t WasmObjectWriter::getProvisionalTableIndex(
+    const WasmRelocationEntry &RelEntry) {
+  const MCSymbolWasm *Sym = ResolveSymbol(*RelEntry.Symbol);
+  assert(Sym->isFunction());
+  if (!WasmIndices.count(Sym))
+    report_fatal_error("symbol not found in function/global index space: " +
+                       RelEntry.Symbol->getName());
+  uint32_t WasmIndex = WasmIndices[Sym];
+  // For address-taken imports, simply insert a placeholder null pointer
+  if (WasmIndex < NumFunctionImports)
+    return 0;
+  int32_t TableIndex = TableIndices[WasmIndex - NumFunctionImports];
+  if (TableIndex < 0)
+    report_fatal_error("symbol not found in table index space: " +
+                       Sym->getName());
+  return TableIndex;
+}
+
 static void addData(SmallVectorImpl<char> &DataBytes,
                     MCSectionWasm &DataSection) {
   DEBUG(errs() << "addData: " << DataSection.getSectionName() << "\n");
 
   DataBytes.resize(alignTo(DataBytes.size(), DataSection.getAlignment()));
 
   size_t LastFragmentSize = 0;
   for (const MCFragment &Frag : DataSection) {
static void addData(SmallVectorImpl<char> &DataBytes,
   DEBUG(dbgs() << "addData -> " << DataBytes.size() << "\n");
 }
 
 uint32_t WasmObjectWriter::getRelocationIndexValue(
     const WasmRelocationEntry &RelEntry) {
   switch (RelEntry.Type) {
   case wasm::R_WEBASSEMBLY_TABLE_INDEX_SLEB:
   case wasm::R_WEBASSEMBLY_TABLE_INDEX_I32:
-    if (!IndirectSymbolIndices.count(RelEntry.Symbol))
-      report_fatal_error("symbol not found in table index space: " +
-                         RelEntry.Symbol->getName());
-    return IndirectSymbolIndices[RelEntry.Symbol];
   case wasm::R_WEBASSEMBLY_FUNCTION_INDEX_LEB:
   case wasm::R_WEBASSEMBLY_GLOBAL_INDEX_LEB:
   case wasm::R_WEBASSEMBLY_MEMORY_ADDR_LEB:
   case wasm::R_WEBASSEMBLY_MEMORY_ADDR_SLEB:
   case wasm::R_WEBASSEMBLY_MEMORY_ADDR_I32:
     if (!SymbolIndices.count(RelEntry.Symbol))
       report_fatal_error("symbol not found in function/global index space: " +
                          RelEntry.Symbol->getName());
     return SymbolIndices[RelEntry.Symbol];
   case wasm::R_WEBASSEMBLY_TYPE_INDEX_LEB:
     if (!TypeIndices.count(RelEntry.Symbol))
       report_fatal_error("symbol not found in type index space: " +
                          RelEntry.Symbol->getName());
     return TypeIndices[RelEntry.Symbol];
   default:
     llvm_unreachable("invalid relocation type");
   }
 }
 
 // Apply the portions of the relocation records that we can handle ourselves
 // directly.
 void WasmObjectWriter::applyRelocations(
     ArrayRef<WasmRelocationEntry> Relocations, uint64_t ContentsOffset) {
   raw_pwrite_stream &Stream = getStream();
   for (const WasmRelocationEntry &RelEntry : Relocations) {
     uint64_t Offset = ContentsOffset +
                       RelEntry.FixupSection->getSectionOffset() +
                       RelEntry.Offset;
 
     DEBUG(dbgs() << "applyRelocation: " << RelEntry << "\n");
     switch (RelEntry.Type) {
-    case wasm::R_WEBASSEMBLY_TABLE_INDEX_SLEB:
     case wasm::R_WEBASSEMBLY_FUNCTION_INDEX_LEB:
     case wasm::R_WEBASSEMBLY_TYPE_INDEX_LEB:
     case wasm::R_WEBASSEMBLY_GLOBAL_INDEX_LEB: {
       uint32_t Index = getRelocationIndexValue(RelEntry);
       WritePatchableSLEB(Stream, Index, Offset);
       break;
     }
+    case wasm::R_WEBASSEMBLY_TABLE_INDEX_SLEB: {
+      uint32_t TableIndex = getProvisionalTableIndex(RelEntry);
+      WritePatchableSLEB(Stream, TableIndex, Offset);
+      break;
+    }
     case wasm::R_WEBASSEMBLY_TABLE_INDEX_I32: {
-      uint32_t Index = getRelocationIndexValue(RelEntry);
-      WriteI32(Stream, Index, Offset);
+      uint32_t TableIndex = getProvisionalTableIndex(RelEntry);
+      WriteI32(Stream, TableIndex, Offset);
       break;
     }
     case wasm::R_WEBASSEMBLY_MEMORY_ADDR_SLEB: {
       uint32_t Value = getProvisionalValue(RelEntry);
       WritePatchableSLEB(Stream, Value, Offset);
       break;
     }
     case wasm::R_WEBASSEMBLY_MEMORY_ADDR_LEB: {
void WasmObjectWriter::writeElemSection(ArrayRef<uint32_t> TableElems) {
   SectionBookkeeping Section;
   startSection(Section, wasm::WASM_SEC_ELEM);
 
   encodeULEB128(1, getStream()); // number of "segments"
   encodeULEB128(0, getStream()); // the table index
 
   // init expr for starting offset
   write8(wasm::WASM_OPCODE_I32_CONST);
-  encodeSLEB128(0, getStream());
+  encodeSLEB128(InitialTableOffset, getStream());
   write8(wasm::WASM_OPCODE_END);
 
   encodeULEB128(TableElems.size(), getStream());
   for (uint32_t Elem : TableElems)
     encodeULEB128(Elem, getStream());
 
   endSection(Section);
 }
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();
-  if (TotalFunctions == 0)
+void WasmObjectWriter::writeNameSection(ArrayRef<WasmFunction> Functions) {
+  if (Functions.size() == 0)
     return;
 
   SectionBookkeeping Section;
   startSection(Section, wasm::WASM_SEC_CUSTOM, "name");
   SectionBookkeeping SubSection;
   startSection(SubSection, wasm::WASM_NAMES_FUNCTION);
 
-  encodeULEB128(TotalFunctions, getStream());
-  uint32_t Index = 0;
-  for (const WasmImport &Import : Imports) {
-    if (Import.Kind == wasm::WASM_EXTERNAL_FUNCTION) {
-      encodeULEB128(Index, getStream());
-      writeString(Import.FieldName);
-      ++Index;
-    }
-  }
+  encodeULEB128(Functions.size(), getStream());
+  uint32_t Index = NumFunctionImports;
   for (const WasmFunction &Func : Functions) {
     encodeULEB128(Index, getStream());
     writeString(Func.Sym->getName());
     ++Index;
   }
 
   endSection(SubSection);
   endSection(Section);
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> SymbolFlags,
     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 (!SymbolFlags.empty()) {
     startSection(SubSection, wasm::WASM_SYMBOL_INFO);
     encodeULEB128(SymbolFlags.size(), getStream());
-    for (auto Pair: SymbolFlags) {
-      writeString(Pair.first);
-      encodeULEB128(Pair.second, getStream());
+    for (const auto &SI : SymbolFlags) {
+      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<WasmSymEntry, 4> &SymbolFlags,
+                     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() ? wasm::WASM_SYMBOL_BINDING_LOCAL : 0);
+  if (Flags != 0) {
+    uint32_t Kind = WS.isFunction() ? wasm::WASM_EXTERNAL_FUNCTION
+                                    : wasm::WASM_EXTERNAL_GLOBAL;
+    SymbolFlags.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> SymbolFlags;
   SmallVector<std::pair<uint16_t, uint32_t>, 2> InitFuncs;
   std::map<StringRef, std::vector<WasmComdatEntry>> Comdats;
-  unsigned NumFuncImports = 0;
+  unsigned NumFuncExports = 0;
+  unsigned NumGlobalExports = 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(/*SetUsed=*/false) || WS.isVariable()) {
+    if (!WS.isDefined(/*SetUsed=*/false)) {
       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;
+        WasmIndices[&WS] = SymbolIndices[&WS] = NumFunctionImports;
+        ++NumFunctionImports;
       } else {
         Import.Kind = wasm::WASM_EXTERNAL_GLOBAL;
         Import.Type = int32_t(PtrType);
         Import.IsMutable = false;
-        SymbolIndices[&WS] = NumGlobalImports;
+        WasmIndices[&WS] = SymbolIndices[&WS] = NumGlobalImports;
 
         // If this global is the stack pointer, make it mutable.
         if (WS.getName() == "__stack_pointer")
           Import.IsMutable = true;
 
         ++NumGlobalImports;
       }
 
       Imports.push_back(Import);
     }
   }
 
   for (MCSection &Sec : Asm) {
     auto &Section = static_cast<MCSectionWasm &>(Sec);
     if (!Section.isWasmData())
       continue;
 
     // .init_array sections are handled specially elsewhere.
     if (cast<MCSectionWasm>(Sec).getSectionName().startswith(".init_array"))
       continue;
void WasmObjectWriter::writeObject(MCAssembler &Asm,
   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);
     DEBUG(dbgs() << "MCSymbol: '" << S << "'"
-                 << " isDefined=" << S.isDefined() << " isExternal="
-                 << S.isExternal() << " isTemporary=" << S.isTemporary()
+                 << " isDefined=" << S.isDefined()
+                 << " isExternal=" << S.isExternal()
+                 << " isTemporary=" << S.isTemporary()
                  << " isFunction=" << WS.isFunction()
                  << " isWeak=" << WS.isWeak()
                  << " isHidden=" << WS.isHidden()
                  << " isVariable=" << WS.isVariable() << "\n");
 
-    if (WS.isWeak() || WS.isHidden()) {
-      uint32_t Flags = (WS.isWeak() ? wasm::WASM_SYMBOL_BINDING_WEAK : 0) |
-          (WS.isHidden() ? wasm::WASM_SYMBOL_VISIBILITY_HIDDEN : 0);
-      SymbolFlags.emplace_back(WS.getName(), Flags);
-    }
-
     if (WS.isVariable())
       continue;
 
-    unsigned Index;
+    unsigned WasmIndex, SymbolIndex;
 
     if (WS.isFunction()) {
       if (WS.isDefined(/*SetUsed=*/false)) {
         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();
+        WasmIndex = NumFunctionImports + Functions.size();
+        SymbolIndex = NumFunctionImports + NumFuncExports;
+        ++NumFuncExports;
 
         // Prepare the function.
         WasmFunction Func;
         Func.Type = getFunctionType(WS);
         Func.Sym = &WS;
-        SymbolIndices[&WS] = Index;
+        SymbolIndices[&WS] = SymbolIndex;
+        WasmIndices[&WS] = WasmIndex;
         Functions.push_back(Func);
       } else {
         // An import; the index was assigned above.
-        Index = SymbolIndices.find(&WS)->second;
+        WasmIndex = SymbolIndex = SymbolIndices.find(&WS)->second;
       }
 
-      DEBUG(dbgs() << "  -> function index: " << Index << "\n");
+      DEBUG(dbgs() << "  -> function index: " << WasmIndex << "\n");
     } else {
       if (WS.isTemporary() && !WS.getSize())
         continue;
 
       if (!WS.isDefined(/*SetUsed=*/false))
         continue;
 
       if (!WS.getSize())
         report_fatal_error("data symbols must have a size set with .size: " +
                            WS.getName());
 
       int64_t Size = 0;
       if (!WS.getSize()->evaluateAsAbsolute(Size, Layout))
         report_fatal_error(".size expression must be evaluatable");
 
       // For each global, prepare a corresponding wasm global holding its
       // address.  For externals these will also be named exports.
-      Index = NumGlobalImports + Globals.size();
+      WasmIndex = NumGlobalImports + Globals.size();
+      SymbolIndex = NumGlobalImports + NumGlobalExports;
+      ++NumGlobalExports;
       auto &DataSection = static_cast<MCSectionWasm &>(WS.getSection());
       assert(DataSection.isWasmData());
 
       WasmGlobal Global;
       Global.Type = PtrType;
       Global.IsMutable = false;
       Global.HasImport = false;
       Global.InitialValue = DataSection.getMemoryOffset() + Layout.getSymbolOffset(WS);
       Global.ImportIndex = 0;
-      SymbolIndices[&WS] = Index;
-      DEBUG(dbgs() << "  -> global index: " << Index << "\n");
+      SymbolIndices[&WS] = SymbolIndex;
+      WasmIndices[&WS] = WasmIndex;
+      DEBUG(dbgs() << "  -> global index: " << WasmIndex << "\n");
       Globals.push_back(Global);
     }
 
+    addFlags(SymbolFlags, SymbolIndex, WS);
+
     // If the symbol is visible outside this translation unit, export it.
     if (WS.isDefined(/*SetUsed=*/false)) {
       WasmExport Export;
       Export.FieldName = WS.getName();
-      Export.Index = Index;
+      Export.Index = WasmIndex;
       if (WS.isFunction())
         Export.Kind = wasm::WASM_EXTERNAL_FUNCTION;
       else
         Export.Kind = wasm::WASM_EXTERNAL_GLOBAL;
       DEBUG(dbgs() << "  -> export " << Exports.size() << "\n");
       Exports.push_back(Export);
 
-      if (!WS.isExternal())
-        SymbolFlags.emplace_back(WS.getName(), wasm::WASM_SYMBOL_BINDING_LOCAL);
-
       if (WS.isFunction()) {
         auto &Section = static_cast<MCSectionWasm &>(WS.getSection(false));
         if (const MCSymbolWasm *C = Section.getGroup())
           Comdats[C->getName()].emplace_back(
-              WasmComdatEntry{wasm::WASM_COMDAT_FUNCTION, Index});
+              WasmComdatEntry{wasm::WASM_COMDAT_FUNCTION, WasmIndex});
       }
     }
   }
 
   // Handle weak aliases. We need to process these in a separate pass because
   // we need to have processed the target of the alias before the alias itself
   // and the symbols are not necessarily ordered in this way.
   for (const MCSymbol &S : Asm.symbols()) {
     if (!S.isVariable())
       continue;
 
     assert(S.isDefined(/*SetUsed=*/false));
 
     // Find the target symbol of this weak alias and export that index
     const auto &WS = static_cast<const MCSymbolWasm &>(S);
     const MCSymbolWasm *ResolvedSym = ResolveSymbol(WS);
     DEBUG(dbgs() << WS.getName() << ": weak alias of '" << *ResolvedSym << "'\n");
-    assert(SymbolIndices.count(ResolvedSym) > 0);
-    uint32_t Index = SymbolIndices.find(ResolvedSym)->second;
-    DEBUG(dbgs() << "  -> index:" << Index << "\n");
+    assert(WasmIndices.count(ResolvedSym) > 0);
+    uint32_t WasmIndex = WasmIndices.find(ResolvedSym)->second;
+    DEBUG(dbgs() << "  -> index:" << WasmIndex << "\n");
+
+    unsigned SymbolIndex;
+    if (WS.isFunction()) {
+      SymbolIndex = NumFunctionImports + NumFuncExports;
+      ++NumFuncExports;
+    } else {
+      SymbolIndex = NumGlobalImports + NumGlobalExports;
+      ++NumGlobalExports;
+    }
+    SymbolIndices[&WS] = SymbolIndex;
+    WasmIndices[&WS] = WasmIndex;
+
+    addFlags(SymbolFlags, SymbolIndex, WS);
 
     WasmExport Export;
     Export.FieldName = WS.getName();
-    Export.Index = Index;
+    Export.Index = WasmIndex;
     if (WS.isFunction())
       Export.Kind = wasm::WASM_EXTERNAL_FUNCTION;
     else
       Export.Kind = wasm::WASM_EXTERNAL_GLOBAL;
     DEBUG(dbgs() << "  -> export " << Exports.size() << "\n");
     Exports.push_back(Export);
-
-    if (!WS.isExternal())
-      SymbolFlags.emplace_back(WS.getName(), wasm::WASM_SYMBOL_BINDING_LOCAL);
   }
 
   {
+    TableIndices.resize(Functions.size(), -1);
     auto HandleReloc = [&](const WasmRelocationEntry &Rel) {
-      // Functions referenced by a relocation need to prepared to be called
-      // indirectly.
-      const MCSymbolWasm& WS = *Rel.Symbol;
-      if (WS.isFunction() && IndirectSymbolIndices.count(&WS) == 0) {
-        switch (Rel.Type) {
-        case wasm::R_WEBASSEMBLY_TABLE_INDEX_I32:
-        case wasm::R_WEBASSEMBLY_TABLE_INDEX_SLEB:
-        case wasm::R_WEBASSEMBLY_MEMORY_ADDR_I32:
-        case wasm::R_WEBASSEMBLY_MEMORY_ADDR_SLEB: {
-          uint32_t Index = SymbolIndices.find(&WS)->second;
-          IndirectSymbolIndices[&WS] = TableElems.size();
-          DEBUG(dbgs() << "  -> adding to table: " << TableElems.size() << "\n");
-          TableElems.push_back(Index);
-          registerFunctionType(WS);
-          break;
-        }
-        default:
-          break;
-        }
+      // Functions referenced by a relocation need to put in the table.  This is
+      // purely to make the object file's provisional values readable, and is
+      // ignored by the linker, which re-calculates the relocations itself.
+      if (Rel.Type != wasm::R_WEBASSEMBLY_TABLE_INDEX_I32 &&
+          Rel.Type != wasm::R_WEBASSEMBLY_TABLE_INDEX_SLEB)
+        return;
+      assert(Rel.Symbol->isFunction());
+      const MCSymbolWasm* WS = ResolveSymbol(*Rel.Symbol);
+      uint32_t WasmIndex = WasmIndices[WS];
+      if (WasmIndex < NumFunctionImports)
+        return; // Can't put imports in the table XXX test this, surely not?!?
+      uint32_t FuncIndex = WasmIndex - NumFunctionImports;
+      if (TableIndices[FuncIndex] == -1) {
+        TableIndices[FuncIndex] = TableElems.size() + InitialTableOffset;
+        TableElems.push_back(FuncIndex);
       }
     };
 
     for (const WasmRelocationEntry &RelEntry : CodeRelocations)
       HandleReloc(RelEntry);
     for (const WasmRelocationEntry &RelEntry : DataRelocations)
       HandleReloc(RelEntry);
   }
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);
   writeCodeRelocSection();
   writeDataRelocSection();
   writeLinkingMetaDataSection(DataSegments, DataSize, SymbolFlags,
                               InitFuncs, Comdats);
 
   // TODO: Translate the .comment section to the output.
   // TODO: Translate debug sections to the output.
 }

lib/Object/WasmObjectFile.cpp

while (Ptr < End) {
     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);
+        if (Index >= Functions.size() + NumImportedFunctions || Name.empty())
+          return make_error<GenericBinaryError>("Invalid name entry",
+                                                object_error::parse_failed);
+        if (Index >= NumImportedFunctions)
+          Functions[Index].Name = Name; // Override any existing name
       }
       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();
 }
 
-void WasmObjectFile::populateSymbolTable() {
+Error WasmObjectFile::populateSymbolTable() {
+  FunctionSymbols.reserve(NumImportedFunctions + NumExportedFunctions);
+  GlobalSymbols.reserve(NumImportedGlobals + NumExportedGlobals);
+  StringSet<> SymbolNames;
+
   // Add imports to symbol table
-  size_t GlobalIndex = 0;
-  size_t FunctionIndex = 0;
   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);
-      SymbolMap.try_emplace(Import.Field, Symbols.size());
-      Symbols.emplace_back(Import.Field, WasmSymbol::SymbolType::GLOBAL_IMPORT,
-                           ImportSection, GlobalIndex++);
-      DEBUG(dbgs() << "Adding import: " << Symbols.back()
-                   << " sym index:" << Symbols.size() << "\n");
+      Symbols = &GlobalSymbols;
+      ImportType = WasmSymbol::SymbolType::GLOBAL_IMPORT;
       break;
     case wasm::WASM_EXTERNAL_FUNCTION:
-      SymbolMap.try_emplace(Import.Field, Symbols.size());
-      Symbols.emplace_back(Import.Field,
-                           WasmSymbol::SymbolType::FUNCTION_IMPORT,
-                           ImportSection, FunctionIndex++, Import.SigIndex);
-      DEBUG(dbgs() << "Adding import: " << Symbols.back()
-                   << " sym index:" << Symbols.size() << "\n");
+      Symbols = &FunctionSymbols;
+      ImportType = WasmSymbol::SymbolType::FUNCTION_IMPORT;
+      FunctionType = Import.SigIndex;
       break;
     default:
-      break;
+      continue;
     }
+    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()
+                 << " sym index:" << SymbolIndex << "\n");
   }
 
   // Add exports to symbol table
   for (const wasm::WasmExport& Export : Exports) {
-    if (Export.Kind == wasm::WASM_EXTERNAL_FUNCTION ||
-        Export.Kind == wasm::WASM_EXTERNAL_GLOBAL) {
-      WasmSymbol::SymbolType ExportType =
-          Export.Kind == wasm::WASM_EXTERNAL_FUNCTION
-              ? WasmSymbol::SymbolType::FUNCTION_EXPORT
-              : WasmSymbol::SymbolType::GLOBAL_EXPORT;
-      auto Pair = SymbolMap.try_emplace(Export.Name, Symbols.size());
-      if (Pair.second) {
-        Symbols.emplace_back(Export.Name, ExportType,
-                             ExportSection, Export.Index);
-        DEBUG(dbgs() << "Adding export: " << Symbols.back()
-                     << " sym index:" << Symbols.size() << "\n");
-      } else {
-        uint32_t SymIndex = Pair.first->second;
-        const WasmSymbol &OldSym = Symbols[SymIndex];
-        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");
-      }
+    WasmSymbol::SymbolType ExportType;
+    std::vector<WasmSymbol> *Symbols;
+    unsigned FunctionType = 0;
+    switch (Export.Kind) {
+    case wasm::WASM_EXTERNAL_GLOBAL:
+      assert(Export.Index >= NumImportedGlobals);
+      Symbols = &GlobalSymbols;
+      ExportType = WasmSymbol::SymbolType::GLOBAL_EXPORT;
+      break;
+    case wasm::WASM_EXTERNAL_FUNCTION: {
+      assert(Export.Index >= NumImportedFunctions);
+      Symbols = &FunctionSymbols;
+      ExportType = WasmSymbol::SymbolType::FUNCTION_EXPORT;
+      FunctionType = FunctionTypes[Export.Index - NumImportedFunctions];
+      wasm::WasmFunction &Func = Functions[Export.Index - NumImportedFunctions];
+      if (Func.Name.empty())
+        Func.Name = Export.Name;
+      break;
+    default:
+      continue;
     }
+    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()
+                 << " sym index:" << SymbolIndex << "\n");
   }
+
+  return Error::success();
 }
 
 Error WasmObjectFile::parseLinkingSection(const uint8_t *Ptr,
                                           const uint8_t *End) {
   HasLinkingSection = true;
 
   // 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();
+  if (Error Err = populateSymbolTable())
+    return Err;
 
   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);
-        DEBUG(dbgs() << "reading syminfo: " << Symbol << "\n");
-        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 SymIndex = iter->second;
-        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);
while (Ptr < End) {
     }
     case wasm::WASM_INIT_FUNCS: {
       uint32_t Count = readVaruint32(Ptr);
       LinkingData.InitFunctions.reserve(Count);
       for (uint32_t i = 0; i < Count; i++) {
         wasm::WasmInitFunc Init;
         Init.Priority = readVaruint32(Ptr);
         Init.FunctionIndex = readVaruint32(Ptr);
-        if (!isValidFunctionIndex(Init.FunctionIndex))
+        if (!isValidFunctionSymbolIndex(Init.FunctionIndex))
           return make_error<GenericBinaryError>("Invalid function index: " +
                                                     Twine(Init.FunctionIndex),
                                                 object_error::parse_failed);
         LinkingData.InitFunctions.emplace_back(Init);
       }
       break;
     }
     case wasm::WASM_COMDAT_INFO:
while (EntryCount--) {
           return make_error<GenericBinaryError>("COMDAT data index out of range",
                                                 object_error::parse_failed);
         if (!DataSegments[Index].Data.Comdat.empty())
           return make_error<GenericBinaryError>("Data segment in two COMDATs",
                                                 object_error::parse_failed);
         DataSegments[Index].Data.Comdat = Name;
         break;
       case wasm::WASM_COMDAT_FUNCTION:
-        if (Index < NumImportedFunctions || !isValidFunctionIndex(Index))
+        if (Index < NumImportedFunctions || !isValidFunctionWasmIndex(Index))
           return make_error<GenericBinaryError>("COMDAT function index out of range",
                                                 object_error::parse_failed);
         Index -= NumImportedFunctions;
         if (!Functions[Index].Comdat.empty())
           return make_error<GenericBinaryError>("Function in two COMDATs",
                                                 object_error::parse_failed);
         Functions[Index].Comdat = Name;
         break;
Error WasmObjectFile::parseExportSection(const uint8_t *Ptr, const uint8_t *End) {
   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);
     switch (Ex.Kind) {
     case wasm::WASM_EXTERNAL_FUNCTION:
-      if (Ex.Index >= FunctionTypes.size() + NumImportedFunctions)
+      ++NumExportedFunctions;
+      if (Ex.Index < NumImportedFunctions ||
+          Ex.Index >= FunctionTypes.size() + NumImportedFunctions)
         return make_error<GenericBinaryError>("Invalid function export",
                                               object_error::parse_failed);
       break;
-    case wasm::WASM_EXTERNAL_GLOBAL: {
-      if (Ex.Index >= Globals.size() + NumImportedGlobals)
+    case wasm::WASM_EXTERNAL_GLOBAL:
+      ++NumExportedGlobals;
+      if (Ex.Index < NumImportedGlobals ||
+          Ex.Index >= Globals.size() + NumImportedGlobals)
         return make_error<GenericBinaryError>("Invalid global export",
                                               object_error::parse_failed);
       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();
 }
 
-bool WasmObjectFile::isValidFunctionIndex(uint32_t Index) const {
-  return Index < FunctionTypes.size() + NumImportedFunctions;
+bool WasmObjectFile::isValidFunctionWasmIndex(uint32_t Index) const {
+  return Index < NumImportedFunctions + FunctionTypes.size();
+}
+
+bool WasmObjectFile::isValidFunctionSymbolIndex(uint32_t Index) const {
+  return Index < NumImportedFunctions + NumExportedFunctions;
 }
 
 Error WasmObjectFile::parseStartSection(const uint8_t *Ptr, const uint8_t *End) {
   StartFunction = readVaruint32(Ptr);
-  if (!isValidFunctionIndex(StartFunction))
+  if (!isValidFunctionWasmIndex(StartFunction))
     return make_error<GenericBinaryError>("Invalid start function",
                                           object_error::parse_failed);
   return Error::success();
 }
 
 Error WasmObjectFile::parseCodeSection(const uint8_t *Ptr, const uint8_t *End) {
   const uint8_t *CodeSectionStart = Ptr;
   uint32_t FunctionCount = readVaruint32(Ptr);
   if (FunctionCount != FunctionTypes.size()) {
     return make_error<GenericBinaryError>("Invalid function count",
                                           object_error::parse_failed);
   }
 
   while (FunctionCount--) {
     wasm::WasmFunction Function;
     const uint8_t *FunctionStart = Ptr;
     uint32_t Size = readVaruint32(Ptr);
     const uint8_t *FunctionEnd = Ptr + Size;
 
-    Function.Index = NumImportedFunctions + Functions.size();
+    Function.WasmIndex = NumImportedFunctions + Functions.size();
     Function.CodeSectionOffset = FunctionStart - CodeSectionStart;
     Function.Size = FunctionEnd - FunctionStart;
 
     uint32_t NumLocalDecls = readVaruint32(Ptr);
     Function.Locals.reserve(NumLocalDecls);
     while (NumLocalDecls--) {
       wasm::WasmLocalDecl Decl;
       Decl.Count = readVaruint32(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;
 }
 
 basic_symbol_iterator WasmObjectFile::symbol_begin() const {
   DataRefImpl Ref;
   Ref.d.a = 0;
   return BasicSymbolRef(Ref, this);
 }
 
 basic_symbol_iterator WasmObjectFile::symbol_end() const {
   DataRefImpl Ref;
-  Ref.d.a = Symbols.size();
+  Ref.d.a = FunctionSymbols.size() + GlobalSymbols.size();
   return BasicSymbolRef(Ref, this);
 }
 
 const WasmSymbol &WasmObjectFile::getWasmSymbol(const DataRefImpl &Symb) const {
-  return Symbols[Symb.d.a];
+  unsigned Index = Symb.d.a;
+  return Index >= FunctionSymbols.size()
+         ? GlobalSymbols[Index - FunctionSymbols.size()]
+         : FunctionSymbols[Index];
 }
 
 const WasmSymbol &WasmObjectFile::getWasmSymbol(const SymbolRef &Symb) const {
   return getWasmSymbol(Symb.getRawDataRefImpl());
 }
 
 Expected<StringRef> WasmObjectFile::getSymbolName(DataRefImpl Symb) const {
   return getWasmSymbol(Symb).Name;
 }
 
 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;
+    return Sym.WasmIndex;
   case WasmSymbol::SymbolType::GLOBAL_EXPORT: {
-    uint32_t GlobalIndex = Sym.ElementIndex - NumImportedGlobals;
+    uint32_t GlobalIndex = Sym.WasmIndex - 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;
   }
   }
   llvm_unreachable("invalid symbol type");

 
 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;

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/weak-alias.ll

 ; CHECK-NEXT:         Field:           foo_alias
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         SigIndex:        0
 ; CHECK-NEXT:       - Module:          env
 ; CHECK-NEXT:         Field:           bar_alias
 ; CHECK-NEXT:         Kind:            GLOBAL
 ; CHECK-NEXT:         GlobalType:      I32
 ; CHECK-NEXT:         GlobalMutable:   false
 ; CHECK-NEXT:   - Type:            FUNCTION
 ; CHECK-NEXT:     FunctionTypes:   [ 0, 0, 0, 0, 0 ]
 ; CHECK-NEXT:   - Type:            GLOBAL
 ; CHECK-NEXT:     Globals:         
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Type:            I32
 ; CHECK-NEXT:         Mutable:         false
 ; CHECK-NEXT:         InitExpr:        
 ; CHECK-NEXT:           Opcode:          I32_CONST

 ; CHECK-NEXT:         Mutable:         false
 ; CHECK-NEXT:         InitExpr:        
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           0
 ; CHECK-NEXT:   - Type:            EXPORT
 ; CHECK-NEXT:     Exports:         
 ; CHECK-NEXT:       - Name:            foo
 ; CHECK-NEXT:         Kind:            FUNCTION
-; CHECK-NEXT:         Index:           1
-; CHECK-NEXT:       - Name:            call_direct
-; CHECK-NEXT:         Kind:            FUNCTION
-; CHECK-NEXT:         Index:           2
-; CHECK-NEXT:       - Name:            call_alias
-; CHECK-NEXT:         Kind:            FUNCTION
-; CHECK-NEXT:         Index:           3
-; CHECK-NEXT:       - Name:            call_direct_ptr
+; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:       - Name:            foo
 ; CHECK-NEXT:         Kind:            FUNCTION
-; CHECK-NEXT:         Index:           4
-; CHECK-NEXT:       - Name:            direct_address
-; CHECK-NEXT:         Kind:            GLOBAL
 ; CHECK-NEXT:         Index:           1
-; CHECK-NEXT:       - Name:            call_alias_ptr
-; CHECK-NEXT:         Kind:            FUNCTION
-; CHECK-NEXT:         Index:           5
-; CHECK-NEXT:       - Name:            alias_address
-; CHECK-NEXT:         Kind:            GLOBAL
-; CHECK-NEXT:         Index:           2
 ; CHECK-NEXT:       - Name:            bar
 ; CHECK-NEXT:         Kind:            GLOBAL
-; CHECK-NEXT:         Index:           3
+; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:       - Name:            bar_alias_address
+; CHECK-NEXT:         Kind:            GLOBAL
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:       - Name:            foo_alias
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:       - Name:            bar_alias
 ; CHECK-NEXT:         Kind:            GLOBAL
-; CHECK-NEXT:         Index:           3
-; CHECK-NEXT:   - Type:            ELEM
-; CHECK-NEXT:     Segments:        
-; CHECK-NEXT:       - Offset:          
-; CHECK-NEXT:           Opcode:          I32_CONST
-; CHECK-NEXT:           Value:           0
-; CHECK-NEXT:         Functions:       [ 1, 0 ]
-; CHECK-NEXT:   - Type:            CODE
-; CHECK-NEXT:     Relocations:     
-; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_FUNCTION_INDEX_LEB
-; CHECK-NEXT:         Index:           1
-; CHECK-NEXT:         Offset:          0x00000009
-; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_FUNCTION_INDEX_LEB
-; CHECK-NEXT:         Index:           0
-; CHECK-NEXT:         Offset:          0x00000012
-; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           1
-; CHECK-NEXT:         Offset:          0x0000001E
-; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_TYPE_INDEX_LEB
-; CHECK-NEXT:         Index:           0
-; CHECK-NEXT:         Offset:          0x00000024
-; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           2
-; CHECK-NEXT:         Offset:          0x00000031
-; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_TYPE_INDEX_LEB
 ; CHECK-NEXT:         Index:           0
-; CHECK-NEXT:         Offset:          0x00000037
-; CHECK-NEXT:     Functions:       
-; CHECK-NEXT:       - Index:           1
-; CHECK-NEXT:         Locals:          
-; CHECK-NEXT:         Body:            41000B
-; CHECK-NEXT:       - Index:           2
-; CHECK-NEXT:         Locals:          
-; CHECK-NEXT:         Body:            1081808080000B
-; CHECK-NEXT:       - Index:           3
-; CHECK-NEXT:         Locals:          
-; CHECK-NEXT:         Body:            1080808080000B
-; CHECK-NEXT:       - Index:           4
-; CHECK-NEXT:         Locals:          
-; CHECK-NEXT:         Body:            410028028880808000118080808000000B
-; CHECK-NEXT:       - Index:           5
-; CHECK-NEXT:         Locals:          
-; CHECK-NEXT:         Body:            410028029080808000118080808000000B
-; CHECK-NEXT:   - Type:            DATA
+
+; CHECK:        - Type:            DATA
 ; CHECK-NEXT:     Relocations:     
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_TABLE_INDEX_I32
 ; CHECK-NEXT:         Index:           0
 ; CHECK-NEXT:         Offset:          0x0000000F
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_TABLE_INDEX_I32
 ; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000018
 ; CHECK-NEXT:     Segments:        

 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           8
 ; CHECK-NEXT:         Content:         '00000000'
 
 ; CHECK:        - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            name
 ; CHECK-NEXT:     FunctionNames:   
 ; CHECK-NEXT:       - Index:           0
-; CHECK-NEXT:         Name:            foo_alias
+; CHECK-NEXT:         Name:            call_alias
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Name:            foo
 ; CHECK-NEXT:       - Index:           2
 ; CHECK-NEXT:         Name:            call_direct
 ; CHECK-NEXT:       - Index:           3
 ; CHECK-NEXT:         Name:            call_alias
 ; CHECK-NEXT:       - Index:           4
 ; CHECK-NEXT:         Name:            call_direct_ptr
 ; CHECK-NEXT:       - Index:           5
 ; 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_alias
-; CHECK-NEXT:         Flags:           [ BINDING_WEAK, VISIBILITY_HIDDEN ]
-; CHECK-NEXT:       - Name:            bar_alias
-; CHECK-NEXT:         Flags:           [ BINDING_WEAK, VISIBILITY_HIDDEN ]
-; CHECK-NEXT:       - Name:            foo
-; CHECK-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
-; CHECK-NEXT:       - Name:            call_direct
-; CHECK-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
+; CHECK-NEXT:     SymbolInfo:
 ; CHECK-NEXT:       - Name:            call_alias
 ; CHECK-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
 ; CHECK-NEXT:       - Name:            call_direct_ptr
 ; CHECK-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
 ; CHECK-NEXT:       - Name:            call_alias_ptr
 ; CHECK-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
+; CHECK-NEXT:       - Name:            foo_alias
+; CHECK-NEXT:         Flags:           [ BINDING_WEAK, VISIBILITY_HIDDEN ]
+; CHECK-NEXT:       - Name:            bar_alias
+; 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
 ; CHECK-NEXT:         Alignment:       8
 ; 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: 00000000 g     F name  call_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: 00000000 g     F EXPORT  .hidden call_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
+; CHECK-SYMS-NEXT: 00000008 g       EXPORT  bar_alias_address
+; CHECK-SYMS-NEXT: 00000001 gw    F EXPORT  .hidden foo_alias
+; CHECK-SYMS-NEXT: 00000000 gw      EXPORT  .hidden bar_alias

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

Exports:
         Index:           1
       - Name:            global_export
         Kind:            GLOBAL
         Index:           0
   - 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

Exports:
         Index:           0x00000004
       - Name:            weak_global_data
         Kind:            GLOBAL
         Index:           0x00000003
   - 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

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
 

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: ]

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),

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)
+    for (const llvm::wasm::WasmFunction &Func: Obj.functions()) {
+      if (Func.Name.empty())
         continue;
       WasmYAML::NameEntry NameEntry;
-      NameEntry.Name = Symbol.Name;
-      NameEntry.Index = Sym.getValue();
+      NameEntry.Name = Func.Name;
+      NameEntry.Index = Func.WasmIndex;
       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();
       LinkingSec->Comdats.emplace_back(WasmYAML::Comdat{ComdatName, {}});
     }
     for (auto &Func : Obj.functions()) {
       if (!Func.Comdat.empty()) {
         auto &Comdat = LinkingSec->Comdats[ComdatIndexes[Func.Comdat]];
         Comdat.Entries.emplace_back(
-                WasmYAML::ComdatEntry{wasm::WASM_COMDAT_FUNCTION, Func.Index});
+                WasmYAML::ComdatEntry{wasm::WASM_COMDAT_FUNCTION,
+                                      Func.WasmIndex});
       }
     }
     uint32_t SegmentIndex = 0;
     for (const object::WasmSegment &Segment : Obj.dataSegments()) {
       if (!Segment.Data.Name.empty()) {
         WasmYAML::SegmentInfo SegmentInfo;
         SegmentInfo.Name = Segment.Data.Name;
         SegmentInfo.Index = SegmentIndex;
         SegmentInfo.Alignment = Segment.Data.Alignment;
         SegmentInfo.Flags = Segment.Data.Flags;
         LinkingSec->SegmentInfos.push_back(SegmentInfo);
       }
       if (!Segment.Data.Comdat.empty()) {
         auto &Comdat = LinkingSec->Comdats[ComdatIndexes[Segment.Data.Comdat]];
         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);
     }
case wasm::WASM_SEC_ELEM: {
       }
       S = std::move(ElemSec);
       break;
     }
     case wasm::WASM_SEC_CODE: {
       auto CodeSec = make_unique<WasmYAML::CodeSection>();
       for (auto &Func : Obj.functions()) {
         WasmYAML::Function Function;
-        Function.Index = Func.Index;
+        Function.Index = Func.WasmIndex;
         for (auto &Local : Func.Locals) {
           WasmYAML::LocalDecl LocalDecl;
           LocalDecl.Type = Local.Type;
           LocalDecl.Count = Local.Count;
           Function.Locals.push_back(LocalDecl);
         }
         Function.Body = yaml::BinaryRef(Func.Body);
         CodeSec->Functions.push_back(Function);

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()) {