[WebAssembly] Use LEB encoding for value types

Previously we were using the encoded LEB hex values
for the value types.  This change uses the decoded
negative value and the LEB encoder to write them out.

Differential Revision: https://reviews.llvm.org/D30847

Patch by Sam Clegg

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@297777 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/include/llvm/MC/MCSymbolWasm.h b/include/llvm/MC/MCSymbolWasm.h
index 4f8820f..4445be0 100644 (file)
--- a/include/llvm/MC/MCSymbolWasm.h
+++ b/include/llvm/MC/MCSymbolWasm.h
@@ -10,14 +10,15 @@
 #define LLVM_MC_MCSYMBOLWASM_H
 
 #include "llvm/MC/MCSymbol.h"
+#include "llvm/Support/Wasm.h"
 
 namespace llvm {
 class MCSymbolWasm : public MCSymbol {
 private:
   bool IsFunction = false;
   std::string ModuleName;
-  SmallVector<unsigned, 1> Returns;
-  SmallVector<unsigned, 4> Params;
+  SmallVector<wasm::ValType, 1> Returns;
+  SmallVector<wasm::ValType, 4> Params;
 
   /// An expression describing how to calculate the size of a symbol. If a
   /// symbol has no size this field will be NULL.
@@ -39,13 +40,15 @@ public:
 
   const StringRef getModuleName() const { return ModuleName; }
 
-  const SmallVector<unsigned, 1> &getReturns() const { return Returns; }
-  void setReturns(SmallVectorImpl<unsigned> &&Rets) {
+  const SmallVector<wasm::ValType, 1> &getReturns() const { return Returns; }
+
+  void setReturns(SmallVectorImpl<wasm::ValType> &&Rets) {
     Returns = std::move(Rets);
   }
 
-  const SmallVector<unsigned, 4> &getParams() const { return Params; }
-  void setParams(SmallVectorImpl<unsigned> &&Pars) {
+  const SmallVector<wasm::ValType, 4> &getParams() const { return Params; }
+
+  void setParams(SmallVectorImpl<wasm::ValType> &&Pars) {
     Params = std::move(Pars);
   }
 };

diff --git a/include/llvm/Support/Wasm.h b/include/llvm/Support/Wasm.h
index feb5fd0..cd15e21 100644 (file)
--- a/include/llvm/Support/Wasm.h
+++ b/include/llvm/Support/Wasm.h
@@ -53,14 +53,14 @@ enum : unsigned {
 };
 
 // Type immediate encodings used in various contexts.
-enum : unsigned {
-  WASM_TYPE_I32          = 0x7f,
-  WASM_TYPE_I64          = 0x7e,
-  WASM_TYPE_F32          = 0x7d,
-  WASM_TYPE_F64          = 0x7c,
-  WASM_TYPE_ANYFUNC      = 0x70,
-  WASM_TYPE_FUNC         = 0x60,
-  WASM_TYPE_NORESULT     = 0x40, // for blocks with no result values
+enum {
+  WASM_TYPE_I32          = -0x01,
+  WASM_TYPE_I64          = -0x02,
+  WASM_TYPE_F32          = -0x03,
+  WASM_TYPE_F64          = -0x04,
+  WASM_TYPE_ANYFUNC      = -0x10,
+  WASM_TYPE_FUNC         = -0x20,
+  WASM_TYPE_NORESULT     = -0x40, // for blocks with no result values
 };
 
 // Kinds of externals (for imports and exports).
@@ -81,6 +81,14 @@ enum : unsigned {
   WASM_OPCODE_F64_CONST  = 0x44,
 };
 
+// Subset of types that a value can have
+enum class ValType {
+  I32 = WASM_TYPE_I32,
+  I64 = WASM_TYPE_I64,
+  F32 = WASM_TYPE_F32,
+  F64 = WASM_TYPE_F64,
+};
+
 #define WASM_RELOC(name, value) name = value,
 
 enum : unsigned {

diff --git a/lib/MC/WasmObjectWriter.cpp b/lib/MC/WasmObjectWriter.cpp
index e61b125..20ace61 100644 (file)
--- a/lib/MC/WasmObjectWriter.cpp
+++ b/lib/MC/WasmObjectWriter.cpp
@@ -109,6 +109,10 @@ private:
 
   void writeHeader(const MCAssembler &Asm);
 
+  void writeValueType(wasm::ValType Ty) {
+    encodeSLEB128(int32_t(Ty), getStream());
+  }
+
   void recordRelocation(MCAssembler &Asm, const MCAsmLayout &Layout,
                         const MCFragment *Fragment, const MCFixup &Fixup,
                         MCValue Target, bool &IsPCRel,
@@ -140,7 +144,7 @@ void WasmObjectWriter::startSection(SectionBookkeeping &Section,
   assert((Name != nullptr) == (SectionId == wasm::WASM_SEC_CUSTOM) &&
          "Only custom sections can have names");
 
-  write8(SectionId);
+  encodeULEB128(SectionId, getStream());
 
   Section.SizeOffset = getStream().tell();
 
@@ -290,10 +294,10 @@ struct WasmFunctionType {
   enum { Plain, Empty, Tombstone } State;
 
   // The return types of the function.
-  SmallVector<unsigned, 1> Returns;
+  SmallVector<wasm::ValType, 1> Returns;
 
   // The parameter types of the function.
-  SmallVector<unsigned, 4> Params;
+  SmallVector<wasm::ValType, 4> Params;
 
   WasmFunctionType() : State(Plain) {}
 
@@ -317,10 +321,10 @@ struct WasmFunctionTypeDenseMapInfo {
   }
   static unsigned getHashValue(const WasmFunctionType &FuncTy) {
     uintptr_t Value = FuncTy.State;
-    for (unsigned Ret : FuncTy.Returns)
-      Value += DenseMapInfo<unsigned>::getHashValue(Ret);
-    for (unsigned Param : FuncTy.Params)
-      Value += DenseMapInfo<unsigned>::getHashValue(Param);
+    for (wasm::ValType Ret : FuncTy.Returns)
+      Value += DenseMapInfo<int32_t>::getHashValue(int32_t(Ret));
+    for (wasm::ValType Param : FuncTy.Params)
+      Value += DenseMapInfo<int32_t>::getHashValue(int32_t(Param));
     return Value;
   }
   static bool isEqual(const WasmFunctionType &LHS,
@@ -756,13 +760,13 @@ void WasmObjectWriter::writeObject(MCAssembler &Asm,
     encodeULEB128(FunctionTypes.size(), getStream());
 
     for (WasmFunctionType &FuncTy : FunctionTypes) {
-      write8(wasm::WASM_TYPE_FUNC);
+      encodeSLEB128(wasm::WASM_TYPE_FUNC, getStream());
       encodeULEB128(FuncTy.Params.size(), getStream());
-      for (unsigned Ty : FuncTy.Params)
-        write8(Ty);
+      for (wasm::ValType Ty : FuncTy.Params)
+        writeValueType(Ty);
       encodeULEB128(FuncTy.Returns.size(), getStream());
-      for (unsigned Ty : FuncTy.Returns)
-        write8(Ty);
+      for (wasm::ValType Ty : FuncTy.Returns)
+        writeValueType(Ty);
     }
 
     endSection(Section);
@@ -782,15 +786,15 @@ void WasmObjectWriter::writeObject(MCAssembler &Asm,
       encodeULEB128(FieldName.size(), getStream());
       writeBytes(FieldName);
 
-      write8(Import.Kind);
+      encodeULEB128(Import.Kind, getStream());
 
       switch (Import.Kind) {
       case wasm::WASM_EXTERNAL_FUNCTION:
         encodeULEB128(Import.Type, getStream());
         break;
       case wasm::WASM_EXTERNAL_GLOBAL:
-        write8(Import.Type);
-        write8(0); // mutability
+        encodeSLEB128(Import.Type, getStream());
+        encodeULEB128(0, getStream()); // mutability
         break;
       default:
         llvm_unreachable("unsupported import kind");
@@ -820,7 +824,7 @@ void WasmObjectWriter::writeObject(MCAssembler &Asm,
   // The number of tables, fixed to 1 for now.
   encodeULEB128(1, getStream());
 
-  write8(wasm::WASM_TYPE_ANYFUNC);
+  encodeSLEB128(wasm::WASM_TYPE_ANYFUNC, getStream());
 
   encodeULEB128(0, getStream());                 // flags
   encodeULEB128(TableElems.size(), getStream()); // initial
@@ -846,7 +850,7 @@ void WasmObjectWriter::writeObject(MCAssembler &Asm,
 
     encodeULEB128(Globals.size(), getStream());
     for (const WasmGlobal &Global : Globals) {
-      write8(Global.Type);
+      encodeSLEB128(Global.Type, getStream());
       write8(Global.IsMutable);
 
       write8(wasm::WASM_OPCODE_I32_CONST);
@@ -866,7 +870,7 @@ void WasmObjectWriter::writeObject(MCAssembler &Asm,
       encodeULEB128(Export.FieldName.size(), getStream());
       writeBytes(Export.FieldName);
 
-      write8(Export.Kind);
+      encodeSLEB128(Export.Kind, getStream());
 
       encodeULEB128(Export.Index, getStream());
     }
@@ -1007,7 +1011,7 @@ void WasmObjectWriter::writeObject(MCAssembler &Asm,
   if (!CodeRelocations.empty()) {
     startSection(Section, wasm::WASM_SEC_CUSTOM, "reloc.CODE");
 
-    write8(wasm::WASM_SEC_CODE);
+    encodeULEB128(wasm::WASM_SEC_CODE, getStream());
 
     encodeULEB128(CodeRelocations.size(), getStream());
 
@@ -1020,7 +1024,7 @@ void WasmObjectWriter::writeObject(MCAssembler &Asm,
   if (!DataRelocations.empty()) {
     startSection(Section, wasm::WASM_SEC_CUSTOM, "reloc.DATA");
 
-    write8(wasm::WASM_SEC_DATA);
+    encodeULEB128(wasm::WASM_SEC_DATA, getStream());
 
     encodeULEB128(DataRelocations.size(), getStream());
 

diff --git a/lib/Target/WebAssembly/MCTargetDesc/WebAssemblyMCTargetDesc.cpp b/lib/Target/WebAssembly/MCTargetDesc/WebAssemblyMCTargetDesc.cpp
index 9ccaf43..9fd3ec8 100644 (file)
--- a/lib/Target/WebAssembly/MCTargetDesc/WebAssemblyMCTargetDesc.cpp
+++ b/lib/Target/WebAssembly/MCTargetDesc/WebAssemblyMCTargetDesc.cpp
@@ -141,12 +141,12 @@ extern "C" void LLVMInitializeWebAssemblyTargetMC() {
   }
 }
 
-WebAssembly::ValType WebAssembly::toValType(const MVT &Ty) {
+wasm::ValType WebAssembly::toValType(const MVT &Ty) {
   switch (Ty.SimpleTy) {
-  case MVT::i32: return WebAssembly::ValType::I32;
-  case MVT::i64: return WebAssembly::ValType::I64;
-  case MVT::f32: return WebAssembly::ValType::F32;
-  case MVT::f64: return WebAssembly::ValType::F64;
+  case MVT::i32: return wasm::ValType::I32;
+  case MVT::i64: return wasm::ValType::I64;
+  case MVT::f32: return wasm::ValType::F32;
+  case MVT::f64: return wasm::ValType::F64;
   default: llvm_unreachable("unexpected type");
   }
 }

diff --git a/lib/Target/WebAssembly/MCTargetDesc/WebAssemblyMCTargetDesc.h b/lib/Target/WebAssembly/MCTargetDesc/WebAssemblyMCTargetDesc.h
index 1108f5f..795658c 100644 (file)
--- a/lib/Target/WebAssembly/MCTargetDesc/WebAssemblyMCTargetDesc.h
+++ b/lib/Target/WebAssembly/MCTargetDesc/WebAssemblyMCTargetDesc.h
@@ -17,6 +17,7 @@
 
 #include "llvm/MC/MCInstrDesc.h"
 #include "llvm/Support/DataTypes.h"
+#include "llvm/Support/Wasm.h"
 
 namespace llvm {
 
@@ -149,40 +150,25 @@ static const unsigned StoreP2AlignOperandNo = 0;
 
 /// This is used to indicate block signatures.
 enum class ExprType {
-  Void    = 0x40,
-  I32     = 0x7f,
-  I64     = 0x7e,
-  F32     = 0x7d,
-  F64     = 0x7c,
-  I8x16   = 0x7b,
-  I16x8   = 0x7a,
-  I32x4   = 0x79,
-  F32x4   = 0x78,
-  B8x16   = 0x77,
-  B16x8   = 0x76,
-  B32x4   = 0x75
-};
-
-/// This is used to indicate local types.
-enum class ValType {
-  I32     = 0x7f,
-  I64     = 0x7e,
-  F32     = 0x7d,
-  F64     = 0x7c,
-  I8x16   = 0x7b,
-  I16x8   = 0x7a,
-  I32x4   = 0x79,
-  F32x4   = 0x78,
-  B8x16   = 0x77,
-  B16x8   = 0x76,
-  B32x4   = 0x75
+  Void    = -0x40,
+  I32     = -0x01,
+  I64     = -0x02,
+  F32     = -0x03,
+  F64     = -0x04,
+  I8x16   = -0x05,
+  I16x8   = -0x06,
+  I32x4   = -0x07,
+  F32x4   = -0x08,
+  B8x16   = -0x09,
+  B16x8   = -0x0a,
+  B32x4   = -0x0b
 };
 
 /// Instruction opcodes emitted via means other than CodeGen.
 static const unsigned Nop = 0x01;
 static const unsigned End = 0x0b;
 
-ValType toValType(const MVT &Ty);
+wasm::ValType toValType(const MVT &Ty);
 
 } // end namespace WebAssembly
 } // end namespace llvm

diff --git a/lib/Target/WebAssembly/MCTargetDesc/WebAssemblyTargetStreamer.cpp b/lib/Target/WebAssembly/MCTargetDesc/WebAssemblyTargetStreamer.cpp
index 5a28593..a499cc2 100644 (file)
--- a/lib/Target/WebAssembly/MCTargetDesc/WebAssemblyTargetStreamer.cpp
+++ b/lib/Target/WebAssembly/MCTargetDesc/WebAssemblyTargetStreamer.cpp
@@ -152,30 +152,20 @@ void WebAssemblyTargetELFStreamer::emitIndirectFunctionType(
 void WebAssemblyTargetELFStreamer::emitGlobalImport(StringRef name) {
 }
 
-static unsigned MVT2WasmType(MVT Ty) {
-  switch (Ty.SimpleTy) {
-  case MVT::i32: return wasm::WASM_TYPE_I32;
-  case MVT::i64: return wasm::WASM_TYPE_I64;
-  case MVT::f32: return wasm::WASM_TYPE_F32;
-  case MVT::f64: return wasm::WASM_TYPE_F64;
-  default: llvm_unreachable("unsupported type");
-  }
-}
-
 void WebAssemblyTargetWasmStreamer::emitParam(MCSymbol *Symbol,
                                               ArrayRef<MVT> Types) {
-  SmallVector<unsigned, 4> Params;
+  SmallVector<wasm::ValType, 4> Params;
   for (MVT Ty : Types)
-    Params.push_back(MVT2WasmType(Ty));
+    Params.push_back(WebAssembly::toValType(Ty));
 
   cast<MCSymbolWasm>(Symbol)->setParams(std::move(Params));
 }
 
 void WebAssemblyTargetWasmStreamer::emitResult(MCSymbol *Symbol,
                                                ArrayRef<MVT> Types) {
-  SmallVector<unsigned, 4> Returns;
+  SmallVector<wasm::ValType, 4> Returns;
   for (MVT Ty : Types)
-    Returns.push_back(MVT2WasmType(Ty));
+    Returns.push_back(WebAssembly::toValType(Ty));
 
   cast<MCSymbolWasm>(Symbol)->setReturns(std::move(Returns));
 }

diff --git a/lib/Target/WebAssembly/WebAssemblyMCInstLower.cpp b/lib/Target/WebAssembly/WebAssemblyMCInstLower.cpp
index 354662d..ff186eb 100644 (file)
--- a/lib/Target/WebAssembly/WebAssemblyMCInstLower.cpp
+++ b/lib/Target/WebAssembly/WebAssemblyMCInstLower.cpp
@@ -45,32 +45,32 @@ WebAssemblyMCInstLower::GetGlobalAddressSymbol(const MachineOperand &MO) const {
     const TargetMachine &TM = MF.getTarget();
     const Function &CurrentFunc = *MF.getFunction();
 
-    SmallVector<unsigned, 4> Returns;
-    SmallVector<unsigned, 4> Params;
+    SmallVector<wasm::ValType, 4> Returns;
+    SmallVector<wasm::ValType, 4> Params;
 
-    WebAssembly::ValType iPTR =
+    wasm::ValType iPTR =
         MF.getSubtarget<WebAssemblySubtarget>().hasAddr64() ?
-        WebAssembly::ValType::I64 :
-        WebAssembly::ValType::I32;
+        wasm::ValType::I64 :
+        wasm::ValType::I32;
 
     SmallVector<MVT, 4> ResultMVTs;
     ComputeLegalValueVTs(CurrentFunc, TM, FuncTy->getReturnType(), ResultMVTs);
     // WebAssembly can't currently handle returning tuples.
     if (ResultMVTs.size() <= 1)
       for (MVT ResultMVT : ResultMVTs)
-        Returns.push_back(unsigned(WebAssembly::toValType(ResultMVT)));
+        Returns.push_back(WebAssembly::toValType(ResultMVT));
     else
-      Params.push_back(unsigned(iPTR));
+      Params.push_back(iPTR);
 
     for (Type *Ty : FuncTy->params()) {
       SmallVector<MVT, 4> ParamMVTs;
       ComputeLegalValueVTs(CurrentFunc, TM, Ty, ParamMVTs);
       for (MVT ParamMVT : ParamMVTs)
-        Params.push_back(unsigned(WebAssembly::toValType(ParamMVT)));
+        Params.push_back(WebAssembly::toValType(ParamMVT));
     }
 
     if (FuncTy->isVarArg())
-      Params.push_back(unsigned(iPTR));
+      Params.push_back(iPTR);
 
     WasmSym->setReturns(std::move(Returns));
     WasmSym->setParams(std::move(Params));
@@ -95,8 +95,8 @@ MCSymbol *WebAssemblyMCInstLower::GetExternalSymbolSymbol(
   if (strcmp(Name, "__stack_pointer") == 0)
     return WasmSym;
 
-  SmallVector<unsigned, 4> Returns;
-  SmallVector<unsigned, 4> Params;
+  SmallVector<wasm::ValType, 4> Returns;
+  SmallVector<wasm::ValType, 4> Params;
   GetSignature(Subtarget, Name, Returns, Params);
 
   WasmSym->setReturns(std::move(Returns));
@@ -128,15 +128,15 @@ MCOperand WebAssemblyMCInstLower::LowerSymbolOperand(MCSymbol *Sym,
 }
 
 // Return the WebAssembly type associated with the given register class.
-static unsigned getType(const TargetRegisterClass *RC) {
+static wasm::ValType getType(const TargetRegisterClass *RC) {
   if (RC == &WebAssembly::I32RegClass)
-    return unsigned(WebAssembly::ExprType::I32);
+    return wasm::ValType::I32;
   if (RC == &WebAssembly::I64RegClass)
-    return unsigned(WebAssembly::ExprType::I64);
+    return wasm::ValType::I64;
   if (RC == &WebAssembly::F32RegClass)
-    return unsigned(WebAssembly::ExprType::F32);
+    return wasm::ValType::F32;
   if (RC == &WebAssembly::F64RegClass)
-    return unsigned(WebAssembly::ExprType::F64);
+    return wasm::ValType::F64;
   llvm_unreachable("Unexpected register class");
 }
 
@@ -172,8 +172,8 @@ void WebAssemblyMCInstLower::Lower(const MachineInstr *MI,
         if (Info.OperandType == WebAssembly::OPERAND_TYPEINDEX) {
           MCSymbol *Sym = Printer.createTempSymbol("typeindex");
           if (!isa<MCSymbolELF>(Sym)) {
-            SmallVector<unsigned, 4> Returns;
-            SmallVector<unsigned, 4> Params;
+            SmallVector<wasm::ValType, 4> Returns;
+            SmallVector<wasm::ValType, 4> Params;
 
             const MachineRegisterInfo &MRI =
                 MI->getParent()->getParent()->getRegInfo();

diff --git a/lib/Target/WebAssembly/WebAssemblyRuntimeLibcallSignatures.cpp b/lib/Target/WebAssembly/WebAssemblyRuntimeLibcallSignatures.cpp
index 974aa52..c02ef4a 100644 (file)
--- a/lib/Target/WebAssembly/WebAssemblyRuntimeLibcallSignatures.cpp
+++ b/lib/Target/WebAssembly/WebAssemblyRuntimeLibcallSignatures.cpp
@@ -971,10 +971,8 @@ RuntimeLibcallNames[RTLIB::UNKNOWN_LIBCALL] = {
 };
 
 void llvm::GetSignature(const WebAssemblySubtarget &Subtarget,
-                        RTLIB::Libcall LC,
-                        SmallVectorImpl<unsigned> &Rets,
-                        SmallVectorImpl<unsigned> &Params)
-{
+                        RTLIB::Libcall LC, SmallVectorImpl<wasm::ValType> &Rets,
+                        SmallVectorImpl<wasm::ValType> &Params) {
   assert(Rets.empty());
   assert(Params.empty());
 
@@ -986,315 +984,313 @@ void llvm::GetSignature(const WebAssemblySubtarget &Subtarget,
   case func:
     break;
   case f32_func_f32:
-    Rets.push_back(unsigned(WebAssembly::ExprType::F32));
-    Params.push_back(unsigned(WebAssembly::ExprType::F32));
+    Rets.push_back(wasm::ValType::F32);
+    Params.push_back(wasm::ValType::F32);
     break;
   case f32_func_f64:
-    Rets.push_back(unsigned(WebAssembly::ExprType::F32));
-    Params.push_back(unsigned(WebAssembly::ExprType::F64));
+    Rets.push_back(wasm::ValType::F32);
+    Params.push_back(wasm::ValType::F64);
     break;
   case f32_func_i32:
-    Rets.push_back(unsigned(WebAssembly::ExprType::F32));
-    Params.push_back(unsigned(WebAssembly::ExprType::I32));
+    Rets.push_back(wasm::ValType::F32);
+    Params.push_back(wasm::ValType::I32);
     break;
   case f32_func_i64:
-    Rets.push_back(unsigned(WebAssembly::ExprType::F32));
-    Params.push_back(unsigned(WebAssembly::ExprType::I64));
+    Rets.push_back(wasm::ValType::F32);
+    Params.push_back(wasm::ValType::I64);
     break;
   case f32_func_i16:
-    Rets.push_back(unsigned(WebAssembly::ExprType::F32));
-    Params.push_back(unsigned(WebAssembly::ExprType::I32));
+    Rets.push_back(wasm::ValType::F32);
+    Params.push_back(wasm::ValType::I32);
     break;
   case f64_func_f32:
-    Rets.push_back(unsigned(WebAssembly::ExprType::F64));
-    Params.push_back(unsigned(WebAssembly::ExprType::F32));
+    Rets.push_back(wasm::ValType::F64);
+    Params.push_back(wasm::ValType::F32);
     break;
   case f64_func_f64:
-    Rets.push_back(unsigned(WebAssembly::ExprType::F64));
-    Params.push_back(unsigned(WebAssembly::ExprType::F64));
+    Rets.push_back(wasm::ValType::F64);
+    Params.push_back(wasm::ValType::F64);
     break;
   case f64_func_i32:
-    Rets.push_back(unsigned(WebAssembly::ExprType::F64));
-    Params.push_back(unsigned(WebAssembly::ExprType::I32));
+    Rets.push_back(wasm::ValType::F64);
+    Params.push_back(wasm::ValType::I32);
     break;
   case f64_func_i64:
-    Rets.push_back(unsigned(WebAssembly::ExprType::F64));
-    Params.push_back(unsigned(WebAssembly::ExprType::I64));
+    Rets.push_back(wasm::ValType::F64);
+    Params.push_back(wasm::ValType::I64);
     break;
   case i32_func_f32:
-    Rets.push_back(unsigned(WebAssembly::ExprType::I32));
-    Params.push_back(unsigned(WebAssembly::ExprType::F32));
+    Rets.push_back(wasm::ValType::I32);
+    Params.push_back(wasm::ValType::F32);
     break;
   case i32_func_f64:
-    Rets.push_back(unsigned(WebAssembly::ExprType::I32));
-    Params.push_back(unsigned(WebAssembly::ExprType::F64));
+    Rets.push_back(wasm::ValType::I32);
+    Params.push_back(wasm::ValType::F64);
     break;
   case i32_func_i32:
-    Rets.push_back(unsigned(WebAssembly::ExprType::I32));
-    Params.push_back(unsigned(WebAssembly::ExprType::I32));
+    Rets.push_back(wasm::ValType::I32);
+    Params.push_back(wasm::ValType::I32);
     break;
   case i64_func_f32:
-    Rets.push_back(unsigned(WebAssembly::ExprType::I64));
-    Params.push_back(unsigned(WebAssembly::ExprType::F32));
+    Rets.push_back(wasm::ValType::I64);
+    Params.push_back(wasm::ValType::F32);
     break;
   case i64_func_f64:
-    Rets.push_back(unsigned(WebAssembly::ExprType::I64));
-    Params.push_back(unsigned(WebAssembly::ExprType::F64));
+    Rets.push_back(wasm::ValType::I64);
+    Params.push_back(wasm::ValType::F64);
     break;
   case i64_func_i64:
-    Rets.push_back(unsigned(WebAssembly::ExprType::I64));
-    Params.push_back(unsigned(WebAssembly::ExprType::I64));
+    Rets.push_back(wasm::ValType::I64);
+    Params.push_back(wasm::ValType::I64);
     break;
   case f32_func_f32_f32:
-    Rets.push_back(unsigned(WebAssembly::ExprType::F32));
-    Params.push_back(unsigned(WebAssembly::ExprType::F32));
-    Params.push_back(unsigned(WebAssembly::ExprType::F32));
+    Rets.push_back(wasm::ValType::F32);
+    Params.push_back(wasm::ValType::F32);
+    Params.push_back(wasm::ValType::F32);
     break;
   case f32_func_f32_i32:
-    Rets.push_back(unsigned(WebAssembly::ExprType::F32));
-    Params.push_back(unsigned(WebAssembly::ExprType::F32));
-    Params.push_back(unsigned(WebAssembly::ExprType::I32));
+    Rets.push_back(wasm::ValType::F32);
+    Params.push_back(wasm::ValType::F32);
+    Params.push_back(wasm::ValType::I32);
     break;
   case f32_func_i64_i64:
-    Rets.push_back(unsigned(WebAssembly::ExprType::F32));
-    Params.push_back(unsigned(WebAssembly::ExprType::I64));
-    Params.push_back(unsigned(WebAssembly::ExprType::I64));
+    Rets.push_back(wasm::ValType::F32);
+    Params.push_back(wasm::ValType::I64);
+    Params.push_back(wasm::ValType::I64);
     break;
   case f64_func_f64_f64:
-    Rets.push_back(unsigned(WebAssembly::ExprType::F64));
-    Params.push_back(unsigned(WebAssembly::ExprType::F64));
-    Params.push_back(unsigned(WebAssembly::ExprType::F64));
+    Rets.push_back(wasm::ValType::F64);
+    Params.push_back(wasm::ValType::F64);
+    Params.push_back(wasm::ValType::F64);
     break;
   case f64_func_f64_i32:
-    Rets.push_back(unsigned(WebAssembly::ExprType::F64));
-    Params.push_back(unsigned(WebAssembly::ExprType::F64));
-    Params.push_back(unsigned(WebAssembly::ExprType::I32));
+    Rets.push_back(wasm::ValType::F64);
+    Params.push_back(wasm::ValType::F64);
+    Params.push_back(wasm::ValType::I32);
     break;
   case f64_func_i64_i64:
-    Rets.push_back(unsigned(WebAssembly::ExprType::F64));
-    Params.push_back(unsigned(WebAssembly::ExprType::I64));
-    Params.push_back(unsigned(WebAssembly::ExprType::I64));
+    Rets.push_back(wasm::ValType::F64);
+    Params.push_back(wasm::ValType::I64);
+    Params.push_back(wasm::ValType::I64);
     break;
   case i16_func_f32:
-    Rets.push_back(unsigned(WebAssembly::ExprType::I32));
-    Params.push_back(unsigned(WebAssembly::ExprType::F32));
+    Rets.push_back(wasm::ValType::I32);
+    Params.push_back(wasm::ValType::F32);
     break;
   case i8_func_i8_i8:
-    Rets.push_back(unsigned(WebAssembly::ExprType::I32));
-    Params.push_back(unsigned(WebAssembly::ExprType::I32));
-    Params.push_back(unsigned(WebAssembly::ExprType::I32));
+    Rets.push_back(wasm::ValType::I32);
+    Params.push_back(wasm::ValType::I32);
+    Params.push_back(wasm::ValType::I32);
     break;
   case func_f32_iPTR_iPTR:
-    Params.push_back(unsigned(WebAssembly::ExprType::F32));
-    Params.push_back(unsigned(iPTR));
-    Params.push_back(unsigned(iPTR));
+    Params.push_back(wasm::ValType::F32);
+    Params.push_back(wasm::ValType(iPTR));
+    Params.push_back(wasm::ValType(iPTR));
     break;
   case func_f64_iPTR_iPTR:
-    Params.push_back(unsigned(WebAssembly::ExprType::F64));
-    Params.push_back(unsigned(iPTR));
-    Params.push_back(unsigned(iPTR));
+    Params.push_back(wasm::ValType::F64);
+    Params.push_back(wasm::ValType(iPTR));
+    Params.push_back(wasm::ValType(iPTR));
     break;
   case i16_func_i16_i16:
-    Rets.push_back(unsigned(WebAssembly::ExprType::I32));
-    Params.push_back(unsigned(WebAssembly::ExprType::I32));
-    Params.push_back(unsigned(WebAssembly::ExprType::I32));
+    Rets.push_back(wasm::ValType::I32);
+    Params.push_back(wasm::ValType::I32);
+    Params.push_back(wasm::ValType::I32);
     break;
   case i32_func_f32_f32:
-    Rets.push_back(unsigned(WebAssembly::ExprType::I32));
-    Params.push_back(unsigned(WebAssembly::ExprType::F32));
-    Params.push_back(unsigned(WebAssembly::ExprType::F32));
+    Rets.push_back(wasm::ValType::I32);
+    Params.push_back(wasm::ValType::F32);
+    Params.push_back(wasm::ValType::F32);
     break;
   case i32_func_f64_f64:
-    Rets.push_back(unsigned(WebAssembly::ExprType::I32));
-    Params.push_back(unsigned(WebAssembly::ExprType::F64));
-    Params.push_back(unsigned(WebAssembly::ExprType::F64));
+    Rets.push_back(wasm::ValType::I32);
+    Params.push_back(wasm::ValType::F64);
+    Params.push_back(wasm::ValType::F64);
     break;
   case i32_func_i32_i32:
-    Rets.push_back(unsigned(WebAssembly::ExprType::I32));
-    Params.push_back(unsigned(WebAssembly::ExprType::I32));
-    Params.push_back(unsigned(WebAssembly::ExprType::I32));
+    Rets.push_back(wasm::ValType::I32);
+    Params.push_back(wasm::ValType::I32);
+    Params.push_back(wasm::ValType::I32);
     break;
   case i64_func_i64_i64:
-    Rets.push_back(unsigned(WebAssembly::ExprType::I64));
-    Params.push_back(unsigned(WebAssembly::ExprType::I64));
-    Params.push_back(unsigned(WebAssembly::ExprType::I64));
+    Rets.push_back(wasm::ValType::I64);
+    Params.push_back(wasm::ValType::I64);
+    Params.push_back(wasm::ValType::I64);
     break;
   case i64_i64_func_f32:
 #if 0 // TODO: Enable this when wasm gets multiple-return-value support.
-    Rets.push_back(unsigned(WebAssembly::ExprType::I64));
-    Rets.push_back(unsigned(WebAssembly::ExprType::I64));
+    Rets.push_back(wasm::ValType::I64);
+    Rets.push_back(wasm::ValType::I64);
 #else
-    Params.push_back(unsigned(iPTR));
+    Params.push_back(wasm::ValType(iPTR));
 #endif
-    Params.push_back(unsigned(WebAssembly::ExprType::F32));
+    Params.push_back(wasm::ValType::F32);
     break;
   case i64_i64_func_f64:
 #if 0 // TODO: Enable this when wasm gets multiple-return-value support.
-    Rets.push_back(unsigned(WebAssembly::ExprType::I64));
-    Rets.push_back(unsigned(WebAssembly::ExprType::I64));
+    Rets.push_back(wasm::ValType::I64);
+    Rets.push_back(wasm::ValType::I64);
 #else
-    Params.push_back(unsigned(iPTR));
+    Params.push_back(wasm::ValType(iPTR));
 #endif
-    Params.push_back(unsigned(WebAssembly::ExprType::F64));
+    Params.push_back(wasm::ValType::F64);
     break;
   case i16_i16_func_i16_i16:
 #if 0 // TODO: Enable this when wasm gets multiple-return-value support.
-    Rets.push_back(unsigned(WebAssembly::ExprType::I32));
-    Rets.push_back(unsigned(WebAssembly::ExprType::I32));
+    Rets.push_back(wasm::ValType::I32);
+    Rets.push_back(wasm::ValType::I32);
 #else
-    Params.push_back(unsigned(iPTR));
+    Params.push_back(wasm::ValType(iPTR));
 #endif
-    Params.push_back(unsigned(WebAssembly::ExprType::I32));
-    Params.push_back(unsigned(WebAssembly::ExprType::I32));
+    Params.push_back(wasm::ValType::I32);
+    Params.push_back(wasm::ValType::I32);
     break;
   case i32_i32_func_i32_i32:
 #if 0 // TODO: Enable this when wasm gets multiple-return-value support.
-    Rets.push_back(unsigned(WebAssembly::ExprType::I32));
-    Rets.push_back(unsigned(WebAssembly::ExprType::I32));
+    Rets.push_back(wasm::ValType::I32);
+    Rets.push_back(wasm::ValType::I32);
 #else
-    Params.push_back(unsigned(iPTR));
+    Params.push_back(wasm::ValType(iPTR));
 #endif
-    Params.push_back(unsigned(WebAssembly::ExprType::I32));
-    Params.push_back(unsigned(WebAssembly::ExprType::I32));
+    Params.push_back(wasm::ValType::I32);
+    Params.push_back(wasm::ValType::I32);
     break;
   case i64_i64_func_i64_i64:
 #if 0 // TODO: Enable this when wasm gets multiple-return-value support.
-    Rets.push_back(unsigned(WebAssembly::ExprType::I64));
-    Rets.push_back(unsigned(WebAssembly::ExprType::I64));
+    Rets.push_back(wasm::ValType::I64);
+    Rets.push_back(wasm::ValType::I64);
 #else
-    Params.push_back(unsigned(iPTR));
+    Params.push_back(wasm::ValType(iPTR));
 #endif
-    Params.push_back(unsigned(WebAssembly::ExprType::I64));
-    Params.push_back(unsigned(WebAssembly::ExprType::I64));
+    Params.push_back(wasm::ValType::I64);
+    Params.push_back(wasm::ValType::I64);
     break;
   case i64_i64_func_i64_i64_i64_i64:
 #if 0 // TODO: Enable this when wasm gets multiple-return-value support.
-    Rets.push_back(unsigned(WebAssembly::ExprType::I64));
-    Rets.push_back(unsigned(WebAssembly::ExprType::I64));
+    Rets.push_back(wasm::ValType::I64);
+    Rets.push_back(wasm::ValType::I64);
 #else
-    Params.push_back(unsigned(iPTR));
+    Params.push_back(wasm::ValType(iPTR));
 #endif
-    Params.push_back(unsigned(WebAssembly::ExprType::I64));
-    Params.push_back(unsigned(WebAssembly::ExprType::I64));
-    Params.push_back(unsigned(WebAssembly::ExprType::I64));
-    Params.push_back(unsigned(WebAssembly::ExprType::I64));
+    Params.push_back(wasm::ValType::I64);
+    Params.push_back(wasm::ValType::I64);
+    Params.push_back(wasm::ValType::I64);
+    Params.push_back(wasm::ValType::I64);
     break;
   case i64_i64_i64_i64_func_i64_i64_i64_i64:
 #if 0 // TODO: Enable this when wasm gets multiple-return-value support.
-    Rets.push_back(unsigned(WebAssembly::ExprType::I64));
-    Rets.push_back(unsigned(WebAssembly::ExprType::I64));
-    Rets.push_back(unsigned(WebAssembly::ExprType::I64));
-    Rets.push_back(unsigned(WebAssembly::ExprType::I64));
+    Rets.push_back(wasm::ValType::I64);
+    Rets.push_back(wasm::ValType::I64);
+    Rets.push_back(wasm::ValType::I64);
+    Rets.push_back(wasm::ValType::I64);
 #else
-    Params.push_back(unsigned(iPTR));
+    Params.push_back(wasm::ValType(iPTR));
 #endif
-    Params.push_back(unsigned(WebAssembly::ExprType::I64));
-    Params.push_back(unsigned(WebAssembly::ExprType::I64));
-    Params.push_back(unsigned(WebAssembly::ExprType::I64));
-    Params.push_back(unsigned(WebAssembly::ExprType::I64));
+    Params.push_back(wasm::ValType::I64);
+    Params.push_back(wasm::ValType::I64);
+    Params.push_back(wasm::ValType::I64);
+    Params.push_back(wasm::ValType::I64);
     break;
   case i64_i64_func_i64_i64_i32:
 #if 0 // TODO: Enable this when wasm gets multiple-return-value support.
-    Rets.push_back(unsigned(WebAssembly::ExprType::I64));
-    Rets.push_back(unsigned(WebAssembly::ExprType::I64));
-    Rets.push_back(unsigned(WebAssembly::ExprType::I64));
-    Rets.push_back(unsigned(WebAssembly::ExprType::I64));
+    Rets.push_back(wasm::ValType::I64);
+    Rets.push_back(wasm::ValType::I64);
+    Rets.push_back(wasm::ValType::I64);
+    Rets.push_back(wasm::ValType::I64);
 #else
-    Params.push_back(unsigned(iPTR));
+    Params.push_back(wasm::ValType(iPTR));
 #endif
-    Params.push_back(unsigned(WebAssembly::ExprType::I64));
-    Params.push_back(unsigned(WebAssembly::ExprType::I64));
-    Params.push_back(unsigned(WebAssembly::ExprType::I32));
+    Params.push_back(wasm::ValType::I64);
+    Params.push_back(wasm::ValType::I64);
+    Params.push_back(wasm::ValType::I32);
     break;
   case iPTR_func_iPTR_i32_iPTR:
-    Rets.push_back(unsigned(iPTR));
-    Params.push_back(unsigned(iPTR));
-    Params.push_back(unsigned(WebAssembly::ExprType::I32));
-    Params.push_back(unsigned(iPTR));
+    Rets.push_back(wasm::ValType(iPTR));
+    Params.push_back(wasm::ValType(iPTR));
+    Params.push_back(wasm::ValType::I32);
+    Params.push_back(wasm::ValType(iPTR));
     break;
   case iPTR_func_iPTR_iPTR_iPTR:
-    Rets.push_back(unsigned(iPTR));
-    Params.push_back(unsigned(iPTR));
-    Params.push_back(unsigned(iPTR));
-    Params.push_back(unsigned(iPTR));
+    Rets.push_back(wasm::ValType(iPTR));
+    Params.push_back(wasm::ValType(iPTR));
+    Params.push_back(wasm::ValType(iPTR));
+    Params.push_back(wasm::ValType(iPTR));
     break;
   case f32_func_f32_f32_f32:
-    Rets.push_back(unsigned(WebAssembly::ExprType::F32));
-    Params.push_back(unsigned(WebAssembly::ExprType::F32));
-    Params.push_back(unsigned(WebAssembly::ExprType::F32));
-    Params.push_back(unsigned(WebAssembly::ExprType::F32));
+    Rets.push_back(wasm::ValType::F32);
+    Params.push_back(wasm::ValType::F32);
+    Params.push_back(wasm::ValType::F32);
+    Params.push_back(wasm::ValType::F32);
     break;
   case f64_func_f64_f64_f64:
-    Rets.push_back(unsigned(WebAssembly::ExprType::F64));
-    Params.push_back(unsigned(WebAssembly::ExprType::F64));
-    Params.push_back(unsigned(WebAssembly::ExprType::F64));
-    Params.push_back(unsigned(WebAssembly::ExprType::F64));
+    Rets.push_back(wasm::ValType::F64);
+    Params.push_back(wasm::ValType::F64);
+    Params.push_back(wasm::ValType::F64);
+    Params.push_back(wasm::ValType::F64);
     break;
   case func_i64_i64_iPTR_iPTR:
-    Params.push_back(unsigned(WebAssembly::ExprType::I64));
-    Params.push_back(unsigned(WebAssembly::ExprType::I64));
-    Params.push_back(unsigned(iPTR));
-    Params.push_back(unsigned(iPTR));
+    Params.push_back(wasm::ValType::I64);
+    Params.push_back(wasm::ValType::I64);
+    Params.push_back(wasm::ValType(iPTR));
+    Params.push_back(wasm::ValType(iPTR));
     break;
   case func_iPTR_f32:
-    Params.push_back(unsigned(iPTR));
-    Params.push_back(unsigned(WebAssembly::ExprType::F32));
+    Params.push_back(wasm::ValType(iPTR));
+    Params.push_back(wasm::ValType::F32);
     break;
   case func_iPTR_f64:
-    Params.push_back(unsigned(iPTR));
-    Params.push_back(unsigned(WebAssembly::ExprType::F64));
+    Params.push_back(wasm::ValType(iPTR));
+    Params.push_back(wasm::ValType::F64);
     break;
   case func_iPTR_i32:
-    Params.push_back(unsigned(iPTR));
-    Params.push_back(unsigned(WebAssembly::ExprType::I32));
+    Params.push_back(wasm::ValType(iPTR));
+    Params.push_back(wasm::ValType::I32);
     break;
   case func_iPTR_i64:
-    Params.push_back(unsigned(iPTR));
-    Params.push_back(unsigned(WebAssembly::ExprType::I64));
+    Params.push_back(wasm::ValType(iPTR));
+    Params.push_back(wasm::ValType::I64);
     break;
   case func_iPTR_i64_i64:
-    Params.push_back(unsigned(iPTR));
-    Params.push_back(unsigned(WebAssembly::ExprType::I64));
-    Params.push_back(unsigned(WebAssembly::ExprType::I64));
+    Params.push_back(wasm::ValType(iPTR));
+    Params.push_back(wasm::ValType::I64);
+    Params.push_back(wasm::ValType::I64);
     break;
   case func_iPTR_i64_i64_i64_i64:
-    Params.push_back(unsigned(iPTR));
-    Params.push_back(unsigned(WebAssembly::ExprType::I64));
-    Params.push_back(unsigned(WebAssembly::ExprType::I64));
-    Params.push_back(unsigned(WebAssembly::ExprType::I64));
-    Params.push_back(unsigned(WebAssembly::ExprType::I64));
+    Params.push_back(wasm::ValType(iPTR));
+    Params.push_back(wasm::ValType::I64);
+    Params.push_back(wasm::ValType::I64);
+    Params.push_back(wasm::ValType::I64);
+    Params.push_back(wasm::ValType::I64);
     break;
   case func_iPTR_i64_i64_i64_i64_i64_i64:
-    Params.push_back(unsigned(iPTR));
-    Params.push_back(unsigned(WebAssembly::ExprType::I64));
-    Params.push_back(unsigned(WebAssembly::ExprType::I64));
-    Params.push_back(unsigned(WebAssembly::ExprType::I64));
-    Params.push_back(unsigned(WebAssembly::ExprType::I64));
-    Params.push_back(unsigned(WebAssembly::ExprType::I64));
-    Params.push_back(unsigned(WebAssembly::ExprType::I64));
+    Params.push_back(wasm::ValType(iPTR));
+    Params.push_back(wasm::ValType::I64);
+    Params.push_back(wasm::ValType::I64);
+    Params.push_back(wasm::ValType::I64);
+    Params.push_back(wasm::ValType::I64);
+    Params.push_back(wasm::ValType::I64);
+    Params.push_back(wasm::ValType::I64);
     break;
   case i32_func_i64_i64:
-    Rets.push_back(unsigned(WebAssembly::ExprType::I32));
-    Params.push_back(unsigned(WebAssembly::ExprType::I64));
-    Params.push_back(unsigned(WebAssembly::ExprType::I64));
+    Rets.push_back(wasm::ValType::I32);
+    Params.push_back(wasm::ValType::I64);
+    Params.push_back(wasm::ValType::I64);
     break;
   case i32_func_i64_i64_i64_i64:
-    Rets.push_back(unsigned(WebAssembly::ExprType::I32));
-    Params.push_back(unsigned(WebAssembly::ExprType::I64));
-    Params.push_back(unsigned(WebAssembly::ExprType::I64));
-    Params.push_back(unsigned(WebAssembly::ExprType::I64));
-    Params.push_back(unsigned(WebAssembly::ExprType::I64));
+    Rets.push_back(wasm::ValType::I32);
+    Params.push_back(wasm::ValType::I64);
+    Params.push_back(wasm::ValType::I64);
+    Params.push_back(wasm::ValType::I64);
+    Params.push_back(wasm::ValType::I64);
     break;
   case unsupported:
     llvm_unreachable("unsupported runtime library signature");
   }
 }
 
-void llvm::GetSignature(const WebAssemblySubtarget &Subtarget,
-                        const char *Name,
-                        SmallVectorImpl<unsigned> &Rets,
-                        SmallVectorImpl<unsigned> &Params)
-{
+void llvm::GetSignature(const WebAssemblySubtarget &Subtarget, const char *Name,
+                        SmallVectorImpl<wasm::ValType> &Rets,
+                        SmallVectorImpl<wasm::ValType> &Params) {
   assert(strcmp(RuntimeLibcallNames[RTLIB::DEOPTIMIZE], "__llvm_deoptimize") ==
          0);
 

diff --git a/lib/Target/WebAssembly/WebAssemblyRuntimeLibcallSignatures.h b/lib/Target/WebAssembly/WebAssemblyRuntimeLibcallSignatures.h
index 690ca86..1290676 100644 (file)
--- a/lib/Target/WebAssembly/WebAssemblyRuntimeLibcallSignatures.h
+++ b/lib/Target/WebAssembly/WebAssemblyRuntimeLibcallSignatures.h
@@ -25,13 +25,12 @@ class WebAssemblySubtarget;
 
 extern void GetSignature(const WebAssemblySubtarget &Subtarget,
                          RTLIB::Libcall LC,
-                         SmallVectorImpl<unsigned> &Rets,
-                         SmallVectorImpl<unsigned> &Params);
+                         SmallVectorImpl<wasm::ValType> &Rets,
+                         SmallVectorImpl<wasm::ValType> &Params);
 
 extern void GetSignature(const WebAssemblySubtarget &Subtarget,
-                         const char *Name,
-                         SmallVectorImpl<unsigned> &Rets,
-                         SmallVectorImpl<unsigned> &Params);
+                         const char *Name, SmallVectorImpl<wasm::ValType> &Rets,
+                         SmallVectorImpl<wasm::ValType> &Params);
 
 } // end namespace llvm