[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

wasm/Symbols.h

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;
+  bool HasOutputIndex = false;
 };
 
 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;
+  bool HasTableIndex = false;
 
   // 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,

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 HasOutputIndex;
 }
 
 uint32_t Symbol::getOutputIndex() const {
   if (auto *F = dyn_cast_or_null<InputFunction>(Chunk))
     return F->getOutputIndex();
-  return OutputIndex.getValue();
+  assert(HasOutputIndex);
+  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(!HasOutputIndex);
+  HasOutputIndex = true;
   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(HasTableIndex);
+  return TableIndex;
 }
 
 bool FunctionSymbol::hasTableIndex() const {
   if (auto *F = dyn_cast_or_null<InputFunction>(Chunk))
     return F->hasTableIndex();
-  return TableIndex.hasValue();
+  return HasTableIndex;
 }
 
 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(!HasTableIndex);
+  HasTableIndex = true;
   TableIndex = Index;
 }
 
 uint32_t DefinedGlobal::getVirtualAddress() const {
   assert(isGlobal());
   DEBUG(dbgs() << "getVirtualAddress: " << getName() << "\n");
   return Chunk ? dyn_cast<InputSegment>(Chunk)->translateVA(VirtualAddress)
                : VirtualAddress;