[lld][WebAssembly] Common superclass for input globals/events/tables

[wingo]

Summary

This commit regroups commonalities among InputGlobal, InputEvent, and
InputTable into the new InputDefinition. The subclasses are defined
inline in the new InputDefinition.h. NFC.

Depends on D91870.

[wingo]

This followup refactor is as suggested in https://reviews.llvm.org/D94075. NFC.

[wingo]

In D94677#2497906, @wingo wrote:

This followup refactor is as suggested in https://reviews.llvm.org/D94075. NFC.

Ping. Should apply more or less fine to "main".

[sbc100]

You can add "NFC" to the title to label this as a non-functional change.

lld/wasm/InputDefinition.h

2 ↗

(On Diff #316626)

I don't love the name "InputDefinition", but I don't have any great ideas for anything better.

Maybe @tlively has some thoughts?

lld/wasm/Writer.cpp

213

Is moving this code into a method a separate refactor, or essential to the PR? (Just wondering, not asking you split it out necessarily).

Why make this into its own method? Given that it only has a single call site. I'm mostly curious what your thinking is, not opposed to this.

Do you think its still worth keeping this function now now that its just one line?

[tlively]

lld/wasm/InputDefinition.h

2 ↗

(On Diff #316626)

Would InputItem be better?

[wingo]

I see that this is marked changes requested, but I don't understand what changes -- is it InputItem?

lld/wasm/Writer.cpp

213

Paging this back in -- I think this was because the different InputGlobal, InputEvent etc had different styles with regards to what was public instance state and what had to be accessed via methods. To harmonize these things, now that they are all in one file, I made the InitExpr be private and added the method accessor. & Of course no, this setGlobalPointer method is certainly no longer needed at this point. WDYT?

[sbc100]

lgtm with the base class rename.

Regarding the "requested changes" features, I was going through all my outstanding reviews and trying to audit them all. For any issue where the last set of comments were from me I thought it would make sense to mark like this to take it off my incoming queue.

lld/wasm/InputDefinition.h

2 ↗

(On Diff #316626)

How about "InputElement" ? I think we have used element elsewhere to refer to something that might be global or an event, etc. See ElementIndex in WasmSymbolInfo for example.

25 ↗

(On Diff #316626)

Is the explicit keyword useful here? I'm used to seeing it mostly on single-arg constructors.

[sbc100]

lld/wasm/Writer.cpp

213

I'll leave to you.. if you think this one-line method makes the code below more readable feel free to leave it.

[wingo]

Address feedback

[wingo]

lld/wasm/InputDefinition.h

25 ↗

(On Diff #316626)

Aah good catch; fixed.

lld/include/lld/Common/LLVM.h

 } // namespace object
 
 namespace wasm {
 struct WasmEvent;
 struct WasmEventType;
 struct WasmFunction;
 struct WasmGlobal;
 struct WasmGlobalType;
+struct WasmInitExpr;
 struct WasmLimits;
 struct WasmRelocation;
 struct WasmSignature;
 struct WasmTable;
 struct WasmTableType;
 } // namespace wasm
 } // namespace llvm
 

 using llvm::object::WasmSection;
 using llvm::object::WasmSegment;
 using llvm::object::WasmSymbol;
 using llvm::wasm::WasmEvent;
 using llvm::wasm::WasmEventType;
 using llvm::wasm::WasmFunction;
 using llvm::wasm::WasmGlobal;
 using llvm::wasm::WasmGlobalType;
+using llvm::wasm::WasmInitExpr;
 using llvm::wasm::WasmLimits;
 using llvm::wasm::WasmRelocation;
 using llvm::wasm::WasmSignature;
 using llvm::wasm::WasmTable;
 using llvm::wasm::WasmTableType;
 } // end namespace lld.
 
 namespace std {

lld/wasm/Driver.cpp

 //===- Driver.cpp ---------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lld/Common/Driver.h"
 #include "Config.h"
 #include "InputChunks.h"
-#include "InputGlobal.h"
-#include "InputTable.h"
+#include "InputElement.h"
 #include "MarkLive.h"
 #include "SymbolTable.h"
 #include "Writer.h"
 #include "lld/Common/Args.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Filesystem.h"
 #include "lld/Common/Memory.h"
 #include "lld/Common/Reproduce.h"

lld/wasm/InputElement.h

+//===- InputElement.h ----------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLD_WASM_INPUT_ELEMENT_H
+#define LLD_WASM_INPUT_ELEMENT_H
+
+#include "Config.h"
+#include "InputFiles.h"
+#include "WriterUtils.h"
+#include "lld/Common/LLVM.h"
+#include "llvm/Object/Wasm.h"
+
+namespace lld {
+namespace wasm {
+
+// Represents a single element (Global, Event, Table, etc) within an input
+// file.
+class InputElement {
+protected:
+  InputElement(StringRef name, ObjFile *f)
+      : file(f), live(!config->gcSections), name(name) {}
+
+public:
+  StringRef getName() const { return name; }
+  uint32_t getAssignedIndex() const { return assignedIndex.getValue(); }
+  bool hasAssignedIndex() const { return assignedIndex.hasValue(); }
+  void assignIndex(uint32_t index) {
+    assert(!hasAssignedIndex());
+    assignedIndex = index;
+  }
+
+  ObjFile *file;
+  bool live = false;
+
+protected:
+  StringRef name;
+  llvm::Optional<uint32_t> assignedIndex;
+};
+
+class InputGlobal : public InputElement {
+public:
+  InputGlobal(const WasmGlobal &g, ObjFile *f)
+      : InputElement(g.SymbolName, f), type(g.Type), initExpr(g.InitExpr) {}
+
+  const WasmGlobalType &getType() const { return type; }
+  const WasmInitExpr &getInitExpr() const { return initExpr; }
+
+  void setPointerValue(uint64_t value) {
+    if (config->is64.getValueOr(false)) {
+      assert(initExpr.Opcode == llvm::wasm::WASM_OPCODE_I64_CONST);
+      initExpr.Value.Int64 = value;
+    } else {
+      assert(initExpr.Opcode == llvm::wasm::WASM_OPCODE_I32_CONST);
+      initExpr.Value.Int32 = value;
+    }
+  }
+
+private:
+  WasmGlobalType type;
+  WasmInitExpr initExpr;
+};
+
+class InputEvent : public InputElement {
+public:
+  InputEvent(const WasmSignature &s, const WasmEvent &e, ObjFile *f)
+      : InputElement(e.SymbolName, f), signature(s), type(e.Type) {}
+
+  const WasmEventType &getType() const { return type; }
+
+  const WasmSignature &signature;
+
+private:
+  WasmEventType type;
+};
+
+class InputTable : public InputElement {
+public:
+  InputTable(const WasmTable &t, ObjFile *f)
+      : InputElement(t.SymbolName, f), type(t.Type) {}
+
+  const WasmTableType &getType() const { return type; }
+  void setLimits(const WasmLimits &limits) { type.Limits = limits; }
+
+private:
+  WasmTableType type;
+};
+
+} // namespace wasm
+
+inline std::string toString(const wasm::InputElement *d) {
+  return (toString(d->file) + ":(" + d->getName() + ")").str();
+}
+
+} // namespace lld
+
+#endif // LLD_WASM_INPUT_ELEMENT_H

lld/wasm/InputEvent.h

-//===- InputEvent.h ---------------------------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// Wasm events are features that suspend the current execution and transfer the
-// control flow to a corresponding handler. Currently the only supported event
-// kind is exceptions.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLD_WASM_INPUT_EVENT_H
-#define LLD_WASM_INPUT_EVENT_H
-
-#include "Config.h"
-#include "InputFiles.h"
-#include "WriterUtils.h"
-#include "lld/Common/ErrorHandler.h"
-#include "llvm/Object/Wasm.h"
-
-namespace lld {
-namespace wasm {
-
-// Represents a single Wasm Event within an input file. These are combined to
-// form the final EVENTS section.
-class InputEvent {
-public:
-  InputEvent(const WasmSignature &s, const WasmEvent &e, ObjFile *f)
-      : file(f), event(e), signature(s), live(!config->gcSections) {}
-
-  StringRef getName() const { return event.SymbolName; }
-  const WasmEventType &getType() const { return event.Type; }
-
-  uint32_t getEventIndex() const { return eventIndex.getValue(); }
-  bool hasEventIndex() const { return eventIndex.hasValue(); }
-  void setEventIndex(uint32_t index) {
-    assert(!hasEventIndex());
-    eventIndex = index;
-  }
-
-  ObjFile *file;
-  WasmEvent event;
-  const WasmSignature &signature;
-
-  bool live = false;
-
-protected:
-  llvm::Optional<uint32_t> eventIndex;
-};
-
-} // namespace wasm
-
-inline std::string toString(const wasm::InputEvent *e) {
-  return (toString(e->file) + ":(" + e->getName() + ")").str();
-}
-
-} // namespace lld
-
-#endif // LLD_WASM_INPUT_EVENT_H

lld/wasm/InputFiles.cpp

 //===- InputFiles.cpp -----------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "InputFiles.h"
 #include "Config.h"
 #include "InputChunks.h"
-#include "InputEvent.h"
-#include "InputGlobal.h"
-#include "InputTable.h"
+#include "InputElement.h"
 #include "OutputSegment.h"
 #include "SymbolTable.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Memory.h"
 #include "lld/Common/Reproduce.h"
 #include "llvm/Object/Binary.h"
 #include "llvm/Object/Wasm.h"
 #include "llvm/Support/TarWriter.h"

lld/wasm/InputGlobal.h

-//===- InputGlobal.h --------------------------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLD_WASM_INPUT_GLOBAL_H
-#define LLD_WASM_INPUT_GLOBAL_H
-
-#include "Config.h"
-#include "InputFiles.h"
-#include "WriterUtils.h"
-#include "lld/Common/ErrorHandler.h"
-#include "llvm/Object/Wasm.h"
-
-namespace lld {
-namespace wasm {
-
-// Represents a single Wasm Global Variable within an input file. These are
-// combined to form the final GLOBALS section.
-class InputGlobal {
-public:
-  InputGlobal(const WasmGlobal &g, ObjFile *f)
-      : file(f), global(g), live(!config->gcSections) {}
-
-  StringRef getName() const { return global.SymbolName; }
-  const WasmGlobalType &getType() const { return global.Type; }
-
-  uint32_t getGlobalIndex() const { return globalIndex.getValue(); }
-  bool hasGlobalIndex() const { return globalIndex.hasValue(); }
-  void setGlobalIndex(uint32_t index) {
-    assert(!hasGlobalIndex());
-    globalIndex = index;
-  }
-
-  ObjFile *file;
-  WasmGlobal global;
-
-  bool live = false;
-
-protected:
-  llvm::Optional<uint32_t> globalIndex;
-};
-
-} // namespace wasm
-
-inline std::string toString(const wasm::InputGlobal *g) {
-  return (toString(g->file) + ":(" + g->getName() + ")").str();
-}
-
-} // namespace lld
-
-#endif // LLD_WASM_INPUT_GLOBAL_H

lld/wasm/InputTable.h

-//===- InputTable.h --------------------------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLD_WASM_INPUT_TABLE_H
-#define LLD_WASM_INPUT_TABLE_H
-
-#include "Config.h"
-#include "InputFiles.h"
-#include "WriterUtils.h"
-#include "lld/Common/ErrorHandler.h"
-#include "llvm/Object/Wasm.h"
-
-namespace lld {
-namespace wasm {
-
-// Represents a single Wasm Table within an input file. These are combined to
-// form the final TABLES section.
-class InputTable {
-public:
-  InputTable(const WasmTable &t, ObjFile *f)
-      : file(f), table(t), live(!config->gcSections) {}
-
-  StringRef getName() const { return table.SymbolName; }
-  const WasmTableType &getType() const { return table.Type; }
-
-  // Somewhat confusingly, we generally use the term "table index" to refer to
-  // the offset of a function in the well-known indirect function table.  We
-  // refer to different tables instead by "table numbers".
-  uint32_t getTableNumber() const { return tableNumber.getValue(); }
-  bool hasTableNumber() const { return tableNumber.hasValue(); }
-  void setTableNumber(uint32_t n) {
-    assert(!hasTableNumber());
-    tableNumber = n;
-  }
-
-  void setLimits(const WasmLimits &limits) { table.Type.Limits = limits; }
-
-  ObjFile *file;
-  WasmTable table;
-
-  bool live = false;
-
-protected:
-  llvm::Optional<uint32_t> tableNumber;
-};
-
-} // namespace wasm
-
-inline std::string toString(const wasm::InputTable *t) {
-  return (toString(t->file) + ":(" + t->getName() + ")").str();
-}
-
-} // namespace lld
-
-#endif // LLD_WASM_INPUT_TABLE_H

lld/wasm/MapFile.cpp

 //          - 00000015     10    .text
 //          - 0000000e     10            test.o:(.text)
 //          - 00000000      5                    local
 //          - 00000000      5                    f(int)
 //
 //===----------------------------------------------------------------------===//
 
 #include "MapFile.h"
+#include "InputElement.h"
 #include "InputFiles.h"
-#include "InputGlobal.h"
 #include "OutputSections.h"
 #include "OutputSegment.h"
 #include "SymbolTable.h"
 #include "Symbols.h"
 #include "SyntheticSections.h"
 #include "lld/Common/Strings.h"
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/SetVector.h"
if (auto *code = dyn_cast<CodeSection>(osec)) {
                       chunk->getSize());
           os.indent(8) << toString(chunk) << '\n';
           for (Symbol *sym : sectionSyms[chunk])
             os << symStr[sym] << '\n';
         }
       }
     } else if (auto *globals = dyn_cast<GlobalSection>(osec)) {
       for (auto *global : globals->inputGlobals) {
-        writeHeader(os, global->getGlobalIndex(), 0, 0);
+        writeHeader(os, global->getAssignedIndex(), 0, 0);
         os.indent(8) << global->getName() << '\n';
       }
     }
     // TODO: other section/symbol types
   }
 }

lld/wasm/MarkLive.cpp

 // Live bits. The Writer will then ignore chunks whose Live bits are off, so
 // that such chunk are not appear in the output.
 //
 //===----------------------------------------------------------------------===//
 
 #include "MarkLive.h"
 #include "Config.h"
 #include "InputChunks.h"
-#include "InputEvent.h"
-#include "InputGlobal.h"
-#include "InputTable.h"
+#include "InputElement.h"
 #include "SymbolTable.h"
 #include "Symbols.h"
 
 #define DEBUG_TYPE "lld"
 
 using namespace llvm;
 using namespace llvm::wasm;
 

lld/wasm/SymbolTable.cpp

 //===- SymbolTable.cpp ----------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "SymbolTable.h"
 #include "Config.h"
 #include "InputChunks.h"
-#include "InputEvent.h"
-#include "InputGlobal.h"
-#include "InputTable.h"
+#include "InputElement.h"
 #include "WriterUtils.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Memory.h"
 #include "llvm/ADT/SetVector.h"
 
 #define DEBUG_TYPE "lld"
 
 using namespace llvm;

lld/wasm/Symbols.cpp

 //===- Symbols.cpp --------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "Symbols.h"
 #include "Config.h"
 #include "InputChunks.h"
-#include "InputEvent.h"
+#include "InputElement.h"
 #include "InputFiles.h"
-#include "InputGlobal.h"
-#include "InputTable.h"
 #include "OutputSections.h"
 #include "OutputSegment.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Memory.h"
 #include "lld/Common/Strings.h"
 
 #define DEBUG_TYPE "lld"
 

 
 uint64_t DefinedData::getOutputSegmentIndex() const {
   LLVM_DEBUG(dbgs() << "getOutputSegmentIndex: " << getName() << "\n");
   return segment->outputSeg->index;
 }
 
 uint32_t GlobalSymbol::getGlobalIndex() const {
   if (auto *f = dyn_cast<DefinedGlobal>(this))
-    return f->global->getGlobalIndex();
+    return f->global->getAssignedIndex();
   assert(globalIndex != INVALID_INDEX);
   return globalIndex;
 }
 
 void GlobalSymbol::setGlobalIndex(uint32_t index) {
   LLVM_DEBUG(dbgs() << "setGlobalIndex " << name << " -> " << index << "\n");
   assert(globalIndex == INVALID_INDEX);
   globalIndex = index;
 }
 
 bool GlobalSymbol::hasGlobalIndex() const {
   if (auto *f = dyn_cast<DefinedGlobal>(this))
-    return f->global->hasGlobalIndex();
+    return f->global->hasAssignedIndex();
   return globalIndex != INVALID_INDEX;
 }
 
 DefinedGlobal::DefinedGlobal(StringRef name, uint32_t flags, InputFile *file,
                              InputGlobal *global)
     : GlobalSymbol(name, DefinedGlobalKind, flags, file,
                    global ? &global->getType() : nullptr),
       global(global) {}
 
 uint32_t EventSymbol::getEventIndex() const {
   if (auto *f = dyn_cast<DefinedEvent>(this))
-    return f->event->getEventIndex();
+    return f->event->getAssignedIndex();
   assert(eventIndex != INVALID_INDEX);
   return eventIndex;
 }
 
 void EventSymbol::setEventIndex(uint32_t index) {
   LLVM_DEBUG(dbgs() << "setEventIndex " << name << " -> " << index << "\n");
   assert(eventIndex == INVALID_INDEX);
   eventIndex = index;
 }
 
 bool EventSymbol::hasEventIndex() const {
   if (auto *f = dyn_cast<DefinedEvent>(this))
-    return f->event->hasEventIndex();
+    return f->event->hasAssignedIndex();
   return eventIndex != INVALID_INDEX;
 }
 
 DefinedEvent::DefinedEvent(StringRef name, uint32_t flags, InputFile *file,
                            InputEvent *event)
     : EventSymbol(name, DefinedEventKind, flags, file,
                   event ? &event->getType() : nullptr,
                   event ? &event->signature : nullptr),
       event(event) {}
 
 void TableSymbol::setLimits(const WasmLimits &limits) {
   if (auto *t = dyn_cast<DefinedTable>(this))
     t->table->setLimits(limits);
   auto *newType = make<WasmTableType>(*tableType);
   newType->Limits = limits;
   tableType = newType;
 }
 
 uint32_t TableSymbol::getTableNumber() const {
   if (const auto *t = dyn_cast<DefinedTable>(this))
-    return t->table->getTableNumber();
+    return t->table->getAssignedIndex();
   assert(tableNumber != INVALID_INDEX);
   return tableNumber;
 }
 
 void TableSymbol::setTableNumber(uint32_t number) {
   LLVM_DEBUG(dbgs() << "setTableNumber " << name << " -> " << number << "\n");
   assert(tableNumber == INVALID_INDEX);
   tableNumber = number;
 }
 
 bool TableSymbol::hasTableNumber() const {
   if (const auto *t = dyn_cast<DefinedTable>(this))
-    return t->table->hasTableNumber();
+    return t->table->hasAssignedIndex();
   return tableNumber != INVALID_INDEX;
 }
 
 DefinedTable::DefinedTable(StringRef name, uint32_t flags, InputFile *file,
                            InputTable *table)
     : TableSymbol(name, DefinedTableKind, flags, file,
                   table ? &table->getType() : nullptr),
       table(table) {}

lld/wasm/SyntheticSections.cpp

 //===- SyntheticSections.cpp ----------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains linker-synthesized sections.
 //
 //===----------------------------------------------------------------------===//
 
 #include "SyntheticSections.h"
 
 #include "InputChunks.h"
-#include "InputEvent.h"
-#include "InputGlobal.h"
-#include "InputTable.h"
+#include "InputElement.h"
 #include "OutputSegment.h"
 #include "SymbolTable.h"
 #include "llvm/Support/Path.h"
 
 using namespace llvm;
 using namespace llvm::wasm;
 
 namespace lld {

 }
 
 void TableSection::addTable(InputTable *table) {
   if (!table->live)
     return;
   uint32_t tableNumber =
       out.importSec->getNumImportedTables() + inputTables.size();
   inputTables.push_back(table);
-  table->setTableNumber(tableNumber);
+  table->assignIndex(tableNumber);
 }
 
 void MemorySection::writeBody() {
   raw_ostream &os = bodyOutputStream;
 
   bool hasMax = maxMemoryPages != 0 || config->sharedMemory;
   writeUleb128(os, 1, "memory count");
   unsigned flags = 0;
if (hasMax)
     writeUleb128(os, maxMemoryPages, "max pages");
 }
 
 void EventSection::writeBody() {
   raw_ostream &os = bodyOutputStream;
 
   writeUleb128(os, inputEvents.size(), "event count");
   for (InputEvent *e : inputEvents) {
-    e->event.Type.SigIndex = out.typeSec->lookupType(e->signature);
-    writeEvent(os, e->event);
+    WasmEventType type = e->getType();
+    type.SigIndex = out.typeSec->lookupType(e->signature);
+    writeEventType(os, type);
   }
 }
 
 void EventSection::addEvent(InputEvent *event) {
   if (!event->live)
     return;
   uint32_t eventIndex =
       out.importSec->getNumImportedEvents() + inputEvents.size();
   LLVM_DEBUG(dbgs() << "addEvent: " << eventIndex << "\n");
-  event->setEventIndex(eventIndex);
+  event->assignIndex(eventIndex);
   inputEvents.push_back(event);
 }
 
 void GlobalSection::assignIndexes() {
   uint32_t globalIndex = out.importSec->getNumImportedGlobals();
   for (InputGlobal *g : inputGlobals)
-    g->setGlobalIndex(globalIndex++);
+    g->assignIndex(globalIndex++);
   for (Symbol *sym : internalGotSymbols)
     sym->setGOTIndex(globalIndex++);
   isSealed = true;
 }
 
 void GlobalSection::addInternalGOTEntry(Symbol *sym) {
   assert(!isSealed);
   if (sym->requiresGOT)
for (const Symbol *sym : internalGotSymbols) {
     writeUleb128(os, sym->getGOTIndex(), "got_entry");
   }
 }
 
 void GlobalSection::writeBody() {
   raw_ostream &os = bodyOutputStream;
 
   writeUleb128(os, numGlobals(), "global count");
-  for (InputGlobal *g : inputGlobals)
-    writeGlobal(os, g->global);
+  for (InputGlobal *g : inputGlobals) {
+    writeGlobalType(os, g->getType());
+    writeInitExpr(os, g->getInitExpr());
+  }
   // TODO(wvo): when do these need I64_CONST?
   for (const Symbol *sym : internalGotSymbols) {
-    WasmGlobal global;
     // In the case of dynamic linking, internal GOT entries
     // need to be mutable since they get updated to the correct
     // runtime value during `__wasm_apply_global_relocs`.
     bool mutable_ = config->isPic & !sym->isStub;
-    global.Type = {WASM_TYPE_I32, mutable_};
-    global.InitExpr.Opcode = WASM_OPCODE_I32_CONST;
+    WasmGlobalType type{WASM_TYPE_I32, mutable_};
+    WasmInitExpr initExpr;
+    initExpr.Opcode = WASM_OPCODE_I32_CONST;
     if (auto *d = dyn_cast<DefinedData>(sym))
-      global.InitExpr.Value.Int32 = d->getVirtualAddress();
+      initExpr.Value.Int32 = d->getVirtualAddress();
     else if (auto *f = dyn_cast<FunctionSymbol>(sym))
-      global.InitExpr.Value.Int32 = f->isStub ? 0 : f->getTableIndex();
+      initExpr.Value.Int32 = f->isStub ? 0 : f->getTableIndex();
     else {
       assert(isa<UndefinedData>(sym));
-      global.InitExpr.Value.Int32 = 0;
+      initExpr.Value.Int32 = 0;
     }
-    writeGlobal(os, global);
+    writeGlobalType(os, type);
+    writeInitExpr(os, initExpr);
   }
   for (const DefinedData *sym : dataAddressGlobals) {
-    WasmGlobal global;
-    global.Type = {WASM_TYPE_I32, false};
-    global.InitExpr.Opcode = WASM_OPCODE_I32_CONST;
-    global.InitExpr.Value.Int32 = sym->getVirtualAddress();
-    writeGlobal(os, global);
+    WasmGlobalType type{WASM_TYPE_I32, false};
+    WasmInitExpr initExpr;
+    initExpr.Opcode = WASM_OPCODE_I32_CONST;
+    initExpr.Value.Int32 = sym->getVirtualAddress();
+    writeGlobalType(os, type);
+    writeInitExpr(os, initExpr);
   }
 }
 
 void GlobalSection::addGlobal(InputGlobal *global) {
   assert(!isSealed);
   if (!global->live)
     return;
   inputGlobals.push_back(global);
for (const Symbol *s : out.importSec->importedSymbols) {
       }
     }
     for (const Symbol *s : out.importSec->gotSymbols) {
       writeUleb128(sub.os, s->getGOTIndex(), "global index");
       writeStr(sub.os, toString(*s), "symbol name");
     }
     for (const InputGlobal *g : out.globalSec->inputGlobals) {
       if (!g->getName().empty()) {
-        writeUleb128(sub.os, g->getGlobalIndex(), "global index");
+        writeUleb128(sub.os, g->getAssignedIndex(), "global index");
         writeStr(sub.os, maybeDemangleSymbol(g->getName()), "symbol name");
       }
     }
     for (Symbol *s : out.globalSec->internalGotSymbols) {
       writeUleb128(sub.os, s->getGOTIndex(), "global index");
       if (isa<FunctionSymbol>(s))
         writeStr(sub.os, "GOT.func.internal." + toString(*s), "symbol name");
       else

lld/wasm/Writer.cpp

 //===- Writer.cpp ---------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "Writer.h"
 #include "Config.h"
 #include "InputChunks.h"
-#include "InputEvent.h"
-#include "InputGlobal.h"
-#include "InputTable.h"
+#include "InputElement.h"
 #include "MapFile.h"
 #include "OutputSections.h"
 #include "OutputSegment.h"
 #include "Relocations.h"
 #include "SymbolTable.h"
 #include "SyntheticSections.h"
 #include "WriterUtils.h"
 #include "lld/Common/ErrorHandler.h"
void Writer::writeSections() {
   uint8_t *buf = buffer->getBufferStart();
   parallelForEach(outputSections, [buf](OutputSection *s) {
     assert(s->isNeeded());
     s->writeTo(buf);
   });
 }
 
 static void setGlobalPtr(DefinedGlobal *g, uint64_t memoryPtr) {
-  if (config->is64.getValueOr(false)) {
-    assert(g->global->global.InitExpr.Opcode == WASM_OPCODE_I64_CONST);
-    g->global->global.InitExpr.Value.Int64 = memoryPtr;
-  } else {
-    assert(g->global->global.InitExpr.Opcode == WASM_OPCODE_I32_CONST);
-    g->global->global.InitExpr.Value.Int32 = memoryPtr;
-  }
+  g->global->setPointerValue(memoryPtr);
 }
 
 // Fix the memory layout of the output binary.  This assigns memory offsets
 // to each of the input data sections as well as the explicit stack region.
 // The default memory layout is as follows, from low to high.
 //
 //  - initialized data (starting at Config->globalBase)
 //  - BSS data (not currently implemented in llvm)
auto placeStack = [&]() {
     if (config->relocatable || config->isPic)
       return;
     memoryPtr = alignTo(memoryPtr, stackAlignment);
     if (config->zStackSize != alignTo(config->zStackSize, stackAlignment))
       error("stack size must be " + Twine(stackAlignment) + "-byte aligned");
     log("mem: stack size  = " + Twine(config->zStackSize));
     log("mem: stack base  = " + Twine(memoryPtr));
     memoryPtr += config->zStackSize;
-    auto *sp = cast<DefinedGlobal>(WasmSym::stackPointer);
-    switch (sp->global->global.InitExpr.Opcode) {
-    case WASM_OPCODE_I32_CONST:
-      sp->global->global.InitExpr.Value.Int32 = memoryPtr;
-      break;
-    case WASM_OPCODE_I64_CONST:
-      sp->global->global.InitExpr.Value.Int64 = memoryPtr;
-      break;
-    default:
-      llvm_unreachable("init expr must be i32/i64.const");
-    }
+    setGlobalPtr(cast<DefinedGlobal>(WasmSym::stackPointer), memoryPtr);
     log("mem: stack top   = " + Twine(memoryPtr));
   };
 
   if (config->stackFirst) {
     placeStack();
   } else {
     memoryPtr = config->globalBase;
     log("mem: global base = " + Twine(config->globalBase));

lld/wasm/WriterUtils.h

 void writeMemArg(raw_ostream &os, uint32_t alignment, uint64_t offset);
 
 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 writeEventType(raw_ostream &os, const llvm::wasm::WasmEventType &type);
 
 void writeEvent(raw_ostream &os, const llvm::wasm::WasmEvent &event);
 
 void writeTableType(raw_ostream &os, const llvm::wasm::WasmTableType &type);
 
 void writeImport(raw_ostream &os, const llvm::wasm::WasmImport &import);
 

lld/wasm/WriterUtils.cpp

 }
 
 void writeGlobalType(raw_ostream &os, const WasmGlobalType &type) {
   // TODO: Update WasmGlobalType to use ValType and remove this cast.
   writeValueType(os, ValType(type.Type), "global type");
   writeU8(os, type.Mutable, "global mutable");
 }
 
-void writeGlobal(raw_ostream &os, const WasmGlobal &global) {
-  writeGlobalType(os, global.Type);
-  writeInitExpr(os, global.InitExpr);
-}
-
 void writeEventType(raw_ostream &os, const WasmEventType &type) {
   writeUleb128(os, type.Attribute, "event attribute");
   writeUleb128(os, type.SigIndex, "sig index");
 }
 
 void writeEvent(raw_ostream &os, const WasmEvent &event) {
   writeEventType(os, event.Type);
 }