[WebAssembly] Add V128 value type to binary format

[tlively]

• Add to switch in MCTargetDesc

[dschuff]

Is this enough to add SIMD to one of our existing binary-format tests?

[tlively]

• add tests, fix calls to make tests work, and remove dead code.

[aheejin]

test/CodeGen/WebAssembly/call.ll

15

Nit: v128_nullary or v16i8_nullary for symmetry?

124

Maybe we can make this call-related stuff another CL, which is not relevant to V128?

test/MC/WebAssembly/types.ll

2

What's the purpose of this test?

11

No argument for rest of functions?

19

Nit: indentation 2 spaces

[tlively]

test/MC/WebAssembly/types.ll

2

It checks that the ValTypes are emitted to an object file correctly, including the new V128 one.

[tlively]

• Address comments

[aheejin]

test/MC/WebAssembly/types.ll

11

Oh, I wasn't suggesting deleting the argument... actually was suggesting adding it to other functions too (for symmetry), but if you don't think we need it, that's probably fine.

[aheejin]

test/MC/WebAssembly/types.ll

2

Nit: Then probably it would make more sense to move this to D52254..?

[tlively]

test/MC/WebAssembly/types.ll

2

I think at least part of this test belongs in this CL since it's the only thing testing the ObjectYAML support for V128, but splitting up the test file into two commits is probably more trouble than it's worth, so I would prefer to just keep it here.

[aheejin]

test/MC/WebAssembly/types.ll

2

Yeah that makes sense.

[tlively]

@aheejin is this blocked on anything else?

[aheejin]

I was not sure if what @dschuff asked was done. If it was I’m ok with the change.

include/llvm/BinaryFormat/Wasm.h

 };
 
 // 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_V128 = 0x7B,
   WASM_TYPE_ANYFUNC = 0x70,
   WASM_TYPE_EXCEPT_REF = 0x68,
   WASM_TYPE_FUNC = 0x60,
   WASM_TYPE_NORESULT = 0x40, // for blocks with no result values
 };
 
 // Kinds of externals (for imports and exports).
 enum : unsigned {

 };
 
 // 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,
+  V128 = WASM_TYPE_V128,
   EXCEPT_REF = WASM_TYPE_EXCEPT_REF,
 };
 
 // Kind codes used in the custom "name" section
 enum : unsigned {
   WASM_NAMES_FUNCTION = 0x1,
   WASM_NAMES_LOCAL = 0x2,
 };

lib/ObjectYAML/WasmYAML.cpp

 
 void ScalarEnumerationTraits<WasmYAML::ValueType>::enumeration(
     IO &IO, WasmYAML::ValueType &Type) {
 #define ECase(X) IO.enumCase(Type, #X, wasm::WASM_TYPE_##X);
   ECase(I32);
   ECase(I64);
   ECase(F32);
   ECase(F64);
+  ECase(V128);
   ECase(ANYFUNC);
   ECase(FUNC);
   ECase(NORESULT);
 #undef ECase
 }
 
 void ScalarEnumerationTraits<WasmYAML::ExportKind>::enumeration(
     IO &IO, WasmYAML::ExportKind &Kind) {

lib/Target/WebAssembly/InstPrinter/WebAssemblyInstPrinter.h

public:
   // Autogenerated by tblgen.
   void printInstruction(const MCInst *MI, raw_ostream &O);
   static const char *getRegisterName(unsigned RegNo);
 };
 
 namespace WebAssembly {
 
 const char *TypeToString(MVT Ty);
-const char *TypeToString(wasm::ValType Type);
 
 } // end namespace WebAssembly
 
 } // end namespace llvm
 
 #endif

lib/Target/WebAssembly/InstPrinter/WebAssemblyInstPrinter.cpp

const char *llvm::WebAssembly::TypeToString(MVT Ty) {
   case MVT::v2f64:
     return "v128";
   case MVT::ExceptRef:
     return "except_ref";
   default:
     llvm_unreachable("unsupported type");
   }
 }
-
-const char *llvm::WebAssembly::TypeToString(wasm::ValType Type) {
-  switch (Type) {
-  case wasm::ValType::I32:
-    return "i32";
-  case wasm::ValType::I64:
-    return "i64";
-  case wasm::ValType::F32:
-    return "f32";
-  case wasm::ValType::F64:
-    return "f64";
-  case wasm::ValType::EXCEPT_REF:
-    return "except_ref";
-  }
-  llvm_unreachable("unsupported type");
-}

lib/Target/WebAssembly/MCTargetDesc/WebAssemblyMCTargetDesc.cpp

wasm::ValType WebAssembly::toValType(const MVT &Ty) {
   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;
+  case MVT::v16i8:
+  case MVT::v8i16:
+  case MVT::v4i32:
+  case MVT::v2i64:
+  case MVT::v4f32:
+  case MVT::v2f64:
+    return wasm::ValType::V128;
   case MVT::ExceptRef:
     return wasm::ValType::EXCEPT_REF;
   default:
     llvm_unreachable("unexpected type");
   }
 }

lib/Target/WebAssembly/WebAssemblyInstrCall.td

 }
 
 let Uses = [SP32, SP64], isCall = 1 in {
   defm "" : CALL<I32, "i32.">;
   defm "" : CALL<I64, "i64.">;
   defm "" : CALL<F32, "f32.">;
   defm "" : CALL<F64, "f64.">;
   defm "" : CALL<EXCEPT_REF, "except_ref.">;
-  defm "" : SIMD_CALL<v16i8, "i8x16.">;
-  defm "" : SIMD_CALL<v8i16, "i16x8.">;
-  defm "" : SIMD_CALL<v4i32, "i32x4.">;
-  defm "" : SIMD_CALL<v2i64, "i64x2.">;
-  defm "" : SIMD_CALL<v4f32, "f32x4.">;
-  defm "" : SIMD_CALL<v2f64, "f64x2.">;
+  defm "" : SIMD_CALL<v16i8, "v128.">;
+  defm "" : SIMD_CALL<v8i16, "v128.">;
+  defm "" : SIMD_CALL<v4i32, "v128.">;
+  defm "" : SIMD_CALL<v2i64, "v128.">;
+  defm "" : SIMD_CALL<v4f32, "v128.">;
+  defm "" : SIMD_CALL<v2f64, "v128.">;
 
   defm CALL_VOID : I<(outs), (ins function32_op:$callee, variable_ops),
                      (outs), (ins function32_op:$callee),
                      [(WebAssemblycall0 (i32 imm:$callee))],
                      "call    \t$callee", "call\t$callee", 0x10>;
 
   let isCodeGenOnly = 1 in {
     defm PCALL_INDIRECT_VOID : I<(outs), (ins I32:$callee, variable_ops),

lib/Target/WebAssembly/WebAssemblyMCInstLower.cpp

static wasm::ValType getType(const TargetRegisterClass *RC) {
   if (RC == &WebAssembly::I32RegClass)
     return wasm::ValType::I32;
   if (RC == &WebAssembly::I64RegClass)
     return wasm::ValType::I64;
   if (RC == &WebAssembly::F32RegClass)
     return wasm::ValType::F32;
   if (RC == &WebAssembly::F64RegClass)
     return wasm::ValType::F64;
+  if (RC == &WebAssembly::V128RegClass)
+    return wasm::ValType::V128;
   llvm_unreachable("Unexpected register class");
 }
 
 void WebAssemblyMCInstLower::Lower(const MachineInstr *MI,
                                    MCInst &OutMI) const {
   OutMI.setOpcode(MI->getOpcode());
 
   const MCInstrDesc &Desc = MI->getDesc();

test/CodeGen/WebAssembly/call.ll

-; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -wasm-keep-registers -wasm-temporary-workarounds=false | FileCheck %s
-; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -wasm-keep-registers -fast-isel -fast-isel-abort=1 -wasm-temporary-workarounds=false | FileCheck %s
+; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -wasm-keep-registers -wasm-temporary-workarounds=false -mattr=+sign-ext,+simd128 | FileCheck %s
+; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -wasm-keep-registers -fast-isel -fast-isel-abort=1 -wasm-temporary-workarounds=false -mattr=+sign-ext,+simd128 | FileCheck %s
 
 ; Test that basic call operations assemble as expected.
 
 target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
 target triple = "wasm32-unknown-unknown"
 
 declare i32 @i32_nullary()
 declare i32 @i32_unary(i32)
 declare i32 @i32_binary(i32, i32)
 declare i64 @i64_nullary()
 declare float @float_nullary()
 declare double @double_nullary()
+declare <16 x i8> @v128_nullary()
 declare void @void_nullary()
 
 ; CHECK-LABEL: call_i32_nullary:
 ; CHECK-NEXT: .result i32{{$}}
 ; CHECK-NEXT: {{^}} i32.call $push[[NUM:[0-9]+]]=, i32_nullary@FUNCTION{{$}}
 ; CHECK-NEXT: return $pop[[NUM]]{{$}}
 define i32 @call_i32_nullary() {
   %r = call i32 @i32_nullary()

 ; CHECK-NEXT: .result f64{{$}}
 ; CHECK-NEXT: {{^}} f64.call $push[[NUM:[0-9]+]]=, double_nullary@FUNCTION{{$}}
 ; CHECK-NEXT: return $pop[[NUM]]{{$}}
 define double @call_double_nullary() {
   %r = call double @double_nullary()
   ret double %r
 }
 
+; CHECK-LABEL: call_v128_nullary:
+; CHECK-NEXT: .result v128{{$}}
+; CHECK-NEXT: {{^}} v128.call $push[[NUM:[0-9]+]]=, v128_nullary@FUNCTION{{$}}
+; CHECK-NEXT: return $pop[[NUM]]{{$}}
+define <16 x i8> @call_v128_nullary() {
+  %r = call <16 x i8> @v128_nullary()
+  ret <16 x i8> %r
+}
+
 ; CHECK-LABEL: call_void_nullary:
 ; CHECK-NEXT: {{^}} call void_nullary@FUNCTION{{$}}
 ; CHECK-NEXT: return{{$}}
 define void @call_void_nullary() {
   call void @void_nullary()
   ret void
 }
 

 ; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}}
 ; CHECK-NEXT: {{^}} i32.call_indirect $push[[NUM:[0-9]+]]=, $pop[[L0]]{{$}}
 ; CHECK-NEXT: return $pop[[NUM]]{{$}}
 define i32 @call_indirect_i32(i32 ()* %callee) {
   %t = call i32 %callee()
   ret i32 %t
 }
 
+; CHECK-LABEL: call_indirect_v128:
+; CHECK-NEXT: .param i32{{$}}
+; CHECK-NEXT: .result v128{{$}}
+; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}}
+; CHECK-NEXT: {{^}} v128.call_indirect $push[[NUM:[0-9]+]]=, $pop[[L0]]{{$}}
+; CHECK-NEXT: return $pop[[NUM]]{{$}}
+define <16 x i8> @call_indirect_v128(<16 x i8> ()* %callee) {
+  %t = call <16 x i8> %callee()
+  ret <16 x i8> %t
+}
+
 ; CHECK-LABEL: call_indirect_arg:
 ; CHECK-NEXT: .param i32, i32{{$}}
 ; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 1{{$}}
 ; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 0{{$}}
 ; CHECK-NEXT: {{^}} call_indirect $pop[[L0]], $pop[[L1]]{{$}}
 ; CHECK-NEXT: return{{$}}
 define void @call_indirect_arg(void (i32)* %callee, i32 %arg) {
   call void %callee(i32 %arg)

test/MC/WebAssembly/types.ll

+; RUN: llc -wasm-enable-unimplemented-simd -mattr=+sign-ext,+simd128 -filetype=obj %s -o - | obj2yaml | FileCheck %s
+
+target triple = "wasm32-unknown-unknown"
+
+declare i32 @i32()
+declare i64 @i64()
+declare float @f32()
+declare double @f64()
+declare <16 x i8> @v16i8()
+declare <8 x i16> @v8i16()
+declare <4 x i32> @v4i32()
+declare <2 x i64> @v2i64()
+declare <4 x float> @v4f32()
+declare <2 x double> @v2f64()
+
+define void @f1() {
+entry:
+  %tmp1 = call i32 @i32()
+  %tmp2 = call i64 @i64()
+  %tmp3 = call float @f32()
+  %tmp4 = call double @f64()
+  %tmp5 = call <16 x i8> @v16i8()
+  %tmp6 = call <8 x i16> @v8i16()
+  %tmp7 = call <4 x i32> @v4i32()
+  %tmp8 = call <2 x i64> @v2i64()
+  %tmp9 = call <4 x float> @v4f32()
+  %tmp10 = call <2 x double> @v2f64()
+  ret void
+}
+
+; CHECK-LABEL: - Type: TYPE
+; CHECK-NEXT:    Signatures:
+; CHECK-NEXT:       - Index: 0
+; CHECK-NEXT:         ReturnType: NORESULT
+; CHECK-NEXT:         ParamTypes:
+; CHECK-NEXT:       - Index: 1
+; CHECK-NEXT:         ReturnType: I32
+; CHECK-NEXT:         ParamTypes:
+; CHECK-NEXT:       - Index: 2
+; CHECK-NEXT:         ReturnType: I64
+; CHECK-NEXT:         ParamTypes:
+; CHECK-NEXT:       - Index: 3
+; CHECK-NEXT:         ReturnType: F32
+; CHECK-NEXT:         ParamTypes:
+; CHECK-NEXT:       - Index: 4
+; CHECK-NEXT:         ReturnType: F64
+; CHECK-NEXT:         ParamTypes:
+; CHECK-NEXT:       - Index: 5
+; CHECK-NEXT:         ReturnType: V128
+; CHECK-NEXT:         ParamTypes:
+; should be no additional types
+; CHECK-NOT: ReturnType