[WebAssembly] Pre-symtab tidy of LLD globals. NFC.

[ncw]

Summary

Update LLD to match commit D42750.

Must be merged simultaneously to avoid build break.

[sbc100]

wasm/WriterUtils.h

40

These are not un-used AFAICT

wasm/InputFiles.cpp

InputSegment *ObjFile::getSegment(const WasmSymbol &WasmSym) const {
   return nullptr;
 }
 
 // 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);
+  assert(Global.Type.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");
case WasmSymbol::SymbolType::GLOBAL_EXPORT: {
       }
     }
     case WasmSymbol::SymbolType::GLOBAL_IMPORT:
       S = createUndefined(WasmSym, Symbol::Kind::UndefinedGlobalKind);
       break;
     }
 
     Symbols.push_back(S);
-    if (WasmSym.isFunction()) {
+    if (WasmSym.isTypeFunction()) {
       FunctionSymbols[WasmSym.ElementIndex] = S;
       if (WasmSym.HasAltIndex)
         FunctionSymbols[WasmSym.AltIndex] = S;
     } else {
       GlobalSymbols[WasmSym.ElementIndex] = S;
       if (WasmSym.HasAltIndex)
         GlobalSymbols[WasmSym.AltIndex] = S;
     }

 Symbol *ObjFile::createUndefined(const WasmSymbol &Sym, Symbol::Kind Kind,
                                  const WasmSignature *Signature) {
   return Symtab->addUndefined(Sym.Name, Kind, Sym.Flags, this, Signature);
 }
 
 Symbol *ObjFile::createDefined(const WasmSymbol &Sym, Symbol::Kind Kind,
                                InputChunk *Chunk, uint32_t Address) {
   Symbol *S;
-  if (Sym.isLocal()) {
+  if (Sym.isBindingLocal()) {
     S = make<Symbol>(Sym.Name, true);
     S->update(Kind, this, Sym.Flags, Chunk, Address);
     return S;
   }
   return Symtab->addDefined(Sym.Name, Kind, Sym.Flags, this, Chunk, Address);
 }
 
 void ArchiveFile::parse() {

wasm/Writer.cpp

if (DefinedGlobals.empty())
     return;
 
   SyntheticSection *Section = createSyntheticSection(WASM_SEC_GLOBAL);
   raw_ostream &OS = Section->getStream();
 
   writeUleb128(OS, DefinedGlobals.size(), "global count");
   for (const Symbol *Sym : DefinedGlobals) {
     WasmGlobal Global;
-    Global.Type = WASM_TYPE_I32;
-    Global.Mutable = Sym == Config->StackPointerSymbol;
+    Global.Type.Type = WASM_TYPE_I32;
+    Global.Type.Mutable = Sym == Config->StackPointerSymbol;
     Global.InitExpr.Opcode = WASM_OPCODE_I32_CONST;
     Global.InitExpr.Value.Int32 = Sym->getVirtualAddress();
     writeGlobal(OS, Global);
   }
 }
 
 void Writer::createTableSection() {
   // Always output a table section, even if there are no indirect calls.

wasm/WriterUtils.h

inline bool operator==(const llvm::wasm::WasmSignature &LHS,
   return LHS.ReturnType == RHS.ReturnType && LHS.ParamTypes == RHS.ParamTypes;
 }
 
 inline bool operator!=(const llvm::wasm::WasmSignature &LHS,
                        const llvm::wasm::WasmSignature &RHS) {
   return !(LHS == RHS);
 }
 
+// Used for general comparison
+inline bool operator==(const llvm::wasm::WasmGlobalType &LHS,
+                       const llvm::wasm::WasmGlobalType &RHS) {
+  return LHS.Type == RHS.Type && LHS.Mutable == RHS.Mutable;
+}
+
+inline bool operator!=(const llvm::wasm::WasmGlobalType &LHS,
+                       const llvm::wasm::WasmGlobalType &RHS) {
+  return !(LHS == RHS);
+}
+
 namespace lld {
 namespace wasm {
 
 struct OutputRelocation {
   llvm::wasm::WasmRelocation Reloc;
   uint32_t NewIndex;
   uint32_t Value;
 };

 void writeValueType(raw_ostream &OS, int32_t Type, const char *msg);
 
 void writeSig(raw_ostream &OS, const llvm::wasm::WasmSignature &Sig);
 
 void writeInitExpr(raw_ostream &OS, const llvm::wasm::WasmInitExpr &InitExpr);
 
 void writeLimits(raw_ostream &OS, const llvm::wasm::WasmLimits &Limits);
 
+void writeGlobalType(raw_ostream &OS, const llvm::wasm::WasmGlobalType &Type);
+
 void writeGlobal(raw_ostream &OS, const llvm::wasm::WasmGlobal &Global);
 
 void writeImport(raw_ostream &OS, const llvm::wasm::WasmImport &Import);
 
 void writeExport(raw_ostream &OS, const llvm::wasm::WasmExport &Export);
 
 void writeReloc(raw_ostream &OS, const OutputRelocation &Reloc);
 
 } // namespace wasm
 
 std::string toString(const llvm::wasm::ValType Type);
 std::string toString(const llvm::wasm::WasmSignature &Sig);
 
 } // namespace lld
 
 #endif // LLD_WASM_WRITERUTILS_H

wasm/WriterUtils.cpp

 
 void wasm::writeLimits(raw_ostream &OS, const WasmLimits &Limits) {
   writeUleb128(OS, Limits.Flags, "limits flags");
   writeUleb128(OS, Limits.Initial, "limits initial");
   if (Limits.Flags & WASM_LIMITS_FLAG_HAS_MAX)
     writeUleb128(OS, Limits.Maximum, "limits max");
 }
 
+void wasm::writeGlobalType(raw_ostream &OS, const WasmGlobalType &Type) {
+  writeValueType(OS, Type.Type, "global type");
+  writeUleb128(OS, Type.Mutable, "global mutable");
+}
+
 void wasm::writeGlobal(raw_ostream &OS, const WasmGlobal &Global) {
-  writeValueType(OS, Global.Type, "global type");
-  writeUleb128(OS, Global.Mutable, "global mutable");
+  writeGlobalType(OS, Global.Type);
   writeInitExpr(OS, Global.InitExpr);
 }
 
 void wasm::writeImport(raw_ostream &OS, const WasmImport &Import) {
   writeStr(OS, Import.Module, "import module name");
   writeStr(OS, Import.Field, "import field name");
   writeU8(OS, Import.Kind, "import kind");
   switch (Import.Kind) {
   case WASM_EXTERNAL_FUNCTION:
     writeUleb128(OS, Import.SigIndex, "import sig index");
     break;
   case WASM_EXTERNAL_GLOBAL:
-    writeValueType(OS, Import.Global.Type, "import global type");
-    writeUleb128(OS, Import.Global.Mutable, "import global mutable");
+    writeGlobalType(OS, Import.Global);
     break;
   case WASM_EXTERNAL_MEMORY:
     writeLimits(OS, Import.Memory);
     break;
   default:
     fatal("unsupported import type: " + Twine(Import.Kind));
   }
 }