[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 ↗

(On Diff #129478)

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"

159

Do we need these new methods?

265

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

lib/MC/WasmObjectWriter.cpp

579–581

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.

776

Why this change?

878

Rename this argument to Symbolnfo?

lib/Object/WasmObjectFile.cpp

754

isValidFunctionWasmIndex?

759

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

950

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 ↗

(On Diff #129478)

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 ↗

(On Diff #129478)

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.

159

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.

265

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 ↗

(On Diff #129478)

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

776

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

295

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.

950

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

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

61 ↗

(On Diff #129478)

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

155

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

test/MC/WebAssembly/weak-alias.ll

68

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

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.

105

Revert this change, since SymbolIndex is a temporary measure?

lib/Object/WasmObjectFile.cpp

458

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

969

Revert this?

[ncw]

Updated, renamed WasmIndex -> ElementIndex

lib/Object/WasmObjectFile.cpp

458

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

1049

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

1103

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.

1138–1141

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

[ncw]

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

include/llvm/Object/Wasm.h

public:
   enum class SymbolType {
     FUNCTION_IMPORT,
     FUNCTION_EXPORT,
     GLOBAL_IMPORT,
     GLOBAL_EXPORT,
   };
 
   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 Symbol index space, which consists of all Symbols
+  // together, in order of declaration.
+  uint32_t SymbolIndex;
+  // For a function or global symbol, the index into the the 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 then definitions.
+  uint32_t WasmIndex;
 
-  // For function, the type index
+  // For a function symbol, 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 isTypeFunction() const {
     return Type == WasmSymbol::SymbolType::FUNCTION_IMPORT ||
            Type == WasmSymbol::SymbolType::FUNCTION_EXPORT;
   }
 
   bool isTypeGlobal() const {
     return Type == SymbolType::GLOBAL_IMPORT ||
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:
   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; }
+  uint32_t getNumImportedGlobals() const { return NumImportedGlobals; }
+  uint32_t getNumImportedFunctions() const { return NumImportedFunctions; }
 
   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;
   Expected<StringRef> getSymbolName(DataRefImpl Symb) const override;
 
public:
   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 isDefinedFunctionIndex(uint32_t Index) const;
+  bool isValidGlobalIndex(uint32_t Index) const;
+  bool isDefinedGlobalIndex(uint32_t Index) const;
+  bool isValidFunctionSymbolIndex(uint32_t Index) const;
   wasm::WasmFunction& getDefinedFunction(uint32_t Index);
 
   const WasmSection &getWasmSection(DataRefImpl Ref) const;
   const wasm::WasmRelocation &getWasmRelocation(DataRefImpl Ref) const;
 
   WasmSection* findCustomSectionByName(StringRef Name);
   WasmSection* findSectionByType(uint32_t Type);
 
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<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;
 
+  // TODO: will get rid of this map in next commit, once we get replace the
+  // WASM_SYMBOL_INFO section with WASM_SYMBOL_TABLE
   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

lib/MC/WasmObjectWriter.cpp

class WasmObjectWriter : public MCObjectWriter {
   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> TableIndices;
-  // Maps function/global symbols to the function/global index space.
+  // Maps function/global symbols to the (shared) 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;
 
   DenseMap<WasmFunctionType, int32_t, WasmFunctionTypeDenseMapInfo>
       FunctionTypeIndices;
   SmallVector<WasmFunctionType, 4> FunctionTypes;
   SmallVector<WasmGlobal, 4> Globals;
   unsigned NumFunctionImports = 0;
   unsigned NumGlobalImports = 0;
 
public:
   ~WasmObjectWriter() override;
 
 private:
   void reset() override {
     CodeRelocations.clear();
     DataRelocations.clear();
     TypeIndices.clear();
     SymbolIndices.clear();
+    WasmIndices.clear();
     TableIndices.clear();
     FunctionTypeIndices.clear();
     FunctionTypes.clear();
     Globals.clear();
     MCObjectWriter::reset();
     NumFunctionImports = 0;
     NumGlobalImports = 0;
   }
WasmObjectWriter::getProvisionalValue(const WasmRelocationEntry &RelEntry) {
   switch (RelEntry.Type) {
   case wasm::R_WEBASSEMBLY_TABLE_INDEX_SLEB:
   case wasm::R_WEBASSEMBLY_TABLE_INDEX_I32: {
     // Provisional value is table address of the resolved symbol itself
     const MCSymbolWasm *Sym = ResolveSymbol(*RelEntry.Symbol);
     assert(Sym->isFunction());
     return TableIndices[Sym];
   }
-  case wasm::R_WEBASSEMBLY_FUNCTION_INDEX_LEB:
   case wasm::R_WEBASSEMBLY_TYPE_INDEX_LEB:
-  case wasm::R_WEBASSEMBLY_GLOBAL_INDEX_LEB:
-    // Provisional value is function/type/global index itself
+    // Provisional value is same as the index
     return getRelocationIndexValue(RelEntry);
+  case wasm::R_WEBASSEMBLY_FUNCTION_INDEX_LEB:
+  case wasm::R_WEBASSEMBLY_GLOBAL_INDEX_LEB:
+    // Provisional value is function/global Wasm index
+    if (!WasmIndices.count(RelEntry.Symbol))
+      report_fatal_error("symbol not found in wasm index space: " +
+                         RelEntry.Symbol->getName());
+    return WasmIndices[RelEntry.Symbol];
   case wasm::R_WEBASSEMBLY_MEMORY_ADDR_LEB:
   case wasm::R_WEBASSEMBLY_MEMORY_ADDR_I32:
   case wasm::R_WEBASSEMBLY_MEMORY_ADDR_SLEB: {
     // Provisional value is address of the global
     const MCSymbolWasm *Sym = ResolveSymbol(*RelEntry.Symbol);
     // For undefined symbols, use zero
     if (!Sym->isDefined())
       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.
     return Address;
   }
   default:
     llvm_unreachable("invalid relocation type");
static void addData(SmallVectorImpl<char> &DataBytes,
   // fragment, otherwise the linker cannot map symbols to a unique
   // data segment.  This can be triggered by zero-sized structs
   // See: test/MC/WebAssembly/bss.ll
   if (LastFragmentSize == 0)
     DataBytes.resize(DataBytes.size() + 1);
   DEBUG(dbgs() << "addData -> " << DataBytes.size() << "\n");
 }
 
 uint32_t
 WasmObjectWriter::getRelocationIndexValue(const WasmRelocationEntry &RelEntry) {
   if (RelEntry.Type == 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];
   }
 
   if (!SymbolIndices.count(RelEntry.Symbol))
-    report_fatal_error("symbol not found in function/global index space: " +
+    report_fatal_error("symbol not found in symbol index space: " +
                        RelEntry.Symbol->getName());
   return SymbolIndices[RelEntry.Symbol];
 }
 
 // Apply the portions of the relocation records that we can handle ourselves
 // directly.
 void WasmObjectWriter::applyRelocations(
     ArrayRef<WasmRelocationEntry> Relocations, uint64_t ContentsOffset) {
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(kInitialTableOffset, getStream());
   write8(wasm::WASM_OPCODE_END);
 
   encodeULEB128(TableElems.size(), getStream());
   for (uint32_t Elem : TableElems)
     encodeULEB128(Elem, getStream());
 
   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<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) {
     startSection(SubSection, wasm::WASM_SYMBOL_INFO);
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 NumSymbols = 0;
   SmallVector<WasmDataSegment, 4> DataSegments;
   uint32_t DataSize = 0;
 
+  auto AddSymbol = [&](const MCSymbolWasm &WS) {
+    uint32_t Flags = (WS.isWeak() ? wasm::WASM_SYMBOL_BINDING_WEAK : 0) |
+        (WS.isHidden() ? wasm::WASM_SYMBOL_VISIBILITY_HIDDEN : 0) |
+        (!WS.isExternal() && WS.isDefined() ? wasm::WASM_SYMBOL_BINDING_LOCAL : 0);
+    if (Flags != 0) {
+      SymbolFlags.emplace_back(WS.getName(), Flags);
+    }
+  };
+
   // For now, always emit the memory import, since loads and stores are not
   // valid without it. In the future, we could perhaps be more clever and omit
   // it if there are no loads or stores.
   MCSymbolWasm *MemorySym =
       cast<MCSymbolWasm>(Ctx.getOrCreateSymbol("__linear_memory"));
   WasmImport MemImport;
   MemImport.ModuleName = MemorySym->getModuleName();
   MemImport.FieldName = MemorySym->getName();
for (const MCSymbol &S : Asm.symbols()) {
     // (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()) {
+    if (!WS.isDefined() && !WS.isComdat()) {
       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] = NumFunctionImports;
-        ++NumFunctionImports;
+        WasmIndices[&WS] = NumFunctionImports++;
       } else {
         Import.Kind = wasm::WASM_EXTERNAL_GLOBAL;
         Import.Type = int32_t(PtrType);
         Import.IsMutable = false;
-        SymbolIndices[&WS] = NumGlobalImports;
-
+        WasmIndices[&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);
+
+      SymbolIndices[&WS] = NumSymbols++;
+      AddSymbol(WS);
     }
   }
 
   for (MCSection &Sec : Asm) {
     auto &Section = static_cast<MCSectionWasm &>(Sec);
     if (!Section.isWasmData())
       continue;
 
DEBUG(dbgs() << "MCSymbol: '" << S << "'"
                  << " 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;
+    if (WS.isComdat() && !WS.isDefined())
+      continue;
 
-    unsigned Index;
+    unsigned WasmIndex;
 
     if (WS.isFunction()) {
       if (WS.isDefined()) {
         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 = NumFunctionImports + Functions.size();
-
-        // Prepare the function.
+        // A definition. Export the function body.
+        WasmIndex = NumFunctionImports + Functions.size();
         WasmFunction Func;
         Func.Type = getFunctionType(WS);
         Func.Sym = &WS;
-        SymbolIndices[&WS] = Index;
+        WasmIndices[&WS] = WasmIndex;
         Functions.push_back(Func);
+
+        auto &Section = static_cast<MCSectionWasm &>(WS.getSection());
+        if (const MCSymbolWasm *C = Section.getGroup()) {
+          Comdats[C->getName()].emplace_back(
+              WasmComdatEntry{wasm::WASM_COMDAT_FUNCTION, WasmIndex});
+        }
       } else {
         // An import; the index was assigned above.
-        Index = SymbolIndices.find(&WS)->second;
+        WasmIndex = WasmIndices.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())
-        continue;
-
+      if (WS.isDefined()) {
         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();
-      auto &DataSection = static_cast<MCSectionWasm &>(WS.getSection());
+        auto& DataSection = static_cast<MCSectionWasm&>(WS.getSection());
         assert(DataSection.isWasmData());
 
+        // For each global, prepare a corresponding wasm global holding its
+        // address.  For externals these will also be named exports.
+        WasmIndex = NumGlobalImports + Globals.size();
         WasmGlobal Global;
         Global.Type.Type = static_cast<int32_t>(PtrType);
         Global.Type.Mutable = false;
-      Global.InitialValue = DataSection.getMemoryOffset() + Layout.getSymbolOffset(WS);
-      SymbolIndices[&WS] = Index;
-      DEBUG(dbgs() << "  -> global index: " << Index << "\n");
+        Global.InitialValue =
+            DataSection.getMemoryOffset() + Layout.getSymbolOffset(WS);
+        WasmIndices[&WS] = WasmIndex;
         Globals.push_back(Global);
+      } else {
+        // An import; the index was assigned above.
+        WasmIndex = WasmIndices.find(&WS)->second;
+      }
+      DEBUG(dbgs() << "  -> global index: " << WasmIndex << "\n");
     }
 
     // If the symbol is visible outside this translation unit, export it.
     if (WS.isDefined()) {
       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());
-        if (const MCSymbolWasm *C = Section.getGroup())
-          Comdats[C->getName()].emplace_back(
-              WasmComdatEntry{wasm::WASM_COMDAT_FUNCTION, Index});
-      }
+      SymbolIndices[&WS] = NumSymbols++;
+      AddSymbol(WS);
     }
   }
 
   // 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());
 
     // 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;
+    WasmIndices[&WS] = WasmIndex;
+    DEBUG(dbgs() << "  -> index:" << WasmIndex << "\n");
 
     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);
+    SymbolIndices[&WS] = NumSymbols++;
+    AddSymbol(WS);
   }
 
   {
     auto HandleReloc = [&](const WasmRelocationEntry &Rel) {
       // 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 SymbolIndex = SymbolIndices.find(&WS)->second;
+      uint32_t WasmIndex = WasmIndices.find(&WS)->second;
       uint32_t TableIndex = TableElems.size() + kInitialTableOffset;
       if (TableIndices.try_emplace(&WS, TableIndex).second) {
         DEBUG(dbgs() << "  -> adding " << WS.getName()
                      << " to table: " << TableIndex << "\n");
-        TableElems.push_back(SymbolIndex);
+        TableElems.push_back(WasmIndex);
         registerFunctionType(WS);
       }
     };
 
     for (const WasmRelocationEntry &RelEntry : CodeRelocations)
       HandleReloc(RelEntry);
     for (const WasmRelocationEntry &RelEntry : DataRelocations)
       HandleReloc(RelEntry);

lib/Object/WasmObjectFile.cpp

case wasm::WASM_NAMES_FUNCTION: {
         if (!Seen.insert(Index).second)
           return make_error<GenericBinaryError>("Function named more than once",
                                                 object_error::parse_failed);
         StringRef Name = readString(Ptr);
         if (!isValidFunctionIndex(Index) || Name.empty())
           return make_error<GenericBinaryError>("Invalid name entry",
                                                 object_error::parse_failed);
         DebugNames.push_back(wasm::WasmFunctionName{Index, Name});
         if (isDefinedFunctionIndex(Index)) {
           // Override any existing name; the name specified by the "names"
           // section is the Function's canonical name.
           getDefinedFunction(Index).Name = 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() {
+  Symbols.reserve(NumImportedFunctions + NumImportedGlobals + Exports.size());
+
   // Add imports to symbol table
-  size_t GlobalIndex = 0;
-  size_t FunctionIndex = 0;
   for (const wasm::WasmImport& Import : Imports) {
+    WasmSymbol::SymbolType ImportType;
+    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");
+      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");
+      ImportType = WasmSymbol::SymbolType::FUNCTION_IMPORT;
+      FunctionType = Import.SigIndex;
       break;
     default:
-      break;
+      continue;
     }
+    unsigned SymbolIndex = Symbols.size();
+    if (!SymbolMap.try_emplace(Import.Field, SymbolIndex).second)
+      return make_error<GenericBinaryError>(
+          "Duplicate symbol name " + Import.Field,
+          object_error::parse_failed);
+    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");
-      }
-    }
-    if (Export.Kind == wasm::WASM_EXTERNAL_FUNCTION &&
-        isDefinedFunctionIndex(Export.Index)) {
+    WasmSymbol::SymbolType ExportType;
+    unsigned FunctionType = 0;
+    switch (Export.Kind) {
+    case wasm::WASM_EXTERNAL_GLOBAL:
+      assert(isValidGlobalIndex(Export.Index));
+      if (!isDefinedGlobalIndex(Export.Index))
+        return make_error<GenericBinaryError>("symbol cannot export an import",
+                                              object_error::parse_failed);
+      ExportType = WasmSymbol::SymbolType::GLOBAL_EXPORT;
+      break;
+    case wasm::WASM_EXTERNAL_FUNCTION: {
+      assert(isValidFunctionIndex(Export.Index));
+      if (!isDefinedFunctionIndex(Export.Index))
+        return make_error<GenericBinaryError>("symbol cannot export an import",
+                                              object_error::parse_failed);
+      ExportType = WasmSymbol::SymbolType::FUNCTION_EXPORT;
+      FunctionType = FunctionTypes[Export.Index - NumImportedFunctions];
       auto &Function = getDefinedFunction(Export.Index);
       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;
       }
+      break;
     }
+    default:
+      continue;
     }
+    unsigned SymbolIndex = Symbols.size();
+    if (!SymbolMap.try_emplace(Export.Name, SymbolIndex).second)
+      return make_error<GenericBinaryError>(
+          "Duplicate symbol name " + Export.Name,
+          object_error::parse_failed);
+    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;
   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();
+  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 (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:
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 (!isValidFunctionIndex(Ex.Index))
         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:
+      if (!isValidGlobalIndex(Ex.Index))
         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;
+  return Index < NumImportedFunctions + FunctionTypes.size();
 }
 
 bool WasmObjectFile::isDefinedFunctionIndex(uint32_t Index) const {
   return Index >= NumImportedFunctions && isValidFunctionIndex(Index);
 }
 
+bool WasmObjectFile::isValidGlobalIndex(uint32_t Index) const {
+  return Index < NumImportedGlobals + Globals.size();
+}
+
+bool WasmObjectFile::isDefinedGlobalIndex(uint32_t Index) const {
+  return Index >= NumImportedGlobals && isValidGlobalIndex(Index);
+}
+
+bool WasmObjectFile::isValidFunctionSymbolIndex(uint32_t Index) const {
+  return Index < Symbols.size() && Symbols[Index].isTypeFunction();
+}
+
 wasm::WasmFunction& WasmObjectFile::getDefinedFunction(uint32_t Index) {
   assert(isDefinedFunctionIndex(Index));
   return Functions[Index - NumImportedFunctions];
 }
 
 Error WasmObjectFile::parseStartSection(const uint8_t *Ptr, const uint8_t *End) {
   StartFunction = readVaruint32(Ptr);
   if (!isValidFunctionIndex(StartFunction))
basic_symbol_iterator WasmObjectFile::symbol_end() const {
   Ref.d.a = Symbols.size();
   return BasicSymbolRef(Ref, this);
 }
 
 const WasmSymbol &WasmObjectFile::getWasmSymbol(const DataRefImpl &Symb) const {
   return Symbols[Symb.d.a];
 }
 
 const WasmSymbol &WasmObjectFile::getWasmSymbol(const SymbolRef &Symb) const {
   return getWasmSymbol(Symb.getRawDataRefImpl());
 }
 
 Expected<StringRef> WasmObjectFile::getSymbolName(DataRefImpl Symb) const {
   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:
-    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");

test/MC/WebAssembly/func-address.ll

 ; CHECK:     Relocation {
 ; CHECK:       Type: R_WEBASSEMBLY_FUNCTION_INDEX_LEB (0)
 ; CHECK:       Offset: 0xB
 ; CHECK:       Index: 0x1
 ; CHECK:     }
 ; CHECK:     Relocation {
 ; CHECK:       Type: R_WEBASSEMBLY_TABLE_INDEX_SLEB (1)
 ; CHECK:       Offset: 0x1E
-; CHECK:       Index: 0x2
+; CHECK:       Index: 0x3
 ; CHECK:     }
 ; CHECK:   }

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

 ; CHECK-NEXT:           Value:           1
 ; CHECK-NEXT:         Functions:       [ 5, 7 ]
 ; CHECK-NEXT:   - Type:            CODE
 ; CHECK-NEXT:     Relocations:     
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_FUNCTION_INDEX_LEB
 ; CHECK-NEXT:         Index:           0
 ; CHECK-NEXT:         Offset:          0x00000004
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_TABLE_INDEX_SLEB
-; CHECK-NEXT:         Index:           5
+; CHECK-NEXT:         Index:           6
 ; CHECK-NEXT:         Offset:          0x0000000F
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_SLEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000017
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_FUNCTION_INDEX_LEB
-; CHECK-NEXT:         Index:           1
+; CHECK-NEXT:         Index:           2
 ; CHECK-NEXT:         Offset:          0x0000001D
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_FUNCTION_INDEX_LEB
-; CHECK-NEXT:         Index:           2
+; CHECK-NEXT:         Index:           3
 ; CHECK-NEXT:         Offset:          0x0000002C
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_TABLE_INDEX_SLEB
-; CHECK-NEXT:         Index:           7
+; CHECK-NEXT:         Index:           8
 ; CHECK-NEXT:         Offset:          0x00000037
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_SLEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x0000003F
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_FUNCTION_INDEX_LEB
-; CHECK-NEXT:         Index:           1
+; CHECK-NEXT:         Index:           2
 ; CHECK-NEXT:         Offset:          0x00000045
 ; CHECK-NEXT:     Functions:       
 ; CHECK-NEXT:       - Index:           5
 ; CHECK-NEXT:         Locals:          
 ; CHECK-NEXT:         Body:            1080808080000B
 ; CHECK-NEXT:       - Index:           6
 ; CHECK-NEXT:         Locals:          
 ; CHECK-NEXT:         Body:            024041818080800041004180808080001081808080000D000F0B00000B

 ; CHECK-NEXT:       - Name:            .Lcall_dtors.42
 ; CHECK-NEXT:         Flags:           [ BINDING_LOCAL ]
 ; CHECK-NEXT:       - Name:            .Lregister_call_dtors.42
 ; CHECK-NEXT:         Flags:           [ BINDING_LOCAL ]
 ; CHECK-NEXT:       - Name:            .Lcall_dtors
 ; CHECK-NEXT:         Flags:           [ BINDING_LOCAL ]
 ; CHECK-NEXT:       - Name:            .Lregister_call_dtors
 ; CHECK-NEXT:         Flags:           [ BINDING_LOCAL ]
 ; CHECK-NEXT:     SegmentInfo:     
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Name:            .data.global1
 ; CHECK-NEXT:         Alignment:       8
 ; CHECK-NEXT:         Flags:           [ ]
 ; CHECK-NEXT:     InitFunctions:     
 ; CHECK-NEXT:       - Priority: 42
-; CHECK-NEXT:         FunctionIndex: 3
+; CHECK-NEXT:         FunctionIndex: 4
 ; CHECK-NEXT:       - Priority: 42
-; CHECK-NEXT:         FunctionIndex: 6
+; CHECK-NEXT:         FunctionIndex: 7
 ; CHECK-NEXT:       - Priority: 65535
-; CHECK-NEXT:         FunctionIndex: 4
+; CHECK-NEXT:         FunctionIndex: 5
 ; CHECK-NEXT:       - Priority: 65535
-; CHECK-NEXT:         FunctionIndex: 8
+; CHECK-NEXT:         FunctionIndex: 9
 ; CHECK-NEXT: ...

test/MC/WebAssembly/reloc-code.ll

 
 
 ; CHECK: Format: WASM
 ; CHECK: Relocations [
 ; CHECK-NEXT:   Section (6) CODE {
 ; CHECK-NEXT:     Relocation {
 ; CHECK-NEXT:       Type: R_WEBASSEMBLY_MEMORY_ADDR_LEB (3)
 ; CHECK-NEXT:       Offset: 0x9
-; CHECK-NEXT:       Index: 0x0
+; CHECK-NEXT:       Index: 0x3
 ; CHECK-NEXT:       Addend: 0
 ; CHECK-NEXT:     }
 ; CHECK-NEXT:     Relocation {
 ; CHECK-NEXT:       Type: R_WEBASSEMBLY_MEMORY_ADDR_LEB (3)
 ; CHECK-NEXT:       Offset: 0x14
-; CHECK-NEXT:       Index: 0x1
+; CHECK-NEXT:       Index: 0x4
 ; CHECK-NEXT:       Addend: 0
 ; CHECK-NEXT:     }
 ; CHECK-NEXT:     Relocation {
 ; CHECK-NEXT:       Type: R_WEBASSEMBLY_TYPE_INDEX_LEB (6)
 ; CHECK-NEXT:       Offset: 0x1A
 ; CHECK-NEXT:       Index: 0x1
 ; CHECK-NEXT:     }
 ; CHECK-NEXT:     Relocation {

test/MC/WebAssembly/weak-alias.ll

 ; CHECK-NEXT:           Initial:         0x00000001
 ; CHECK-NEXT:       - Module:          env
 ; CHECK-NEXT:         Field:           __indirect_function_table
 ; CHECK-NEXT:         Kind:            TABLE
 ; CHECK-NEXT:         Table:
 ; CHECK-NEXT:           ElemType:        ANYFUNC
 ; CHECK-NEXT:           Limits:
 ; CHECK-NEXT:             Initial:         0x00000001
-; CHECK-NEXT:       - Module:          env
-; 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:       - Index:           0
 ; CHECK-NEXT:         Type:            I32
 ; CHECK-NEXT:         Mutable:         false
 ; CHECK-NEXT:         InitExpr:        
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           8
-; CHECK-NEXT:       - Index:           2
+; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Type:            I32
 ; CHECK-NEXT:         Mutable:         false
 ; CHECK-NEXT:         InitExpr:        
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           16
-; CHECK-NEXT:       - Index:           3
+; CHECK-NEXT:       - Index:           2
 ; CHECK-NEXT:         Type:            I32
 ; 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:         Index:           0
 ; CHECK-NEXT:       - Name:            call_direct
 ; CHECK-NEXT:         Kind:            FUNCTION
-; CHECK-NEXT:         Index:           2
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:       - Name:            call_alias
 ; CHECK-NEXT:         Kind:            FUNCTION
-; CHECK-NEXT:         Index:           3
+; CHECK-NEXT:         Index:           2
 ; CHECK-NEXT:       - Name:            call_direct_ptr
 ; CHECK-NEXT:         Kind:            FUNCTION
-; CHECK-NEXT:         Index:           4
+; CHECK-NEXT:         Index:           3
 ; CHECK-NEXT:       - Name:            direct_address
 ; CHECK-NEXT:         Kind:            GLOBAL
-; CHECK-NEXT:         Index:           1
+; CHECK-NEXT:         Index:           0
 ; CHECK-NEXT:       - Name:            call_alias_ptr
 ; CHECK-NEXT:         Kind:            FUNCTION
-; CHECK-NEXT:         Index:           5
+; CHECK-NEXT:         Index:           4
 ; CHECK-NEXT:       - Name:            alias_address
 ; CHECK-NEXT:         Kind:            GLOBAL
-; CHECK-NEXT:         Index:           2
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:       - Name:            bar
 ; CHECK-NEXT:         Kind:            GLOBAL
-; CHECK-NEXT:         Index:           3
+; CHECK-NEXT:         Index:           2
 ; CHECK-NEXT:       - Name:            foo_alias
 ; CHECK-NEXT:         Kind:            FUNCTION
-; CHECK-NEXT:         Index:           1
+; CHECK-NEXT:         Index:           0
 ; CHECK-NEXT:       - Name:            bar_alias
 ; CHECK-NEXT:         Kind:            GLOBAL
-; CHECK-NEXT:         Index:           3
+; CHECK-NEXT:         Index:           2
 ; CHECK-NEXT:   - Type:            ELEM
 ; CHECK-NEXT:     Segments:        
 ; CHECK-NEXT:       - Offset:          
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           1
-; CHECK-NEXT:         Functions:       [ 1 ]
+; CHECK-NEXT:         Functions:       [ 0 ]
 ; CHECK-NEXT:   - Type:            CODE
 ; CHECK-NEXT:     Relocations:     
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_FUNCTION_INDEX_LEB
-; CHECK-NEXT:         Index:           1
+; CHECK-NEXT:         Index:           0
 ; CHECK-NEXT:         Offset:          0x00000009
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_FUNCTION_INDEX_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           8
 ; CHECK-NEXT:         Offset:          0x00000012
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           1
+; CHECK-NEXT:         Index:           4
 ; 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:         Index:           6
 ; 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:       - Index:           0
 ; CHECK-NEXT:         Locals:          
 ; CHECK-NEXT:         Body:            41000B
-; CHECK-NEXT:       - Index:           2
+; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Locals:          
-; CHECK-NEXT:         Body:            1081808080000B
-; CHECK-NEXT:       - Index:           3
+; CHECK-NEXT:         Body:            1080808080000B
+; CHECK-NEXT:       - Index:           2
 ; CHECK-NEXT:         Locals:          
 ; CHECK-NEXT:         Body:            1080808080000B
-; CHECK-NEXT:       - Index:           4
+; CHECK-NEXT:       - Index:           3
 ; CHECK-NEXT:         Locals:          
 ; CHECK-NEXT:         Body:            410028028880808000118080808000000B
-; CHECK-NEXT:       - Index:           5
+; CHECK-NEXT:       - Index:           4
 ; CHECK-NEXT:         Locals:          
 ; CHECK-NEXT:         Body:            410028029080808000118080808000000B
 ; CHECK-NEXT:   - Type:            DATA
 ; CHECK-NEXT:     Relocations:     
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_TABLE_INDEX_I32
-; CHECK-NEXT:         Index:           1
+; CHECK-NEXT:         Index:           0
 ; CHECK-NEXT:         Offset:          0x0000000F
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_TABLE_INDEX_I32
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           8
 ; CHECK-NEXT:         Offset:          0x00000018
 ; CHECK-NEXT:     Segments:        
 ; CHECK-NEXT:       - SectionOffset:   6
 ; CHECK-NEXT:         MemoryIndex:     0
 ; CHECK-NEXT:         Offset:          
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           0
 ; CHECK-NEXT:         Content:         '07000000'
 ; CHECK-NEXT:       - SectionOffset:   15
 ; CHECK-NEXT:         MemoryIndex:     0
 ; CHECK-NEXT:         Offset:          
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           8
 ; CHECK-NEXT:         Content:         '01000000'
 ; CHECK-NEXT:       - SectionOffset:   24
 ; CHECK-NEXT:         MemoryIndex:     0
 ; CHECK-NEXT:         Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           16
 ; CHECK-NEXT:         Content:         '01000000'
 ; 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:       - 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: 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
+; CHECK-SYMS-NEXT: 00000000 g     F EXPORT     .hidden foo
+; CHECK-SYMS-NEXT: 00000001 g     F EXPORT     .hidden call_direct
+; CHECK-SYMS-NEXT: 00000002 g     F EXPORT     .hidden call_alias
+; CHECK-SYMS-NEXT: 00000003 g     F EXPORT     .hidden call_direct_ptr
+; CHECK-SYMS-NEXT: 00000008 g       EXPORT     direct_address
+; CHECK-SYMS-NEXT: 00000004 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: 00000000 gw    F EXPORT     .hidden foo_alias
+; CHECK-SYMS-NEXT: 00000000 gw      EXPORT     .hidden bar_alias