[WebAssembly] Simplify FunctionSymbol get/set/hasFunctionType. NFC.

[sbc100]

Summary

Followup from: https://reviews.llvm.org/D43399

[sbc100]

• rename

[ruiu]

LGTM

wasm/Symbols.h

124–126

If you do not = nullptr, please remove it as well.

[sbc100]

• rename
• remove_default

[sbc100]

wasm/Symbols.h

124–126

Ha.. already did that but hadn't uploaded it yet. Great minds ..

[ncw]

Thanks for splitting this one out two, reduces the diff on my patch nicely! With this time delay, you can get onto these changes 24h ahead - which I don't mind, but I will get round to it for work that I've generated if you leave it a day (or two...)

wasm/InputFiles.h

public:
   }
 
 private:
   uint32_t relocateVirtualAddress(uint32_t Index) const;
   uint32_t relocateTypeIndex(uint32_t Original) const;
   uint32_t relocateGlobalIndex(uint32_t Original) const;
   uint32_t relocateTableIndex(uint32_t Original) const;
 
-  Symbol *createDefinedGlobal(const WasmSymbol &Sym, InputChunk *Chunk,
+  Symbol *createDefinedGlobal(const WasmSymbol &Sym, InputSegment *Chunk,
                               uint32_t Address);
-  Symbol *createDefinedFunction(const WasmSymbol &Sym, InputChunk *Chunk);
+  Symbol *createDefinedFunction(const WasmSymbol &Sym, InputFunction *Chunk);
   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;
   bool isExcludedByComdat(InputChunk *Chunk) const;

wasm/InputFiles.cpp

 }
 
 Symbol *ObjFile::createUndefined(const WasmSymbol &Sym, Symbol::Kind Kind,
                                  const WasmSignature *Signature) {
   return Symtab->addUndefined(Sym.Name, Kind, Sym.Flags, this, Signature);
 }
 
 Symbol *ObjFile::createDefinedFunction(const WasmSymbol &Sym,
-                                       InputChunk *Chunk) {
+                                       InputFunction *Function) {
   if (Sym.isBindingLocal())
-    return make<DefinedFunction>(Sym.Name, Sym.Flags, this, Chunk);
-  return Symtab->addDefined(true, Sym.Name, Sym.Flags, this, Chunk);
+    return make<DefinedFunction>(Sym.Name, Sym.Flags, this, Function);
+  return Symtab->addDefined(true, Sym.Name, Sym.Flags, this, Function);
 }
 
-Symbol *ObjFile::createDefinedGlobal(const WasmSymbol &Sym, InputChunk *Chunk,
-                                     uint32_t Address) {
+Symbol *ObjFile::createDefinedGlobal(const WasmSymbol &Sym,
+                                     InputSegment *Segment, uint32_t Address) {
   if (Sym.isBindingLocal())
-    return make<DefinedGlobal>(Sym.Name, Sym.Flags, this, Chunk, Address);
-  return Symtab->addDefined(false, Sym.Name, Sym.Flags, this, Chunk, Address);
+    return make<DefinedGlobal>(Sym.Name, Sym.Flags, this, Segment, Address);
+  return Symtab->addDefined(false, Sym.Name, Sym.Flags, this, Segment, 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.cpp

if (Existing.isFunction() != NewIsFunction) {
     return;
   }
 
   // For function symbols, optionally check the function signature matches too.
   auto *ExistingFunc = dyn_cast<FunctionSymbol>(&Existing);
   if (!ExistingFunc || !Config->CheckSignatures)
     return;
 
+  const WasmSignature *OldSig = ExistingFunc->getFunctionType();
+
   // 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 (!ExistingFunc->hasFunctionType())
+  if (OldSig == nullptr)
     return;
 
   DEBUG(dbgs() << "checkSymbolTypes: " << ExistingFunc->getName() << "\n");
   assert(NewSig);
 
-  const WasmSignature &OldSig = ExistingFunc->getFunctionType();
-  if (*NewSig == OldSig)
+  if (*NewSig == *OldSig)
     return;
 
   error("function signature mismatch: " + ExistingFunc->getName() +
-        "\n>>> defined as " + toString(OldSig) + " in " +
+        "\n>>> defined as " + toString(*OldSig) + " in " +
         toString(ExistingFunc->getFile()) + "\n>>> defined as " +
         toString(*NewSig) + " in " + F.getName());
 }
 
 static void checkSymbolTypes(const Symbol &Existing, const InputFile &F,
                              bool IsFunction, const InputChunk *Chunk) {
   const WasmSignature *Sig = nullptr;
   if (auto *F = dyn_cast_or_null<InputFunction>(Chunk))
if (WasInserted) {
     // neither symbol is week. They conflict.
     reportDuplicate(S, F);
   }
 
   if (Replace) {
     if (CheckTypes)
       checkSymbolTypes(*S, *F, IsFunction, Chunk);
     if (IsFunction)
-      replaceSymbol<DefinedFunction>(S, Name, Flags, F, Chunk);
+      replaceSymbol<DefinedFunction>(S, Name, Flags, F,
+                                     cast<InputFunction>(Chunk));
     else
-      replaceSymbol<DefinedGlobal>(S, Name, Flags, F, Chunk, Address);
+      replaceSymbol<DefinedGlobal>(S, Name, Flags, F, cast<InputSegment>(Chunk),
+                                   Address);
   }
   return S;
 }
 
 Symbol *SymbolTable::addUndefined(StringRef Name, Symbol::Kind Kind,
                                   uint32_t Flags, InputFile *F,
                                   const WasmSignature *Type) {
   DEBUG(dbgs() << "addUndefined: " << Name << "\n");

wasm/Symbols.h

 using llvm::object::Archive;
 using llvm::wasm::WasmSignature;
 
 namespace lld {
 namespace wasm {
 
 class InputFile;
 class InputChunk;
+class InputFunction;
 
 #define INVALID_INDEX UINT32_MAX
 
 // The base class for real symbol classes.
 class Symbol {
 public:
   enum Kind {
     DefinedFunctionKind,

 
 class FunctionSymbol : public Symbol {
 public:
   static bool classof(const Symbol *S) {
     return S->kind() == DefinedFunctionKind ||
            S->kind() == UndefinedFunctionKind;
   }
 
-  bool hasFunctionType() const { return Chunk || FunctionType; }
-  const WasmSignature &getFunctionType() const;
+  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:
-  void setFunctionType(const WasmSignature *Type);
+  FunctionSymbol(StringRef Name, Kind K, uint32_t Flags, InputFile *F,
+                 InputFunction *Function);
 
   FunctionSymbol(StringRef Name, Kind K, uint32_t Flags, InputFile *F,
-                 InputChunk *C)
-      : Symbol(Name, K, Flags, F, C) {}
+                 const WasmSignature* Type)
+      : Symbol(Name, K, Flags, F, nullptr), FunctionType(Type) {}
 
   uint32_t TableIndex = INVALID_INDEX;
 
   // Explict function type, needed for undefined or synthetic functions only.
   const WasmSignature *FunctionType = nullptr;
 };
 
 class DefinedFunction : public FunctionSymbol {
 public:
   DefinedFunction(StringRef Name, uint32_t Flags, InputFile *F = nullptr,
-                  InputChunk *C = nullptr)
-      : FunctionSymbol(Name, DefinedFunctionKind, Flags, F, C) {}
+                  InputFunction *Function = nullptr)
+      : FunctionSymbol(Name, DefinedFunctionKind, Flags, F, Function) {}
 
   DefinedFunction(StringRef Name, uint32_t Flags, const WasmSignature *Type)
-      : FunctionSymbol(Name, DefinedFunctionKind, Flags, nullptr, nullptr) {
-    setFunctionType(Type);
-  }
+      : FunctionSymbol(Name, DefinedFunctionKind, Flags, nullptr, Type) {}
 
   static bool classof(const Symbol *S) {
     return S->kind() == DefinedFunctionKind;
   }
 };
 
 class UndefinedFunction : public FunctionSymbol {
 public:
   UndefinedFunction(StringRef Name, uint32_t Flags, InputFile *File = nullptr,
                     const WasmSignature *Type = nullptr)
-      : FunctionSymbol(Name, UndefinedFunctionKind, Flags, File, nullptr) {
-    setFunctionType(Type);
-  }
+      : FunctionSymbol(Name, UndefinedFunctionKind, Flags, File, Type) {}
 
   static bool classof(const Symbol *S) {
     return S->kind() == UndefinedFunctionKind;
   }
 };
 
 class GlobalSymbol : public Symbol {
 public:

wasm/Symbols.cpp

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;
 }
 
-const WasmSignature &FunctionSymbol::getFunctionType() const {
-  if (auto *F = dyn_cast_or_null<InputFunction>(Chunk))
-    return F->Signature;
-
-  assert(FunctionType != nullptr);
-  return *FunctionType;
-}
-
-void FunctionSymbol::setFunctionType(const WasmSignature *Type) {
-  assert(FunctionType == nullptr);
-  assert(!Chunk);
-  FunctionType = Type;
-}
+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();
   assert(TableIndex != INVALID_INDEX);
   return TableIndex;
 }
 

wasm/Writer.cpp

void Writer::createImportSection() {
 
   writeUleb128(OS, NumImports, "import count");
 
   for (const FunctionSymbol *Sym : ImportedFunctions) {
     WasmImport Import;
     Import.Module = "env";
     Import.Field = Sym->getName();
     Import.Kind = WASM_EXTERNAL_FUNCTION;
-    Import.SigIndex = lookupType(Sym->getFunctionType());
+    Import.SigIndex = lookupType(*Sym->getFunctionType());
     writeImport(OS, Import);
   }
 
   if (Config->ImportMemory) {
     WasmImport Import;
     Import.Module = "env";
     Import.Field = "memory";
     Import.Kind = WASM_EXTERNAL_MEMORY;
void Writer::calculateTypes() {
   for (ObjFile *File : Symtab->ObjectFiles) {
     ArrayRef<WasmSignature> Types = File->getWasmObj()->types();
     for (uint32_t I = 0; I < Types.size(); I++)
       if (File->TypeIsUsed[I])
         File->TypeMap[I] = registerType(Types[I]);
   }
 
   for (const FunctionSymbol *Sym : ImportedFunctions)
-    registerType(Sym->getFunctionType());
+    registerType(*Sym->getFunctionType());
 
   for (const InputFunction *F : DefinedFunctions)
     registerType(F->Signature);
 }
 
 void Writer::assignIndexes() {
   uint32_t GlobalIndex = ImportedGlobals.size() + DefinedGlobals.size();
   uint32_t FunctionIndex = ImportedFunctions.size() + DefinedFunctions.size();