[WebAssembly] Add type prefixes to call instructions

[sunfish]

Summary

As suggested in https://github.com/WebAssembly/experimental/issues/53 , this patch adds return type information to call and call_indirect instructions.

[dschuff]

This seems like a good idea for LLVM's current .s format.

[jfb]

Agreed, lgtm.

llvm/trunk/lib/Target/WebAssembly/WebAssemblyInstrCall.td

 // stack space to allocate or free, which is used for varargs lowering.
 let Uses = [SP32, SP64], Defs = [SP32, SP64], isCodeGenOnly = 1 in {
 def ADJCALLSTACKDOWN : I<(outs), (ins i32imm:$amt),
                          [(WebAssemblycallseq_start timm:$amt)]>;
 def ADJCALLSTACKUP : I<(outs), (ins i32imm:$amt),
                        [(WebAssemblycallseq_end timm:$amt, undef)]>;
 } // isCodeGenOnly = 1
 
-multiclass CALL<WebAssemblyRegClass vt> {
+multiclass CALL<WebAssemblyRegClass vt, string prefix> {
   def CALL_#vt : I<(outs vt:$dst), (ins i32imm:$callee, variable_ops),
                    [(set vt:$dst, (WebAssemblycall1 (i32 imm:$callee)))],
-                   "call    \t$dst, $callee">;
+                   !strconcat(prefix, "call\t$dst, $callee")>;
   def CALL_INDIRECT_#vt : I<(outs vt:$dst), (ins I32:$callee, variable_ops),
                             [(set vt:$dst, (WebAssemblycall1 I32:$callee))],
-                            "call_indirect\t$dst, $callee">;
+                            !strconcat(prefix, "call_indirect\t$dst, $callee")>;
 }
 let Uses = [SP32, SP64], isCall = 1 in {
-  defm : CALL<I32>;
-  defm : CALL<I64>;
-  defm : CALL<F32>;
-  defm : CALL<F64>;
+  defm : CALL<I32, "i32.">;
+  defm : CALL<I64, "i64.">;
+  defm : CALL<F32, "f32.">;
+  defm : CALL<F64, "f64.">;
 
   def CALL_VOID : I<(outs), (ins i32imm:$callee, variable_ops),
                     [(WebAssemblycall0 (i32 imm:$callee))],
                     "call    \t$callee">;
   def CALL_INDIRECT_VOID : I<(outs), (ins I32:$callee, variable_ops),
                              [(WebAssemblycall0 I32:$callee)],
                              "call_indirect\t$callee">;
 } // Uses = [SP32,SP64], isCall = 1

llvm/trunk/test/CodeGen/WebAssembly/call.ll

 declare i32 @i32_binary(i32, i32)
 declare i64 @i64_nullary()
 declare float @float_nullary()
 declare double @double_nullary()
 declare void @void_nullary()
 
 ; CHECK-LABEL: call_i32_nullary:
 ; CHECK-NEXT: .result i32{{$}}
-; CHECK-NEXT: call $push[[NUM:[0-9]+]]=, i32_nullary{{$}}
+; CHECK-NEXT: {{^}} i32.call $push[[NUM:[0-9]+]]=, i32_nullary{{$}}
 ; CHECK-NEXT: return $pop[[NUM]]{{$}}
 define i32 @call_i32_nullary() {
   %r = call i32 @i32_nullary()
   ret i32 %r
 }
 
 ; CHECK-LABEL: call_i64_nullary:
 ; CHECK-NEXT: .result i64{{$}}
-; CHECK-NEXT: call $push[[NUM:[0-9]+]]=, i64_nullary{{$}}
+; CHECK-NEXT: {{^}} i64.call $push[[NUM:[0-9]+]]=, i64_nullary{{$}}
 ; CHECK-NEXT: return $pop[[NUM]]{{$}}
 define i64 @call_i64_nullary() {
   %r = call i64 @i64_nullary()
   ret i64 %r
 }
 
 ; CHECK-LABEL: call_float_nullary:
 ; CHECK-NEXT: .result f32{{$}}
-; CHECK-NEXT: call $push[[NUM:[0-9]+]]=, float_nullary{{$}}
+; CHECK-NEXT: {{^}} f32.call $push[[NUM:[0-9]+]]=, float_nullary{{$}}
 ; CHECK-NEXT: return $pop[[NUM]]{{$}}
 define float @call_float_nullary() {
   %r = call float @float_nullary()
   ret float %r
 }
 
 ; CHECK-LABEL: call_double_nullary:
 ; CHECK-NEXT: .result f64{{$}}
-; CHECK-NEXT: call $push[[NUM:[0-9]+]]=, double_nullary{{$}}
+; CHECK-NEXT: {{^}} f64.call $push[[NUM:[0-9]+]]=, double_nullary{{$}}
 ; CHECK-NEXT: return $pop[[NUM]]{{$}}
 define double @call_double_nullary() {
   %r = call double @double_nullary()
   ret double %r
 }
 
 ; CHECK-LABEL: call_void_nullary:
-; CHECK-NEXT: call void_nullary{{$}}
+; CHECK-NEXT: {{^}} call void_nullary{{$}}
 ; CHECK-NEXT: return{{$}}
 define void @call_void_nullary() {
   call void @void_nullary()
   ret void
 }
 
 ; CHECK-LABEL: call_i32_unary:
 ; CHECK-NEXT: .param i32{{$}}
 ; CHECK-NEXT: .result i32{{$}}
-; CHECK-NEXT: call $push[[NUM:[0-9]+]]=, i32_unary, $0{{$}}
+; CHECK-NEXT: {{^}} i32.call $push[[NUM:[0-9]+]]=, i32_unary, $0{{$}}
 ; CHECK-NEXT: return $pop[[NUM]]{{$}}
 define i32 @call_i32_unary(i32 %a) {
   %r = call i32 @i32_unary(i32 %a)
   ret i32 %r
 }
 
 ; CHECK-LABEL: call_i32_binary:
 ; CHECK-NEXT: .param i32, i32{{$}}
 ; CHECK-NEXT: .result i32{{$}}
-; CHECK-NEXT: call $push[[NUM:[0-9]+]]=, i32_binary, $0, $1{{$}}
+; CHECK-NEXT: {{^}} i32.call $push[[NUM:[0-9]+]]=, i32_binary, $0, $1{{$}}
 ; CHECK-NEXT: return $pop[[NUM]]{{$}}
 define i32 @call_i32_binary(i32 %a, i32 %b) {
   %r = call i32 @i32_binary(i32 %a, i32 %b)
   ret i32 %r
 }
 
 ; CHECK-LABEL: call_indirect_void:
 ; CHECK-NEXT: .param i32{{$}}
-; CHECK-NEXT: call_indirect $0{{$}}
+; CHECK-NEXT: {{^}} call_indirect $0{{$}}
 ; CHECK-NEXT: return{{$}}
 define void @call_indirect_void(void ()* %callee) {
   call void %callee()
   ret void
 }
 
 ; CHECK-LABEL: call_indirect_i32:
 ; CHECK-NEXT: .param i32{{$}}
 ; CHECK-NEXT: .result i32{{$}}
-; CHECK-NEXT: call_indirect $push[[NUM:[0-9]+]]=, $0{{$}}
+; CHECK-NEXT: {{^}} i32.call_indirect $push[[NUM:[0-9]+]]=, $0{{$}}
 ; CHECK-NEXT: return $pop[[NUM]]{{$}}
 define i32 @call_indirect_i32(i32 ()* %callee) {
   %t = call i32 %callee()
   ret i32 %t
 }
 
 ; CHECK-LABEL: tail_call_void_nullary:
-; CHECK-NEXT: call void_nullary{{$}}
+; CHECK-NEXT: {{^}} call void_nullary{{$}}
 ; CHECK-NEXT: return{{$}}
 define void @tail_call_void_nullary() {
   tail call void @void_nullary()
   ret void
 }
 
 ; CHECK-LABEL: fastcc_tail_call_void_nullary:
-; CHECK-NEXT: call void_nullary{{$}}
+; CHECK-NEXT: {{^}} call void_nullary{{$}}
 ; CHECK-NEXT: return{{$}}
 define void @fastcc_tail_call_void_nullary() {
   tail call fastcc void @void_nullary()
   ret void
 }
 
 ; CHECK-LABEL: coldcc_tail_call_void_nullary:
-; CHECK-NEXT: call void_nullary
+; CHECK-NEXT: {{^}} call void_nullary
 ; CHECK-NEXT: return{{$}}
 define void @coldcc_tail_call_void_nullary() {
   tail call coldcc void @void_nullary()
   ret void
 }
 
 ; FIXME test the following:
 ;  - More argument combinations.
 ;  - Tail call.
 ;  - Interesting returns (struct, multiple).
 ;  - Vararg.

llvm/trunk/test/CodeGen/WebAssembly/f32.ll

 ; CHECK-NEXT: return $pop1{{$}}
 define float @fmax32(float %x) {
   %a = fcmp ugt float %x, 0.0
   %b = select i1 %a, float %x, float 0.0
   ret float %b
 }
 
 ; CHECK-LABEL: fma32:
-; CHECK: call $push0=, fmaf, $0, $1, $2{{$}}
+; CHECK: {{^}} f32.call $push0=, fmaf, $0, $1, $2{{$}}
 ; CHECK-NEXT: return $pop0{{$}}
 define float @fma32(float %a, float %b, float %c) {
   %d = call float @llvm.fma.f32(float %a, float %b, float %c)
   ret float %d
 }

llvm/trunk/test/CodeGen/WebAssembly/f64.ll

 ; CHECK-NEXT: return $pop1{{$}}
 define double @fmax64(double %x) {
   %a = fcmp ugt double %x, 0.0
   %b = select i1 %a, double %x, double 0.0
   ret double %b
 }
 
 ; CHECK-LABEL: fma64:
-; CHECK: call $push0=, fma, $0, $1, $2{{$}}
+; CHECK: {{^}} f64.call $push0=, fma, $0, $1, $2{{$}}
 ; CHECK-NEXT: return $pop0{{$}}
 define double @fma64(double %a, double %b, double %c) {
   %d = call double @llvm.fma.f64(double %a, double %b, double %c)
   ret double %d
 }

llvm/trunk/test/CodeGen/WebAssembly/frem.ll

 ; RUN: llc < %s -asm-verbose=false | FileCheck %s
 
 ; Test that the frem instruction works.
 
 target datalayout = "e-p:32:32-i64:64-n32:64-S128"
 target triple = "wasm32-unknown-unknown"
 
 ; CHECK-LABEL: frem32:
 ; CHECK-NEXT: .param f32, f32{{$}}
 ; CHECK-NEXT: .result f32{{$}}
-; CHECK-NEXT: call $push0=, fmodf, $0, $1{{$}}
+; CHECK-NEXT: {{^}} f32.call $push0=, fmodf, $0, $1{{$}}
 ; CHECK-NEXT: return $pop0{{$}}
 define float @frem32(float %x, float %y) {
   %a = frem float %x, %y
   ret float %a
 }
 
 ; CHECK-LABEL: frem64:
 ; CHECK-NEXT: .param f64, f64{{$}}
 ; CHECK-NEXT: .result f64{{$}}
-; CHECK-NEXT: call $push0=, fmod, $0, $1{{$}}
+; CHECK-NEXT: {{^}} f64.call $push0=, fmod, $0, $1{{$}}
 ; CHECK-NEXT: return $pop0{{$}}
 define double @frem64(double %x, double %y) {
   %a = frem double %x, %y
   ret double %a
 }

llvm/trunk/test/CodeGen/WebAssembly/returned.ll

 ; RUN: llc < %s -asm-verbose=false | FileCheck %s
 
 ; Test that the "returned" attribute is optimized effectively.
 
 target datalayout = "e-p:32:32-i64:64-n32:64-S128"
 target triple = "wasm32-unknown-unknown"
 
 ; CHECK-LABEL: _Z3foov:
 ; CHECK-NEXT: .result   i32{{$}}
 ; CHECK-NEXT: i32.const $push0=, 1{{$}}
-; CHECK-NEXT: call      $push1=, _Znwm, $pop0{{$}}
-; CHECK-NEXT: call      $push2=, _ZN5AppleC1Ev, $pop1{{$}}
+; CHECK-NEXT: {{^}} i32.call      $push1=, _Znwm, $pop0{{$}}
+; CHECK-NEXT: {{^}} i32.call      $push2=, _ZN5AppleC1Ev, $pop1{{$}}
 ; CHECK-NEXT: return    $pop2{{$}}
 %class.Apple = type { i8 }
 declare noalias i8* @_Znwm(i32)
 declare %class.Apple* @_ZN5AppleC1Ev(%class.Apple* returned)
 define %class.Apple* @_Z3foov() {
 entry:
   %call = tail call noalias i8* @_Znwm(i32 1)
   %0 = bitcast i8* %call to %class.Apple*
   %call1 = tail call %class.Apple* @_ZN5AppleC1Ev(%class.Apple* %0)
   ret %class.Apple* %0
 }
 
 ; CHECK-LABEL: _Z3barPvS_l:
 ; CHECK-NEXT: .param   i32, i32, i32{{$}}
 ; CHECK-NEXT: .result  i32{{$}}
-; CHECK-NEXT: call     $push0=, memcpy, $0, $1, $2{{$}}
+; CHECK-NEXT: {{^}} i32.call     $push0=, memcpy, $0, $1, $2{{$}}
 ; CHECK-NEXT: return   $pop0{{$}}
 declare i8* @memcpy(i8* returned, i8*, i32)
 define i8* @_Z3barPvS_l(i8* %p, i8* %s, i32 %n) {
 entry:
   %call = tail call i8* @memcpy(i8* %p, i8* %s, i32 %n)
   ret i8* %p
 }
 
 ; Test that the optimization isn't performed on constant arguments.
 
 ; CHECK-LABEL: test_constant_arg:
 ; CHECK-NEXT: i32.const   $push0=, global{{$}}
-; CHECK-NEXT: call        $discard=, returns_arg, $pop0{{$}}
+; CHECK-NEXT: {{^}} i32.call        $discard=, returns_arg, $pop0{{$}}
 ; CHECK-NEXT: return{{$}}
 @global = external global i32
 @addr = global i32* @global
 define void @test_constant_arg() {
   %call = call i32* @returns_arg(i32* @global)
   ret void
 }
 declare i32* @returns_arg(i32* returned)

llvm/trunk/test/CodeGen/WebAssembly/unused-argument.ll

 ; CHECK-NEXT: .param i32, i32{{$}}
 ; CHECK-NEXT: .result i32{{$}}
 ; CHECK-NEXT: return $0{{$}}
 define i32 @unused_second(i32 %x, i32 %y) {
   ret i32 %x
 }
 
 ; CHECK-LABEL: call_something:
-; CHECK-NEXT: call $discard=, return_something{{$}}
+; CHECK-NEXT: {{^}} i32.call $discard=, return_something{{$}}
 ; CHECK-NEXT: return{{$}}
 declare i32 @return_something()
 define void @call_something() {
   call i32 @return_something()
   ret void
 }