[WebAssembly] Remove InputChunk from Symbol baseclass. NFC.

[sbc100]

Summary

Instead include InputFuction and InputSegment directly
in the subclasses that use them (DefinedFunction and
DefinedGlobal).

[ruiu]

wasm/Symbols.cpp

33 ↗

(On Diff #134990)

Newline before return.

39 ↗

(On Diff #134990)

Ditto

wasm/Symbols.h

106 ↗

(On Diff #134990)

I think Type is always given.

wasm/Writer.cpp

665 ↗

(On Diff #134990)

I would recommend removing Symbol::isLive and use getChunk() and isLive() directly instead. It is because the notion of dead/alive is about chunks (or sections), and symbols are not directly considered as dead/alive. You could think that symbols are dead if they point to dead sections, and that makes some sense, but I think that not adding isLive() to Symbol makes things easier to understand.

[sbc100]

• feedback

wasm/Writer.cpp

665 ↗

(On Diff #134990)

OK. reverting for now.

I was looking at how COFF and ELF does. COFF has an isLive() method on the Symbol which works like this one, and ELF has Used bit on the symbol which seems to mean Live where its used.

We might want to unify these going forward, but keeping this change small.

[ruiu]

LGTM

wasm/Symbols.h

125 ↗

(On Diff #135080)

Style error

[sbc100]

• feedback
• clang-format

lld/trunk/wasm/Symbols.h

 using llvm::object::Archive;
 using llvm::wasm::WasmSignature;
 
 namespace lld {
 namespace wasm {
 
 class InputFile;
 class InputChunk;
+class InputSegment;
 class InputFunction;
 
 #define INVALID_INDEX UINT32_MAX
 
 // The base class for real symbol classes.
 class Symbol {
 public:
   enum Kind {
public:
   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; }
-  InputChunk *getChunk() const { return Chunk; }
+  InputChunk *getChunk() const;
 
   void setHidden(bool IsHidden);
 
   uint32_t getOutputIndex() const;
 
   // Returns true if an output index has been set for this symbol
   bool hasOutputIndex() const;
 
   // Set the output index of the symbol (in the function or global index
   // space of the output object.
   void setOutputIndex(uint32_t Index);
 
 protected:
-  Symbol(StringRef Name, Kind K, uint32_t Flags, InputFile *F, InputChunk *C)
-      : Name(Name), SymbolKind(K), Flags(Flags), File(F), Chunk(C) {}
+  Symbol(StringRef Name, Kind K, uint32_t Flags, InputFile *F)
+      : Name(Name), SymbolKind(K), Flags(Flags), File(F) {}
 
   StringRef Name;
   Kind SymbolKind;
   uint32_t Flags;
   InputFile *File;
-  InputChunk *Chunk;
   uint32_t OutputIndex = INVALID_INDEX;
 };
 
 class FunctionSymbol : public Symbol {
 public:
   static bool classof(const Symbol *S) {
     return S->kind() == DefinedFunctionKind ||
            S->kind() == UndefinedFunctionKind;
   }
 
   const WasmSignature *getFunctionType() const { return FunctionType; }
 
   uint32_t getTableIndex() const;
 
   // Returns true if a table index has been set for this symbol
   bool hasTableIndex() const;
 
   // Set the table index of the symbol
   void setTableIndex(uint32_t Index);
 
 protected:
   FunctionSymbol(StringRef Name, Kind K, uint32_t Flags, InputFile *F,
-                 InputFunction *Function);
-
-  FunctionSymbol(StringRef Name, Kind K, uint32_t Flags, InputFile *F,
-                 const WasmSignature* Type)
-      : Symbol(Name, K, Flags, F, nullptr), FunctionType(Type) {}
+                 const WasmSignature *Type)
+      : Symbol(Name, K, Flags, F), FunctionType(Type) {}
 
   uint32_t TableIndex = INVALID_INDEX;
 
   const WasmSignature *FunctionType;
 };
 
 class DefinedFunction : public FunctionSymbol {
 public:
   DefinedFunction(StringRef Name, uint32_t Flags, InputFile *F,
-                  InputFunction *Function)
-      : FunctionSymbol(Name, DefinedFunctionKind, Flags, F, Function) {}
+                  InputFunction *Function);
 
   DefinedFunction(StringRef Name, uint32_t Flags, const WasmSignature *Type)
       : FunctionSymbol(Name, DefinedFunctionKind, Flags, nullptr, Type) {}
 
   static bool classof(const Symbol *S) {
     return S->kind() == DefinedFunctionKind;
   }
+
+  InputFunction *Function;
 };
 
 class UndefinedFunction : public FunctionSymbol {
 public:
   UndefinedFunction(StringRef Name, uint32_t Flags, InputFile *File = nullptr,
                     const WasmSignature *Type = nullptr)
       : FunctionSymbol(Name, UndefinedFunctionKind, Flags, File, Type) {}
 
   static bool classof(const Symbol *S) {
     return S->kind() == UndefinedFunctionKind;
   }
 };
 
 class GlobalSymbol : public Symbol {
 public:
   static bool classof(const Symbol *S) {
     return S->kind() == DefinedGlobalKind || S->kind() == UndefinedGlobalKind;
   }
 
 protected:
-  GlobalSymbol(StringRef Name, Kind K, uint32_t Flags, InputFile *F,
-               InputChunk *C)
-      : Symbol(Name, K, Flags, F, C) {}
+  GlobalSymbol(StringRef Name, Kind K, uint32_t Flags, InputFile *F)
+      : Symbol(Name, K, Flags, F) {}
 };
 
 class DefinedGlobal : public GlobalSymbol {
 public:
   DefinedGlobal(StringRef Name, uint32_t Flags, InputFile *F = nullptr,
-                InputChunk *C = nullptr, uint32_t Address = 0)
-      : GlobalSymbol(Name, DefinedGlobalKind, Flags, F, C),
+                InputSegment *Segment = nullptr, uint32_t Address = 0)
+      : GlobalSymbol(Name, DefinedGlobalKind, Flags, F), Segment(Segment),
         VirtualAddress(Address) {}
 
   static bool classof(const Symbol *S) {
     return S->kind() == DefinedGlobalKind;
   }
 
   uint32_t getVirtualAddress() const;
-
   void setVirtualAddress(uint32_t VA);
 
+  InputSegment *Segment;
+
 protected:
   uint32_t VirtualAddress;
 };
 
 class UndefinedGlobal : public GlobalSymbol {
 public:
   UndefinedGlobal(StringRef Name, uint32_t Flags, InputFile *File = nullptr)
-      : GlobalSymbol(Name, UndefinedGlobalKind, Flags, File, nullptr) {}
+      : GlobalSymbol(Name, UndefinedGlobalKind, Flags, File) {}
   static bool classof(const Symbol *S) {
     return S->kind() == UndefinedGlobalKind;
   }
 };
 
 class LazySymbol : public Symbol {
 public:
   LazySymbol(StringRef Name, InputFile *File, const Archive::Symbol &Sym)
-      : Symbol(Name, LazyKind, 0, File, nullptr), ArchiveSymbol(Sym) {}
+      : Symbol(Name, LazyKind, 0, File), ArchiveSymbol(Sym) {}
 
   static bool classof(const Symbol *S) { return S->kind() == LazyKind; }
 
   const Archive::Symbol &getArchiveSymbol() { return ArchiveSymbol; }
 
 protected:
   Archive::Symbol ArchiveSymbol;
 };

lld/trunk/wasm/Symbols.cpp

 
 DefinedFunction *WasmSym::CallCtors;
 DefinedGlobal *WasmSym::DsoHandle;
 DefinedGlobal *WasmSym::DataEnd;
 DefinedGlobal *WasmSym::HeapBase;
 DefinedGlobal *WasmSym::StackPointer;
 
 bool Symbol::hasOutputIndex() const {
-  if (auto *F = dyn_cast_or_null<InputFunction>(Chunk))
-    return F->hasOutputIndex();
+  if (auto *F = dyn_cast<DefinedFunction>(this))
+    if (F->Function)
+      return F->Function->hasOutputIndex();
   return OutputIndex != INVALID_INDEX;
 }
 
 uint32_t Symbol::getOutputIndex() const {
-  if (auto *F = dyn_cast_or_null<InputFunction>(Chunk))
-    return F->getOutputIndex();
+  if (auto *F = dyn_cast<DefinedFunction>(this))
+    if (F->Function)
+      return F->Function->getOutputIndex();
   assert(OutputIndex != INVALID_INDEX);
   return OutputIndex;
 }
 
+InputChunk *Symbol::getChunk() const {
+  if (auto *F = dyn_cast<DefinedFunction>(this))
+    return F->Function;
+  if (auto *G = dyn_cast<DefinedGlobal>(this))
+    return G->Segment;
+  return nullptr;
+}
+
 void Symbol::setOutputIndex(uint32_t Index) {
   DEBUG(dbgs() << "setOutputIndex " << Name << " -> " << Index << "\n");
-  assert(!dyn_cast_or_null<InputFunction>(Chunk));
   assert(OutputIndex == INVALID_INDEX);
   OutputIndex = Index;
 }
 
 bool Symbol::isWeak() const {
   return (Flags & WASM_SYMBOL_BINDING_MASK) == WASM_SYMBOL_BINDING_WEAK;
 }
 
void Symbol::setHidden(bool IsHidden) {
   DEBUG(dbgs() << "setHidden: " << Name << " -> " << IsHidden << "\n");
   Flags &= ~WASM_SYMBOL_VISIBILITY_MASK;
   if (IsHidden)
     Flags |= WASM_SYMBOL_VISIBILITY_HIDDEN;
   else
     Flags |= WASM_SYMBOL_VISIBILITY_DEFAULT;
 }
 
-FunctionSymbol::FunctionSymbol(StringRef Name, Kind K, uint32_t Flags,
-                               InputFile *F, InputFunction *Function)
-    : Symbol(Name, K, Flags, F, Function), FunctionType(&Function->Signature) {}
-
 uint32_t FunctionSymbol::getTableIndex() const {
-  if (auto *F = dyn_cast_or_null<InputFunction>(Chunk))
-    return F->getTableIndex();
+  if (auto *F = dyn_cast<DefinedFunction>(this))
+    return F->Function->getTableIndex();
   assert(TableIndex != INVALID_INDEX);
   return TableIndex;
 }
 
 bool FunctionSymbol::hasTableIndex() const {
-  if (auto *F = dyn_cast_or_null<InputFunction>(Chunk))
-    return F->hasTableIndex();
+  if (auto *F = dyn_cast<DefinedFunction>(this))
+    return F->Function->hasTableIndex();
   return TableIndex != INVALID_INDEX;
 }
 
 void FunctionSymbol::setTableIndex(uint32_t Index) {
   // For imports, we set the table index here on the Symbol; for defined
   // functions we set the index on the InputFunction so that we don't export
   // the same thing twice (keeps the table size down).
-  if (auto *F = dyn_cast_or_null<InputFunction>(Chunk)) {
-    F->setTableIndex(Index);
+  if (auto *F = dyn_cast<DefinedFunction>(this)) {
+    F->Function->setTableIndex(Index);
     return;
   }
   DEBUG(dbgs() << "setTableIndex " << Name << " -> " << Index << "\n");
   assert(TableIndex == INVALID_INDEX);
   TableIndex = Index;
 }
 
+DefinedFunction::DefinedFunction(StringRef Name, uint32_t Flags, InputFile *F,
+                                 InputFunction *Function)
+    : FunctionSymbol(Name, DefinedFunctionKind, Flags, F,
+                     Function ? &Function->Signature : nullptr),
+      Function(Function) {}
+
 uint32_t DefinedGlobal::getVirtualAddress() const {
   DEBUG(dbgs() << "getVirtualAddress: " << getName() << "\n");
-  return Chunk ? dyn_cast<InputSegment>(Chunk)->translateVA(VirtualAddress)
-               : VirtualAddress;
+  return Segment ? Segment->translateVA(VirtualAddress) : VirtualAddress;
 }
 
 void DefinedGlobal::setVirtualAddress(uint32_t Value) {
   DEBUG(dbgs() << "setVirtualAddress " << Name << " -> " << Value << "\n");
   VirtualAddress = Value;
 }
 
 std::string lld::toString(const wasm::Symbol &Sym) {