[WebAssembly] Refactor use of signatures

[dschuff]

Summary

Update use of WasmSignature to go along with D52580

[sbc100]

LGTM with nits

wasm/WriterUtils.cpp

78

Why not instead change the param type of valueTypeToString?

84

I think the style guide doesn't like auto unless the type is completely obvious (normally if its written on the RHS on the same line in a cast or similar).

119–120

Probably worth updating the type of WasmGlobalType.Type .. maybe add a TODO here saying this cast should probably not be needed in the future?

[dschuff]

• Comments

[xbolva00]

This comment was removed by xbolva00.

wasm/Driver.cpp

if (!Config->Relocatable) {
     llvm::wasm::WasmGlobal Global;
     Global.Type = {WASM_TYPE_I32, true};
     Global.InitExpr.Value.Int32 = 0;
     Global.InitExpr.Opcode = WASM_OPCODE_I32_CONST;
     Global.SymbolName = "__stack_pointer";
     InputGlobal *StackPointer = make<InputGlobal>(Global, nullptr);
     StackPointer->Live = true;
 
-    static WasmSignature NullSignature = {{}, WASM_TYPE_NORESULT};
+    static WasmSignature NullSignature = {{}, {}};
 
     // Add synthetic symbols before any others
     WasmSym::CallCtors = Symtab->addSyntheticFunction(
         "__wasm_call_ctors", WASM_SYMBOL_VISIBILITY_HIDDEN,
         make<SyntheticFunction>(NullSignature, "__wasm_call_ctors"));
     // TODO(sbc): Remove WASM_SYMBOL_VISIBILITY_HIDDEN when the mutable global
     // spec proposal is implemented in all major browsers.
     // See: https://github.com/WebAssembly/mutable-global

wasm/Writer.cpp

 // Populate InitFunctions vector with init functions from all input objects.
 // This is then used either when creating the output linking section or to
 // synthesize the "__wasm_call_ctors" function.
 void Writer::calculateInitFunctions() {
   for (ObjFile *File : Symtab->ObjectFiles) {
     const WasmLinkingData &L = File->getWasmObj()->linkingData();
     for (const WasmInitFunc &F : L.InitFunctions) {
       FunctionSymbol *Sym = File->getFunctionSymbol(F.Symbol);
-      if (*Sym->FunctionType != WasmSignature{{}, WASM_TYPE_NORESULT})
+      if (*Sym->FunctionType != WasmSignature{{}, {}})
         error("invalid signature for init func: " + toString(*Sym));
       InitFunctions.emplace_back(WasmInitEntry{Sym, F.Priority});
     }
   }
 
   // Sort in order of priority (lowest first) so that they are called
   // in the correct order.
   std::stable_sort(InitFunctions.begin(), InitFunctions.end(),

wasm/WriterUtils.h

void writeBytes(raw_ostream &OS, const char *Bytes, size_t count,
                 const Twine &Msg);
 
 void writeStr(raw_ostream &OS, StringRef String, const Twine &Msg);
 
 void writeU8(raw_ostream &OS, uint8_t byte, const Twine &Msg);
 
 void writeU32(raw_ostream &OS, uint32_t Number, const Twine &Msg);
 
-void writeValueType(raw_ostream &OS, uint8_t Type, const Twine &Msg);
+void writeValueType(raw_ostream &OS, llvm::wasm::ValType Type,
+                    const Twine &Msg);
 
 void writeSig(raw_ostream &OS, const llvm::wasm::WasmSignature &Sig);
 
 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);

wasm/WriterUtils.cpp

 #include "llvm/Support/LEB128.h"
 
 #define DEBUG_TYPE "lld"
 
 using namespace llvm;
 using namespace llvm::wasm;
 using namespace lld::wasm;
 
-static const char *valueTypeToString(uint8_t Type) {
+static const char *valueTypeToString(ValType Type) {
   switch (Type) {
-  case WASM_TYPE_I32:
+  case wasm::ValType::I32:
     return "i32";
-  case WASM_TYPE_I64:
+  case wasm::ValType::I64:
     return "i64";
-  case WASM_TYPE_F32:
+  case wasm::ValType::F32:
     return "f32";
-  case WASM_TYPE_F64:
+  case wasm::ValType::F64:
     return "f64";
   default:
     llvm_unreachable("invalid value type");
   }
 }
 
 namespace lld {
 
void wasm::writeU8(raw_ostream &OS, uint8_t Byte, const Twine &Msg) {
   OS << Byte;
 }
 
 void wasm::writeU32(raw_ostream &OS, uint32_t Number, const Twine &Msg) {
   debugWrite(OS.tell(), Msg + "[0x" + utohexstr(Number) + "]");
   support::endian::write(OS, Number, support::little);
 }
 
-void wasm::writeValueType(raw_ostream &OS, uint8_t Type, const Twine &Msg) {
-  writeU8(OS, Type, Msg + "[type: " + valueTypeToString(Type) + "]");
+void wasm::writeValueType(raw_ostream &OS, ValType Type, const Twine &Msg) {
+  writeU8(OS, static_cast<uint8_t>(Type),
+          Msg + "[type: " + valueTypeToString(Type) + "]");
 }
 
 void wasm::writeSig(raw_ostream &OS, const WasmSignature &Sig) {
   writeU8(OS, WASM_TYPE_FUNC, "signature type");
-  writeUleb128(OS, Sig.ParamTypes.size(), "param Count");
-  for (uint8_t ParamType : Sig.ParamTypes) {
+  writeUleb128(OS, Sig.Params.size(), "param Count");
+  for (ValType ParamType : Sig.Params) {
     writeValueType(OS, ParamType, "param type");
   }
-  if (Sig.ReturnType == WASM_TYPE_NORESULT) {
-    writeUleb128(OS, 0, "result Count");
-  } else {
-    writeUleb128(OS, 1, "result Count");
-    writeValueType(OS, Sig.ReturnType, "result type");
+  writeUleb128(OS, Sig.Returns.size(), "result Count");
+  if (Sig.Returns.size()) {
+    writeValueType(OS, Sig.Returns[0], "result type");
   }
 }
 
 void wasm::writeInitExpr(raw_ostream &OS, const WasmInitExpr &InitExpr) {
   writeU8(OS, InitExpr.Opcode, "opcode");
   switch (InitExpr.Opcode) {
   case WASM_OPCODE_I32_CONST:
     writeSleb128(OS, InitExpr.Value.Int32, "literal (i32)");

 void wasm::writeLimits(raw_ostream &OS, const WasmLimits &Limits) {
   writeU8(OS, Limits.Flags, "limits flags");
   writeUleb128(OS, Limits.Initial, "limits initial");
   if (Limits.Flags & WASM_LIMITS_FLAG_HAS_MAX)
     writeUleb128(OS, Limits.Maximum, "limits max");
 }
 
 void wasm::writeGlobalType(raw_ostream &OS, const WasmGlobalType &Type) {
-  writeValueType(OS, Type.Type, "global 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 wasm::writeGlobal(raw_ostream &OS, const WasmGlobal &Global) {
   writeGlobalType(OS, Global.Type);
   writeInitExpr(OS, Global.InitExpr);
 }
 
std::string lld::toString(ValType Type) {
   case ValType::EXCEPT_REF:
     return "except_ref";
   }
   llvm_unreachable("Invalid wasm::ValType");
 }
 
 std::string lld::toString(const WasmSignature &Sig) {
   SmallString<128> S("(");
-  for (uint32_t Type : Sig.ParamTypes) {
+  for (ValType Type : Sig.Params) {
     if (S.size() != 1)
       S += ", ";
-    S += toString(static_cast<ValType>(Type));
+    S += toString(Type);
   }
   S += ") -> ";
-  if (Sig.ReturnType == WASM_TYPE_NORESULT)
+  if (Sig.Returns.size() == 0)
     S += "void";
   else
-    S += toString(static_cast<ValType>(Sig.ReturnType));
+    S += toString(Sig.Returns[0]);
   return S.str();
 }
 
 std::string lld::toString(const WasmGlobalType &Sig) {
   return (Sig.Mutable ? "var " : "const ") +
          toString(static_cast<ValType>(Sig.Type));
 }