[WebAssebmly] Remove use of Optional to fix assertion in gcc

[sbc100]

Summary

This was causing GCC builds with fail with:
Symbols.h:240:3: error: static assertion failed: Symbol types must be
trivially destructible

static_assert(std::is_trivially_destructible<T>(

The reason this is a gcc-only failure is that OptionalStorage has
as specialization for POD types that isn't built under GCC.

[ruiu]

If they can't be 0, 0 is a good initial value that represents "no value". If 0 is a valid value, we can use (uint32_t)-1. We do that in other ports, and it is perhaps better for consistency.

I just removed the failing static_assert to unbreak buildbots. Please add it back to this patch.

[sbc100]

• feedback
• Revert "Remove a failing static_assert."

[ruiu]

Did you verify that this compiles with gcc?

[sbc100]

Yup.. repro'd the failure then confirmed fix.

[ruiu]

LGTM

lld/trunk/wasm/Symbols.h

 using llvm::wasm::WasmSignature;
 
 namespace lld {
 namespace wasm {
 
 class InputFile;
 class InputChunk;
 
+#define INVALID_INDEX UINT32_MAX
+
 // The base class for real symbol classes.
 class Symbol {
 public:
   enum Kind {
     DefinedFunctionKind,
     DefinedGlobalKind,
 
     LazyKind,
protected:
   Symbol(StringRef Name, Kind K, uint32_t Flags, InputFile *F, InputChunk *C)
       : Name(Name), SymbolKind(K), Flags(Flags), File(F), Chunk(C) {}
 
   StringRef Name;
   Kind SymbolKind;
   uint32_t Flags;
   InputFile *File;
   InputChunk *Chunk;
-  llvm::Optional<uint32_t> OutputIndex;
+  uint32_t OutputIndex = INVALID_INDEX;
 };
 
 class FunctionSymbol : public Symbol {
 public:
   static bool classof(const Symbol *S) {
     return S->kind() == DefinedFunctionKind ||
            S->kind() == UndefinedFunctionKind;
   }

 
 protected:
   void setFunctionType(const WasmSignature *Type);
 
   FunctionSymbol(StringRef Name, Kind K, uint32_t Flags, InputFile *F,
                  InputChunk *C)
       : Symbol(Name, K, Flags, F, C) {}
 
-  llvm::Optional<uint32_t> TableIndex;
+  uint32_t TableIndex = INVALID_INDEX;
 
   // Explict function type, needed for undefined or synthetic functions only.
   const WasmSignature *FunctionType = nullptr;
 };
 
 class DefinedFunction : public FunctionSymbol {
 public:
   DefinedFunction(StringRef Name, uint32_t Flags, InputFile *F = nullptr,
union SymbolUnion {
   alignas(DefinedGlobal) char B[sizeof(DefinedGlobal)];
   alignas(LazySymbol) char C[sizeof(LazySymbol)];
   alignas(UndefinedFunction) char D[sizeof(UndefinedFunction)];
   alignas(UndefinedGlobal) char E[sizeof(UndefinedFunction)];
 };
 
 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), "Symbol too small");
   static_assert(alignof(T) <= alignof(SymbolUnion),
                 "SymbolUnion not aligned enough");
   assert(static_cast<Symbol *>(static_cast<T *>(nullptr)) == nullptr &&
          "Not a Symbol");
   return new (S) T(std::forward<ArgT>(Arg)...);
 }
 

lld/trunk/wasm/Symbols.cpp

 DefinedGlobal *WasmSym::DsoHandle;
 DefinedGlobal *WasmSym::DataEnd;
 DefinedGlobal *WasmSym::HeapBase;
 DefinedGlobal *WasmSym::StackPointer;
 
 bool Symbol::hasOutputIndex() const {
   if (auto *F = dyn_cast_or_null<InputFunction>(Chunk))
     return F->hasOutputIndex();
-  return OutputIndex.hasValue();
+  return OutputIndex != INVALID_INDEX;
 }
 
 uint32_t Symbol::getOutputIndex() const {
   if (auto *F = dyn_cast_or_null<InputFunction>(Chunk))
     return F->getOutputIndex();
-  return OutputIndex.getValue();
+  assert(OutputIndex != INVALID_INDEX);
+  return OutputIndex;
 }
 
 void Symbol::setOutputIndex(uint32_t Index) {
   DEBUG(dbgs() << "setOutputIndex " << Name << " -> " << Index << "\n");
   assert(!dyn_cast_or_null<InputFunction>(Chunk));
-  assert(!OutputIndex.hasValue());
+  assert(OutputIndex == INVALID_INDEX);
   OutputIndex = Index;
 }
 
 bool Symbol::isWeak() const {
   return (Flags & WASM_SYMBOL_BINDING_MASK) == WASM_SYMBOL_BINDING_WEAK;
 }
 
 bool Symbol::isLocal() const {
void FunctionSymbol::setFunctionType(const WasmSignature *Type) {
   assert(FunctionType == nullptr);
   assert(!Chunk);
   FunctionType = Type;
 }
 
 uint32_t FunctionSymbol::getTableIndex() const {
   if (auto *F = dyn_cast_or_null<InputFunction>(Chunk))
     return F->getTableIndex();
-  return TableIndex.getValue();
+  assert(TableIndex != INVALID_INDEX);
+  return TableIndex;
 }
 
 bool FunctionSymbol::hasTableIndex() const {
   if (auto *F = dyn_cast_or_null<InputFunction>(Chunk))
     return F->hasTableIndex();
-  return TableIndex.hasValue();
+  return TableIndex != INVALID_INDEX;
 }
 
 void FunctionSymbol::setTableIndex(uint32_t Index) {
   // For imports, we set the table index here on the Symbol; for defined
   // functions we set the index on the InputFunction so that we don't export
   // the same thing twice (keeps the table size down).
   if (auto *F = dyn_cast_or_null<InputFunction>(Chunk)) {
     F->setTableIndex(Index);
     return;
   }
   DEBUG(dbgs() << "setTableIndex " << Name << " -> " << Index << "\n");
-  assert(!TableIndex.hasValue());
+  assert(TableIndex == INVALID_INDEX);
   TableIndex = Index;
 }
 
 uint32_t DefinedGlobal::getVirtualAddress() const {
   assert(isGlobal());
   DEBUG(dbgs() << "getVirtualAddress: " << getName() << "\n");
   return Chunk ? dyn_cast<InputSegment>(Chunk)->translateVA(VirtualAddress)
                : VirtualAddress;