[WebAssembly] Use LEB encoding for value types

[sbc100]

Summary

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.

[dschuff]

lib/Target/WebAssembly/MCTargetDesc/WebAssemblyMCTargetDesc.h

183

my first comment was here, that it probably makes sense to keep opcodes as unsigned in general; it's the general convention in LLVM and there could eventually be more wasm opcodes than will fit in a uint8.

More generally still, it's pretty common in LLVM to use unsigned for things that will eventually just be encoded (or most things generally really). So the fact that we have a good reason to use negative values here is unusual. So maybe it warrants a typedef instead of just using int32_t?

[sbc100]

Update types in WebAssemblyMCTargetDesc.h

[sbc100]

• Revert change of Nop and End types

[sbc100]

lib/Target/WebAssembly/MCTargetDesc/WebAssemblyMCTargetDesc.h

183

I reverted this part of the change.

I guess we could use the above ValType everywhere in the change rather than int32_t?

Or we could stick with what dan had which is to not decode or encode the negative LEBs at all?

This change was motivated because I'm working other tools which assume that these get decoded and encoded when read and written, but I could instead change my work to use this approach?

[dschuff]

lib/Target/WebAssembly/MCTargetDesc/WebAssemblyMCTargetDesc.h

183

I do like the idea of using the negative values and encoding them when we encode everything else, rather than using the encoded values everywhere. So the question is whether to use ValType instead of int32_t. I think I'd be inclined to use ValType.

[sunfish]

Using ValType sounds good to me.

[sbc100]

• Move more types to Support/Wasm.h
• clang-format

[dschuff]

LGTM with nit

lib/Target/WebAssembly/MCTargetDesc/WebAssemblyTargetStreamer.cpp

155

This now duplicates WebAssembly::toValType in WebAssemblyMCTargetDesc, can that one be easily used?

[dschuff]

A couple of observations of pre-existing stuff:

1. It seems odd that we have both wasm and WebAssembly namespaces
2. based on the name and the history of wasm, ExprType vs ValType seem like they ought to be the same thing. Right now it looks like ExprType was made for block signatures. We might want to unify or rationalize the use of those somehow; it might not be obvious everywhere on the face of it where we'd need a general block signature (i.e. that may be void) and where we want a non-void type.

[sbc100]

• remove MVT2WasmType in favor of WebAssembly::toValType
• Merge remote-tracking branch 'refs/remotes/origin/master' into fix_value_types

[sunfish]

When wasm gets multiple return values, and maybe block signatures are extended to multiple values, ExprType marks the places that will turn into sequence-of-types, while ValType will always be used for individual values.

[sbc100]

In terms the namespacing, yes it probably makes sense to try to merge them and be consistent, but thats not something for this PR.

[sbc100]

Ping? Hopefully this change is good to go now.

include/llvm/MC/MCSymbolWasm.h

 
 #include "llvm/MC/MCSymbol.h"
 
 namespace llvm {
 class MCSymbolWasm : public MCSymbol {
 private:
   bool IsFunction = false;
   std::string ModuleName;
-  SmallVector<unsigned, 1> Returns;
-  SmallVector<unsigned, 4> Params;
+  SmallVector<int32_t, 1> Returns;
+  SmallVector<int32_t, 4> Params;
 
   /// An expression describing how to calculate the size of a symbol. If a
   /// symbol has no size this field will be NULL.
   const MCExpr *SymbolSize = nullptr;
 
 public:
   // Use a module name of "env" for now, for compatibility with existing tools.
   // This is temporary, and may change, as the ABI is not yet stable.
   MCSymbolWasm(const StringMapEntry<bool> *Name, bool isTemporary)
       : MCSymbol(SymbolKindWasm, Name, isTemporary),
         ModuleName("env") {}
   static bool classof(const MCSymbol *S) { return S->isWasm(); }
 
   const MCExpr *getSize() const { return SymbolSize; }
   void setSize(const MCExpr *SS) { SymbolSize = SS; }
 
   bool isFunction() const { return IsFunction; }
   void setIsFunction(bool isFunc) { IsFunction = isFunc; }
 
   const StringRef getModuleName() const { return ModuleName; }
 
-  const SmallVector<unsigned, 1> &getReturns() const { return Returns; }
-  void setReturns(SmallVectorImpl<unsigned> &&Rets) {
+  const SmallVector<int32_t, 1> &getReturns() const { return Returns; }
+  void setReturns(SmallVectorImpl<int32_t> &&Rets) {
     Returns = std::move(Rets);
   }
 
-  const SmallVector<unsigned, 4> &getParams() const { return Params; }
-  void setParams(SmallVectorImpl<unsigned> &&Pars) {
+  const SmallVector<int32_t, 4> &getParams() const { return Params; }
+  void setParams(SmallVectorImpl<int32_t> &&Pars) {
     Params = std::move(Pars);
   }
 };
 }
 
 #endif

include/llvm/Support/Wasm.h

enum : unsigned {
   WASM_SEC_EXPORT = 7,   // Exports
   WASM_SEC_START = 8,    // Start function declaration
   WASM_SEC_ELEM = 9,     // Elements section
   WASM_SEC_CODE = 10,    // Function bodies (code)
   WASM_SEC_DATA = 11     // Data segments
 };
 
 // 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).
 enum : unsigned {
   WASM_EXTERNAL_FUNCTION = 0x0,
   WASM_EXTERNAL_TABLE    = 0x1,
   WASM_EXTERNAL_MEMORY   = 0x2,
   WASM_EXTERNAL_GLOBAL   = 0x3,

lib/MC/WasmObjectWriter.cpp

 
 // Write out a section header and a patchable section size field.
 void WasmObjectWriter::startSection(SectionBookkeeping &Section,
                                     unsigned SectionId,
                                     const char *Name) {
   assert((Name != nullptr) == (SectionId == wasm::WASM_SEC_CUSTOM) &&
          "Only custom sections can have names");
 
-  write8(SectionId);
+  encodeULEB128(SectionId, getStream());
 
   Section.SizeOffset = getStream().tell();
 
   // The section size. We don't know the size yet, so reserve enough space
   // for any 32-bit value; we'll patch it later.
   encodeULEB128(UINT32_MAX, getStream());
 
   // The position where the section starts, for measuring its size.

 
 // The signature of a wasm function, in a struct capable of being used as a
 // DenseMap key.
 struct WasmFunctionType {
   // Support empty and tombstone instances, needed by DenseMap.
   enum { Plain, Empty, Tombstone } State;
 
   // The return types of the function.
-  SmallVector<unsigned, 1> Returns;
+  SmallVector<int32_t, 1> Returns;
 
   // The parameter types of the function.
-  SmallVector<unsigned, 4> Params;
+  SmallVector<int32_t, 4> Params;
 
   WasmFunctionType() : State(Plain) {}
 
   bool operator==(const WasmFunctionType &Other) const {
     return State == Other.State && Returns == Other.Returns &&
            Params == Other.Params;
   }
 };
 
 // Traits for using WasmFunctionType in a DenseMap.
 struct WasmFunctionTypeDenseMapInfo {
   static WasmFunctionType getEmptyKey() {
     WasmFunctionType FuncTy;
     FuncTy.State = WasmFunctionType::Empty;
     return FuncTy;
   }
   static WasmFunctionType getTombstoneKey() {
     WasmFunctionType FuncTy;
     FuncTy.State = WasmFunctionType::Tombstone;
     return FuncTy;
   }
   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 (int32_t Ret : FuncTy.Returns)
+      Value += DenseMapInfo<uint32_t>::getHashValue(Ret);
+    for (int32_t Param : FuncTy.Params)
+      Value += DenseMapInfo<int32_t>::getHashValue(Param);
     return Value;
   }
   static bool isEqual(const WasmFunctionType &LHS,
                       const WasmFunctionType &RHS) {
     return LHS == RHS;
   }
 };
 
void WasmObjectWriter::writeObject(MCAssembler &Asm,
 
   // === Type Section =========================================================
   if (!FunctionTypes.empty()) {
     startSection(Section, wasm::WASM_SEC_TYPE);
 
     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 (int32_t Ty : FuncTy.Params)
+        encodeSLEB128(Ty, getStream());
       encodeULEB128(FuncTy.Returns.size(), getStream());
-      for (unsigned Ty : FuncTy.Returns)
-        write8(Ty);
+      for (int32_t Ty : FuncTy.Returns)
+        encodeSLEB128(Ty, getStream());
     }
 
     endSection(Section);
   }
 
   // === Import Section ========================================================
   if (!Imports.empty()) {
     startSection(Section, wasm::WASM_SEC_IMPORT);
 
     encodeULEB128(Imports.size(), getStream());
     for (const WasmImport &Import : Imports) {
       StringRef ModuleName = Import.ModuleName;
       encodeULEB128(ModuleName.size(), getStream());
       writeBytes(ModuleName);
 
       StringRef FieldName = Import.FieldName;
       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");
       }
     }
 
     endSection(Section);
   }
void WasmObjectWriter::writeObject(MCAssembler &Asm,
   // For now, always emit the table section, since indirect calls are not
   // valid without it. In the future, we could perhaps be more clever and omit
   // it if there are no indirect calls.
   startSection(Section, wasm::WASM_SEC_TABLE);
 
   // 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
 
   endSection(Section);
 
   // === Memory Section ========================================================
   // For now, always emit the memory section, since loads and stores are not
void WasmObjectWriter::writeObject(MCAssembler &Asm,
   endSection(Section);
 
   // === Global Section ========================================================
   if (!Globals.empty()) {
     startSection(Section, wasm::WASM_SEC_GLOBAL);
 
     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);
       encodeSLEB128(Global.InitialValue, getStream()); // offset
       write8(wasm::WASM_OPCODE_END);
     }
 
     endSection(Section);
   }
 
   // === Export Section ========================================================
   if (!Exports.empty()) {
     startSection(Section, wasm::WASM_SEC_EXPORT);
 
     encodeULEB128(Exports.size(), getStream());
     for (const WasmExport &Export : Exports) {
       encodeULEB128(Export.FieldName.size(), getStream());
       writeBytes(Export.FieldName);
 
-      write8(Export.Kind);
+      encodeSLEB128(Export.Kind, getStream());
 
       encodeULEB128(Export.Index, getStream());
     }
 
     endSection(Section);
   }
 
 #if 0 // TODO: Start Section
#endif
 
   // See: https://github.com/WebAssembly/tool-conventions/blob/master/Linking.md
   // for descriptions of the reloc sections.
 
   // === Code Reloc Section ====================================================
   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());
 
     WriteRelocations(CodeRelocations, getStream(), SymbolIndices);
 
     endSection(Section);
   }
 
   // === Data Reloc Section ====================================================
   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());
 
     WriteRelocations(DataRelocations, getStream(), SymbolIndices);
 
     endSection(Section);
   }
 

lib/Target/WebAssembly/MCTargetDesc/WebAssemblyMCTargetDesc.h

 static const unsigned StoreAddressOperandNo = 2;
 
 /// The operand number of the load or store p2align in load/store instructions.
 static const unsigned LoadP2AlignOperandNo = 1;
 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
+  Void    = -0x40,
+  I32     = -0x01,
+  I64     = -0x02,
+  F32     = -0x03,
+  F64     = -0x04,
+  I8x16   = -0x05,
+  I16x8   = -0x06,
+  I32x4   = -0x07,
+  F32x4   = -0x08,
+  B8x16   = -0x09,
+  B16x8   = -0x0a,
+  B32x4   = -0x0b
 };
 
 /// 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
+  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);
 
 } // end namespace WebAssembly
 } // end namespace llvm
 
 #endif

lib/Target/WebAssembly/MCTargetDesc/WebAssemblyTargetStreamer.cpp

void WebAssemblyTargetELFStreamer::emitIndirectFunctionType(
     StringRef name, SmallVectorImpl<MVT> &Params, SmallVectorImpl<MVT> &Results) {
   // Nothing to emit here. TODO: Re-design how linking works and re-evaluate
   // whether it's necessary for .o files to declare indirect function types.
 }
 
 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<int32_t, 4> Params;
   for (MVT Ty : Types)
     Params.push_back(MVT2WasmType(Ty));
 
   cast<MCSymbolWasm>(Symbol)->setParams(std::move(Params));
 }
 
 void WebAssemblyTargetWasmStreamer::emitResult(MCSymbol *Symbol,
                                                ArrayRef<MVT> Types) {
-  SmallVector<unsigned, 4> Returns;
+  SmallVector<int32_t, 4> Returns;
   for (MVT Ty : Types)
     Returns.push_back(MVT2WasmType(Ty));
 
   cast<MCSymbolWasm>(Symbol)->setReturns(std::move(Returns));
 }
 
 void WebAssemblyTargetWasmStreamer::emitLocal(ArrayRef<MVT> Types) {
   SmallVector<std::pair<MVT, uint32_t>, 4> Grouped;

lib/Target/WebAssembly/WebAssemblyMCInstLower.cpp

WebAssemblyMCInstLower::GetGlobalAddressSymbol(const MachineOperand &MO) const {
 
   MCSymbolWasm *WasmSym = cast<MCSymbolWasm>(Sym);
 
   if (const auto *FuncTy = dyn_cast<FunctionType>(Global->getValueType())) {
     const MachineFunction &MF = *MO.getParent()->getParent()->getParent();
     const TargetMachine &TM = MF.getTarget();
     const Function &CurrentFunc = *MF.getFunction();
 
-    SmallVector<unsigned, 4> Returns;
-    SmallVector<unsigned, 4> Params;
+    SmallVector<int32_t, 4> Returns;
+    SmallVector<int32_t, 4> Params;
 
     WebAssembly::ValType iPTR =
         MF.getSubtarget<WebAssemblySubtarget>().hasAddr64() ?
         WebAssembly::ValType::I64 :
         WebAssembly::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(int32_t(WebAssembly::toValType(ResultMVT)));
     else
-      Params.push_back(unsigned(iPTR));
+      Params.push_back(int32_t(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(int32_t(WebAssembly::toValType(ParamMVT)));
     }
 
     if (FuncTy->isVarArg())
-      Params.push_back(unsigned(iPTR));
+      Params.push_back(int32_t(iPTR));
 
     WasmSym->setReturns(std::move(Returns));
     WasmSym->setParams(std::move(Params));
     WasmSym->setIsFunction(true);
   }
 
   return WasmSym;
 }
 
 MCSymbol *WebAssemblyMCInstLower::GetExternalSymbolSymbol(
     const MachineOperand &MO) const {
   const char *Name = MO.getSymbolName();
   MCSymbol *Sym = Printer.GetExternalSymbolSymbol(Name);
   if (isa<MCSymbolELF>(Sym))
     return Sym;
 
   MCSymbolWasm *WasmSym = cast<MCSymbolWasm>(Sym);
   const WebAssemblySubtarget &Subtarget = Printer.getSubtarget();
 
   // __stack_pointer is a global variable; all other external symbols used by
   // CodeGen are functions.
   if (strcmp(Name, "__stack_pointer") == 0)
     return WasmSym;
 
-  SmallVector<unsigned, 4> Returns;
-  SmallVector<unsigned, 4> Params;
+  SmallVector<int32_t, 4> Returns;
+  SmallVector<int32_t, 4> Params;
   GetSignature(Subtarget, Name, Returns, Params);
 
   WasmSym->setReturns(std::move(Returns));
   WasmSym->setParams(std::move(Params));
   WasmSym->setIsFunction(true);
 
   return WasmSym;
 }
if (Offset != 0) {
     Expr =
         MCBinaryExpr::createAdd(Expr, MCConstantExpr::create(Offset, Ctx), Ctx);
   }
 
   return MCOperand::createExpr(Expr);
 }
 
 // Return the WebAssembly type associated with the given register class.
-static unsigned getType(const TargetRegisterClass *RC) {
+static int32_t getType(const TargetRegisterClass *RC) {
   if (RC == &WebAssembly::I32RegClass)
-    return unsigned(WebAssembly::ExprType::I32);
+    return int32_t(WebAssembly::ExprType::I32);
   if (RC == &WebAssembly::I64RegClass)
-    return unsigned(WebAssembly::ExprType::I64);
+    return int32_t(WebAssembly::ExprType::I64);
   if (RC == &WebAssembly::F32RegClass)
-    return unsigned(WebAssembly::ExprType::F32);
+    return int32_t(WebAssembly::ExprType::F32);
   if (RC == &WebAssembly::F64RegClass)
-    return unsigned(WebAssembly::ExprType::F64);
+    return int32_t(WebAssembly::ExprType::F64);
   llvm_unreachable("Unexpected register class");
 }
 
 void WebAssemblyMCInstLower::Lower(const MachineInstr *MI,
                                    MCInst &OutMI) const {
   OutMI.setOpcode(MI->getOpcode());
 
   const MCInstrDesc &Desc = MI->getDesc();
case MachineOperand::MO_Register: {
       break;
     }
     case MachineOperand::MO_Immediate:
       if (i < Desc.NumOperands) {
         const MCOperandInfo &Info = Desc.OpInfo[i];
         if (Info.OperandType == WebAssembly::OPERAND_TYPEINDEX) {
           MCSymbol *Sym = Printer.createTempSymbol("typeindex");
           if (!isa<MCSymbolELF>(Sym)) {
-            SmallVector<unsigned, 4> Returns;
-            SmallVector<unsigned, 4> Params;
+            SmallVector<int32_t, 4> Returns;
+            SmallVector<int32_t, 4> Params;
 
             const MachineRegisterInfo &MRI =
                 MI->getParent()->getParent()->getRegInfo();
             for (const MachineOperand &MO : MI->defs())
               Returns.push_back(getType(MRI.getRegClass(MO.getReg())));
             for (const MachineOperand &MO : MI->explicit_uses())
               if (MO.isReg())
                 Params.push_back(getType(MRI.getRegClass(MO.getReg())));

lib/Target/WebAssembly/WebAssemblyRuntimeLibcallSignatures.h

 #include "llvm/CodeGen/RuntimeLibcalls.h"
 
 namespace llvm {
 
 class WebAssemblySubtarget;
 
 extern void GetSignature(const WebAssemblySubtarget &Subtarget,
                          RTLIB::Libcall LC,
-                         SmallVectorImpl<unsigned> &Rets,
-                         SmallVectorImpl<unsigned> &Params);
+                         SmallVectorImpl<int32_t> &Rets,
+                         SmallVectorImpl<int32_t> &Params);
 
 extern void GetSignature(const WebAssemblySubtarget &Subtarget,
                          const char *Name,
-                         SmallVectorImpl<unsigned> &Rets,
-                         SmallVectorImpl<unsigned> &Params);
+                         SmallVectorImpl<int32_t> &Rets,
+                         SmallVectorImpl<int32_t> &Params);
 
 } // end namespace llvm
 
 #endif

lib/Target/WebAssembly/WebAssemblyRuntimeLibcallSignatures.cpp

 
 /* STACKPROTECTOR_CHECK_FAIL */ "__stack_chk_fail",
 
 /* DEOPTIMIZE */ "__llvm_deoptimize",
 };
 
 void llvm::GetSignature(const WebAssemblySubtarget &Subtarget,
                         RTLIB::Libcall LC,
-                        SmallVectorImpl<unsigned> &Rets,
-                        SmallVectorImpl<unsigned> &Params)
+                        SmallVectorImpl<int32_t> &Rets,
+                        SmallVectorImpl<int32_t> &Params)
 {
   assert(Rets.empty());
   assert(Params.empty());
 
   WebAssembly::ExprType iPTR = Subtarget.hasAddr64() ?
                                WebAssembly::ExprType::I64 :
                                WebAssembly::ExprType::I32;
 
   switch (RuntimeLibcallSignatures[LC]) {
   case func:
     break;
   case f32_func_f32:
-    Rets.push_back(unsigned(WebAssembly::ExprType::F32));
-    Params.push_back(unsigned(WebAssembly::ExprType::F32));
+    Rets.push_back(int32_t(WebAssembly::ExprType::F32));
+    Params.push_back(int32_t(WebAssembly::ExprType::F32));
     break;
   case f32_func_f64:
-    Rets.push_back(unsigned(WebAssembly::ExprType::F32));
-    Params.push_back(unsigned(WebAssembly::ExprType::F64));
+    Rets.push_back(int32_t(WebAssembly::ExprType::F32));
+    Params.push_back(int32_t(WebAssembly::ExprType::F64));
     break;
   case f32_func_i32:
-    Rets.push_back(unsigned(WebAssembly::ExprType::F32));
-    Params.push_back(unsigned(WebAssembly::ExprType::I32));
+    Rets.push_back(int32_t(WebAssembly::ExprType::F32));
+    Params.push_back(int32_t(WebAssembly::ExprType::I32));
     break;
   case f32_func_i64:
-    Rets.push_back(unsigned(WebAssembly::ExprType::F32));
-    Params.push_back(unsigned(WebAssembly::ExprType::I64));
+    Rets.push_back(int32_t(WebAssembly::ExprType::F32));
+    Params.push_back(int32_t(WebAssembly::ExprType::I64));
     break;
   case f32_func_i16:
-    Rets.push_back(unsigned(WebAssembly::ExprType::F32));
-    Params.push_back(unsigned(WebAssembly::ExprType::I32));
+    Rets.push_back(int32_t(WebAssembly::ExprType::F32));
+    Params.push_back(int32_t(WebAssembly::ExprType::I32));
     break;
   case f64_func_f32:
-    Rets.push_back(unsigned(WebAssembly::ExprType::F64));
-    Params.push_back(unsigned(WebAssembly::ExprType::F32));
+    Rets.push_back(int32_t(WebAssembly::ExprType::F64));
+    Params.push_back(int32_t(WebAssembly::ExprType::F32));
     break;
   case f64_func_f64:
-    Rets.push_back(unsigned(WebAssembly::ExprType::F64));
-    Params.push_back(unsigned(WebAssembly::ExprType::F64));
+    Rets.push_back(int32_t(WebAssembly::ExprType::F64));
+    Params.push_back(int32_t(WebAssembly::ExprType::F64));
     break;
   case f64_func_i32:
-    Rets.push_back(unsigned(WebAssembly::ExprType::F64));
-    Params.push_back(unsigned(WebAssembly::ExprType::I32));
+    Rets.push_back(int32_t(WebAssembly::ExprType::F64));
+    Params.push_back(int32_t(WebAssembly::ExprType::I32));
     break;
   case f64_func_i64:
-    Rets.push_back(unsigned(WebAssembly::ExprType::F64));
-    Params.push_back(unsigned(WebAssembly::ExprType::I64));
+    Rets.push_back(int32_t(WebAssembly::ExprType::F64));
+    Params.push_back(int32_t(WebAssembly::ExprType::I64));
     break;
   case i32_func_f32:
-    Rets.push_back(unsigned(WebAssembly::ExprType::I32));
-    Params.push_back(unsigned(WebAssembly::ExprType::F32));
+    Rets.push_back(int32_t(WebAssembly::ExprType::I32));
+    Params.push_back(int32_t(WebAssembly::ExprType::F32));
     break;
   case i32_func_f64:
-    Rets.push_back(unsigned(WebAssembly::ExprType::I32));
-    Params.push_back(unsigned(WebAssembly::ExprType::F64));
+    Rets.push_back(int32_t(WebAssembly::ExprType::I32));
+    Params.push_back(int32_t(WebAssembly::ExprType::F64));
     break;
   case i32_func_i32:
-    Rets.push_back(unsigned(WebAssembly::ExprType::I32));
-    Params.push_back(unsigned(WebAssembly::ExprType::I32));
+    Rets.push_back(int32_t(WebAssembly::ExprType::I32));
+    Params.push_back(int32_t(WebAssembly::ExprType::I32));
     break;
   case i64_func_f32:
-    Rets.push_back(unsigned(WebAssembly::ExprType::I64));
-    Params.push_back(unsigned(WebAssembly::ExprType::F32));
+    Rets.push_back(int32_t(WebAssembly::ExprType::I64));
+    Params.push_back(int32_t(WebAssembly::ExprType::F32));
     break;
   case i64_func_f64:
-    Rets.push_back(unsigned(WebAssembly::ExprType::I64));
-    Params.push_back(unsigned(WebAssembly::ExprType::F64));
+    Rets.push_back(int32_t(WebAssembly::ExprType::I64));
+    Params.push_back(int32_t(WebAssembly::ExprType::F64));
     break;
   case i64_func_i64:
-    Rets.push_back(unsigned(WebAssembly::ExprType::I64));
-    Params.push_back(unsigned(WebAssembly::ExprType::I64));
+    Rets.push_back(int32_t(WebAssembly::ExprType::I64));
+    Params.push_back(int32_t(WebAssembly::ExprType::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(int32_t(WebAssembly::ExprType::F32));
+    Params.push_back(int32_t(WebAssembly::ExprType::F32));
+    Params.push_back(int32_t(WebAssembly::ExprType::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(int32_t(WebAssembly::ExprType::F32));
+    Params.push_back(int32_t(WebAssembly::ExprType::F32));
+    Params.push_back(int32_t(WebAssembly::ExprType::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(int32_t(WebAssembly::ExprType::F32));
+    Params.push_back(int32_t(WebAssembly::ExprType::I64));
+    Params.push_back(int32_t(WebAssembly::ExprType::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(int32_t(WebAssembly::ExprType::F64));
+    Params.push_back(int32_t(WebAssembly::ExprType::F64));
+    Params.push_back(int32_t(WebAssembly::ExprType::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(int32_t(WebAssembly::ExprType::F64));
+    Params.push_back(int32_t(WebAssembly::ExprType::F64));
+    Params.push_back(int32_t(WebAssembly::ExprType::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(int32_t(WebAssembly::ExprType::F64));
+    Params.push_back(int32_t(WebAssembly::ExprType::I64));
+    Params.push_back(int32_t(WebAssembly::ExprType::I64));
     break;
   case i16_func_f32:
-    Rets.push_back(unsigned(WebAssembly::ExprType::I32));
-    Params.push_back(unsigned(WebAssembly::ExprType::F32));
+    Rets.push_back(int32_t(WebAssembly::ExprType::I32));
+    Params.push_back(int32_t(WebAssembly::ExprType::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(int32_t(WebAssembly::ExprType::I32));
+    Params.push_back(int32_t(WebAssembly::ExprType::I32));
+    Params.push_back(int32_t(WebAssembly::ExprType::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(int32_t(WebAssembly::ExprType::F32));
+    Params.push_back(int32_t(iPTR));
+    Params.push_back(int32_t(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(int32_t(WebAssembly::ExprType::F64));
+    Params.push_back(int32_t(iPTR));
+    Params.push_back(int32_t(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(int32_t(WebAssembly::ExprType::I32));
+    Params.push_back(int32_t(WebAssembly::ExprType::I32));
+    Params.push_back(int32_t(WebAssembly::ExprType::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(int32_t(WebAssembly::ExprType::I32));
+    Params.push_back(int32_t(WebAssembly::ExprType::F32));
+    Params.push_back(int32_t(WebAssembly::ExprType::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(int32_t(WebAssembly::ExprType::I32));
+    Params.push_back(int32_t(WebAssembly::ExprType::F64));
+    Params.push_back(int32_t(WebAssembly::ExprType::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(int32_t(WebAssembly::ExprType::I32));
+    Params.push_back(int32_t(WebAssembly::ExprType::I32));
+    Params.push_back(int32_t(WebAssembly::ExprType::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(int32_t(WebAssembly::ExprType::I64));
+    Params.push_back(int32_t(WebAssembly::ExprType::I64));
+    Params.push_back(int32_t(WebAssembly::ExprType::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(int32_t(WebAssembly::ExprType::I64));
+    Rets.push_back(int32_t(WebAssembly::ExprType::I64));
 #else
-    Params.push_back(unsigned(iPTR));
+    Params.push_back(int32_t(iPTR));
 #endif
-    Params.push_back(unsigned(WebAssembly::ExprType::F32));
+    Params.push_back(int32_t(WebAssembly::ExprType::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(int32_t(WebAssembly::ExprType::I64));
+    Rets.push_back(int32_t(WebAssembly::ExprType::I64));
 #else
-    Params.push_back(unsigned(iPTR));
+    Params.push_back(int32_t(iPTR));
 #endif
-    Params.push_back(unsigned(WebAssembly::ExprType::F64));
+    Params.push_back(int32_t(WebAssembly::ExprType::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(int32_t(WebAssembly::ExprType::I32));
+    Rets.push_back(int32_t(WebAssembly::ExprType::I32));
 #else
-    Params.push_back(unsigned(iPTR));
+    Params.push_back(int32_t(iPTR));
 #endif
-    Params.push_back(unsigned(WebAssembly::ExprType::I32));
-    Params.push_back(unsigned(WebAssembly::ExprType::I32));
+    Params.push_back(int32_t(WebAssembly::ExprType::I32));
+    Params.push_back(int32_t(WebAssembly::ExprType::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(int32_t(WebAssembly::ExprType::I32));
+    Rets.push_back(int32_t(WebAssembly::ExprType::I32));
 #else
-    Params.push_back(unsigned(iPTR));
+    Params.push_back(int32_t(iPTR));
 #endif
-    Params.push_back(unsigned(WebAssembly::ExprType::I32));
-    Params.push_back(unsigned(WebAssembly::ExprType::I32));
+    Params.push_back(int32_t(WebAssembly::ExprType::I32));
+    Params.push_back(int32_t(WebAssembly::ExprType::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(int32_t(WebAssembly::ExprType::I64));
+    Rets.push_back(int32_t(WebAssembly::ExprType::I64));
 #else
-    Params.push_back(unsigned(iPTR));
+    Params.push_back(int32_t(iPTR));
 #endif
-    Params.push_back(unsigned(WebAssembly::ExprType::I64));
-    Params.push_back(unsigned(WebAssembly::ExprType::I64));
+    Params.push_back(int32_t(WebAssembly::ExprType::I64));
+    Params.push_back(int32_t(WebAssembly::ExprType::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(int32_t(WebAssembly::ExprType::I64));
+    Rets.push_back(int32_t(WebAssembly::ExprType::I64));
 #else
-    Params.push_back(unsigned(iPTR));
+    Params.push_back(int32_t(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(int32_t(WebAssembly::ExprType::I64));
+    Params.push_back(int32_t(WebAssembly::ExprType::I64));
+    Params.push_back(int32_t(WebAssembly::ExprType::I64));
+    Params.push_back(int32_t(WebAssembly::ExprType::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(int32_t(WebAssembly::ExprType::I64));
+    Rets.push_back(int32_t(WebAssembly::ExprType::I64));
+    Rets.push_back(int32_t(WebAssembly::ExprType::I64));
+    Rets.push_back(int32_t(WebAssembly::ExprType::I64));
 #else
-    Params.push_back(unsigned(iPTR));
+    Params.push_back(int32_t(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(int32_t(WebAssembly::ExprType::I64));
+    Params.push_back(int32_t(WebAssembly::ExprType::I64));
+    Params.push_back(int32_t(WebAssembly::ExprType::I64));
+    Params.push_back(int32_t(WebAssembly::ExprType::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(int32_t(WebAssembly::ExprType::I64));
+    Rets.push_back(int32_t(WebAssembly::ExprType::I64));
+    Rets.push_back(int32_t(WebAssembly::ExprType::I64));
+    Rets.push_back(int32_t(WebAssembly::ExprType::I64));
 #else
-    Params.push_back(unsigned(iPTR));
+    Params.push_back(int32_t(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(int32_t(WebAssembly::ExprType::I64));
+    Params.push_back(int32_t(WebAssembly::ExprType::I64));
+    Params.push_back(int32_t(WebAssembly::ExprType::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(int32_t(iPTR));
+    Params.push_back(int32_t(iPTR));
+    Params.push_back(int32_t(WebAssembly::ExprType::I32));
+    Params.push_back(int32_t(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(int32_t(iPTR));
+    Params.push_back(int32_t(iPTR));
+    Params.push_back(int32_t(iPTR));
+    Params.push_back(int32_t(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(int32_t(WebAssembly::ExprType::F32));
+    Params.push_back(int32_t(WebAssembly::ExprType::F32));
+    Params.push_back(int32_t(WebAssembly::ExprType::F32));
+    Params.push_back(int32_t(WebAssembly::ExprType::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(int32_t(WebAssembly::ExprType::F64));
+    Params.push_back(int32_t(WebAssembly::ExprType::F64));
+    Params.push_back(int32_t(WebAssembly::ExprType::F64));
+    Params.push_back(int32_t(WebAssembly::ExprType::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(int32_t(WebAssembly::ExprType::I64));
+    Params.push_back(int32_t(WebAssembly::ExprType::I64));
+    Params.push_back(int32_t(iPTR));
+    Params.push_back(int32_t(iPTR));
     break;
   case func_iPTR_f32:
-    Params.push_back(unsigned(iPTR));
-    Params.push_back(unsigned(WebAssembly::ExprType::F32));
+    Params.push_back(int32_t(iPTR));
+    Params.push_back(int32_t(WebAssembly::ExprType::F32));
     break;
   case func_iPTR_f64:
-    Params.push_back(unsigned(iPTR));
-    Params.push_back(unsigned(WebAssembly::ExprType::F64));
+    Params.push_back(int32_t(iPTR));
+    Params.push_back(int32_t(WebAssembly::ExprType::F64));
     break;
   case func_iPTR_i32:
-    Params.push_back(unsigned(iPTR));
-    Params.push_back(unsigned(WebAssembly::ExprType::I32));
+    Params.push_back(int32_t(iPTR));
+    Params.push_back(int32_t(WebAssembly::ExprType::I32));
     break;
   case func_iPTR_i64:
-    Params.push_back(unsigned(iPTR));
-    Params.push_back(unsigned(WebAssembly::ExprType::I64));
+    Params.push_back(int32_t(iPTR));
+    Params.push_back(int32_t(WebAssembly::ExprType::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(int32_t(iPTR));
+    Params.push_back(int32_t(WebAssembly::ExprType::I64));
+    Params.push_back(int32_t(WebAssembly::ExprType::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(int32_t(iPTR));
+    Params.push_back(int32_t(WebAssembly::ExprType::I64));
+    Params.push_back(int32_t(WebAssembly::ExprType::I64));
+    Params.push_back(int32_t(WebAssembly::ExprType::I64));
+    Params.push_back(int32_t(WebAssembly::ExprType::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(int32_t(iPTR));
+    Params.push_back(int32_t(WebAssembly::ExprType::I64));
+    Params.push_back(int32_t(WebAssembly::ExprType::I64));
+    Params.push_back(int32_t(WebAssembly::ExprType::I64));
+    Params.push_back(int32_t(WebAssembly::ExprType::I64));
+    Params.push_back(int32_t(WebAssembly::ExprType::I64));
+    Params.push_back(int32_t(WebAssembly::ExprType::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(int32_t(WebAssembly::ExprType::I32));
+    Params.push_back(int32_t(WebAssembly::ExprType::I64));
+    Params.push_back(int32_t(WebAssembly::ExprType::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(int32_t(WebAssembly::ExprType::I32));
+    Params.push_back(int32_t(WebAssembly::ExprType::I64));
+    Params.push_back(int32_t(WebAssembly::ExprType::I64));
+    Params.push_back(int32_t(WebAssembly::ExprType::I64));
+    Params.push_back(int32_t(WebAssembly::ExprType::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)
+                        SmallVectorImpl<int32_t> &Rets,
+                        SmallVectorImpl<int32_t> &Params)
 {
   assert(strcmp(RuntimeLibcallNames[RTLIB::DEOPTIMIZE], "__llvm_deoptimize") ==
          0);
 
   for (size_t i = 0, e = RTLIB::UNKNOWN_LIBCALL; i < e; ++i)
     if (RuntimeLibcallNames[i] && strcmp(RuntimeLibcallNames[i], Name) == 0)
       return GetSignature(Subtarget, RTLIB::Libcall(i), Rets, Params);
 
   llvm_unreachable("unexpected runtime library name");
 }