Index: wasm/Driver.cpp
===================================================================
--- wasm/Driver.cpp
+++ wasm/Driver.cpp
@@ -305,8 +305,8 @@
 
     // It is possible for undefined functions not to have a signature (eg. if
     // added via "--undefined"), but weak undefined ones do have a signature.
-    assert(FuncSym->FunctionType);
-    const WasmSignature &Sig = *FuncSym->FunctionType;
+    assert(FuncSym->Signature);
+    const WasmSignature &Sig = *FuncSym->Signature;
 
     // Add a synthetic dummy for weak undefined functions.  These dummies will
     // be GC'd if not used as the target of any "call" instructions.
Index: wasm/InputFiles.cpp
===================================================================
--- wasm/InputFiles.cpp
+++ wasm/InputFiles.cpp
@@ -357,7 +357,7 @@
 
   switch (Sym.Info.Kind) {
   case WASM_SYMBOL_TYPE_FUNCTION:
-    return Symtab->addUndefinedFunction(Name, Flags, this, Sym.FunctionType);
+    return Symtab->addUndefinedFunction(Name, Flags, this, Sym.Signature);
   case WASM_SYMBOL_TYPE_DATA:
     return Symtab->addUndefinedData(Name, Flags, this);
   case WASM_SYMBOL_TYPE_GLOBAL:
Index: wasm/LTO.cpp
===================================================================
--- wasm/LTO.cpp
+++ wasm/LTO.cpp
@@ -80,7 +80,7 @@
 static void undefine(Symbol *S) {
   if (auto F = dyn_cast<DefinedFunction>(S))
     replaceSymbol<UndefinedFunction>(F, F->getName(), 0, F->getFile(),
-                                     F->FunctionType);
+                                     F->Signature);
   else if (isa<DefinedData>(S))
     replaceSymbol<UndefinedData>(S, S->getName(), 0, S->getFile());
   else
Index: wasm/SymbolTable.cpp
===================================================================
--- wasm/SymbolTable.cpp
+++ wasm/SymbolTable.cpp
@@ -110,9 +110,9 @@
   if (!NewSig)
     return;
 
-  const WasmSignature *OldSig = ExistingFunction->FunctionType;
+  const WasmSignature *OldSig = ExistingFunction->Signature;
   if (!OldSig) {
-    ExistingFunction->FunctionType = NewSig;
+    ExistingFunction->Signature = NewSig;
     return;
   }
 
@@ -221,10 +221,10 @@
     // functions) but the old symbols does then preserve the old signature
     const WasmSignature *OldSig = nullptr;
     if (auto* F = dyn_cast<FunctionSymbol>(S))
-      OldSig = F->FunctionType;
+      OldSig = F->Signature;
     auto NewSym = replaceSymbol<DefinedFunction>(S, Name, Flags, File, Function);
-    if (!NewSym->FunctionType)
-      NewSym->FunctionType = OldSig;
+    if (!NewSym->Signature)
+      NewSym->Signature = OldSig;
   }
   return S;
 }
Index: wasm/Symbols.h
===================================================================
--- wasm/Symbols.h
+++ wasm/Symbols.h
@@ -94,10 +94,14 @@
   unsigned IsUsedInRegularObj : 1;
   unsigned ForceExport : 1;
 
+  const WasmSignature *Signature;
+
 protected:
-  Symbol(StringRef Name, Kind K, uint32_t Flags, InputFile *F)
-      : IsUsedInRegularObj(false), ForceExport(false), Name(Name),
-        SymbolKind(K), Flags(Flags), File(F), Referenced(!Config->GcSections) {}
+  Symbol(StringRef Name, Kind K, uint32_t Flags, InputFile *F,
+         const WasmSignature *Sig = nullptr)
+      : IsUsedInRegularObj(false), ForceExport(false), Signature(Sig),
+        Name(Name), SymbolKind(K), Flags(Flags), File(F),
+        Referenced(!Config->GcSections) {}
 
   StringRef Name;
   Kind SymbolKind;
@@ -124,12 +128,10 @@
   void setFunctionIndex(uint32_t Index);
   bool hasFunctionIndex() const;
 
-  const WasmSignature *FunctionType;
-
 protected:
   FunctionSymbol(StringRef Name, Kind K, uint32_t Flags, InputFile *F,
-                 const WasmSignature *Type)
-      : Symbol(Name, K, Flags, F), FunctionType(Type) {}
+                 const WasmSignature *Sig)
+      : Symbol(Name, K, Flags, F, Sig) {}
 
   uint32_t TableIndex = INVALID_INDEX;
   uint32_t FunctionIndex = INVALID_INDEX;
@@ -150,8 +152,8 @@
 class UndefinedFunction : public FunctionSymbol {
 public:
   UndefinedFunction(StringRef Name, uint32_t Flags, InputFile *File = nullptr,
-                    const WasmSignature *Type = nullptr)
-      : FunctionSymbol(Name, UndefinedFunctionKind, Flags, File, Type) {}
+                    const WasmSignature *Sig = nullptr)
+      : FunctionSymbol(Name, UndefinedFunctionKind, Flags, File, Sig) {}
 
   static bool classof(const Symbol *S) {
     return S->kind() == UndefinedFunctionKind;
Index: wasm/Writer.cpp
===================================================================
--- wasm/Writer.cpp
+++ wasm/Writer.cpp
@@ -182,7 +182,7 @@
     Import.Field = Sym->getName();
     if (auto *FunctionSym = dyn_cast<FunctionSymbol>(Sym)) {
       Import.Kind = WASM_EXTERNAL_FUNCTION;
-      Import.SigIndex = lookupType(*FunctionSym->FunctionType);
+      Import.SigIndex = lookupType(*FunctionSym->Signature);
     } else {
       auto *GlobalSym = cast<GlobalSymbol>(Sym);
       Import.Kind = WASM_EXTERNAL_GLOBAL;
@@ -884,7 +884,7 @@
 
   for (const Symbol *Sym : ImportedSymbols)
     if (auto *F = dyn_cast<FunctionSymbol>(Sym))
-      registerType(*F->FunctionType);
+      registerType(*F->Signature);
 
   for (const InputFunction *F : InputFunctions)
     registerType(F->Signature);
@@ -1035,7 +1035,7 @@
     const WasmLinkingData &L = File->getWasmObj()->linkingData();
     for (const WasmInitFunc &F : L.InitFunctions) {
       FunctionSymbol *Sym = File->getFunctionSymbol(F.Symbol);
-      if (*Sym->FunctionType != WasmSignature{{}, {}})
+      if (*Sym->Signature != WasmSignature{{}, {}})
         error("invalid signature for init func: " + toString(*Sym));
       InitFunctions.emplace_back(WasmInitEntry{Sym, F.Priority});
     }