[WebAssembly] Reorder Symbol fields to make it smaller

[MaskRay]

Summary

On 64-bit systems, this decreases sizeof(SymbolUnion) from 112 to 96.

[sbc100]

Nice! I wonder if its worth adding some kind of static assert or unittest to avoid accidental increases in future? Either way lgtm.

[MaskRay]

Add a size assert

[MaskRay]

static_assert(sizeof(SymbolUnion) <= 96, "SymbolUnion too large");

c:\b\slave\sanitizer-windows\build\llvm.src\tools\lld\wasm\Symbols.h(481): error C2338: SymbolUnion too large

*NIX systems place bitfields at the next available unit where the entire bitfield would fit in an aligned storage unit of the declared type;

UndefinedFunction  ;;;; sizeof(UndefinedFunction) = 96
└⏷56 llvm::StringRef ImportName
└⏷72 llvm::StringRef ImportModule
├╸88 bool IsCalledDirectly
├╸48 uint32_t TableIndex
├╸52 uint32_t FunctionIndex
└⏷ 0 llvm::StringRef Name
└⏷16 lld::wasm::InputFile *File
├╸24 uint32_t Flags
├╸28 uint32_t OutputSymbolIndex
├╸32 uint32_t GOTIndex
├╸36 lld::wasm::Symbol::Kind SymbolKind
├╸37 unsigned int Referenced                    ;;;;;;;; on Windows, 40
├╸37.1 unsigned int IsUsedInRegularObj
├╸37.2 unsigned int ForceExport
├╸37.3 unsigned int CanInline
└╸37.4 unsigned int Traced

On Windows, bit fields are placed differently, sizeof(UndefinedFunction) = 104.

wasm/Symbols.h

 class InputSection;
 class OutputSection;
 
 #define INVALID_INDEX UINT32_MAX
 
 // The base class for real symbol classes.
 class Symbol {
 public:
-  enum Kind {
+  enum Kind : uint8_t {
     DefinedFunctionKind,
     DefinedDataKind,
     DefinedGlobalKind,
     DefinedEventKind,
     SectionKind,
     OutputSectionKind,
     UndefinedFunctionKind,
     UndefinedDataKind,
public:
   // Get/set the index in the output symbol table.  This is only used for
   // relocatable output.
   uint32_t getOutputSymbolIndex() const;
   void setOutputSymbolIndex(uint32_t Index);
 
   WasmSymbolType getWasmType() const;
   bool isExported() const;
 
-  // True if the symbol was used for linking and thus need to be added to the
-  // output file's symbol table. This is true for all symbols except for
-  // unreferenced DSO symbols, lazy (archive) symbols, and bitcode symbols that
-  // are unreferenced except by other bitcode objects.
-  unsigned IsUsedInRegularObj : 1;
-
-  // True if ths symbol is explicity marked for export (i.e. via the -e/--export
-  // command line flag)
-  unsigned ForceExport : 1;
-
-  // False if LTO shouldn't inline whatever this symbol points to. If a symbol
-  // is overwritten after LTO, LTO shouldn't inline the symbol because it
-  // doesn't know the final contents of the symbol.
-  unsigned CanInline : 1;
-
-  // True if this symbol is specified by --trace-symbol option.
-  unsigned Traced : 1;
-
   const WasmSignature* getSignature() const;
 
   bool isInGOT() const { return GOTIndex != INVALID_INDEX; }
 
   uint32_t getGOTIndex() const {
     assert(GOTIndex != INVALID_INDEX);
     return GOTIndex;
   }
 
   void setGOTIndex(uint32_t Index);
   bool hasGOTIndex() const { return GOTIndex != INVALID_INDEX; }
 
 protected:
   Symbol(StringRef Name, Kind K, uint32_t Flags, InputFile *F)
-      : IsUsedInRegularObj(false), ForceExport(false), CanInline(false),
-        Traced(false), Name(Name), SymbolKind(K), Flags(Flags), File(F),
-        Referenced(!Config->GcSections) {}
+      : Name(Name), File(F), Flags(Flags), SymbolKind(K),
+        Referenced(!Config->GcSections), IsUsedInRegularObj(false),
+        ForceExport(false), CanInline(false), Traced(false) {}
 
   StringRef Name;
-  Kind SymbolKind;
-  uint32_t Flags;
   InputFile *File;
+  uint32_t Flags;
   uint32_t OutputSymbolIndex = INVALID_INDEX;
   uint32_t GOTIndex = INVALID_INDEX;
-  bool Referenced;
+  Kind SymbolKind;
+  unsigned Referenced : 1;
+
+public:
+  // True if the symbol was used for linking and thus need to be added to the
+  // output file's symbol table. This is true for all symbols except for
+  // unreferenced DSO symbols, lazy (archive) symbols, and bitcode symbols that
+  // are unreferenced except by other bitcode objects.
+  unsigned IsUsedInRegularObj : 1;
+
+  // True if ths symbol is explicity marked for export (i.e. via the -e/--export
+  // command line flag)
+  unsigned ForceExport : 1;
+
+  // False if LTO shouldn't inline whatever this symbol points to. If a symbol
+  // is overwritten after LTO, LTO shouldn't inline the symbol because it
+  // doesn't know the final contents of the symbol.
+  unsigned CanInline : 1;
+
+  // True if this symbol is specified by --trace-symbol option.
+  unsigned Traced : 1;
 };
 
 class FunctionSymbol : public Symbol {
 public:
   static bool classof(const Symbol *S) {
     return S->kind() == DefinedFunctionKind ||
            S->kind() == UndefinedFunctionKind;
   }
union SymbolUnion {
   alignas(DefinedEvent) char D[sizeof(DefinedEvent)];
   alignas(LazySymbol) char E[sizeof(LazySymbol)];
   alignas(UndefinedFunction) char F[sizeof(UndefinedFunction)];
   alignas(UndefinedData) char G[sizeof(UndefinedData)];
   alignas(UndefinedGlobal) char H[sizeof(UndefinedGlobal)];
   alignas(SectionSymbol) char I[sizeof(SectionSymbol)];
 };
 
+// It is important to keep the size of SymbolUnion small for performance and
+// memory usage reasons. 96 bytes is a soft limit based on the size of
+// UndefinedFunction on a 64-bit system.
+static_assert(sizeof(SymbolUnion) <= 96, "SymbolUnion too large");
+
 void printTraceSymbol(Symbol *Sym);
 void printTraceSymbolUndefined(StringRef Name, const InputFile* File);
 
 template <typename T, typename... ArgT>
 T *replaceSymbol(Symbol *S, ArgT &&... Arg) {
   static_assert(std::is_trivially_destructible<T>(),
                 "Symbol types must be trivially destructible");
   static_assert(sizeof(T) <= sizeof(SymbolUnion), "SymbolUnion too small");