[WebAssembly] Inline accessor functions that are called only once.

[ruiu]

Summary

Looks like these accessor functions are a bit overly defensive, and
due to the amount of code, that part isn't easy to read. We have
code to log translation results in writeTo and writeRelocations, so
I don't think we need to log it again in these functions.
I think the new function is much easier to understand.

[sbc100]

Agreed. This is mostly a historical legacy since these used to be public method used elsewhere. I've been meaning to do something like this myself.

lld/wasm/InputFiles.cpp

68 ↗

(On Diff #135770)

I think this assert is useful. It ensures the type is valid and part of the output.

[ruiu]

lld/wasm/InputFiles.cpp

68 ↗

(On Diff #135770)

Done.

lld/trunk/wasm/InputFiles.h

public:
 
   ArrayRef<Symbol *> getSymbols() const { return Symbols; }
   Symbol *getSymbol(uint32_t Index) const { return Symbols[Index]; }
   FunctionSymbol *getFunctionSymbol(uint32_t Index) const;
   DataSymbol *getDataSymbol(uint32_t Index) const;
   GlobalSymbol *getGlobalSymbol(uint32_t Index) const;
 
 private:
-  uint32_t relocateVirtualAddress(uint32_t Index) const;
-  uint32_t relocateFunctionIndex(uint32_t Original) const;
-  uint32_t relocateTypeIndex(uint32_t Original) const;
-  uint32_t relocateGlobalIndex(uint32_t Original) const;
-  uint32_t relocateTableIndex(uint32_t Original) const;
-  uint32_t relocateSymbolIndex(uint32_t Original) const;
-
   Symbol *createDefinedData(const WasmSymbol &Sym, InputSegment *Segment,
                             uint32_t Offset, uint32_t DataSize);
   Symbol *createDefinedFunction(const WasmSymbol &Sym, InputFunction *Function);
   Symbol *createDefinedGlobal(const WasmSymbol &Sym, InputGlobal *Global);
   Symbol *createUndefined(const WasmSymbol &Sym);
 
   void initializeSymbols();
   InputSegment *getSegment(const WasmSymbol &WasmSym) const;

lld/trunk/wasm/InputFiles.cpp

 
 void ObjFile::dumpInfo() const {
   log("info for: " + getName() + "\n" +
       "              Symbols : " + Twine(Symbols.size()) + "\n" +
       "     Function Imports : " + Twine(NumFunctionImports) + "\n" +
       "       Global Imports : " + Twine(NumGlobalImports) + "\n");
 }
 
-uint32_t ObjFile::relocateVirtualAddress(uint32_t GlobalIndex) const {
-  if (auto *DG = dyn_cast<DefinedData>(getDataSymbol(GlobalIndex)))
-    return DG->getVirtualAddress();
-  else
-    return 0;
-}
-
-uint32_t ObjFile::relocateFunctionIndex(uint32_t Original) const {
-  const FunctionSymbol *Sym = getFunctionSymbol(Original);
-  uint32_t Index = Sym->getOutputIndex();
-  DEBUG(dbgs() << "relocateFunctionIndex: " << toString(*Sym) << ": "
-               << Original << " -> " << Index << "\n");
-  return Index;
-}
-
-uint32_t ObjFile::relocateTypeIndex(uint32_t Original) const {
-  assert(TypeIsUsed[Original]);
-  return TypeMap[Original];
-}
-
-uint32_t ObjFile::relocateTableIndex(uint32_t Original) const {
-  const FunctionSymbol *Sym = getFunctionSymbol(Original);
-  // The null case is possible, if you take the address of a weak function
-  // that's simply not supplied.
-  uint32_t Index = Sym->hasTableIndex() ? Sym->getTableIndex() : 0;
-  DEBUG(dbgs() << "relocateTableIndex: " << toString(*Sym) << ": " << Original
-               << " -> " << Index << "\n");
-  return Index;
-}
-
-uint32_t ObjFile::relocateGlobalIndex(uint32_t Original) const {
-  const Symbol *Sym = getGlobalSymbol(Original);
-  uint32_t Index = Sym->getOutputIndex();
-  DEBUG(dbgs() << "relocateGlobalIndex: " << toString(*Sym) << ": " << Original
-               << " -> " << Index << "\n");
-  return Index;
-}
-
-uint32_t ObjFile::relocateSymbolIndex(uint32_t Original) const {
-  Symbol *Sym = getSymbol(Original);
-  uint32_t Index = Sym->getOutputSymbolIndex();
-  DEBUG(dbgs() << "relocateSymbolIndex: " << toString(*Sym) << ": " << Original
-               << " -> " << Index << "\n");
-  return Index;
-}
-
 // Relocations contain an index into the function, global or table index
 // space of the input file.  This function takes a relocation and returns the
 // relocated index (i.e. translates from the input index space to the output
 // index space).
 uint32_t ObjFile::calcNewIndex(const WasmRelocation &Reloc) const {
-  if (Reloc.Type == R_WEBASSEMBLY_TYPE_INDEX_LEB)
-    return relocateTypeIndex(Reloc.Index);
-
-  return relocateSymbolIndex(Reloc.Index);
+  if (Reloc.Type == R_WEBASSEMBLY_TYPE_INDEX_LEB) {
+    assert(TypeIsUsed[Reloc.Index]);
+    return TypeMap[Reloc.Index];
+  }
+  return Symbols[Reloc.Index]->getOutputSymbolIndex();
 }
 
 // Translate from the relocation's index into the final linked output value.
 uint32_t ObjFile::calcNewValue(const WasmRelocation &Reloc) const {
   switch (Reloc.Type) {
   case R_WEBASSEMBLY_TABLE_INDEX_I32:
-  case R_WEBASSEMBLY_TABLE_INDEX_SLEB:
-    return relocateTableIndex(Reloc.Index);
+  case R_WEBASSEMBLY_TABLE_INDEX_SLEB: {
+    // The null case is possible, if you take the address of a weak function
+    // that's simply not supplied.
+    FunctionSymbol *Sym = getFunctionSymbol(Reloc.Index);
+    if (Sym->hasTableIndex())
+      return Sym->getTableIndex();
+    return 0;
+  }
   case R_WEBASSEMBLY_MEMORY_ADDR_SLEB:
   case R_WEBASSEMBLY_MEMORY_ADDR_I32:
   case R_WEBASSEMBLY_MEMORY_ADDR_LEB:
-    return relocateVirtualAddress(Reloc.Index) + Reloc.Addend;
+    if (auto *Sym = dyn_cast<DefinedData>(getDataSymbol(Reloc.Index)))
+      return Sym->getVirtualAddress() + Reloc.Addend;
+    return Reloc.Addend;
   case R_WEBASSEMBLY_TYPE_INDEX_LEB:
-    return relocateTypeIndex(Reloc.Index);
+    return TypeMap[Reloc.Index];
   case R_WEBASSEMBLY_FUNCTION_INDEX_LEB:
-    return relocateFunctionIndex(Reloc.Index);
+    return getFunctionSymbol(Reloc.Index)->getOutputIndex();
   case R_WEBASSEMBLY_GLOBAL_INDEX_LEB:
-    return relocateGlobalIndex(Reloc.Index);
+    return getGlobalSymbol(Reloc.Index)->getOutputIndex();
   default:
     llvm_unreachable("unknown relocation type");
   }
 }
 
 void ObjFile::parse() {
   // Parse a memory buffer as a wasm file.
   DEBUG(dbgs() << "Parsing object: " << toString(this) << "\n");