[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

 
 struct OutputRelocation {
   llvm::wasm::WasmRelocation Reloc;
   uint32_t NewIndex;
   uint32_t Value;
 };
 
 void debugWrite(uint64_t offset, llvm::Twine msg);
 
 void writeUleb128(raw_ostream &OS, uint32_t Number, const char *msg);
 
 void writeSleb128(raw_ostream &OS, int32_t Number, const char *msg);
 
 void writeBytes(raw_ostream &OS, const char *bytes, size_t count,
                 const char *msg = nullptr);
 
 void writeStr(raw_ostream &OS, const llvm::StringRef String,
               const char *msg = nullptr);
 
 void writeU8(raw_ostream &OS, uint8_t byte, const char *msg);
 
 void writeU32(raw_ostream &OS, uint32_t Number, const char *msg);
 
 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));
   }
 }