[WebAssembly] Refactor symbol and symbol table to remove WasmSymbol references

[sbc100]

Summary

This WasmSymbol types comes directly from the input objects
but we want to be able to represent synthetic symbols too.

This is more in line with how the ELF linker represents symbols.

This change also removes the logic from Symbol::getVirtualAddress
for finding the global address and instead has the InputFile
provide this.

[sbc100]

rebase

[sbc100]

• clang-format

[sbc100]

• refactor

[sbc100]

• add comment

[sbc100]

This change depends on D41315

[ruiu]

LGTM

wasm/InputFiles.cpp

264

It felt that the function signature is a bit too flexible (for example, you could pass Kind::UndefinedFunctionKind to createDefined function), but since these functions are private functions, that's perhaps okay.

[sbc100]

• rebase

wasm/InputFiles.h

 
 #include "lld/Common/LLVM.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/Object/Archive.h"
 #include "llvm/Object/Wasm.h"
 #include "llvm/Support/MemoryBuffer.h"
 
+#include "Symbols.h"
 #include "WriterUtils.h"
 
 #include <vector>
 
 using llvm::object::Archive;
 using llvm::object::WasmObjectFile;
 using llvm::object::WasmSection;
 using llvm::object::WasmSymbol;
 using llvm::wasm::WasmImport;
 using llvm::wasm::WasmSignature;
 
 namespace lld {
 namespace wasm {
 
-class Symbol;
 class InputFunction;
 class InputSegment;
 
 class InputFile {
 public:
   enum Kind {
     ObjectKind,
     ArchiveKind,
public:
   void dumpInfo() const;
 
   uint32_t relocateTypeIndex(uint32_t Original) const;
   uint32_t relocateFunctionIndex(uint32_t Original) const;
   uint32_t relocateGlobalIndex(uint32_t Original) const;
   uint32_t relocateTableIndex(uint32_t Original) const;
   uint32_t getRelocatedAddress(uint32_t Index) const;
 
-  size_t getNumGlobalImports() const { return NumGlobalImports; }
-
   const WasmSection *CodeSection = nullptr;
 
   std::vector<uint32_t> TypeMap;
   std::vector<InputSegment *> Segments;
   std::vector<InputFunction *> Functions;
 
   ArrayRef<Symbol *> getSymbols() { return Symbols; }
   ArrayRef<Symbol *> getTableSymbols() { return TableSymbols; }
 
 private:
-  Symbol *createDefined(const WasmSymbol &Sym,
+  Symbol *createDefined(const WasmSymbol &Sym, Symbol::Kind Kind,
                         const InputSegment *Segment = nullptr,
-                        InputFunction *Function = nullptr);
-  Symbol *createUndefined(const WasmSymbol &Sym,
+                        InputFunction *Function = nullptr,
+                        uint32_t Address = UINT32_MAX);
+  Symbol *createUndefined(const WasmSymbol &Sym, Symbol::Kind Kind,
                           const WasmSignature *Signature = nullptr);
   void initializeSymbols();
   InputSegment *getSegment(const WasmSymbol &WasmSym) const;
   const WasmSignature *getFunctionSig(const WasmSymbol &Sym) const;
+  uint32_t getGlobalValue(const WasmSymbol &Sym) const;
   InputFunction *getFunction(const WasmSymbol &Sym) const;
 
   // List of all symbols referenced or defined by this file.
   std::vector<Symbol *> Symbols;
 
   // List of all function symbols indexed by the function index space
   std::vector<Symbol *> FunctionSymbols;
 

wasm/InputFiles.cpp

 static void copyRelocationsRange(std::vector<WasmRelocation> &To,
                                  ArrayRef<WasmRelocation> From, size_t Start,
                                  size_t Size) {
   for (const WasmRelocation &R : From)
     if (R.Offset >= Start && R.Offset < Start + Size)
       To.push_back(R);
 }
 
+// Get the value stored in the wasm global represented by this symbol.
+// This represents the virtual address of the symbol in the input file.
+uint32_t ObjFile::getGlobalValue(const WasmSymbol &Sym) const {
+  const WasmGlobal &Global =
+      getWasmObj()->globals()[Sym.ElementIndex - NumGlobalImports];
+  assert(Global.Type == llvm::wasm::WASM_TYPE_I32);
+  return Global.InitExpr.Value.Int32;
+}
+
 // Get the signature for a given function symbol, either by looking
 // it up in function sections (for defined functions), of the imports section
 // (for imported functions).
 const WasmSignature *ObjFile::getFunctionSig(const WasmSymbol &Sym) const {
   DEBUG(dbgs() << "getFunctionSig: " << Sym.Name << "\n");
   return &WasmObj->types()[Sym.FunctionType];
 }
 
void ObjFile::initializeSymbols() {
 
   // Populate `FunctionSymbols` and `GlobalSymbols` based on the WasmSymbols
   // in the object
   for (const SymbolRef &Sym : WasmObj->symbols()) {
     const WasmSymbol &WasmSym = WasmObj->getWasmSymbol(Sym.getRawDataRefImpl());
     Symbol *S;
     switch (WasmSym.Type) {
     case WasmSymbol::SymbolType::FUNCTION_IMPORT:
-      S = createUndefined(WasmSym, getFunctionSig(WasmSym));
+      S = createUndefined(WasmSym, Symbol::Kind::UndefinedFunctionKind,
+                          getFunctionSig(WasmSym));
       break;
     case WasmSymbol::SymbolType::GLOBAL_IMPORT:
-      S = createUndefined(WasmSym);
+      S = createUndefined(WasmSym, Symbol::Kind::UndefinedGlobalKind);
       break;
     case WasmSymbol::SymbolType::GLOBAL_EXPORT:
-      S = createDefined(WasmSym, getSegment(WasmSym), nullptr);
+      S = createDefined(WasmSym, Symbol::Kind::DefinedGlobalKind,
+                        getSegment(WasmSym), nullptr, getGlobalValue(WasmSym));
       break;
     case WasmSymbol::SymbolType::FUNCTION_EXPORT:
-      S = createDefined(WasmSym, nullptr, getFunction(WasmSym));
+      S = createDefined(WasmSym, Symbol::Kind::DefinedFunctionKind, nullptr,
+                        getFunction(WasmSym));
       break;
     case WasmSymbol::SymbolType::DEBUG_FUNCTION_NAME:
       // These are for debugging only, no need to create linker symbols for them
       continue;
     }
 
     Symbols.push_back(S);
     if (WasmSym.isFunction()) {
for (uint64_t FunctionIndex : Segment.Functions)
       TableSymbols.push_back(FunctionSymbols[FunctionIndex]);
   }
 
   DEBUG(dbgs() << "TableSymbols: " << TableSymbols.size() << "\n");
   DEBUG(dbgs() << "Functions   : " << FunctionSymbols.size() << "\n");
   DEBUG(dbgs() << "Globals     : " << GlobalSymbols.size() << "\n");
 }
 
-Symbol *ObjFile::createUndefined(const WasmSymbol &Sym,
+Symbol *ObjFile::createUndefined(const WasmSymbol &Sym, Symbol::Kind Kind,
                                  const WasmSignature *Signature) {
-  return Symtab->addUndefined(this, &Sym, Signature);
+  return Symtab->addUndefined(Sym.Name, Kind, Sym.Flags, this, Signature);
 }
 
-Symbol *ObjFile::createDefined(const WasmSymbol &Sym,
+Symbol *ObjFile::createDefined(const WasmSymbol &Sym, Symbol::Kind Kind,
                                const InputSegment *Segment,
-                               InputFunction *Function) {
+                               InputFunction *Function, uint32_t Address) {
   Symbol *S;
   if (Sym.isLocal()) {
     S = make<Symbol>(Sym.Name, true);
-    Symbol::Kind Kind;
-    if (Sym.Type == WasmSymbol::SymbolType::FUNCTION_EXPORT)
-      Kind = Symbol::Kind::DefinedFunctionKind;
-    else if (Sym.Type == WasmSymbol::SymbolType::GLOBAL_EXPORT)
-      Kind = Symbol::Kind::DefinedGlobalKind;
-    else
-      llvm_unreachable("invalid local symbol type");
-    S->update(Kind, this, &Sym, Segment, Function);
+    S->update(Kind, this, Sym.Flags, Segment, Function, Address);
     return S;
   }
-  return Symtab->addDefined(this, &Sym, Segment, Function);
+  return Symtab->addDefined(Sym.Name, Kind, Sym.Flags, this, Segment, Function,
+                            Address);
 }
 
 void ArchiveFile::parse() {
   // Parse a MemoryBufferRef as an archive file.
   DEBUG(dbgs() << "Parsing library: " << toString(this) << "\n");
   File = CHECK(Archive::create(MB), toString(this));
 
   // Read the symbol table to construct Lazy symbols.

wasm/SymbolTable.h

 
 #include "InputFiles.h"
 #include "Symbols.h"
 
 #include "llvm/ADT/CachedHashString.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/Support/raw_ostream.h"
 
-using llvm::object::WasmSymbol;
 using llvm::wasm::WasmSignature;
 
 namespace lld {
 namespace wasm {
 
 class InputSegment;
 
 // SymbolTable is a bucket of all known symbols, including defined,
public:
   std::vector<ObjFile *> ObjectFiles;
 
   void reportDuplicate(Symbol *Existing, InputFile *NewFile);
   void reportRemainingUndefines();
 
   ArrayRef<Symbol *> getSymbols() const { return SymVector; }
   Symbol *find(StringRef Name);
 
-  Symbol *addDefined(InputFile *F, const WasmSymbol *Sym,
-                     const InputSegment *Segment = nullptr,
-                     InputFunction *Function = nullptr);
-  Symbol *addUndefined(InputFile *F, const WasmSymbol *Sym,
-                       const WasmSignature *Signature = nullptr);
+  Symbol *addDefined(StringRef Name, Symbol::Kind Kind, uint32_t Flags,
+                     InputFile *F, const InputSegment *Segment = nullptr,
+                     InputFunction *Function = nullptr, uint32_t Address = 0);
+  Symbol *addUndefined(StringRef Name, Symbol::Kind Kind, uint32_t Flags,
+                       InputFile *F, const WasmSignature *Signature = nullptr);
   Symbol *addUndefinedFunction(StringRef Name, const WasmSignature *Type);
   Symbol *addDefinedGlobal(StringRef Name);
   void addLazy(ArchiveFile *F, const Archive::Symbol *Sym);
 
 private:
   std::pair<Symbol *, bool> insert(StringRef Name);
 
   llvm::DenseMap<llvm::CachedHashStringRef, Symbol *> SymMap;

wasm/SymbolTable.cpp

 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Memory.h"
 
 #include <unordered_set>
 
 #define DEBUG_TYPE "lld"
 
 using namespace llvm;
+using namespace llvm::wasm;
 using namespace lld;
 using namespace lld::wasm;
 
 SymbolTable *lld::wasm::Symtab;
 
 void SymbolTable::addFile(InputFile *File) {
   log("Processing: " + toString(File));
   File->parse();
void SymbolTable::reportDuplicate(Symbol *Existing, InputFile *NewFile) {
   error("duplicate symbol: " + toString(*Existing) + "\n>>> defined in " +
         toString(Existing->getFile()) + "\n>>> defined in " +
         toString(NewFile));
 }
 
 // Check the type of new symbol matches that of the symbol is replacing.
 // For functions this can also involve verifying that the signatures match.
 static void checkSymbolTypes(const Symbol &Existing, const InputFile &F,
-                             const WasmSymbol &New,
-                             const WasmSignature *NewSig) {
+                             Symbol::Kind Kind, const WasmSignature *NewSig) {
   if (Existing.isLazy())
     return;
 
-  bool NewIsFunction = New.Type == WasmSymbol::SymbolType::FUNCTION_EXPORT ||
-                       New.Type == WasmSymbol::SymbolType::FUNCTION_IMPORT;
+  bool NewIsFunction = Kind == Symbol::Kind::UndefinedFunctionKind ||
+                       Kind == Symbol::Kind::DefinedFunctionKind;
 
   // First check the symbol types match (i.e. either both are function
   // symbols or both are data symbols).
   if (Existing.isFunction() != NewIsFunction) {
-    error("symbol type mismatch: " + New.Name + "\n>>> defined as " +
+    error("symbol type mismatch: " + Existing.getName() + "\n>>> defined as " +
           (Existing.isFunction() ? "Function" : "Global") + " in " +
           toString(Existing.getFile()) + "\n>>> defined as " +
           (NewIsFunction ? "Function" : "Global") + " in " + F.getName());
     return;
   }
 
   // For function symbols, optionally check the function signature matches too.
   if (!NewIsFunction || !Config->CheckSignatures)
     return;
   // Skip the signature check if the existing function has no signature (e.g.
   // if it is an undefined symbol generated by --undefined command line flag).
   if (!Existing.hasFunctionType())
     return;
 
-  DEBUG(dbgs() << "checkSymbolTypes: " << New.Name << "\n");
+  DEBUG(dbgs() << "checkSymbolTypes: " << Existing.getName() << "\n");
   assert(NewSig);
 
   const WasmSignature &OldSig = Existing.getFunctionType();
   if (*NewSig == OldSig)
     return;
 
-  error("function signature mismatch: " + New.Name + "\n>>> defined as " +
-        toString(OldSig) + " in " + toString(Existing.getFile()) +
-        "\n>>> defined as " + toString(*NewSig) + " in " + F.getName());
+  error("function signature mismatch: " + Existing.getName() +
+        "\n>>> defined as " + toString(OldSig) + " in " +
+        toString(Existing.getFile()) + "\n>>> defined as " + toString(*NewSig) +
+        " in " + F.getName());
 }
 
 Symbol *SymbolTable::addDefinedGlobal(StringRef Name) {
   DEBUG(dbgs() << "addDefinedGlobal: " << Name << "\n");
   Symbol *S;
   bool WasInserted;
   std::tie(S, WasInserted) = insert(Name);
   if (WasInserted)
     S->update(Symbol::DefinedGlobalKind);
   else if (!S->isGlobal())
     error("symbol type mismatch: " + Name);
   return S;
 }
 
-Symbol *SymbolTable::addDefined(InputFile *F, const WasmSymbol *Sym,
+Symbol *SymbolTable::addDefined(StringRef Name, Symbol::Kind Kind,
+                                uint32_t Flags, InputFile *F,
                                 const InputSegment *Segment,
-                                InputFunction *Function) {
-  DEBUG(dbgs() << "addDefined: " << Sym->Name << "\n");
+                                InputFunction *Function, uint32_t Address) {
+  DEBUG(dbgs() << "addDefined: " << Name << " addr:" << Address << "\n");
   Symbol *S;
   bool WasInserted;
-  Symbol::Kind Kind = Symbol::DefinedFunctionKind;
-  if (Sym->Type == WasmSymbol::SymbolType::GLOBAL_EXPORT)
-    Kind = Symbol::DefinedGlobalKind;
 
-  std::tie(S, WasInserted) = insert(Sym->Name);
+  std::tie(S, WasInserted) = insert(Name);
   if (WasInserted) {
-    S->update(Kind, F, Sym, Segment, Function);
+    S->update(Kind, F, Flags, Segment, Function, Address);
   } else if (S->isLazy()) {
     // The existing symbol is lazy. Replace it without checking types since
     // lazy symbols don't have any type information.
-    DEBUG(dbgs() << "replacing existing lazy symbol: " << Sym->Name << "\n");
-    S->update(Kind, F, Sym, Segment, Function);
+    DEBUG(dbgs() << "replacing existing lazy symbol: " << Name << "\n");
+    S->update(Kind, F, Flags, Segment, Function, Address);
   } else if (!S->isDefined()) {
     // The existing symbol table entry is undefined. The new symbol replaces
     // it, after checking the type matches
-    DEBUG(dbgs() << "resolving existing undefined symbol: " << Sym->Name
-                 << "\n");
-    checkSymbolTypes(*S, *F, *Sym, Function ? &Function->Signature : nullptr);
-    S->update(Kind, F, Sym, Segment, Function);
-  } else if (Sym->isWeak()) {
+    DEBUG(dbgs() << "resolving existing undefined symbol: " << Name << "\n");
+    checkSymbolTypes(*S, *F, Kind, Function ? &Function->Signature : nullptr);
+    S->update(Kind, F, Flags, Segment, Function, Address);
+  } else if ((Flags & WASM_SYMBOL_BINDING_MASK) == WASM_SYMBOL_BINDING_WEAK) {
     // the new symbol is weak we can ignore it
     DEBUG(dbgs() << "existing symbol takes precedence\n");
   } else if (S->isWeak()) {
     // the new symbol is not weak and the existing symbol is, so we replace
     // it
     DEBUG(dbgs() << "replacing existing weak symbol\n");
-    checkSymbolTypes(*S, *F, *Sym, Function ? &Function->Signature : nullptr);
-    S->update(Kind, F, Sym, Segment, Function);
+    checkSymbolTypes(*S, *F, Kind, Function ? &Function->Signature : nullptr);
+    S->update(Kind, F, Flags, Segment, Function, Address);
   } else {
     // neither symbol is week. They conflict.
     reportDuplicate(S, F);
   }
   return S;
 }
 
 Symbol *SymbolTable::addUndefinedFunction(StringRef Name,
                                           const WasmSignature *Type) {
   Symbol *S;
   bool WasInserted;
   std::tie(S, WasInserted) = insert(Name);
   if (WasInserted) {
     S->update(Symbol::UndefinedFunctionKind);
     S->setFunctionType(Type);
   } else if (!S->isFunction()) {
     error("symbol type mismatch: " + Name);
   }
   return S;
 }
 
-Symbol *SymbolTable::addUndefined(InputFile *F, const WasmSymbol *Sym,
+Symbol *SymbolTable::addUndefined(StringRef Name, Symbol::Kind Kind,
+                                  uint32_t Flags, InputFile *F,
                                   const WasmSignature *Type) {
-  DEBUG(dbgs() << "addUndefined: " << Sym->Name << "\n");
+  DEBUG(dbgs() << "addUndefined: " << Name << "\n");
   Symbol *S;
   bool WasInserted;
-  Symbol::Kind Kind = Symbol::UndefinedFunctionKind;
-  if (Sym->Type == WasmSymbol::SymbolType::GLOBAL_IMPORT)
-    Kind = Symbol::UndefinedGlobalKind;
-  std::tie(S, WasInserted) = insert(Sym->Name);
+  std::tie(S, WasInserted) = insert(Name);
   if (WasInserted) {
-    S->update(Kind, F, Sym);
+    S->update(Kind, F, Flags);
     if (Type)
       S->setFunctionType(Type);
   } else if (S->isLazy()) {
     DEBUG(dbgs() << "resolved by existing lazy\n");
     auto *AF = cast<ArchiveFile>(S->getFile());
     AF->addMember(&S->getArchiveSymbol());
   } else if (S->isDefined()) {
     DEBUG(dbgs() << "resolved by existing\n");
-    checkSymbolTypes(*S, *F, *Sym, Type);
+    checkSymbolTypes(*S, *F, Kind, Type);
   }
   return S;
 }
 
 void SymbolTable::addLazy(ArchiveFile *F, const Archive::Symbol *Sym) {
   DEBUG(dbgs() << "addLazy: " << Sym->getName() << "\n");
   StringRef Name = Sym->getName();
   Symbol *S;

wasm/Symbols.h

 #ifndef LLD_WASM_SYMBOLS_H
 #define LLD_WASM_SYMBOLS_H
 
 #include "lld/Common/LLVM.h"
 #include "llvm/Object/Archive.h"
 #include "llvm/Object/Wasm.h"
 
 using llvm::object::Archive;
-using llvm::object::WasmSymbol;
-using llvm::wasm::WasmExport;
-using llvm::wasm::WasmImport;
 using llvm::wasm::WasmSignature;
 
 namespace lld {
 namespace wasm {
 
 class InputFile;
 class InputSegment;
 class InputFunction;
 
 class Symbol {
 public:
   enum Kind {
     DefinedFunctionKind,
     DefinedGlobalKind,
 
     LazyKind,
     UndefinedFunctionKind,
     UndefinedGlobalKind,
 
     LastDefinedKind = DefinedGlobalKind,
     InvalidKind,
   };
 
-  Symbol(StringRef Name, bool IsLocal)
-      : WrittenToSymtab(0), WrittenToNameSec(0), IsLocal(IsLocal), Name(Name) {}
+  Symbol(StringRef Name, uint32_t Flags)
+      : WrittenToSymtab(0), WrittenToNameSec(0), Flags(Flags), Name(Name) {}
 
   Kind getKind() const { return SymbolKind; }
 
   bool isLazy() const { return SymbolKind == LazyKind; }
   bool isDefined() const { return SymbolKind <= LastDefinedKind; }
   bool isUndefined() const {
     return SymbolKind == UndefinedGlobalKind ||
            SymbolKind == UndefinedFunctionKind;
   }
   bool isFunction() const {
     return SymbolKind == DefinedFunctionKind ||
            SymbolKind == UndefinedFunctionKind;
   }
   bool isGlobal() const { return !isFunction(); }
-  bool isLocal() const { return IsLocal; }
+  bool isLocal() const;
   bool isWeak() const;
   bool isHidden() const;
 
   // Returns the symbol name.
   StringRef getName() const { return Name; }
 
   // Returns the file from which this symbol was created.
   InputFile *getFile() const { return File; }
public:
   void setTableIndex(uint32_t Index);
 
   // Returns the virtual address of a defined global.
   // Only works for globals, not functions.
   uint32_t getVirtualAddress() const;
 
   void setVirtualAddress(uint32_t VA);
 
-  void update(Kind K, InputFile *F = nullptr, const WasmSymbol *Sym = nullptr,
+  void update(Kind K, InputFile *F = nullptr, uint32_t Flags = 0,
               const InputSegment *Segment = nullptr,
-              const InputFunction *Function = nullptr);
+              const InputFunction *Function = nullptr,
+              uint32_t Address = UINT32_MAX);
 
   void setArchiveSymbol(const Archive::Symbol &Sym) { ArchiveSymbol = Sym; }
   const Archive::Symbol &getArchiveSymbol() { return ArchiveSymbol; }
 
   // This bit is used by Writer::writeNameSection() to prevent
   // symbols from being written to the symbol table more than once.
   unsigned WrittenToSymtab : 1;
   unsigned WrittenToNameSec : 1;
 
 protected:
-  unsigned IsLocal : 1;
+  uint32_t Flags;
+  uint32_t VirtualAddress = 0;
 
   StringRef Name;
   Archive::Symbol ArchiveSymbol = {nullptr, 0, 0};
   Kind SymbolKind = InvalidKind;
   InputFile *File = nullptr;
-  const WasmSymbol *Sym = nullptr;
   const InputSegment *Segment = nullptr;
   const InputFunction *Function = nullptr;
   llvm::Optional<uint32_t> OutputIndex;
   llvm::Optional<uint32_t> TableIndex;
-  llvm::Optional<uint32_t> VirtualAddress;
   const WasmSignature *FunctionType = nullptr;
 };
 
 } // namespace wasm
 
 // Returns a symbol name for an error message.
 std::string toString(const wasm::Symbol &Sym);
 std::string toString(wasm::Symbol::Kind Kind);
 
 } // namespace lld
 
 #endif

wasm/Symbols.cpp

 #include "InputFunction.h"
 #include "InputSegment.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Strings.h"
 
 #define DEBUG_TYPE "lld"
 
 using namespace llvm;
+using namespace llvm::wasm;
 using namespace lld;
 using namespace lld::wasm;
 
 const WasmSignature &Symbol::getFunctionType() const {
   if (Function != nullptr)
     return Function->Signature;
 
   assert(FunctionType != nullptr);
   return *FunctionType;
 }
 
 void Symbol::setFunctionType(const WasmSignature *Type) {
   assert(FunctionType == nullptr);
   assert(Function == nullptr);
   FunctionType = Type;
 }
 
 uint32_t Symbol::getVirtualAddress() const {
   assert(isGlobal());
   DEBUG(dbgs() << "getVirtualAddress: " << getName() << "\n");
-  if (isUndefined())
-    return 0;
-  if (VirtualAddress.hasValue())
-    return VirtualAddress.getValue();
-
-  ObjFile *Obj = cast<ObjFile>(File);
-  assert(Sym != nullptr);
-  const WasmGlobal &Global =
-      Obj->getWasmObj()
-          ->globals()[Sym->ElementIndex - Obj->getNumGlobalImports()];
-  assert(Global.Type == llvm::wasm::WASM_TYPE_I32);
-  assert(Segment);
-  return Segment->translateVA(Global.InitExpr.Value.Int32);
+  return Segment ? Segment->translateVA(VirtualAddress) : VirtualAddress;
 }
 
 bool Symbol::hasOutputIndex() const {
   if (Function)
     return Function->hasOutputIndex();
   return OutputIndex.hasValue();
 }
 
 uint32_t Symbol::getOutputIndex() const {
   if (Function)
     return Function->getOutputIndex();
   return OutputIndex.getValue();
 }
 
 void Symbol::setVirtualAddress(uint32_t Value) {
   DEBUG(dbgs() << "setVirtualAddress " << Name << " -> " << Value << "\n");
-  assert(!VirtualAddress.hasValue());
+  assert(isGlobal());
   VirtualAddress = Value;
 }
 
 void Symbol::setOutputIndex(uint32_t Index) {
   DEBUG(dbgs() << "setOutputIndex " << Name << " -> " << Index << "\n");
   assert(!Function);
   assert(!OutputIndex.hasValue());
   OutputIndex = Index;
 }
 
 void Symbol::setTableIndex(uint32_t Index) {
   DEBUG(dbgs() << "setTableIndex " << Name << " -> " << Index << "\n");
   assert(!TableIndex.hasValue());
   TableIndex = Index;
 }
 
-void Symbol::update(Kind K, InputFile *F, const WasmSymbol *WasmSym,
-                    const InputSegment *Seg, const InputFunction *Func) {
+void Symbol::update(Kind K, InputFile *F, uint32_t Flags_,
+                    const InputSegment *Seg, const InputFunction *Func,
+                    uint32_t Address) {
   SymbolKind = K;
   File = F;
-  Sym = WasmSym;
+  Flags = Flags_;
   Segment = Seg;
   Function = Func;
+  if (Address != UINT32_MAX)
+    setVirtualAddress(Address);
 }
 
-bool Symbol::isWeak() const { return Sym && Sym->isWeak(); }
+bool Symbol::isWeak() const {
+  return (Flags & WASM_SYMBOL_BINDING_MASK) == WASM_SYMBOL_BINDING_WEAK;
+}
 
-bool Symbol::isHidden() const { return Sym && Sym->isHidden(); }
+bool Symbol::isLocal() const {
+  return (Flags & WASM_SYMBOL_BINDING_MASK) == WASM_SYMBOL_BINDING_LOCAL;
+}
+
+bool Symbol::isHidden() const {
+  return (Flags & WASM_SYMBOL_VISIBILITY_MASK) == WASM_SYMBOL_VISIBILITY_HIDDEN;
+}
 
 std::string lld::toString(const wasm::Symbol &Sym) {
   if (Config->Demangle)
     if (Optional<std::string> S = demangleItanium(Sym.getName()))
       return "`" + *S + "'";
   return Sym.getName();
 }