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

166

Do we need these new methods?

270

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

lib/MC/WasmObjectWriter.cpp

597–598

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.

806

Why this change?

938

Rename this argument to Symbolnfo?

lib/Object/WasmObjectFile.cpp

764

isValidFunctionWasmIndex?

770

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

949

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

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.

166

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.

270

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

806

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.

949

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

172

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

test/MC/WebAssembly/weak-alias.ll

66

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

467

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

971

Revert this?

[ncw]

Updated, renamed WasmIndex -> ElementIndex

lib/Object/WasmObjectFile.cpp

467

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

1177

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

1226

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.

1261

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 Index; // Wasm Function index space
   std::vector<WasmLocalDecl> Locals;
   ArrayRef<uint8_t> Body;
   uint32_t CodeSectionOffset;
   uint32_t Size;
   StringRef Name; // from the "names" section
   StringRef Comdat; // from the "comdat info" section
 };
 

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 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;
   }
 
 
   bool isWeak() const {
     return getBinding() == wasm::WASM_SYMBOL_BINDING_WEAK;
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; }
   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; }
+  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;
+  bool isValidGlobalWasmIndex(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;
   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 NumExportedGlobals = 0;
+  uint32_t NumExportedFunctions = 0;
   uint32_t ImportSection = 0;
   uint32_t ExportSection = 0;
 
-  StringMap<uint32_t> SymbolMap;
+  // TODO: will get rid of this map in next commit
+  StringMap<std::pair<uint32_t,uint32_t>> SymbolMap; // name to pair(kind,index)
 };
 
 } // end namespace object
 
 inline raw_ostream &operator<<(raw_ostream &OS,
                                const object::WasmSymbol &Sym) {
   Sym.print(OS);
   return OS;
 }
 
 } // end namespace llvm
 
 #endif // LLVM_OBJECT_WASM_H

lib/MC/WasmObjectWriter.cpp

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/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;

 uint32_t
 WasmObjectWriter::getProvisionalValue(const WasmRelocationEntry &RelEntry) {
   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.
   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 (!SymbolIndices.count(Sym))
+  if (!WasmIndices.count(Sym))
     report_fatal_error("symbol not found in function/global index space: " +
                        RelEntry.Symbol->getName());
-  uint32_t SymbolIndex = SymbolIndices[Sym];
-  int32_t TableIndex = TableIndices[SymbolIndex];
+  uint32_t WasmIndex = WasmIndices[Sym];
+  int32_t TableIndex = TableIndices[WasmIndex];
   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) {
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];
   } else {
     if (!SymbolIndices.count(RelEntry.Symbol))
       report_fatal_error("symbol not found in function/global 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) {
   raw_pwrite_stream &Stream = getStream();
   for (const WasmRelocationEntry &RelEntry : Relocations) {
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(InitialTableOffset, 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);
if (Pair.second)
     FunctionTypes.push_back(F);
   TypeIndices[&Symbol] = Pair.first->second;
 
   DEBUG(dbgs() << "registerFunctionType: " << Symbol << " new:" << Pair.second << "\n");
   DEBUG(dbgs() << "  -> type index: " << Pair.first->second << "\n");
   return Pair.first->second;
 }
 
+static void addFlags(SmallVector<std::pair<StringRef, uint32_t>, 4> &SymbolFlags,
+                     const MCSymbolWasm &WS) {
+  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);
+  }
+}
+
 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<std::pair<uint16_t, uint32_t>, 2> InitFuncs;
   std::map<StringRef, std::vector<WasmComdatEntry>> Comdats;
+  unsigned NumFuncExports = 0;
+  unsigned NumGlobalExports = 0;
   SmallVector<WasmDataSegment, 4> DataSegments;
   uint32_t DataSize = 0;
 
   // In the special .global_variables section, we've encoded global
   // variables used by the function. Translate them into the Globals
   // list.
   MCSectionWasm *GlobalVars =
       Ctx.getWasmSection(".global_variables", SectionKind::getMetadata());
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;
+        WasmIndices[&WS] = SymbolIndices[&WS] = NumFunctionImports;
         ++NumFunctionImports;
       } else {
         Import.Kind = wasm::WASM_EXTERNAL_GLOBAL;
         Import.Type = int32_t(PtrType);
         Import.IsMutable = false;
-        SymbolIndices[&WS] = NumGlobalImports;
+        unsigned SymbolIndex = NumGlobalImports;
+        WasmIndices[&WS] = SymbolIndices[&WS] = SymbolIndex;
 
         // If this global is the stack pointer, make it mutable.
         if (WS.getName() == "__stack_pointer")
           Import.IsMutable = true;
 
         ++NumGlobalImports;
+
+        addFlags(SymbolFlags, WS);
       }
 
       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()) {
         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();
+        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())
         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, WS);
+
     // 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});
+              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());
 
     // 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, 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(NumFunctionImports + Functions.size(), -1);
     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[WS];
-      if (TableIndices[SymbolIndex] == -1) {
-        TableIndices[SymbolIndex] = TableElems.size() + InitialTableOffset;
+      uint32_t WasmIndex = WasmIndices[WS];
+      if (TableIndices[WasmIndex] == -1) {
+        TableIndices[WasmIndex] = TableElems.size() + InitialTableOffset;
         DEBUG(dbgs() << "  -> adding to table: " << TableElems.size() << "\n");
-        TableElems.push_back(SymbolIndex);
+        TableElems.push_back(WasmIndex);
       }
     };
 
     for (const WasmRelocationEntry &RelEntry : CodeRelocations)
       HandleReloc(RelEntry);
     for (const WasmRelocationEntry &RelEntry : DataRelocations)
       HandleReloc(RelEntry);
   }

lib/Object/WasmObjectFile.cpp

while (Ptr < End) {
     case wasm::WASM_NAMES_FUNCTION: {
       uint32_t Count = readVaruint32(Ptr);
       while (Count--) {
         uint32_t Index = readVaruint32(Ptr);
         if (!Seen.insert(Index).second)
           return make_error<GenericBinaryError>("Function named more than once",
                                                 object_error::parse_failed);
         StringRef Name = readString(Ptr);
-        if (!isValidFunctionIndex(Index) || Name.empty())
+        if (!isValidFunctionWasmIndex(Index) || Name.empty())
           return make_error<GenericBinaryError>("Invalid name entry",
                                                 object_error::parse_failed);
         DebugNames.push_back(wasm::WasmFunctionName{Index, Name});
         if (Index >= NumImportedFunctions) {
           // Override any existing name; the name specified by the "names"
           // section is the Function's canonical name.
           Functions[Index - NumImportedFunctions].Name = Name;
         }
       }
       break;
     }
     // Ignore local names for now
     case wasm::WASM_NAMES_LOCAL:
     default:
       Ptr += Size;
       break;
     }
     if (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);
+
   // 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 (!SymbolMap.try_emplace(Import.Field, Import.Kind, Symbols->size()).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");
-      }
-    }
-    if (Export.Kind == wasm::WASM_EXTERNAL_FUNCTION) {
+    WasmSymbol::SymbolType ExportType;
+    std::vector<WasmSymbol> *Symbols;
+    unsigned FunctionType = 0;
+    switch (Export.Kind) {
+    case wasm::WASM_EXTERNAL_GLOBAL:
+      assert(isValidGlobalWasmIndex(Export.Index));
+      if (Export.Index < NumImportedGlobals)
+        return make_error<GenericBinaryError>("symbol cannot export an import",
+                                              object_error::parse_failed);
+      Symbols = &GlobalSymbols;
+      ExportType = WasmSymbol::SymbolType::GLOBAL_EXPORT;
+      break;
+    case wasm::WASM_EXTERNAL_FUNCTION: {
+      if (Export.Index < NumImportedFunctions)
+        return make_error<GenericBinaryError>("symbol cannot export an import",
+                                              object_error::parse_failed);
+      Symbols = &FunctionSymbols;
+      ExportType = WasmSymbol::SymbolType::FUNCTION_EXPORT;
+      FunctionType = FunctionTypes[Export.Index - NumImportedFunctions];
       auto &Function = Functions[Export.Index - NumImportedFunctions];
       if (Function.Name.empty()) {
         // Use the export's name to set a name for the Function, but only if one
         // hasn't already been set.
         Function.Name = Export.Name;
       }
+      break;
     }
+    default:
+      continue;
     }
+    if (!SymbolMap.try_emplace(Export.Name, Export.Kind, Symbols->size()).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;
   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 (Count--) {
         StringRef Symbol = readString(Ptr);
         uint32_t Flags = readVaruint32(Ptr);
         auto iter = SymbolMap.find(Symbol);
         if (iter == SymbolMap.end()) {
           return make_error<GenericBinaryError>(
               "Invalid symbol name in linking section: " + Symbol,
               object_error::parse_failed);
         }
-        uint32_t SymIndex = iter->second;
+        uint32_t Kind = iter->second.first;
+        uint32_t SymIndex = iter->second.second;
+        std::vector<WasmSymbol> &Symbols =
+            Kind == wasm::WASM_EXTERNAL_FUNCTION ? FunctionSymbols : GlobalSymbols;
         assert(SymIndex < Symbols.size());
         Symbols[SymIndex].Flags = Flags;
         DEBUG(dbgs() << "Set symbol flags index:"
                      << SymIndex << " name:"
                      << Symbols[SymIndex].Name << " expected:"
                      << Symbol << " flags: " << Flags << "\n");
       }
       break;
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 (!isValidFunctionWasmIndex(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:
+      ++NumExportedGlobals;
+      if (!isValidGlobalWasmIndex(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;
+bool WasmObjectFile::isValidFunctionWasmIndex(uint32_t Index) const {
+  return Index < NumImportedFunctions + FunctionTypes.size();
+}
+
+bool WasmObjectFile::isValidFunctionSymbolIndex(uint32_t Index) const {
+  return Index < NumImportedFunctions + NumExportedFunctions;
+}
+
+bool WasmObjectFile::isValidGlobalWasmIndex(uint32_t Index) const {
+  return Index < NumImportedGlobals + Globals.size();
 }
 
 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);

 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:
-    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/global-ctor-dtor.ll

 ; CHECK-NEXT:       - Index:           7
 ; CHECK-NEXT:         Name:            .Lcall_dtors
 ; CHECK-NEXT:       - Index:           8
 ; CHECK-NEXT:         Name:            .Lregister_call_dtors
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            linking
 ; CHECK-NEXT:     DataSize:        4
 ; CHECK-NEXT:     SymbolInfo:      
-; CHECK-NEXT:       - Name:            __dso_handle
-; CHECK-NEXT:         Flags:           [ BINDING_WEAK, VISIBILITY_HIDDEN ]
 ; 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:       - Name:            __dso_handle
+; CHECK-NEXT:         Flags:           [ BINDING_WEAK, VISIBILITY_HIDDEN ]
 ; CHECK-NEXT:     SegmentInfo:     
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Name:            .data.global1
 ; CHECK-NEXT:         Alignment:       8
 ; CHECK-NEXT:         Flags:           [ ]
 ; CHECK-NEXT:     InitFunctions:     
 ; CHECK-NEXT:       - Priority: 42
 ; CHECK-NEXT:         FunctionIndex: 3
 ; CHECK-NEXT:       - Priority: 42
 ; CHECK-NEXT:         FunctionIndex: 6
 ; CHECK-NEXT:       - Priority: 65535
 ; CHECK-NEXT:         FunctionIndex: 4
 ; CHECK-NEXT:       - Priority: 65535
 ; CHECK-NEXT:         FunctionIndex: 8
 ; CHECK-NEXT: ...

test/MC/WebAssembly/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:           5
 ; CHECK-NEXT:         Offset:          0x00000012
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           1
+; CHECK-NEXT:         Index:           0
 ; 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:           1
 ; 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:           1
+; CHECK-NEXT:         Locals:          
+; CHECK-NEXT:         Body:            1080808080000B
 ; CHECK-NEXT:       - Index:           2
 ; CHECK-NEXT:         Locals:          
-; CHECK-NEXT:         Body:            1081808080000B
+; CHECK-NEXT:         Body:            1085808080000B
 ; 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:       - 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:           5
 ; 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:            name
 ; CHECK-NEXT:     FunctionNames:   
 ; CHECK-NEXT:       - Index:           0
-; CHECK-NEXT:         Name:            foo_alias
-; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Name:            foo
-; CHECK-NEXT:       - Index:           2
+; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Name:            call_direct
-; CHECK-NEXT:       - Index:           3
+; CHECK-NEXT:       - Index:           2
 ; CHECK-NEXT:         Name:            call_alias
-; CHECK-NEXT:       - Index:           4
+; CHECK-NEXT:       - Index:           3
 ; CHECK-NEXT:         Name:            call_direct_ptr
-; CHECK-NEXT:       - Index:           5
+; CHECK-NEXT:       - Index:           4
 ; CHECK-NEXT:         Name:            call_alias_ptr
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            linking
 ; CHECK-NEXT:     DataSize:        20
 ; CHECK-NEXT:     SymbolInfo:      
-; CHECK-NEXT:       - Name:            foo_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: 00000004 g     F EXPORT     .hidden call_alias_ptr
+; CHECK-SYMS-NEXT: 00000000 gw    F EXPORT     .hidden foo_alias
+; CHECK-SYMS-NEXT: 00000008 g       EXPORT     direct_address
+; CHECK-SYMS-NEXT: 00000010 g       EXPORT     alias_address
+; CHECK-SYMS-NEXT: 00000000 g       EXPORT     bar
+; CHECK-SYMS-NEXT: 00000000 gw      EXPORT     .hidden bar_alias

test/MC/WebAssembly/weak.ll

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