[WebAssembly] Use function/global index space in WasmSymbol

[sbc100]

Summary

It is useful for the symbol to contain the index of the
function of global it represents in the function/global
index space.

For imports we also store the import index so that the
linker can find, for example, the signature of the
corresponding function, which is defined by the import

In the long run we need to decide whether this API
surface should be closer to binary (where imported
functions are seperate) or the wasm spec (where the
function index space is unified).

[sbc100]

@dschuff PTAL

[dschuff]

I think it probably makes sense to use the function/global index space for the compiler and linker, and user-oriented tools (e.g. objdump, nm). For things like obj2yaml or readobj, maybe a something more raw would be appropriate, but I'd guess that it's not a super-high priority, other than it's nice to have those for testing.

[dschuff]

oh also it looks like you left a couple of words out of the first paragraph of the commit message.

include/llvm/Object/Wasm.h

enum class SymbolType {
     FUNCTION_IMPORT,
     FUNCTION_EXPORT,
     GLOBAL_IMPORT,
     GLOBAL_EXPORT,
     DEBUG_FUNCTION_NAME,
   };
 
   WasmSymbol(StringRef Name, SymbolType Type, uint32_t Section,
-             uint32_t ElementIndex)
-      : Name(Name), Type(Type), Section(Section), ElementIndex(ElementIndex) {}
+             uint32_t ElementIndex, uint32_t ImportIndex = 0)
+      : Name(Name), Type(Type), Section(Section), ElementIndex(ElementIndex),
+        ImportIndex(ImportIndex) {}
 
   StringRef Name;
   SymbolType Type;
   uint32_t Section;
   uint32_t Flags = 0;
 
-  // Index into the imports, exports or functions array of the object depending
-  // on the type
+  // Index into either the function or global index space.
   uint32_t ElementIndex;
 
+  // For imports, the index into the import table
+  uint32_t ImportIndex;
+
+  bool isFunction() const {
+    return Type == WasmSymbol::SymbolType::FUNCTION_IMPORT ||
+           Type == WasmSymbol::SymbolType::FUNCTION_EXPORT ||
+           Type == WasmSymbol::SymbolType::DEBUG_FUNCTION_NAME;
+  }
+
+
   bool isWeak() const {
     return getBinding() == wasm::WASM_SYMBOL_BINDING_WEAK;
   }
 
   bool isGlobal() const {
     return getBinding() == wasm::WASM_SYMBOL_BINDING_GLOBAL;
   }
 
   bool isLocal() const {
     return getBinding() == wasm::WASM_SYMBOL_BINDING_LOCAL;
   }
 
   unsigned getBinding() const {
     return Flags & wasm::WASM_SYMBOL_BINDING_MASK;
   }
 
   void print(raw_ostream &Out) const {
     Out << "Name=" << Name << ", Type=" << static_cast<int>(Type)
-        << ", Flags=" << Flags << " ElemIndex=" << ElementIndex;
+        << ", Flags=" << Flags << " ElemIndex=" << ElementIndex
+        << ", ImportIndex=" << ImportIndex;
   }
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
   LLVM_DUMP_METHOD void dump() const { print(dbgs()); }
 #endif
 };
 
 struct WasmSection {

lib/Object/WasmObjectFile.cpp

if (Ptr != End)
     return make_error<GenericBinaryError>("Name section ended prematurely",
                                           object_error::parse_failed);
   return Error::success();
 }
 
 void WasmObjectFile::populateSymbolTable() {
   // Add imports to symbol table
   size_t ImportIndex = 0;
+  size_t GlobalIndex = 0;
+  size_t FunctionIndex = 0;
   for (const wasm::WasmImport& Import : Imports) {
     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, ImportIndex);
+                           ImportSection, GlobalIndex++, ImportIndex);
       DEBUG(dbgs() << "Adding import: " << Symbols.back()
                    << " sym index:" << Symbols.size() << "\n");
       break;
     case wasm::WASM_EXTERNAL_FUNCTION:
       SymbolMap.try_emplace(Import.Field, Symbols.size());
       Symbols.emplace_back(Import.Field,
                            WasmSymbol::SymbolType::FUNCTION_IMPORT,
-                           ImportSection, ImportIndex);
+                           ImportSection, FunctionIndex++, ImportIndex);
       DEBUG(dbgs() << "Adding import: " << Symbols.back()
                    << " sym index:" << Symbols.size() << "\n");
       break;
     default:
       break;
     }
     ImportIndex++;
   }
 
   // Add exports to symbol table
-  size_t ExportIndex = 0;
   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, ExportIndex);
+                             ExportSection, Export.Index);
         DEBUG(dbgs() << "Adding export: " << Symbols.back()
                      << " sym index:" << Symbols.size() << "\n");
       } else {
         uint32_t SymIndex = Pair.first->second;
         Symbols[SymIndex] =
-            WasmSymbol(Export.Name, ExportType, ExportSection, ExportIndex);
+            WasmSymbol(Export.Name, ExportType, ExportSection, Export.Index);
         DEBUG(dbgs() << "Replacing existing symbol:  " << Symbols[SymIndex]
                      << " sym index:" << SymIndex << "\n");
       }
     }
-    ExportIndex++;
   }
 }
 
 Error WasmObjectFile::parseLinkingSection(const uint8_t *Ptr,
                                           const uint8_t *End) {
   HasLinkingSection = true;
 
   // Only populate the symbol table with imports and exports if the object

 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:
-    return 0;
   case WasmSymbol::SymbolType::FUNCTION_EXPORT:
-    return Exports[Sym.ElementIndex].Index;
+  case WasmSymbol::SymbolType::DEBUG_FUNCTION_NAME:
+    return Sym.ElementIndex;
   case WasmSymbol::SymbolType::GLOBAL_EXPORT: {
-    uint32_t GlobalIndex = Exports[Sym.ElementIndex].Index - NumImportedGlobals;
+    uint32_t GlobalIndex = Sym.ElementIndex - NumImportedGlobals;
     assert(GlobalIndex < Globals.size());
     const wasm::WasmGlobal& Global = Globals[GlobalIndex];
     // WasmSymbols correspond only to I32_CONST globals
     assert(Global.InitExpr.Opcode == wasm::WASM_OPCODE_I32_CONST);
     return Global.InitExpr.Value.Int32;
   }
-  case WasmSymbol::SymbolType::DEBUG_FUNCTION_NAME:
-    return Sym.ElementIndex;
   }
   llvm_unreachable("invalid symbol type");
 }
 
 uint64_t WasmObjectFile::getSymbolValueImpl(DataRefImpl Symb) const {
   return getWasmSymbolValue(getWasmSymbol(Symb));
 }