[WebAssembly] Rename GlobalSymbol types. NFC.

Purely a rename in preparation for adding new global symbol type.

We want to use GlobalSymbol to represent real wasm globals and
DataSymbol for pointers to things in linear memory (what ELF would
call STT_OBJECT).

This reduces the size the patch to add the explicit symbol table
which is coming soon!

Differential Revision: https://reviews.llvm.org/D43476

llvm-svn: 325645

diff --git a/lld/test/wasm/symbol-type-mismatch.ll b/lld/test/wasm/symbol-type-mismatch.ll
index 62380a2c000cf8db047dba49227a66cd5fbbf8b9..16e0f4dc8d5b9e3e03684a6fd0158851b99743f5 100644 (file)
--- a/lld/test/wasm/symbol-type-mismatch.ll
+++ b/lld/test/wasm/symbol-type-mismatch.ll
@@ -7,5 +7,5 @@ target triple = "wasm32-unknown-unknown-wasm"
 @ret32 = extern_weak global i32, align 4
 
 ; CHECK: error: symbol type mismatch: ret32
-; CHECK: >>> defined as Global in {{.*}}symbol-type-mismatch.ll.tmp.o
+; CHECK: >>> defined as Data in {{.*}}symbol-type-mismatch.ll.tmp.o
 ; CHECK: >>> defined as Function in {{.*}}.ret32.o

diff --git a/lld/wasm/Driver.cpp b/lld/wasm/Driver.cpp
index 487e56755cd94d3a31238323d83c5dab77e0ee07..93985c3a05be1f4145220dd34e16b9f543f23ee4 100644 (file)
--- a/lld/wasm/Driver.cpp
+++ b/lld/wasm/Driver.cpp
@@ -301,10 +301,10 @@ void LinkerDriver::link(ArrayRef<const char *> ArgsArr) {
     // Add synthetic symbols before any others
     WasmSym::CallCtors = Symtab->addSyntheticFunction(
         "__wasm_call_ctors", &NullSignature, WASM_SYMBOL_VISIBILITY_HIDDEN);
-    WasmSym::StackPointer = Symtab->addSyntheticGlobal("__stack_pointer");
-    WasmSym::HeapBase = Symtab->addSyntheticGlobal("__heap_base");
-    WasmSym::DsoHandle = Symtab->addSyntheticGlobal("__dso_handle");
-    WasmSym::DataEnd = Symtab->addSyntheticGlobal("__data_end");
+    WasmSym::StackPointer = Symtab->addSyntheticDataSymbol("__stack_pointer");
+    WasmSym::HeapBase = Symtab->addSyntheticDataSymbol("__heap_base");
+    WasmSym::DsoHandle = Symtab->addSyntheticDataSymbol("__dso_handle");
+    WasmSym::DataEnd = Symtab->addSyntheticDataSymbol("__data_end");
 
     if (!Config->Entry.empty())
       EntrySym = addUndefinedFunction(Config->Entry, &NullSignature);

diff --git a/lld/wasm/InputFiles.cpp b/lld/wasm/InputFiles.cpp
index be806c50ef3bec25afa4c0abaafe5055ab475608..655246776712e601da61731e2e9ab9ebda4b16fc 100644 (file)
--- a/lld/wasm/InputFiles.cpp
+++ b/lld/wasm/InputFiles.cpp
@@ -44,13 +44,13 @@ Optional<MemoryBufferRef> lld::wasm::readFile(StringRef Path) {
 void ObjFile::dumpInfo() const {
   log("info for: " + getName() + "\n" +
       "      Total Functions : " + Twine(FunctionSymbols.size()) + "\n" +
-      "        Total Globals : " + Twine(GlobalSymbols.size()) + "\n" +
+      "   Total Data Symbols : " + Twine(DataSymbols.size()) + "\n" +
       "     Function Imports : " + Twine(NumFunctionImports) + "\n" +
       "       Global Imports : " + Twine(NumGlobalImports) + "\n");
 }
 
 uint32_t ObjFile::relocateVirtualAddress(uint32_t GlobalIndex) const {
-  if (auto *DG = dyn_cast<DefinedGlobal>(getGlobalSymbol(GlobalIndex)))
+  if (auto *DG = dyn_cast<DefinedData>(getDataSymbol(GlobalIndex)))
     return DG->getVirtualAddress();
   else
     return 0;
@@ -78,7 +78,7 @@ uint32_t ObjFile::relocateTableIndex(uint32_t Original) const {
 }
 
 uint32_t ObjFile::relocateGlobalIndex(uint32_t Original) const {
-  const Symbol *Sym = getGlobalSymbol(Original);
+  const Symbol *Sym = getDataSymbol(Original);
   uint32_t Index = Sym->getOutputIndex();
   DEBUG(dbgs() << "relocateGlobalIndex: " << toString(*Sym) << ": " << Original
                << " -> " << Index << "\n");
@@ -215,7 +215,7 @@ void ObjFile::initializeSymbols() {
   }
 
   FunctionSymbols.resize(NumFunctionImports + WasmObj->functions().size());
-  GlobalSymbols.resize(NumGlobalImports + WasmObj->globals().size());
+  DataSymbols.resize(NumGlobalImports + WasmObj->globals().size());
 
   ArrayRef<WasmFunction> Funcs = WasmObj->functions();
   ArrayRef<uint32_t> FuncTypes = WasmObj->functionTypes();
@@ -226,7 +226,7 @@ void ObjFile::initializeSymbols() {
     Symtab->addComdat(C, this);
 
   FunctionSymbols.resize(NumFunctionImports + Funcs.size());
-  GlobalSymbols.resize(NumGlobalImports + Globals.size());
+  DataSymbols.resize(NumGlobalImports + Globals.size());
 
   for (const WasmSegment &S : WasmObj->dataSegments()) {
     InputSegment *Seg = make<InputSegment>(S, this);
@@ -242,7 +242,7 @@ void ObjFile::initializeSymbols() {
     Functions.emplace_back(F);
   }
 
-  // Populate `FunctionSymbols` and `GlobalSymbols` based on the WasmSymbols
+  // Populate `FunctionSymbols` and `DataSymbols` based on the WasmSymbols
   // in the object
   for (const SymbolRef &Sym : WasmObj->symbols()) {
     const WasmSymbol &WasmSym = WasmObj->getWasmSymbol(Sym.getRawDataRefImpl());
@@ -264,14 +264,14 @@ void ObjFile::initializeSymbols() {
     case WasmSymbol::SymbolType::GLOBAL_EXPORT: {
       InputSegment *Segment = getSegment(WasmSym);
       if (!isExcludedByComdat(Segment)) {
-        S = createDefinedGlobal(WasmSym, Segment, getGlobalValue(WasmSym));
+        S = createDefinedData(WasmSym, Segment, getGlobalValue(WasmSym));
         break;
       }
       Segment->Live = false;
       LLVM_FALLTHROUGH; // Exclude global, and add the symbol as undefined
     }
     case WasmSymbol::SymbolType::GLOBAL_IMPORT:
-      S = createUndefined(WasmSym, Symbol::Kind::UndefinedGlobalKind);
+      S = createUndefined(WasmSym, Symbol::Kind::UndefinedDataKind);
       break;
     }
 
@@ -281,19 +281,19 @@ void ObjFile::initializeSymbols() {
       if (WasmSym.HasAltIndex)
         FunctionSymbols[WasmSym.AltIndex] = S;
     } else {
-      GlobalSymbols[WasmSym.ElementIndex] = S;
+      DataSymbols[WasmSym.ElementIndex] = S;
       if (WasmSym.HasAltIndex)
-        GlobalSymbols[WasmSym.AltIndex] = S;
+        DataSymbols[WasmSym.AltIndex] = S;
     }
   }
 
   DEBUG(for (size_t I = 0; I < FunctionSymbols.size(); ++I)
             assert(FunctionSymbols[I] != nullptr);
-        for (size_t I = 0; I < GlobalSymbols.size(); ++I)
-            assert(GlobalSymbols[I] != nullptr););
+        for (size_t I = 0; I < DataSymbols.size(); ++I)
+            assert(DataSymbols[I] != nullptr););
 
   DEBUG(dbgs() << "Functions   : " << FunctionSymbols.size() << "\n");
-  DEBUG(dbgs() << "Globals     : " << GlobalSymbols.size() << "\n");
+  DEBUG(dbgs() << "Globals     : " << DataSymbols.size() << "\n");
 }
 
 Symbol *ObjFile::createUndefined(const WasmSymbol &Sym, Symbol::Kind Kind,
@@ -308,11 +308,11 @@ Symbol *ObjFile::createDefinedFunction(const WasmSymbol &Sym,
   return Symtab->addDefinedFunction(Sym.Name, Sym.Flags, this, Function);
 }
 
-Symbol *ObjFile::createDefinedGlobal(const WasmSymbol &Sym,
-                                     InputSegment *Segment, uint32_t Address) {
+Symbol *ObjFile::createDefinedData(const WasmSymbol &Sym, InputSegment *Segment,
+                                   uint32_t Address) {
   if (Sym.isBindingLocal())
-    return make<DefinedGlobal>(Sym.Name, Sym.Flags, this, Segment, Address);
-  return Symtab->addDefinedGlobal(Sym.Name, Sym.Flags, this, Segment, Address);
+    return make<DefinedData>(Sym.Name, Sym.Flags, this, Segment, Address);
+  return Symtab->addDefinedData(Sym.Name, Sym.Flags, this, Segment, Address);
 }
 
 void ArchiveFile::parse() {

diff --git a/lld/wasm/InputFiles.h b/lld/wasm/InputFiles.h
index 8d49d2028aae530cd47eaf357c00834dae459a95..5f399dcf951932bb4cfd672b9e579fd74a3c45c5 100644 (file)
--- a/lld/wasm/InputFiles.h
+++ b/lld/wasm/InputFiles.h
@@ -108,8 +108,8 @@ public:
     return cast<FunctionSymbol>(FunctionSymbols[Index]);
   }
 
-  GlobalSymbol *getGlobalSymbol(uint32_t Index) const {
-    return cast<GlobalSymbol>(GlobalSymbols[Index]);
+  DataSymbol *getDataSymbol(uint32_t Index) const {
+    return cast<DataSymbol>(DataSymbols[Index]);
   }
 
 private:
@@ -118,8 +118,8 @@ private:
   uint32_t relocateGlobalIndex(uint32_t Original) const;
   uint32_t relocateTableIndex(uint32_t Original) const;
 
-  Symbol *createDefinedGlobal(const WasmSymbol &Sym, InputSegment *Segment,
-                              uint32_t Address);
+  Symbol *createDefinedData(const WasmSymbol &Sym, InputSegment *Segment,
+                            uint32_t Address);
   Symbol *createDefinedFunction(const WasmSymbol &Sym, InputFunction *Function);
   Symbol *createUndefined(const WasmSymbol &Sym, Symbol::Kind Kind,
                           const WasmSignature *Signature = nullptr);
@@ -137,7 +137,7 @@ private:
   std::vector<Symbol *> FunctionSymbols;
 
   // List of all global symbols indexed by the global index space
-  std::vector<Symbol *> GlobalSymbols;
+  std::vector<Symbol *> DataSymbols;
 
   uint32_t NumGlobalImports = 0;
   uint32_t NumFunctionImports = 0;

diff --git a/lld/wasm/MarkLive.cpp b/lld/wasm/MarkLive.cpp
index 1e00ca04ea249ee0623b6a117d09e309b74c7c5c..dbeccee76529c7cd6cbe9a181947af6715024ba3 100644 (file)
--- a/lld/wasm/MarkLive.cpp
+++ b/lld/wasm/MarkLive.cpp
@@ -83,7 +83,7 @@ void lld::wasm::markLive() {
       case R_WEBASSEMBLY_MEMORY_ADDR_LEB:
       case R_WEBASSEMBLY_MEMORY_ADDR_SLEB:
       case R_WEBASSEMBLY_MEMORY_ADDR_I32:
-        Enqueue(C->File->getGlobalSymbol(Reloc.Index));
+        Enqueue(C->File->getDataSymbol(Reloc.Index));
         break;
       }
     }

diff --git a/lld/wasm/SymbolTable.cpp b/lld/wasm/SymbolTable.cpp
index 408b5addf8ea18ed019955ffd768b37d3c6cf983..094b5669a006f730edfc76b2429e0a46bfd06b70 100644 (file)
--- a/lld/wasm/SymbolTable.cpp
+++ b/lld/wasm/SymbolTable.cpp
@@ -81,9 +81,9 @@ static void checkSymbolTypes(const Symbol &Existing, const InputFile &F,
   // symbols or both are data symbols).
   if (isa<FunctionSymbol>(Existing) != NewIsFunction) {
     error("symbol type mismatch: " + Existing.getName() + "\n>>> defined as " +
-          (isa<FunctionSymbol>(Existing) ? "Function" : "Global") + " in " +
+          (isa<FunctionSymbol>(Existing) ? "Function" : "Data") + " in " +
           toString(Existing.getFile()) + "\n>>> defined as " +
-          (NewIsFunction ? "Function" : "Global") + " in " + F.getName());
+          (NewIsFunction ? "Function" : "Data") + " in " + F.getName());
     return;
   }
 
@@ -130,13 +130,14 @@ DefinedFunction *SymbolTable::addSyntheticFunction(StringRef Name,
   return replaceSymbol<DefinedFunction>(S, Name, Flags, Type);
 }
 
-DefinedGlobal *SymbolTable::addSyntheticGlobal(StringRef Name, uint32_t Flags) {
-  DEBUG(dbgs() << "addSyntheticGlobal: " << Name << "\n");
+DefinedData *SymbolTable::addSyntheticDataSymbol(StringRef Name,
+                                                 uint32_t Flags) {
+  DEBUG(dbgs() << "addSyntheticDataSymbol: " << Name << "\n");
   Symbol *S;
   bool WasInserted;
   std::tie(S, WasInserted) = insert(Name);
   assert(WasInserted);
-  return replaceSymbol<DefinedGlobal>(S, Name, Flags);
+  return replaceSymbol<DefinedData>(S, Name, Flags);
 }
 
 static bool shouldReplace(const Symbol &Existing, InputFile *NewFile,
@@ -192,15 +193,15 @@ Symbol *SymbolTable::addDefinedFunction(StringRef Name, uint32_t Flags,
   return S;
 }
 
-Symbol *SymbolTable::addDefinedGlobal(StringRef Name, uint32_t Flags,
+Symbol *SymbolTable::addDefinedData(StringRef Name, uint32_t Flags,
                                       InputFile *F, InputSegment *Segment,
                                       uint32_t Address) {
-  DEBUG(dbgs() << "addDefinedGlobal:" << Name << " addr:" << Address << "\n");
+  DEBUG(dbgs() << "addDefinedData:" << Name << " addr:" << Address << "\n");
   Symbol *S;
   bool WasInserted;
   std::tie(S, WasInserted) = insert(Name);
   if (WasInserted || shouldReplace(*S, F, Flags, Segment, false))
-    replaceSymbol<DefinedGlobal>(S, Name, Flags, F, Segment, Address);
+    replaceSymbol<DefinedData>(S, Name, Flags, F, Segment, Address);
   return S;
 }
 
@@ -218,7 +219,7 @@ Symbol *SymbolTable::addUndefined(StringRef Name, Symbol::Kind Kind,
     if (IsFunction)
       replaceSymbol<UndefinedFunction>(S, Name, Flags, F, Type);
     else
-      replaceSymbol<UndefinedGlobal>(S, Name, Flags, F);
+      replaceSymbol<UndefinedData>(S, Name, Flags, F);
     return S;
   }
 

diff --git a/lld/wasm/SymbolTable.h b/lld/wasm/SymbolTable.h
index 523da4d0b77916f01b01e9e2577fffcc5836d164..751bd1f4924db2bcce560902c240b90a5e839c27 100644 (file)
--- a/lld/wasm/SymbolTable.h
+++ b/lld/wasm/SymbolTable.h
@@ -49,16 +49,15 @@ public:
 
   Symbol *addDefinedFunction(StringRef Name, uint32_t Flags, InputFile *F,
                              InputFunction *Function = nullptr);
-  Symbol *addDefinedGlobal(StringRef Name, uint32_t Flags, InputFile *F,
-                           InputSegment *Segment = nullptr,
-                           uint32_t Address = 0);
+  Symbol *addDefinedData(StringRef Name, uint32_t Flags, InputFile *F,
+                         InputSegment *Segment = nullptr, uint32_t Address = 0);
   Symbol *addUndefined(StringRef Name, Symbol::Kind Kind, uint32_t Flags,
                        InputFile *F, const WasmSignature *Signature = nullptr);
   Symbol *addUndefinedFunction(StringRef Name, const WasmSignature *Type);
   void addLazy(ArchiveFile *F, const Archive::Symbol *Sym);
   bool addComdat(StringRef Name, ObjFile *);
 
-  DefinedGlobal *addSyntheticGlobal(StringRef Name, uint32_t Flags = 0);
+  DefinedData *addSyntheticDataSymbol(StringRef Name, uint32_t Flags = 0);
   DefinedFunction *addSyntheticFunction(StringRef Name,
                                         const WasmSignature *Type,
                                         uint32_t Flags = 0);

diff --git a/lld/wasm/Symbols.cpp b/lld/wasm/Symbols.cpp
index 237534ea95106be06f8cd99882df204b7cd43b0d..e94d40095860bb61833f018dbc05696fef9a99c7 100644 (file)
--- a/lld/wasm/Symbols.cpp
+++ b/lld/wasm/Symbols.cpp
@@ -22,10 +22,10 @@ using namespace lld;
 using namespace lld::wasm;
 
 DefinedFunction *WasmSym::CallCtors;
-DefinedGlobal *WasmSym::DsoHandle;
-DefinedGlobal *WasmSym::DataEnd;
-DefinedGlobal *WasmSym::HeapBase;
-DefinedGlobal *WasmSym::StackPointer;
+DefinedData *WasmSym::DsoHandle;
+DefinedData *WasmSym::DataEnd;
+DefinedData *WasmSym::HeapBase;
+DefinedData *WasmSym::StackPointer;
 
 bool Symbol::hasOutputIndex() const {
   if (auto *F = dyn_cast<DefinedFunction>(this))
@@ -45,7 +45,7 @@ uint32_t Symbol::getOutputIndex() const {
 InputChunk *Symbol::getChunk() const {
   if (auto *F = dyn_cast<DefinedFunction>(this))
     return F->Function;
-  if (auto *G = dyn_cast<DefinedGlobal>(this))
+  if (auto *G = dyn_cast<DefinedData>(this))
     return G->Segment;
   return nullptr;
 }
@@ -109,12 +109,12 @@ DefinedFunction::DefinedFunction(StringRef Name, uint32_t Flags, InputFile *F,
                      Function ? &Function->Signature : nullptr),
       Function(Function) {}
 
-uint32_t DefinedGlobal::getVirtualAddress() const {
+uint32_t DefinedData::getVirtualAddress() const {
   DEBUG(dbgs() << "getVirtualAddress: " << getName() << "\n");
   return Segment ? Segment->translateVA(VirtualAddress) : VirtualAddress;
 }
 
-void DefinedGlobal::setVirtualAddress(uint32_t Value) {
+void DefinedData::setVirtualAddress(uint32_t Value) {
   DEBUG(dbgs() << "setVirtualAddress " << Name << " -> " << Value << "\n");
   VirtualAddress = Value;
 }
@@ -130,12 +130,12 @@ std::string lld::toString(wasm::Symbol::Kind Kind) {
   switch (Kind) {
   case wasm::Symbol::DefinedFunctionKind:
     return "DefinedFunction";
-  case wasm::Symbol::DefinedGlobalKind:
-    return "DefinedGlobal";
+  case wasm::Symbol::DefinedDataKind:
+    return "DefinedData";
   case wasm::Symbol::UndefinedFunctionKind:
     return "UndefinedFunction";
-  case wasm::Symbol::UndefinedGlobalKind:
-    return "UndefinedGlobal";
+  case wasm::Symbol::UndefinedDataKind:
+    return "UndefinedData";
   case wasm::Symbol::LazyKind:
     return "LazyKind";
   }

diff --git a/lld/wasm/Symbols.h b/lld/wasm/Symbols.h
index 00b6bef27d2e6f36ecb626348f3027fc398652fc..7425ed181c0d089dfcdcf48276c3154fcb0de670 100644 (file)
--- a/lld/wasm/Symbols.h
+++ b/lld/wasm/Symbols.h
@@ -32,13 +32,13 @@ class Symbol {
 public:
   enum Kind {
     DefinedFunctionKind,
-    DefinedGlobalKind,
+    DefinedDataKind,
 
     LazyKind,
     UndefinedFunctionKind,
-    UndefinedGlobalKind,
+    UndefinedDataKind,
 
-    LastDefinedKind = DefinedGlobalKind,
+    LastDefinedKind = DefinedDataKind,
     InvalidKind,
   };
 
@@ -47,7 +47,7 @@ public:
   bool isLazy() const { return SymbolKind == LazyKind; }
   bool isDefined() const { return SymbolKind <= LastDefinedKind; }
   bool isUndefined() const {
-    return SymbolKind == UndefinedGlobalKind ||
+    return SymbolKind == UndefinedDataKind ||
            SymbolKind == UndefinedFunctionKind;
   }
   bool isLocal() const;
@@ -136,26 +136,26 @@ public:
   }
 };
 
-class GlobalSymbol : public Symbol {
+class DataSymbol : public Symbol {
 public:
   static bool classof(const Symbol *S) {
-    return S->kind() == DefinedGlobalKind || S->kind() == UndefinedGlobalKind;
+    return S->kind() == DefinedDataKind || S->kind() == UndefinedDataKind;
   }
 
 protected:
-  GlobalSymbol(StringRef Name, Kind K, uint32_t Flags, InputFile *F)
+  DataSymbol(StringRef Name, Kind K, uint32_t Flags, InputFile *F)
       : Symbol(Name, K, Flags, F) {}
 };
 
-class DefinedGlobal : public GlobalSymbol {
+class DefinedData : public DataSymbol {
 public:
-  DefinedGlobal(StringRef Name, uint32_t Flags, InputFile *F = nullptr,
-                InputSegment *Segment = nullptr, uint32_t Address = 0)
-      : GlobalSymbol(Name, DefinedGlobalKind, Flags, F), Segment(Segment),
+  DefinedData(StringRef Name, uint32_t Flags, InputFile *F = nullptr,
+              InputSegment *Segment = nullptr, uint32_t Address = 0)
+      : DataSymbol(Name, DefinedDataKind, Flags, F), Segment(Segment),
         VirtualAddress(Address) {}
 
   static bool classof(const Symbol *S) {
-    return S->kind() == DefinedGlobalKind;
+    return S->kind() == DefinedDataKind;
   }
 
   uint32_t getVirtualAddress() const;
@@ -167,12 +167,12 @@ protected:
   uint32_t VirtualAddress;
 };
 
-class UndefinedGlobal : public GlobalSymbol {
+class UndefinedData : public DataSymbol {
 public:
-  UndefinedGlobal(StringRef Name, uint32_t Flags, InputFile *File = nullptr)
-      : GlobalSymbol(Name, UndefinedGlobalKind, Flags, File) {}
+  UndefinedData(StringRef Name, uint32_t Flags, InputFile *File = nullptr)
+      : DataSymbol(Name, UndefinedDataKind, Flags, File) {}
   static bool classof(const Symbol *S) {
-    return S->kind() == UndefinedGlobalKind;
+    return S->kind() == UndefinedDataKind;
   }
 };
 
@@ -194,25 +194,25 @@ struct WasmSym {
   // __stack_pointer
   // Global that holds the address of the top of the explicit value stack in
   // linear memory.
-  static DefinedGlobal *StackPointer;
+  static DefinedData *StackPointer;
 
   // __data_end
   // Symbol marking the end of the data and bss.
-  static DefinedGlobal *DataEnd;
+  static DefinedData *DataEnd;
 
   // __heap_base
   // Symbol marking the end of the data, bss and explicit stack.  Any linear
   // memory following this address is not used by the linked code and can
   // therefore be used as a backing store for brk()/malloc() implementations.
-  static DefinedGlobal *HeapBase;
+  static DefinedData *HeapBase;
 
   // __wasm_call_ctors
   // Function that directly calls all ctors in priority order.
   static DefinedFunction *CallCtors;
 
   // __dso_handle
-  // Global used in calls to __cxa_atexit to determine current DLL
-  static DefinedGlobal *DsoHandle;
+  // Symbol used in calls to __cxa_atexit to determine current DLL
+  static DefinedData *DsoHandle;
 };
 
 // A buffer class that is large enough to hold any Symbol-derived
@@ -220,10 +220,10 @@ struct WasmSym {
 // using the placement new.
 union SymbolUnion {
   alignas(DefinedFunction) char A[sizeof(DefinedFunction)];
-  alignas(DefinedGlobal) char B[sizeof(DefinedGlobal)];
+  alignas(DefinedData) char B[sizeof(DefinedData)];
   alignas(LazySymbol) char C[sizeof(LazySymbol)];
   alignas(UndefinedFunction) char D[sizeof(UndefinedFunction)];
-  alignas(UndefinedGlobal) char E[sizeof(UndefinedFunction)];
+  alignas(UndefinedData) char E[sizeof(UndefinedFunction)];
 };
 
 template <typename T, typename... ArgT>

diff --git a/lld/wasm/Writer.cpp b/lld/wasm/Writer.cpp
index a03fc12bd6dadd1b359f33e5003122425fdda108..ffb987ea5b7786f6c8cdf6bb82fdd328786a06d3 100644 (file)
--- a/lld/wasm/Writer.cpp
+++ b/lld/wasm/Writer.cpp
@@ -119,9 +119,9 @@ private:
   std::vector<const WasmSignature *> Types;
   DenseMap<WasmSignature, int32_t, WasmSignatureDenseMapInfo> TypeIndices;
   std::vector<const FunctionSymbol *> ImportedFunctions;
-  std::vector<const GlobalSymbol *> ImportedGlobals;
+  std::vector<const DataSymbol *> ImportedGlobals;
   std::vector<WasmExportEntry> ExportedSymbols;
-  std::vector<const DefinedGlobal *> DefinedGlobals;
+  std::vector<const DefinedData *> DefinedDataSymbols;
   std::vector<InputFunction *> DefinedFunctions;
   std::vector<const FunctionSymbol *> IndirectFunctions;
   std::vector<WasmInitFunc> InitFunctions;
@@ -226,14 +226,14 @@ void Writer::createMemorySection() {
 }
 
 void Writer::createGlobalSection() {
-  if (DefinedGlobals.empty())
+  if (DefinedDataSymbols.empty())
     return;
 
   SyntheticSection *Section = createSyntheticSection(WASM_SEC_GLOBAL);
   raw_ostream &OS = Section->getStream();
 
-  writeUleb128(OS, DefinedGlobals.size(), "global count");
-  for (const DefinedGlobal *Sym : DefinedGlobals) {
+  writeUleb128(OS, DefinedDataSymbols.size(), "global count");
+  for (const DefinedData *Sym : DefinedDataSymbols) {
     WasmGlobal Global;
     Global.Type.Type = WASM_TYPE_I32;
     Global.Type.Mutable = Sym == WasmSym::StackPointer;
@@ -621,7 +621,7 @@ void Writer::calculateImports() {
     if (auto *F = dyn_cast<FunctionSymbol>(Sym)) {
       F->setOutputIndex(ImportedFunctions.size());
       ImportedFunctions.push_back(F);
-    } else if (auto *G = dyn_cast<GlobalSymbol>(Sym)) {
+    } else if (auto *G = dyn_cast<DataSymbol>(Sym)) {
       G->setOutputIndex(ImportedGlobals.size());
       ImportedGlobals.push_back(G);
     }
@@ -659,7 +659,7 @@ void Writer::calculateExports() {
     for (Symbol *Sym : File->getSymbols()) {
       if (!Sym->isDefined() || File != Sym->getFile())
         continue;
-      if (isa<GlobalSymbol>(Sym))
+      if (!isa<FunctionSymbol>(Sym))
         continue;
       if (!Sym->getChunk()->Live)
         continue;
@@ -670,7 +670,7 @@ void Writer::calculateExports() {
     }
   }
 
-  for (const Symbol *Sym : DefinedGlobals) {
+  for (const Symbol *Sym : DefinedDataSymbols) {
     // Can't export the SP right now because its mutable, and mutuable globals
     // are yet supported in the official binary format.
     // TODO(sbc): Remove this if/when the "mutable global" proposal is accepted.
@@ -719,21 +719,21 @@ void Writer::calculateTypes() {
 }
 
 void Writer::assignIndexes() {
-  uint32_t GlobalIndex = ImportedGlobals.size() + DefinedGlobals.size();
+  uint32_t GlobalIndex = ImportedGlobals.size() + DefinedDataSymbols.size();
   uint32_t FunctionIndex = ImportedFunctions.size() + DefinedFunctions.size();
 
-  auto AddDefinedGlobal = [&](DefinedGlobal *Sym) {
+  auto AddDefinedData = [&](DefinedData *Sym) {
     if (Sym) {
-      DefinedGlobals.emplace_back(Sym);
+      DefinedDataSymbols.emplace_back(Sym);
       Sym->setOutputIndex(GlobalIndex++);
     }
   };
-  AddDefinedGlobal(WasmSym::StackPointer);
-  AddDefinedGlobal(WasmSym::HeapBase);
-  AddDefinedGlobal(WasmSym::DataEnd);
+  AddDefinedData(WasmSym::StackPointer);
+  AddDefinedData(WasmSym::HeapBase);
+  AddDefinedData(WasmSym::DataEnd);
 
   if (Config->Relocatable)
-    DefinedGlobals.reserve(Symtab->getSymbols().size());
+    DefinedDataSymbols.reserve(Symtab->getSymbols().size());
 
   uint32_t TableIndex = kInitialTableOffset;
 
@@ -744,8 +744,8 @@ void Writer::assignIndexes() {
         // Create wasm globals for data symbols defined in this file
         if (File != Sym->getFile())
           continue;
-        if (auto *G = dyn_cast<DefinedGlobal>(Sym))
-          AddDefinedGlobal(G);
+        if (auto *G = dyn_cast<DefinedData>(Sym))
+          AddDefinedData(G);
       }
     }
   }
@@ -893,7 +893,7 @@ void Writer::run() {
 
   if (errorHandler().Verbose) {
     log("Defined Functions: " + Twine(DefinedFunctions.size()));
-    log("Defined Globals  : " + Twine(DefinedGlobals.size()));
+    log("Defined Data Syms: " + Twine(DefinedDataSymbols.size()));
     log("Function Imports : " + Twine(ImportedFunctions.size()));
     log("Global Imports   : " + Twine(ImportedGlobals.size()));
     log("Total Imports    : " +