diff options
Diffstat (limited to 'test/CodeGen/WebAssembly')
66 files changed, 774 insertions, 499 deletions
diff --git a/test/CodeGen/WebAssembly/address-offsets.ll b/test/CodeGen/WebAssembly/address-offsets.ll index b9efec86f0da..da198978fc2f 100644 --- a/test/CodeGen/WebAssembly/address-offsets.ll +++ b/test/CodeGen/WebAssembly/address-offsets.ll @@ -1,10 +1,10 @@ -; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt | FileCheck %s +; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals | FileCheck %s ; Test folding constant offsets and symbols into load and store addresses under ; a variety of circumstances. target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" -target triple = "wasm32-unknown-unknown" +target triple = "wasm32-unknown-unknown-wasm" @g = external global [0 x i32], align 4 diff --git a/test/CodeGen/WebAssembly/byval.ll b/test/CodeGen/WebAssembly/byval.ll index 7a995769a8e7..907320d7977c 100644 --- a/test/CodeGen/WebAssembly/byval.ll +++ b/test/CodeGen/WebAssembly/byval.ll @@ -1,8 +1,8 @@ -; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -verify-machineinstrs | FileCheck %s -; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -verify-machineinstrs -fast-isel | FileCheck %s +; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals -verify-machineinstrs | FileCheck %s +; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals -verify-machineinstrs -fast-isel | FileCheck %s target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" -target triple = "wasm32-unknown-unknown" +target triple = "wasm32-unknown-unknown-wasm" %SmallStruct = type { i32 } %OddStruct = type { i32, i8, i32 } @@ -23,15 +23,13 @@ declare void @ext_byval_func_empty(%EmptyStruct* byval) ; CHECK-LABEL: byval_arg define void @byval_arg(%SmallStruct* %ptr) { ; CHECK: .param i32 - ; CHECK: i32.const $push[[L4:.+]]=, 0 ; Subtract 16 from SP (SP is 16-byte aligned) - ; CHECK: i32.const $push[[L1:.+]]=, 0 - ; CHECK-NEXT: i32.load $push[[L2:.+]]=, __stack_pointer($pop[[L1]]) + ; CHECK-NEXT: get_global $push[[L2:.+]]=, 0 ; CHECK-NEXT: i32.const $push[[L3:.+]]=, 16 ; CHECK-NEXT: i32.sub $push[[L11:.+]]=, $pop[[L2]], $pop[[L3]] ; Ensure SP is stored back before the call ; CHECK-NEXT: tee_local $push[[L10:.+]]=, $[[SP:.+]]=, $pop[[L11]]{{$}} - ; CHECK-NEXT: i32.store __stack_pointer($pop[[L4]]), $pop[[L10]]{{$}} + ; CHECK-NEXT: set_global 0, $pop[[L10]]{{$}} ; Copy the SmallStruct argument to the stack (SP+12, original SP-4) ; CHECK-NEXT: i32.load $push[[L0:.+]]=, 0($0) ; CHECK-NEXT: i32.store 12($[[SP]]), $pop[[L0]] @@ -41,10 +39,9 @@ define void @byval_arg(%SmallStruct* %ptr) { ; CHECK-NEXT: call ext_byval_func@FUNCTION, $pop[[ARG]]{{$}} call void @ext_byval_func(%SmallStruct* byval %ptr) ; Restore the stack - ; CHECK-NEXT: i32.const $push[[L7:.+]]=, 0 ; CHECK-NEXT: i32.const $push[[L6:.+]]=, 16 ; CHECK-NEXT: i32.add $push[[L8:.+]]=, $[[SP]], $pop[[L6]] - ; CHECK-NEXT: i32.store __stack_pointer($pop[[L7]]), $pop[[L8]] + ; CHECK-NEXT: set_global 0, $pop[[L8]] ; CHECK-NEXT: return ret void } @@ -56,7 +53,7 @@ define void @byval_arg_align8(%SmallStruct* %ptr) { ; CHECK: i32.const $push[[L1:.+]]=, 16 ; CHECK-NEXT: i32.sub $push[[L11:.+]]=, {{.+}}, $pop[[L1]] ; CHECK-NEXT: tee_local $push[[L10:.+]]=, $[[SP:.+]]=, $pop[[L11]]{{$}} - ; CHECK-NEXT: i32.store __stack_pointer($pop{{.+}}), $pop[[L10]]{{$}} + ; CHECK-NEXT: set_global 0, $pop[[L10]]{{$}} ; Copy the SmallStruct argument to the stack (SP+8, original SP-8) ; CHECK-NEXT: i32.load $push[[L0:.+]]=, 0($0){{$}} ; CHECK-NEXT: i32.store 8($[[SP]]), $pop[[L0]]{{$}} @@ -75,7 +72,7 @@ define void @byval_arg_double(%AlignedStruct* %ptr) { ; CHECK: i32.const $push[[L1:.+]]=, 16 ; CHECK-NEXT: i32.sub $push[[L14:.+]]=, {{.+}}, $pop[[L1]] ; CHECK-NEXT: tee_local $push[[L13:.+]]=, $[[SP:.+]]=, $pop[[L14]] - ; CHECK-NEXT: i32.store {{.+}}, $pop[[L13]] + ; CHECK-NEXT: set_global 0, $pop[[L13]] ; Copy the AlignedStruct argument to the stack (SP+0, original SP-16) ; Just check the last load/store pair of the memcpy ; CHECK: i64.load $push[[L4:.+]]=, 0($0) @@ -113,13 +110,11 @@ define void @byval_empty_callee(%EmptyStruct* byval %ptr) { ; Call memcpy for "big" byvals. ; CHECK-LABEL: big_byval: -; CHECK: i32.const $push[[L4:.+]]=, 0 -; CHECK: i32.const $push[[L1:.+]]=, 0 -; CHECK-NEXT: i32.load $push[[L2:.+]]=, __stack_pointer($pop[[L1]]) +; CHECK: get_global $push[[L2:.+]]=, 0{{$}} ; CHECK-NEXT: i32.const $push[[L3:.+]]=, 131072 ; CHECK-NEXT: i32.sub $push[[L11:.+]]=, $pop[[L2]], $pop[[L3]] ; CHECK-NEXT: tee_local $push[[L10:.+]]=, $[[SP:.+]]=, $pop[[L11]]{{$}} -; CHECK-NEXT: i32.store __stack_pointer($pop[[L4]]), $pop[[L10]]{{$}} +; CHECK-NEXT: set_global 0, $pop[[L10]]{{$}} ; CHECK-NEXT: i32.const $push[[L0:.+]]=, 131072 ; CHECK-NEXT: i32.call $push[[L11:.+]]=, memcpy@FUNCTION, $[[SP]], ${{.+}}, $pop{{.+}} ; CHECK-NEXT: tee_local $push[[L9:.+]]=, $[[SP:.+]]=, $pop[[L11]]{{$}} diff --git a/test/CodeGen/WebAssembly/call.ll b/test/CodeGen/WebAssembly/call.ll index 1a9d5b8fb8e6..1cf42242a6cc 100644 --- a/test/CodeGen/WebAssembly/call.ll +++ b/test/CodeGen/WebAssembly/call.ll @@ -4,7 +4,7 @@ ; 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" +target triple = "wasm32-unknown-unknown-wasm" declare i32 @i32_nullary() declare i32 @i32_unary(i32) @@ -61,7 +61,8 @@ define void @call_void_nullary() { ; CHECK-LABEL: call_i32_unary: ; CHECK-NEXT: .param i32{{$}} ; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: {{^}} i32.call $push[[NUM:[0-9]+]]=, i32_unary@FUNCTION, $0{{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: {{^}} i32.call $push[[NUM:[0-9]+]]=, i32_unary@FUNCTION, $pop[[L0]]{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define i32 @call_i32_unary(i32 %a) { %r = call i32 @i32_unary(i32 %a) @@ -71,7 +72,9 @@ define i32 @call_i32_unary(i32 %a) { ; CHECK-LABEL: call_i32_binary: ; CHECK-NEXT: .param i32, i32{{$}} ; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: {{^}} i32.call $push[[NUM:[0-9]+]]=, i32_binary@FUNCTION, $0, $1{{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: {{^}} i32.call $push[[NUM:[0-9]+]]=, i32_binary@FUNCTION, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define i32 @call_i32_binary(i32 %a, i32 %b) { %r = call i32 @i32_binary(i32 %a, i32 %b) @@ -80,7 +83,8 @@ define i32 @call_i32_binary(i32 %a, i32 %b) { ; CHECK-LABEL: call_indirect_void: ; CHECK-NEXT: .param i32{{$}} -; CHECK-NEXT: {{^}} call_indirect $0{{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: {{^}} call_indirect $pop[[L0]]{{$}} ; CHECK-NEXT: return{{$}} define void @call_indirect_void(void ()* %callee) { call void %callee() @@ -90,7 +94,8 @@ define void @call_indirect_void(void ()* %callee) { ; CHECK-LABEL: call_indirect_i32: ; CHECK-NEXT: .param i32{{$}} ; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: {{^}} i32.call_indirect $push[[NUM:[0-9]+]]=, $0{{$}} +; 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() @@ -99,7 +104,9 @@ define i32 @call_indirect_i32(i32 ()* %callee) { ; CHECK-LABEL: call_indirect_arg: ; CHECK-NEXT: .param i32, i32{{$}} -; CHECK-NEXT: {{^}} call_indirect $1, $0{{$}} +; 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) @@ -108,7 +115,11 @@ define void @call_indirect_arg(void (i32)* %callee, i32 %arg) { ; CHECK-LABEL: call_indirect_arg_2: ; CHECK-NEXT: .param i32, i32, i32{{$}} -; CHECK-NEXT: {{^}} i32.call_indirect $drop=, $1, $2, $0{{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 2{{$}} +; CHECK-NEXT: get_local $push[[L2:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: {{^}} i32.call_indirect $push[[NUM:[0-9]+]]=, $pop[[L0]], $pop[[L1]], $pop[[L2]]{{$}} +; CHECK-NEXT: drop $pop[[NUM]]{{$}} ; CHECK-NEXT: return{{$}} define void @call_indirect_arg_2(i32 (i32, i32)* %callee, i32 %arg, i32 %arg2) { call i32 %callee(i32 %arg, i32 %arg2) diff --git a/test/CodeGen/WebAssembly/cfg-stackify.ll b/test/CodeGen/WebAssembly/cfg-stackify.ll index 3b42df190266..ae6dd7a34ef8 100644 --- a/test/CodeGen/WebAssembly/cfg-stackify.ll +++ b/test/CodeGen/WebAssembly/cfg-stackify.ll @@ -1,5 +1,5 @@ -; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-block-placement -verify-machineinstrs -fast-isel=false -machine-sink-split-probability-threshold=0 -cgp-freq-ratio-to-skip-merge=1000 | FileCheck %s -; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -tail-dup-placement=0 -verify-machineinstrs -fast-isel=false -machine-sink-split-probability-threshold=0 -cgp-freq-ratio-to-skip-merge=1000 | FileCheck -check-prefix=OPT %s +; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals -disable-block-placement -verify-machineinstrs -fast-isel=false -machine-sink-split-probability-threshold=0 -cgp-freq-ratio-to-skip-merge=1000 | FileCheck %s +; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals -tail-dup-placement=0 -verify-machineinstrs -fast-isel=false -machine-sink-split-probability-threshold=0 -cgp-freq-ratio-to-skip-merge=1000 | FileCheck -check-prefix=OPT %s ; Test the CFG stackifier pass. @@ -7,7 +7,7 @@ ; optnone test. target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" -target triple = "wasm32-unknown-unknown" +target triple = "wasm32-unknown-unknown-wasm" declare void @something() @@ -1144,7 +1144,6 @@ bb7: ; optnone to disable optimizations to test this case. ; CHECK-LABEL: test13: -; CHECK-NEXT: .local i32{{$}} ; CHECK-NEXT: block {{$}} ; CHECK-NEXT: block {{$}} ; CHECK: br_if 0, $pop0{{$}} @@ -1161,7 +1160,6 @@ bb7: ; CHECK-NEXT: end_block{{$}} ; CHECK-NEXT: unreachable{{$}} ; OPT-LABEL: test13: -; OPT-NEXT: .local i32{{$}} ; OPT-NEXT: block {{$}} ; OPT-NEXT: block {{$}} ; OPT: br_if 0, $pop0{{$}} diff --git a/test/CodeGen/WebAssembly/cfi.ll b/test/CodeGen/WebAssembly/cfi.ll index e5664ba73a0d..992e0f0c63d8 100644 --- a/test/CodeGen/WebAssembly/cfi.ll +++ b/test/CodeGen/WebAssembly/cfi.ll @@ -3,7 +3,7 @@ ; Tests that we correctly assign indexes for control flow integrity. target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" -target triple = "wasm32-unknown-unknown" +target triple = "wasm32-unknown-unknown-wasm" @0 = private unnamed_addr constant [2 x void (...)*] [void (...)* bitcast (void ()* @f to void (...)*), void (...)* bitcast (void ()* @g to void (...)*)], align 16 diff --git a/test/CodeGen/WebAssembly/comparisons_f32.ll b/test/CodeGen/WebAssembly/comparisons_f32.ll index 10e037d57a7a..8051b25689dd 100644 --- a/test/CodeGen/WebAssembly/comparisons_f32.ll +++ b/test/CodeGen/WebAssembly/comparisons_f32.ll @@ -4,13 +4,17 @@ ; expected. target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" -target triple = "wasm32-unknown-unknown" +target triple = "wasm32-unknown-unknown-wasm" ; CHECK-LABEL: ord_f32: ; CHECK-NEXT: .param f32, f32{{$}} ; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: f32.eq $push[[NUM0:[0-9]+]]=, $0, $0{{$}} -; CHECK-NEXT: f32.eq $push[[NUM1:[0-9]+]]=, $1, $1{{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: f32.eq $push[[NUM0:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} +; CHECK-NEXT: get_local $push[[L2:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: get_local $push[[L3:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: f32.eq $push[[NUM1:[0-9]+]]=, $pop[[L2]], $pop[[L3]]{{$}} ; CHECK-NEXT: i32.and $push[[NUM2:[0-9]+]]=, $pop[[NUM0]], $pop[[NUM1]]{{$}} ; CHECK-NEXT: return $pop[[NUM2]]{{$}} define i32 @ord_f32(float %x, float %y) { @@ -22,8 +26,12 @@ define i32 @ord_f32(float %x, float %y) { ; CHECK-LABEL: uno_f32: ; CHECK-NEXT: .param f32, f32{{$}} ; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: f32.ne $push[[NUM0:[0-9]+]]=, $0, $0{{$}} -; CHECK-NEXT: f32.ne $push[[NUM1:[0-9]+]]=, $1, $1{{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: f32.ne $push[[NUM0:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} +; CHECK-NEXT: get_local $push[[L2:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: get_local $push[[L3:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: f32.ne $push[[NUM1:[0-9]+]]=, $pop[[L2]], $pop[[L3]]{{$}} ; CHECK-NEXT: i32.or $push[[NUM2:[0-9]+]]=, $pop[[NUM0]], $pop[[NUM1]]{{$}} ; CHECK-NEXT: return $pop[[NUM2]]{{$}} define i32 @uno_f32(float %x, float %y) { @@ -35,7 +43,9 @@ define i32 @uno_f32(float %x, float %y) { ; CHECK-LABEL: oeq_f32: ; CHECK-NEXT: .param f32, f32{{$}} ; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: f32.eq $push[[NUM:[0-9]+]]=, $0, $1{{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: f32.eq $push[[NUM:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define i32 @oeq_f32(float %x, float %y) { %a = fcmp oeq float %x, %y @@ -44,7 +54,7 @@ define i32 @oeq_f32(float %x, float %y) { } ; CHECK-LABEL: une_f32: -; CHECK: f32.ne $push[[NUM:[0-9]+]]=, $0, $1{{$}} +; CHECK: f32.ne $push[[NUM:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define i32 @une_f32(float %x, float %y) { %a = fcmp une float %x, %y @@ -53,7 +63,7 @@ define i32 @une_f32(float %x, float %y) { } ; CHECK-LABEL: olt_f32: -; CHECK: f32.lt $push[[NUM:[0-9]+]]=, $0, $1{{$}} +; CHECK: f32.lt $push[[NUM:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define i32 @olt_f32(float %x, float %y) { %a = fcmp olt float %x, %y @@ -62,7 +72,7 @@ define i32 @olt_f32(float %x, float %y) { } ; CHECK-LABEL: ole_f32: -; CHECK: f32.le $push[[NUM:[0-9]+]]=, $0, $1{{$}} +; CHECK: f32.le $push[[NUM:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define i32 @ole_f32(float %x, float %y) { %a = fcmp ole float %x, %y @@ -71,7 +81,7 @@ define i32 @ole_f32(float %x, float %y) { } ; CHECK-LABEL: ogt_f32: -; CHECK: f32.gt $push[[NUM:[0-9]+]]=, $0, $1{{$}} +; CHECK: f32.gt $push[[NUM:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define i32 @ogt_f32(float %x, float %y) { %a = fcmp ogt float %x, %y @@ -80,7 +90,7 @@ define i32 @ogt_f32(float %x, float %y) { } ; CHECK-LABEL: oge_f32: -; CHECK: f32.ge $push[[NUM:[0-9]+]]=, $0, $1{{$}} +; CHECK: f32.ge $push[[NUM:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define i32 @oge_f32(float %x, float %y) { %a = fcmp oge float %x, %y @@ -93,9 +103,15 @@ define i32 @oge_f32(float %x, float %y) { ; CHECK-LABEL: ueq_f32: ; CHECK-NEXT: .param f32, f32{{$}} ; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: f32.eq $push[[NUM0:[0-9]+]]=, $0, $1{{$}} -; CHECK-NEXT: f32.ne $push[[NUM1:[0-9]+]]=, $0, $0{{$}} -; CHECK-NEXT: f32.ne $push[[NUM2:[0-9]+]]=, $1, $1{{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: f32.eq $push[[NUM0:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} +; CHECK-NEXT: get_local $push[[L2:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: get_local $push[[L3:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: f32.ne $push[[NUM1:[0-9]+]]=, $pop[[L2]], $pop[[L3]]{{$}} +; CHECK-NEXT: get_local $push[[L4:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: get_local $push[[L5:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: f32.ne $push[[NUM2:[0-9]+]]=, $pop[[L4]], $pop[[L5]]{{$}} ; CHECK-NEXT: i32.or $push[[NUM3:[0-9]+]]=, $pop[[NUM1]], $pop[[NUM2]]{{$}} ; CHECK-NEXT: i32.or $push[[NUM4:[0-9]+]]=, $pop[[NUM0]], $pop[[NUM3]]{{$}} ; CHECK-NEXT: return $pop[[NUM4]]{{$}} @@ -108,9 +124,15 @@ define i32 @ueq_f32(float %x, float %y) { ; CHECK-LABEL: one_f32: ; CHECK-NEXT: .param f32, f32{{$}} ; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: f32.ne $push[[NUM0:[0-9]+]]=, $0, $1{{$}} -; CHECK-NEXT: f32.eq $push[[NUM1:[0-9]+]]=, $0, $0{{$}} -; CHECK-NEXT: f32.eq $push[[NUM2:[0-9]+]]=, $1, $1{{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: f32.ne $push[[NUM0:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} +; CHECK-NEXT: get_local $push[[L2:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: get_local $push[[L3:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: f32.eq $push[[NUM1:[0-9]+]]=, $pop[[L2]], $pop[[L3]]{{$}} +; CHECK-NEXT: get_local $push[[L4:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: get_local $push[[L5:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: f32.eq $push[[NUM2:[0-9]+]]=, $pop[[L4]], $pop[[L5]]{{$}} ; CHECK-NEXT: i32.and $push[[NUM3:[0-9]+]]=, $pop[[NUM1]], $pop[[NUM2]]{{$}} ; CHECK-NEXT: i32.and $push[[NUM4:[0-9]+]]=, $pop[[NUM0]], $pop[[NUM3]]{{$}} ; CHECK-NEXT: return $pop[[NUM4]] @@ -123,9 +145,15 @@ define i32 @one_f32(float %x, float %y) { ; CHECK-LABEL: ult_f32: ; CHECK-NEXT: .param f32, f32{{$}} ; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: f32.lt $push[[NUM0:[0-9]+]]=, $0, $1{{$}} -; CHECK-NEXT: f32.ne $push[[NUM1:[0-9]+]]=, $0, $0{{$}} -; CHECK-NEXT: f32.ne $push[[NUM2:[0-9]+]]=, $1, $1{{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: f32.lt $push[[NUM0:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} +; CHECK-NEXT: get_local $push[[L2:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: get_local $push[[L3:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: f32.ne $push[[NUM1:[0-9]+]]=, $pop[[L2]], $pop[[L3]]{{$}} +; CHECK-NEXT: get_local $push[[L4:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: get_local $push[[L5:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: f32.ne $push[[NUM2:[0-9]+]]=, $pop[[L4]], $pop[[L5]]{{$}} ; CHECK-NEXT: i32.or $push[[NUM3:[0-9]+]]=, $pop[[NUM1]], $pop[[NUM2]]{{$}} ; CHECK-NEXT: i32.or $push[[NUM4:[0-9]+]]=, $pop[[NUM0]], $pop[[NUM3]]{{$}} ; CHECK-NEXT: return $pop[[NUM4]]{{$}} @@ -138,9 +166,15 @@ define i32 @ult_f32(float %x, float %y) { ; CHECK-LABEL: ule_f32: ; CHECK-NEXT: .param f32, f32{{$}} ; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: f32.le $push[[NUM0:[0-9]+]]=, $0, $1{{$}} -; CHECK-NEXT: f32.ne $push[[NUM1:[0-9]+]]=, $0, $0{{$}} -; CHECK-NEXT: f32.ne $push[[NUM2:[0-9]+]]=, $1, $1{{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: f32.le $push[[NUM0:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} +; CHECK-NEXT: get_local $push[[L2:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: get_local $push[[L3:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: f32.ne $push[[NUM1:[0-9]+]]=, $pop[[L2]], $pop[[L3]]{{$}} +; CHECK-NEXT: get_local $push[[L4:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: get_local $push[[L5:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: f32.ne $push[[NUM2:[0-9]+]]=, $pop[[L4]], $pop[[L5]]{{$}} ; CHECK-NEXT: i32.or $push[[NUM3:[0-9]+]]=, $pop[[NUM1]], $pop[[NUM2]]{{$}} ; CHECK-NEXT: i32.or $push[[NUM4:[0-9]+]]=, $pop[[NUM0]], $pop[[NUM3]]{{$}} ; CHECK-NEXT: return $pop[[NUM4]]{{$}} @@ -153,9 +187,15 @@ define i32 @ule_f32(float %x, float %y) { ; CHECK-LABEL: ugt_f32: ; CHECK-NEXT: .param f32, f32{{$}} ; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: f32.gt $push[[NUM0:[0-9]+]]=, $0, $1{{$}} -; CHECK-NEXT: f32.ne $push[[NUM1:[0-9]+]]=, $0, $0{{$}} -; CHECK-NEXT: f32.ne $push[[NUM2:[0-9]+]]=, $1, $1{{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: f32.gt $push[[NUM0:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} +; CHECK-NEXT: get_local $push[[L2:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: get_local $push[[L3:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: f32.ne $push[[NUM1:[0-9]+]]=, $pop[[L2]], $pop[[L3]]{{$}} +; CHECK-NEXT: get_local $push[[L4:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: get_local $push[[L5:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: f32.ne $push[[NUM2:[0-9]+]]=, $pop[[L4]], $pop[[L5]]{{$}} ; CHECK-NEXT: i32.or $push[[NUM3:[0-9]+]]=, $pop[[NUM1]], $pop[[NUM2]]{{$}} ; CHECK-NEXT: i32.or $push[[NUM4:[0-9]+]]=, $pop[[NUM0]], $pop[[NUM3]]{{$}} ; CHECK-NEXT: return $pop[[NUM4]]{{$}} @@ -168,9 +208,15 @@ define i32 @ugt_f32(float %x, float %y) { ; CHECK-LABEL: uge_f32: ; CHECK-NEXT: .param f32, f32{{$}} ; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: f32.ge $push[[NUM0:[0-9]+]]=, $0, $1{{$}} -; CHECK-NEXT: f32.ne $push[[NUM1:[0-9]+]]=, $0, $0{{$}} -; CHECK-NEXT: f32.ne $push[[NUM2:[0-9]+]]=, $1, $1{{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: f32.ge $push[[NUM0:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: f32.ne $push[[NUM1:[0-9]+]]=, $pop[[L2]], $pop[[L3]]{{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: f32.ne $push[[NUM2:[0-9]+]]=, $pop[[L4]], $pop[[L5]]{{$}} ; CHECK-NEXT: i32.or $push[[NUM3:[0-9]+]]=, $pop[[NUM1]], $pop[[NUM2]]{{$}} ; CHECK-NEXT: i32.or $push[[NUM4:[0-9]+]]=, $pop[[NUM0]], $pop[[NUM3]]{{$}} ; CHECK-NEXT: return $pop[[NUM4]]{{$}} diff --git a/test/CodeGen/WebAssembly/comparisons_f64.ll b/test/CodeGen/WebAssembly/comparisons_f64.ll index 7d038a09ccbf..6694f989627f 100644 --- a/test/CodeGen/WebAssembly/comparisons_f64.ll +++ b/test/CodeGen/WebAssembly/comparisons_f64.ll @@ -4,13 +4,17 @@ ; expected. target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" -target triple = "wasm32-unknown-unknown" +target triple = "wasm32-unknown-unknown-wasm" ; CHECK-LABEL: ord_f64: ; CHECK-NEXT: .param f64, f64{{$}} ; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: f64.eq $push[[NUM0:[0-9]+]]=, $0, $0{{$}} -; CHECK-NEXT: f64.eq $push[[NUM1:[0-9]+]]=, $1, $1{{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: f64.eq $push[[NUM0:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} +; CHECK-NEXT: get_local $push[[L2:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: get_local $push[[L3:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: f64.eq $push[[NUM1:[0-9]+]]=, $pop[[L2]], $pop[[L3]]{{$}} ; CHECK-NEXT: i32.and $push[[NUM2:[0-9]+]]=, $pop[[NUM0]], $pop[[NUM1]]{{$}} ; CHECK-NEXT: return $pop[[NUM2]]{{$}} define i32 @ord_f64(double %x, double %y) { @@ -22,8 +26,12 @@ define i32 @ord_f64(double %x, double %y) { ; CHECK-LABEL: uno_f64: ; CHECK-NEXT: .param f64, f64{{$}} ; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: f64.ne $push[[NUM0:[0-9]+]]=, $0, $0{{$}} -; CHECK-NEXT: f64.ne $push[[NUM1:[0-9]+]]=, $1, $1{{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: f64.ne $push[[NUM0:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} +; CHECK-NEXT: get_local $push[[L2:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: get_local $push[[L3:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: f64.ne $push[[NUM1:[0-9]+]]=, $pop[[L2]], $pop[[L3]]{{$}} ; CHECK-NEXT: i32.or $push[[NUM2:[0-9]+]]=, $pop[[NUM0]], $pop[[NUM1]]{{$}} ; CHECK-NEXT: return $pop[[NUM2]]{{$}} define i32 @uno_f64(double %x, double %y) { @@ -35,7 +43,9 @@ define i32 @uno_f64(double %x, double %y) { ; CHECK-LABEL: oeq_f64: ; CHECK-NEXT: .param f64, f64{{$}} ; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: f64.eq $push[[NUM:[0-9]+]]=, $0, $1{{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: f64.eq $push[[NUM:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define i32 @oeq_f64(double %x, double %y) { %a = fcmp oeq double %x, %y @@ -44,7 +54,7 @@ define i32 @oeq_f64(double %x, double %y) { } ; CHECK-LABEL: une_f64: -; CHECK: f64.ne $push[[NUM:[0-9]+]]=, $0, $1{{$}} +; CHECK: f64.ne $push[[NUM:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define i32 @une_f64(double %x, double %y) { %a = fcmp une double %x, %y @@ -53,7 +63,7 @@ define i32 @une_f64(double %x, double %y) { } ; CHECK-LABEL: olt_f64: -; CHECK: f64.lt $push[[NUM:[0-9]+]]=, $0, $1{{$}} +; CHECK: f64.lt $push[[NUM:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define i32 @olt_f64(double %x, double %y) { %a = fcmp olt double %x, %y @@ -62,7 +72,7 @@ define i32 @olt_f64(double %x, double %y) { } ; CHECK-LABEL: ole_f64: -; CHECK: f64.le $push[[NUM:[0-9]+]]=, $0, $1{{$}} +; CHECK: f64.le $push[[NUM:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define i32 @ole_f64(double %x, double %y) { %a = fcmp ole double %x, %y @@ -71,7 +81,7 @@ define i32 @ole_f64(double %x, double %y) { } ; CHECK-LABEL: ogt_f64: -; CHECK: f64.gt $push[[NUM:[0-9]+]]=, $0, $1{{$}} +; CHECK: f64.gt $push[[NUM:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define i32 @ogt_f64(double %x, double %y) { %a = fcmp ogt double %x, %y @@ -80,7 +90,7 @@ define i32 @ogt_f64(double %x, double %y) { } ; CHECK-LABEL: oge_f64: -; CHECK: f64.ge $push[[NUM:[0-9]+]]=, $0, $1{{$}} +; CHECK: f64.ge $push[[NUM:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define i32 @oge_f64(double %x, double %y) { %a = fcmp oge double %x, %y @@ -93,9 +103,15 @@ define i32 @oge_f64(double %x, double %y) { ; CHECK-LABEL: ueq_f64: ; CHECK-NEXT: .param f64, f64{{$}} ; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: f64.eq $push[[NUM0:[0-9]+]]=, $0, $1{{$}} -; CHECK-NEXT: f64.ne $push[[NUM1:[0-9]+]]=, $0, $0{{$}} -; CHECK-NEXT: f64.ne $push[[NUM2:[0-9]+]]=, $1, $1{{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: f64.eq $push[[NUM0:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} +; CHECK-NEXT: get_local $push[[L2:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: get_local $push[[L3:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: f64.ne $push[[NUM1:[0-9]+]]=, $pop[[L2]], $pop[[L3]]{{$}} +; CHECK-NEXT: get_local $push[[L4:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: get_local $push[[L5:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: f64.ne $push[[NUM2:[0-9]+]]=, $pop[[L4]], $pop[[L5]]{{$}} ; CHECK-NEXT: i32.or $push[[NUM3:[0-9]+]]=, $pop[[NUM1]], $pop[[NUM2]]{{$}} ; CHECK-NEXT: i32.or $push[[NUM4:[0-9]+]]=, $pop[[NUM0]], $pop[[NUM3]]{{$}} ; CHECK-NEXT: return $pop[[NUM4]]{{$}} @@ -108,9 +124,15 @@ define i32 @ueq_f64(double %x, double %y) { ; CHECK-LABEL: one_f64: ; CHECK-NEXT: .param f64, f64{{$}} ; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: f64.ne $push[[NUM0:[0-9]+]]=, $0, $1{{$}} -; CHECK-NEXT: f64.eq $push[[NUM1:[0-9]+]]=, $0, $0{{$}} -; CHECK-NEXT: f64.eq $push[[NUM2:[0-9]+]]=, $1, $1{{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: f64.ne $push[[NUM0:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} +; CHECK-NEXT: get_local $push[[L2:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: get_local $push[[L3:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: f64.eq $push[[NUM1:[0-9]+]]=, $pop[[L2]], $pop[[L3]]{{$}} +; CHECK-NEXT: get_local $push[[L4:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: get_local $push[[L5:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: f64.eq $push[[NUM2:[0-9]+]]=, $pop[[L4]], $pop[[L5]]{{$}} ; CHECK-NEXT: i32.and $push[[NUM3:[0-9]+]]=, $pop[[NUM1]], $pop[[NUM2]]{{$}} ; CHECK-NEXT: i32.and $push[[NUM4:[0-9]+]]=, $pop[[NUM0]], $pop[[NUM3]]{{$}} ; CHECK-NEXT: return $pop[[NUM4]] @@ -123,9 +145,15 @@ define i32 @one_f64(double %x, double %y) { ; CHECK-LABEL: ult_f64: ; CHECK-NEXT: .param f64, f64{{$}} ; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: f64.lt $push[[NUM0:[0-9]+]]=, $0, $1{{$}} -; CHECK-NEXT: f64.ne $push[[NUM1:[0-9]+]]=, $0, $0{{$}} -; CHECK-NEXT: f64.ne $push[[NUM2:[0-9]+]]=, $1, $1{{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: f64.lt $push[[NUM0:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} +; CHECK-NEXT: get_local $push[[L2:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: get_local $push[[L3:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: f64.ne $push[[NUM1:[0-9]+]]=, $pop[[L2]], $pop[[L3]]{{$}} +; CHECK-NEXT: get_local $push[[L4:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: get_local $push[[L5:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: f64.ne $push[[NUM2:[0-9]+]]=, $pop[[L4]], $pop[[L5]]{{$}} ; CHECK-NEXT: i32.or $push[[NUM3:[0-9]+]]=, $pop[[NUM1]], $pop[[NUM2]]{{$}} ; CHECK-NEXT: i32.or $push[[NUM4:[0-9]+]]=, $pop[[NUM0]], $pop[[NUM3]]{{$}} ; CHECK-NEXT: return $pop[[NUM4]]{{$}} @@ -138,9 +166,15 @@ define i32 @ult_f64(double %x, double %y) { ; CHECK-LABEL: ule_f64: ; CHECK-NEXT: .param f64, f64{{$}} ; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: f64.le $push[[NUM0:[0-9]+]]=, $0, $1{{$}} -; CHECK-NEXT: f64.ne $push[[NUM1:[0-9]+]]=, $0, $0{{$}} -; CHECK-NEXT: f64.ne $push[[NUM2:[0-9]+]]=, $1, $1{{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: f64.le $push[[NUM0:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} +; CHECK-NEXT: get_local $push[[L2:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: get_local $push[[L3:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: f64.ne $push[[NUM1:[0-9]+]]=, $pop[[L2]], $pop[[L3]]{{$}} +; CHECK-NEXT: get_local $push[[L4:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: get_local $push[[L5:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: f64.ne $push[[NUM2:[0-9]+]]=, $pop[[L4]], $pop[[L5]]{{$}} ; CHECK-NEXT: i32.or $push[[NUM3:[0-9]+]]=, $pop[[NUM1]], $pop[[NUM2]]{{$}} ; CHECK-NEXT: i32.or $push[[NUM4:[0-9]+]]=, $pop[[NUM0]], $pop[[NUM3]]{{$}} ; CHECK-NEXT: return $pop[[NUM4]]{{$}} @@ -153,9 +187,15 @@ define i32 @ule_f64(double %x, double %y) { ; CHECK-LABEL: ugt_f64: ; CHECK-NEXT: .param f64, f64{{$}} ; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: f64.gt $push[[NUM0:[0-9]+]]=, $0, $1{{$}} -; CHECK-NEXT: f64.ne $push[[NUM1:[0-9]+]]=, $0, $0{{$}} -; CHECK-NEXT: f64.ne $push[[NUM2:[0-9]+]]=, $1, $1{{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: f64.gt $push[[NUM0:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} +; CHECK-NEXT: get_local $push[[L2:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: get_local $push[[L3:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: f64.ne $push[[NUM1:[0-9]+]]=, $pop[[L2]], $pop[[L3]]{{$}} +; CHECK-NEXT: get_local $push[[L4:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: get_local $push[[L5:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: f64.ne $push[[NUM2:[0-9]+]]=, $pop[[L4]], $pop[[L5]]{{$}} ; CHECK-NEXT: i32.or $push[[NUM3:[0-9]+]]=, $pop[[NUM1]], $pop[[NUM2]]{{$}} ; CHECK-NEXT: i32.or $push[[NUM4:[0-9]+]]=, $pop[[NUM0]], $pop[[NUM3]]{{$}} ; CHECK-NEXT: return $pop[[NUM4]]{{$}} @@ -168,9 +208,15 @@ define i32 @ugt_f64(double %x, double %y) { ; CHECK-LABEL: uge_f64: ; CHECK-NEXT: .param f64, f64{{$}} ; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: f64.ge $push[[NUM0:[0-9]+]]=, $0, $1{{$}} -; CHECK-NEXT: f64.ne $push[[NUM1:[0-9]+]]=, $0, $0{{$}} -; CHECK-NEXT: f64.ne $push[[NUM2:[0-9]+]]=, $1, $1{{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: f64.ge $push[[NUM0:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} +; CHECK-NEXT: get_local $push[[L2:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: get_local $push[[L3:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: f64.ne $push[[NUM1:[0-9]+]]=, $pop[[L2]], $pop[[L3]]{{$}} +; CHECK-NEXT: get_local $push[[L4:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: get_local $push[[L5:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: f64.ne $push[[NUM2:[0-9]+]]=, $pop[[L4]], $pop[[L5]]{{$}} ; CHECK-NEXT: i32.or $push[[NUM3:[0-9]+]]=, $pop[[NUM1]], $pop[[NUM2]]{{$}} ; CHECK-NEXT: i32.or $push[[NUM4:[0-9]+]]=, $pop[[NUM0]], $pop[[NUM3]]{{$}} ; CHECK-NEXT: return $pop[[NUM4]]{{$}} diff --git a/test/CodeGen/WebAssembly/comparisons_i32.ll b/test/CodeGen/WebAssembly/comparisons_i32.ll index d2ba73f79a3d..a9a79c24fb47 100644 --- a/test/CodeGen/WebAssembly/comparisons_i32.ll +++ b/test/CodeGen/WebAssembly/comparisons_i32.ll @@ -4,12 +4,14 @@ ; Test that basic 32-bit integer comparison operations assemble as expected. target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" -target triple = "wasm32-unknown-unknown" +target triple = "wasm32-unknown-unknown-wasm" ; CHECK-LABEL: eq_i32: ; CHECK-NEXT: .param i32, i32{{$}} ; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: i32.eq $push[[NUM:[0-9]+]]=, $0, $1{{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: i32.eq $push[[NUM:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define i32 @eq_i32(i32 %x, i32 %y) { %a = icmp eq i32 %x, %y @@ -18,7 +20,7 @@ define i32 @eq_i32(i32 %x, i32 %y) { } ; CHECK-LABEL: ne_i32: -; CHECK: i32.ne $push[[NUM:[0-9]+]]=, $0, $1{{$}} +; CHECK: i32.ne $push[[NUM:[0-9]+]]=, $pop{{[0-9]+}}, $pop{{[0-9]+}}{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define i32 @ne_i32(i32 %x, i32 %y) { %a = icmp ne i32 %x, %y @@ -27,7 +29,7 @@ define i32 @ne_i32(i32 %x, i32 %y) { } ; CHECK-LABEL: slt_i32: -; CHECK: i32.lt_s $push[[NUM:[0-9]+]]=, $0, $1{{$}} +; CHECK: i32.lt_s $push[[NUM:[0-9]+]]=, $pop{{[0-9]+}}, $pop{{[0-9]+}}{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define i32 @slt_i32(i32 %x, i32 %y) { %a = icmp slt i32 %x, %y @@ -36,7 +38,7 @@ define i32 @slt_i32(i32 %x, i32 %y) { } ; CHECK-LABEL: sle_i32: -; CHECK: i32.le_s $push[[NUM:[0-9]+]]=, $0, $1{{$}} +; CHECK: i32.le_s $push[[NUM:[0-9]+]]=, $pop{{[0-9]+}}, $pop{{[0-9]+}}{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define i32 @sle_i32(i32 %x, i32 %y) { %a = icmp sle i32 %x, %y @@ -45,7 +47,7 @@ define i32 @sle_i32(i32 %x, i32 %y) { } ; CHECK-LABEL: ult_i32: -; CHECK: i32.lt_u $push[[NUM:[0-9]+]]=, $0, $1{{$}} +; CHECK: i32.lt_u $push[[NUM:[0-9]+]]=, $pop{{[0-9]+}}, $pop{{[0-9]+}}{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define i32 @ult_i32(i32 %x, i32 %y) { %a = icmp ult i32 %x, %y @@ -54,7 +56,7 @@ define i32 @ult_i32(i32 %x, i32 %y) { } ; CHECK-LABEL: ule_i32: -; CHECK: i32.le_u $push[[NUM:[0-9]+]]=, $0, $1{{$}} +; CHECK: i32.le_u $push[[NUM:[0-9]+]]=, $pop{{[0-9]+}}, $pop{{[0-9]+}}{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define i32 @ule_i32(i32 %x, i32 %y) { %a = icmp ule i32 %x, %y @@ -63,7 +65,7 @@ define i32 @ule_i32(i32 %x, i32 %y) { } ; CHECK-LABEL: sgt_i32: -; CHECK: i32.gt_s $push[[NUM:[0-9]+]]=, $0, $1{{$}} +; CHECK: i32.gt_s $push[[NUM:[0-9]+]]=, $pop{{[0-9]+}}, $pop{{[0-9]+}}{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define i32 @sgt_i32(i32 %x, i32 %y) { %a = icmp sgt i32 %x, %y @@ -72,7 +74,7 @@ define i32 @sgt_i32(i32 %x, i32 %y) { } ; CHECK-LABEL: sge_i32: -; CHECK: i32.ge_s $push[[NUM:[0-9]+]]=, $0, $1{{$}} +; CHECK: i32.ge_s $push[[NUM:[0-9]+]]=, $pop{{[0-9]+}}, $pop{{[0-9]+}}{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define i32 @sge_i32(i32 %x, i32 %y) { %a = icmp sge i32 %x, %y @@ -81,7 +83,7 @@ define i32 @sge_i32(i32 %x, i32 %y) { } ; CHECK-LABEL: ugt_i32: -; CHECK: i32.gt_u $push[[NUM:[0-9]+]]=, $0, $1{{$}} +; CHECK: i32.gt_u $push[[NUM:[0-9]+]]=, $pop{{[0-9]+}}, $pop{{[0-9]+}}{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define i32 @ugt_i32(i32 %x, i32 %y) { %a = icmp ugt i32 %x, %y @@ -90,7 +92,7 @@ define i32 @ugt_i32(i32 %x, i32 %y) { } ; CHECK-LABEL: uge_i32: -; CHECK: i32.ge_u $push[[NUM:[0-9]+]]=, $0, $1{{$}} +; CHECK: i32.ge_u $push[[NUM:[0-9]+]]=, $pop{{[0-9]+}}, $pop{{[0-9]+}}{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define i32 @uge_i32(i32 %x, i32 %y) { %a = icmp uge i32 %x, %y diff --git a/test/CodeGen/WebAssembly/comparisons_i64.ll b/test/CodeGen/WebAssembly/comparisons_i64.ll index 80950ae5cd9a..106520483c8f 100644 --- a/test/CodeGen/WebAssembly/comparisons_i64.ll +++ b/test/CodeGen/WebAssembly/comparisons_i64.ll @@ -4,12 +4,14 @@ ; Test that basic 64-bit integer comparison operations assemble as expected. target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" -target triple = "wasm32-unknown-unknown" +target triple = "wasm32-unknown-unknown-wasm" ; CHECK-LABEL: eq_i64: ; CHECK-NEXT: .param i64, i64{{$}} ; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: i64.eq $push[[NUM:[0-9]+]]=, $0, $1{{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: i64.eq $push[[NUM:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define i32 @eq_i64(i64 %x, i64 %y) { %a = icmp eq i64 %x, %y @@ -18,7 +20,7 @@ define i32 @eq_i64(i64 %x, i64 %y) { } ; CHECK-LABEL: ne_i64: -; CHECK: i64.ne $push[[NUM:[0-9]+]]=, $0, $1{{$}} +; CHECK: i64.ne $push[[NUM:[0-9]+]]=, $pop{{[0-9]+}}, $pop{{[0-9]+}}{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define i32 @ne_i64(i64 %x, i64 %y) { %a = icmp ne i64 %x, %y @@ -27,7 +29,7 @@ define i32 @ne_i64(i64 %x, i64 %y) { } ; CHECK-LABEL: slt_i64: -; CHECK: i64.lt_s $push[[NUM:[0-9]+]]=, $0, $1{{$}} +; CHECK: i64.lt_s $push[[NUM:[0-9]+]]=, $pop{{[0-9]+}}, $pop{{[0-9]+}}{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define i32 @slt_i64(i64 %x, i64 %y) { %a = icmp slt i64 %x, %y @@ -36,7 +38,7 @@ define i32 @slt_i64(i64 %x, i64 %y) { } ; CHECK-LABEL: sle_i64: -; CHECK: i64.le_s $push[[NUM:[0-9]+]]=, $0, $1{{$}} +; CHECK: i64.le_s $push[[NUM:[0-9]+]]=, $pop{{[0-9]+}}, $pop{{[0-9]+}}{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define i32 @sle_i64(i64 %x, i64 %y) { %a = icmp sle i64 %x, %y @@ -45,7 +47,7 @@ define i32 @sle_i64(i64 %x, i64 %y) { } ; CHECK-LABEL: ult_i64: -; CHECK: i64.lt_u $push[[NUM:[0-9]+]]=, $0, $1{{$}} +; CHECK: i64.lt_u $push[[NUM:[0-9]+]]=, $pop{{[0-9]+}}, $pop{{[0-9]+}}{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define i32 @ult_i64(i64 %x, i64 %y) { %a = icmp ult i64 %x, %y @@ -54,7 +56,7 @@ define i32 @ult_i64(i64 %x, i64 %y) { } ; CHECK-LABEL: ule_i64: -; CHECK: i64.le_u $push[[NUM:[0-9]+]]=, $0, $1{{$}} +; CHECK: i64.le_u $push[[NUM:[0-9]+]]=, $pop{{[0-9]+}}, $pop{{[0-9]+}}{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define i32 @ule_i64(i64 %x, i64 %y) { %a = icmp ule i64 %x, %y @@ -63,7 +65,7 @@ define i32 @ule_i64(i64 %x, i64 %y) { } ; CHECK-LABEL: sgt_i64: -; CHECK: i64.gt_s $push[[NUM:[0-9]+]]=, $0, $1{{$}} +; CHECK: i64.gt_s $push[[NUM:[0-9]+]]=, $pop{{[0-9]+}}, $pop{{[0-9]+}}{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define i32 @sgt_i64(i64 %x, i64 %y) { %a = icmp sgt i64 %x, %y @@ -72,7 +74,7 @@ define i32 @sgt_i64(i64 %x, i64 %y) { } ; CHECK-LABEL: sge_i64: -; CHECK: i64.ge_s $push[[NUM:[0-9]+]]=, $0, $1{{$}} +; CHECK: i64.ge_s $push[[NUM:[0-9]+]]=, $pop{{[0-9]+}}, $pop{{[0-9]+}}{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define i32 @sge_i64(i64 %x, i64 %y) { %a = icmp sge i64 %x, %y @@ -81,7 +83,7 @@ define i32 @sge_i64(i64 %x, i64 %y) { } ; CHECK-LABEL: ugt_i64: -; CHECK: i64.gt_u $push[[NUM:[0-9]+]]=, $0, $1{{$}} +; CHECK: i64.gt_u $push[[NUM:[0-9]+]]=, $pop{{[0-9]+}}, $pop{{[0-9]+}}{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define i32 @ugt_i64(i64 %x, i64 %y) { %a = icmp ugt i64 %x, %y @@ -90,7 +92,7 @@ define i32 @ugt_i64(i64 %x, i64 %y) { } ; CHECK-LABEL: uge_i64: -; CHECK: i64.ge_u $push[[NUM:[0-9]+]]=, $0, $1{{$}} +; CHECK: i64.ge_u $push[[NUM:[0-9]+]]=, $pop{{[0-9]+}}, $pop{{[0-9]+}}{{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define i32 @uge_i64(i64 %x, i64 %y) { %a = icmp uge i64 %x, %y diff --git a/test/CodeGen/WebAssembly/conv.ll b/test/CodeGen/WebAssembly/conv.ll index 27cebb117dd4..913c4b0b19ea 100644 --- a/test/CodeGen/WebAssembly/conv.ll +++ b/test/CodeGen/WebAssembly/conv.ll @@ -1,9 +1,9 @@ -; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt | FileCheck %s +; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals | FileCheck %s ; Test that basic conversion operations assemble as expected. target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" -target triple = "wasm32-unknown-unknown" +target triple = "wasm32-unknown-unknown-wasm" ; CHECK-LABEL: i32_wrap_i64: ; CHECK-NEXT: .param i64{{$}} diff --git a/test/CodeGen/WebAssembly/copysign-casts.ll b/test/CodeGen/WebAssembly/copysign-casts.ll index f8e50d043ca9..7cd40efafcd5 100644 --- a/test/CodeGen/WebAssembly/copysign-casts.ll +++ b/test/CodeGen/WebAssembly/copysign-casts.ll @@ -4,14 +4,14 @@ ; unfolded. target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" -target triple = "wasm32-unknown-unknown" +target triple = "wasm32-unknown-unknown-wasm" declare double @copysign(double, double) nounwind readnone declare float @copysignf(float, float) nounwind readnone ; CHECK-LABEL: fold_promote: -; CHECK: f64.promote/f32 $push0=, $1{{$}} -; CHECK: f64.copysign $push1=, $0, $pop0{{$}} +; CHECK: f64.promote/f32 $push0=, $pop{{[0-9]+}}{{$}} +; CHECK: f64.copysign $push1=, $pop{{[0-9]+}}, $pop0{{$}} define double @fold_promote(double %a, float %b) { %c = fpext float %b to double %t = call double @copysign(double %a, double %c) @@ -19,8 +19,8 @@ define double @fold_promote(double %a, float %b) { } ; CHECK-LABEL: fold_demote:{{$}} -; CHECK: f32.demote/f64 $push0=, $1{{$}} -; CHECK: f32.copysign $push1=, $0, $pop0{{$}} +; CHECK: f32.demote/f64 $push0=, $pop{{[0-9]+}}{{$}} +; CHECK: f32.copysign $push1=, $pop{{[0-9]+}}, $pop0{{$}} define float @fold_demote(float %a, double %b) { %c = fptrunc double %b to float %t = call float @copysignf(float %a, float %c) diff --git a/test/CodeGen/WebAssembly/cpus.ll b/test/CodeGen/WebAssembly/cpus.ll index 78aee0f59d92..9b4ac4425ca9 100644 --- a/test/CodeGen/WebAssembly/cpus.ll +++ b/test/CodeGen/WebAssembly/cpus.ll @@ -1,13 +1,13 @@ ; This tests that llc accepts all valid WebAssembly CPUs. -; RUN: llc < %s -asm-verbose=false -mtriple=wasm32-unknown-unknown -mcpu=mvp 2>&1 | FileCheck %s -; RUN: llc < %s -asm-verbose=false -mtriple=wasm64-unknown-unknown -mcpu=mvp 2>&1 | FileCheck %s -; RUN: llc < %s -asm-verbose=false -mtriple=wasm32-unknown-unknown -mcpu=generic 2>&1 | FileCheck %s -; RUN: llc < %s -asm-verbose=false -mtriple=wasm64-unknown-unknown -mcpu=generic 2>&1 | FileCheck %s -; RUN: llc < %s -asm-verbose=false -mtriple=wasm32-unknown-unknown -mcpu=bleeding-edge 2>&1 | FileCheck %s -; RUN: llc < %s -asm-verbose=false -mtriple=wasm64-unknown-unknown -mcpu=bleeding-edge 2>&1 | FileCheck %s -; RUN: llc < %s -asm-verbose=false -mtriple=wasm32-unknown-unknown -mcpu=invalidcpu 2>&1 | FileCheck %s --check-prefix=INVALID -; RUN: llc < %s -asm-verbose=false -mtriple=wasm64-unknown-unknown -mcpu=invalidcpu 2>&1 | FileCheck %s --check-prefix=INVALID +; RUN: llc < %s -asm-verbose=false -mtriple=wasm32-unknown-unknown-wasm -mcpu=mvp 2>&1 | FileCheck %s +; RUN: llc < %s -asm-verbose=false -mtriple=wasm64-unknown-unknown-wasm -mcpu=mvp 2>&1 | FileCheck %s +; RUN: llc < %s -asm-verbose=false -mtriple=wasm32-unknown-unknown-wasm -mcpu=generic 2>&1 | FileCheck %s +; RUN: llc < %s -asm-verbose=false -mtriple=wasm64-unknown-unknown-wasm -mcpu=generic 2>&1 | FileCheck %s +; RUN: llc < %s -asm-verbose=false -mtriple=wasm32-unknown-unknown-wasm -mcpu=bleeding-edge 2>&1 | FileCheck %s +; RUN: llc < %s -asm-verbose=false -mtriple=wasm64-unknown-unknown-wasm -mcpu=bleeding-edge 2>&1 | FileCheck %s +; RUN: llc < %s -asm-verbose=false -mtriple=wasm32-unknown-unknown-wasm -mcpu=invalidcpu 2>&1 | FileCheck %s --check-prefix=INVALID +; RUN: llc < %s -asm-verbose=false -mtriple=wasm64-unknown-unknown-wasm -mcpu=invalidcpu 2>&1 | FileCheck %s --check-prefix=INVALID ; CHECK-NOT: is not a recognized processor for this target ; INVALID: {{.+}} is not a recognized processor for this target diff --git a/test/CodeGen/WebAssembly/dbgvalue.ll b/test/CodeGen/WebAssembly/dbgvalue.ll index c6a091bc78c8..eb39c6da1c99 100644 --- a/test/CodeGen/WebAssembly/dbgvalue.ll +++ b/test/CodeGen/WebAssembly/dbgvalue.ll @@ -1,4 +1,4 @@ -; RUN: llc < %s -O0 -verify-machineinstrs -mtriple=wasm32-unknown-unknown | FileCheck %s +; RUN: llc < %s -O0 -verify-machineinstrs -mtriple=wasm32-unknown-unknown-wasm | FileCheck %s ; CHECK: BB#0 ; CHECK: #DEBUG_VALUE: usage:self <- %vreg4 @@ -6,7 +6,7 @@ ; CHECK: DW_TAG_variable source_filename = "test/CodeGen/WebAssembly/dbgvalue.ll" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" -target triple = "wasm32-unknown-unknown" +target triple = "wasm32-unknown-unknown-wasm" @key = external local_unnamed_addr global [15 x i8], align 1 @.str = external unnamed_addr constant [33 x i8], align 1 diff --git a/test/CodeGen/WebAssembly/dead-vreg.ll b/test/CodeGen/WebAssembly/dead-vreg.ll index 190a08564001..06487e4cd363 100644 --- a/test/CodeGen/WebAssembly/dead-vreg.ll +++ b/test/CodeGen/WebAssembly/dead-vreg.ll @@ -3,7 +3,7 @@ ; Check that unused vregs aren't assigned registers. target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" -target triple = "wasm32-unknown-unknown" +target triple = "wasm32-unknown-unknown-wasm" define void @foo(i32* nocapture %a, i32 %w, i32 %h) { ; CHECK-LABEL: foo: diff --git a/test/CodeGen/WebAssembly/divrem-constant.ll b/test/CodeGen/WebAssembly/divrem-constant.ll index 6150cab4d4fd..1b4d30ad9493 100644 --- a/test/CodeGen/WebAssembly/divrem-constant.ll +++ b/test/CodeGen/WebAssembly/divrem-constant.ll @@ -3,7 +3,7 @@ ; Test that integer div and rem by constant are optimized appropriately. target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" -target triple = "wasm32-unknown-unknown" +target triple = "wasm32-unknown-unknown-wasm" ; CHECK-LABEL: test_udiv_2: ; CHECK: i32.shr_u diff --git a/test/CodeGen/WebAssembly/f16.ll b/test/CodeGen/WebAssembly/f16.ll new file mode 100644 index 000000000000..6915f93e9b96 --- /dev/null +++ b/test/CodeGen/WebAssembly/f16.ll @@ -0,0 +1,29 @@ +; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt | FileCheck %s +; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -fast-isel | FileCheck %s + +; Test that f16 is expanded. + +target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" +target triple = "wasm32-unknown-unknown-wasm" + +; CHECK-LABEL: demote: +; CHECK-NEXT: .param f32{{$}} +; CHECK-NEXT: .result f32{{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: i32.call $push[[L1:[0-9]+]]=, __gnu_f2h_ieee@FUNCTION, $pop[[L0]]{{$}} +; CHECK-NEXT: f32.call $push[[L2:[0-9]+]]=, __gnu_h2f_ieee@FUNCTION, $pop[[L1]]{{$}} +; CHECK-NEXT: return $pop[[L2]]{{$}} +define half @demote(float %f) { + %t = fptrunc float %f to half + ret half %t +} + +; CHECK-LABEL: promote: +; CHECK-NEXT: .param f32{{$}} +; CHECK-NEXT: .result f32{{$}} +; CHECK-NEXT: get_local $push0=, 0{{$}} +; CHECK-NEXT: return $pop0{{$}} +define float @promote(half %f) { + %t = fpext half %f to float + ret float %t +} diff --git a/test/CodeGen/WebAssembly/f32.ll b/test/CodeGen/WebAssembly/f32.ll index 1c1d8191a987..45f00aa5a01f 100644 --- a/test/CodeGen/WebAssembly/f32.ll +++ b/test/CodeGen/WebAssembly/f32.ll @@ -3,7 +3,7 @@ ; Test that basic 32-bit floating-point operations assemble as expected. target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" -target triple = "wasm32-unknown-unknown" +target triple = "wasm32-unknown-unknown-wasm" declare float @llvm.fabs.f32(float) declare float @llvm.copysign.f32(float, float) @@ -18,104 +18,106 @@ declare float @llvm.fma.f32(float, float, float) ; CHECK-LABEL: fadd32: ; CHECK-NEXT: .param f32, f32{{$}} ; CHECK-NEXT: .result f32{{$}} -; CHECK-NEXT: f32.add $push0=, $0, $1{{$}} -; CHECK-NEXT: return $pop0{{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: f32.add $push[[LR:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} +; CHECK-NEXT: return $pop[[LR]]{{$}} define float @fadd32(float %x, float %y) { %a = fadd float %x, %y ret float %a } ; CHECK-LABEL: fsub32: -; CHECK: f32.sub $push0=, $0, $1{{$}} -; CHECK-NEXT: return $pop0{{$}} +; CHECK: f32.sub $push[[LR:[0-9]+]]=, $pop{{[0-9]+}}, $pop{{[0-9]+}}{{$}} +; CHECK-NEXT: return $pop[[LR]]{{$}} define float @fsub32(float %x, float %y) { %a = fsub float %x, %y ret float %a } ; CHECK-LABEL: fmul32: -; CHECK: f32.mul $push0=, $0, $1{{$}} -; CHECK-NEXT: return $pop0{{$}} +; CHECK: f32.mul $push[[LR:[0-9]+]]=, $pop{{[0-9]+}}, $pop{{[0-9]+}}{{$}} +; CHECK-NEXT: return $pop[[LR]]{{$}} define float @fmul32(float %x, float %y) { %a = fmul float %x, %y ret float %a } ; CHECK-LABEL: fdiv32: -; CHECK: f32.div $push0=, $0, $1{{$}} -; CHECK-NEXT: return $pop0{{$}} +; CHECK: f32.div $push[[LR:[0-9]+]]=, $pop{{[0-9]+}}, $pop{{[0-9]+}}{{$}} +; CHECK-NEXT: return $pop[[LR]]{{$}} define float @fdiv32(float %x, float %y) { %a = fdiv float %x, %y ret float %a } ; CHECK-LABEL: fabs32: -; CHECK: f32.abs $push0=, $0{{$}} -; CHECK-NEXT: return $pop0{{$}} +; CHECK: f32.abs $push[[LR:[0-9]+]]=, $pop{{[0-9]+}}{{$}} +; CHECK-NEXT: return $pop[[LR]]{{$}} define float @fabs32(float %x) { %a = call float @llvm.fabs.f32(float %x) ret float %a } ; CHECK-LABEL: fneg32: -; CHECK: f32.neg $push0=, $0{{$}} -; CHECK-NEXT: return $pop0{{$}} +; CHECK: f32.neg $push[[LR:[0-9]+]]=, $pop{{[0-9]+}}{{$}} +; CHECK-NEXT: return $pop[[LR]]{{$}} define float @fneg32(float %x) { %a = fsub float -0., %x ret float %a } ; CHECK-LABEL: copysign32: -; CHECK: f32.copysign $push0=, $0, $1{{$}} -; CHECK-NEXT: return $pop0{{$}} +; CHECK: f32.copysign $push[[LR:[0-9]+]]=, $pop{{[0-9]+}}, $pop{{[0-9]+}}{{$}} +; CHECK-NEXT: return $pop[[LR]]{{$}} define float @copysign32(float %x, float %y) { %a = call float @llvm.copysign.f32(float %x, float %y) ret float %a } ; CHECK-LABEL: sqrt32: -; CHECK: f32.sqrt $push0=, $0{{$}} -; CHECK-NEXT: return $pop0{{$}} +; CHECK: f32.sqrt $push[[LR:[0-9]+]]=, $pop{{[0-9]+}}{{$}} +; CHECK-NEXT: return $pop[[LR]]{{$}} define float @sqrt32(float %x) { %a = call float @llvm.sqrt.f32(float %x) ret float %a } ; CHECK-LABEL: ceil32: -; CHECK: f32.ceil $push0=, $0{{$}} -; CHECK-NEXT: return $pop0{{$}} +; CHECK: f32.ceil $push[[LR:[0-9]+]]=, $pop{{[0-9]+}}{{$}} +; CHECK-NEXT: return $pop[[LR]]{{$}} define float @ceil32(float %x) { %a = call float @llvm.ceil.f32(float %x) ret float %a } ; CHECK-LABEL: floor32: -; CHECK: f32.floor $push0=, $0{{$}} -; CHECK-NEXT: return $pop0{{$}} +; CHECK: f32.floor $push[[LR:[0-9]+]]=, $pop{{[0-9]+}}{{$}} +; CHECK-NEXT: return $pop[[LR]]{{$}} define float @floor32(float %x) { %a = call float @llvm.floor.f32(float %x) ret float %a } ; CHECK-LABEL: trunc32: -; CHECK: f32.trunc $push0=, $0{{$}} -; CHECK-NEXT: return $pop0{{$}} +; CHECK: f32.trunc $push[[LR:[0-9]+]]=, $pop{{[0-9]+}}{{$}} +; CHECK-NEXT: return $pop[[LR]]{{$}} define float @trunc32(float %x) { %a = call float @llvm.trunc.f32(float %x) ret float %a } ; CHECK-LABEL: nearest32: -; CHECK: f32.nearest $push0=, $0{{$}} -; CHECK-NEXT: return $pop0{{$}} +; CHECK: f32.nearest $push[[LR:[0-9]+]]=, $pop{{[0-9]+}}{{$}} +; CHECK-NEXT: return $pop[[LR]]{{$}} define float @nearest32(float %x) { %a = call float @llvm.nearbyint.f32(float %x) ret float %a } ; CHECK-LABEL: nearest32_via_rint: -; CHECK: f32.nearest $push0=, $0{{$}} -; CHECK-NEXT: return $pop0{{$}} +; CHECK: f32.nearest $push[[LR:[0-9]+]]=, $pop{{[0-9]+}}{{$}} +; CHECK-NEXT: return $pop[[LR]]{{$}} define float @nearest32_via_rint(float %x) { %a = call float @llvm.rint.f32(float %x) ret float %a @@ -128,7 +130,7 @@ define float @nearest32_via_rint(float %x) { ; tests. ; CHECK-LABEL: fmin32: -; CHECK: f32.min $push1=, $0, $pop0{{$}} +; CHECK: f32.min $push1=, $pop{{[0-9]+}}, $pop[[LR]]{{$}} ; CHECK-NEXT: return $pop1{{$}} define float @fmin32(float %x) { %a = fcmp ult float %x, 0.0 @@ -137,7 +139,7 @@ define float @fmin32(float %x) { } ; CHECK-LABEL: fmax32: -; CHECK: f32.max $push1=, $0, $pop0{{$}} +; CHECK: f32.max $push1=, $pop{{[0-9]+}}, $pop[[LR]]{{$}} ; CHECK-NEXT: return $pop1{{$}} define float @fmax32(float %x) { %a = fcmp ugt float %x, 0.0 @@ -146,8 +148,8 @@ define float @fmax32(float %x) { } ; CHECK-LABEL: fma32: -; CHECK: {{^}} f32.call $push0=, fmaf@FUNCTION, $0, $1, $2{{$}} -; CHECK-NEXT: return $pop0{{$}} +; CHECK: {{^}} f32.call $push[[LR:[0-9]+]]=, fmaf@FUNCTION, $pop{{[0-9]+}}, $pop{{[0-9]+}}, $pop{{[0-9]+}}{{$}} +; CHECK-NEXT: return $pop[[LR]]{{$}} define float @fma32(float %a, float %b, float %c) { %d = call float @llvm.fma.f32(float %a, float %b, float %c) ret float %d diff --git a/test/CodeGen/WebAssembly/f64.ll b/test/CodeGen/WebAssembly/f64.ll index 670f3f0b6978..fb52c3f92ad6 100644 --- a/test/CodeGen/WebAssembly/f64.ll +++ b/test/CodeGen/WebAssembly/f64.ll @@ -3,7 +3,7 @@ ; Test that basic 64-bit floating-point operations assemble as expected. target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" -target triple = "wasm32-unknown-unknown" +target triple = "wasm32-unknown-unknown-wasm" declare double @llvm.fabs.f64(double) declare double @llvm.copysign.f64(double, double) @@ -18,104 +18,106 @@ declare double @llvm.fma.f64(double, double, double) ; CHECK-LABEL: fadd64: ; CHECK-NEXT: .param f64, f64{{$}} ; CHECK-NEXT: .result f64{{$}} -; CHECK-NEXT: f64.add $push0=, $0, $1{{$}} -; CHECK-NEXT: return $pop0{{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: f64.add $push[[LR:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} +; CHECK-NEXT: return $pop[[LR]]{{$}} define double @fadd64(double %x, double %y) { %a = fadd double %x, %y ret double %a } ; CHECK-LABEL: fsub64: -; CHECK: f64.sub $push0=, $0, $1{{$}} -; CHECK-NEXT: return $pop0{{$}} +; CHECK: f64.sub $push[[LR:[0-9]+]]=, $pop{{[0-9]+}}, $pop{{[0-9]+}}{{$}} +; CHECK-NEXT: return $pop[[LR]]{{$}} define double @fsub64(double %x, double %y) { %a = fsub double %x, %y ret double %a } ; CHECK-LABEL: fmul64: -; CHECK: f64.mul $push0=, $0, $1{{$}} -; CHECK-NEXT: return $pop0{{$}} +; CHECK: f64.mul $push[[LR:[0-9]+]]=, $pop{{[0-9]+}}, $pop{{[0-9]+}}{{$}} +; CHECK-NEXT: return $pop[[LR]]{{$}} define double @fmul64(double %x, double %y) { %a = fmul double %x, %y ret double %a } ; CHECK-LABEL: fdiv64: -; CHECK: f64.div $push0=, $0, $1{{$}} -; CHECK-NEXT: return $pop0{{$}} +; CHECK: f64.div $push[[LR:[0-9]+]]=, $pop{{[0-9]+}}, $pop{{[0-9]+}}{{$}} +; CHECK-NEXT: return $pop[[LR]]{{$}} define double @fdiv64(double %x, double %y) { %a = fdiv double %x, %y ret double %a } ; CHECK-LABEL: fabs64: -; CHECK: f64.abs $push0=, $0{{$}} -; CHECK-NEXT: return $pop0{{$}} +; CHECK: f64.abs $push[[LR:[0-9]+]]=, $pop{{[0-9]+}}{{$}} +; CHECK-NEXT: return $pop[[LR]]{{$}} define double @fabs64(double %x) { %a = call double @llvm.fabs.f64(double %x) ret double %a } ; CHECK-LABEL: fneg64: -; CHECK: f64.neg $push0=, $0{{$}} -; CHECK-NEXT: return $pop0{{$}} +; CHECK: f64.neg $push[[LR:[0-9]+]]=, $pop{{[0-9]+}}{{$}} +; CHECK-NEXT: return $pop[[LR]]{{$}} define double @fneg64(double %x) { %a = fsub double -0., %x ret double %a } ; CHECK-LABEL: copysign64: -; CHECK: f64.copysign $push0=, $0, $1{{$}} -; CHECK-NEXT: return $pop0{{$}} +; CHECK: f64.copysign $push[[LR:[0-9]+]]=, $pop{{[0-9]+}}, $pop{{[0-9]+}}{{$}} +; CHECK-NEXT: return $pop[[LR]]{{$}} define double @copysign64(double %x, double %y) { %a = call double @llvm.copysign.f64(double %x, double %y) ret double %a } ; CHECK-LABEL: sqrt64: -; CHECK: f64.sqrt $push0=, $0{{$}} -; CHECK-NEXT: return $pop0{{$}} +; CHECK: f64.sqrt $push[[LR:[0-9]+]]=, $pop{{[0-9]+}}{{$}} +; CHECK-NEXT: return $pop[[LR]]{{$}} define double @sqrt64(double %x) { %a = call double @llvm.sqrt.f64(double %x) ret double %a } ; CHECK-LABEL: ceil64: -; CHECK: f64.ceil $push0=, $0{{$}} -; CHECK-NEXT: return $pop0{{$}} +; CHECK: f64.ceil $push[[LR:[0-9]+]]=, $pop{{[0-9]+}}{{$}} +; CHECK-NEXT: return $pop[[LR]]{{$}} define double @ceil64(double %x) { %a = call double @llvm.ceil.f64(double %x) ret double %a } ; CHECK-LABEL: floor64: -; CHECK: f64.floor $push0=, $0{{$}} -; CHECK-NEXT: return $pop0{{$}} +; CHECK: f64.floor $push[[LR:[0-9]+]]=, $pop{{[0-9]+}}{{$}} +; CHECK-NEXT: return $pop[[LR]]{{$}} define double @floor64(double %x) { %a = call double @llvm.floor.f64(double %x) ret double %a } ; CHECK-LABEL: trunc64: -; CHECK: f64.trunc $push0=, $0{{$}} -; CHECK-NEXT: return $pop0{{$}} +; CHECK: f64.trunc $push[[LR:[0-9]+]]=, $pop{{[0-9]+}}{{$}} +; CHECK-NEXT: return $pop[[LR]]{{$}} define double @trunc64(double %x) { %a = call double @llvm.trunc.f64(double %x) ret double %a } ; CHECK-LABEL: nearest64: -; CHECK: f64.nearest $push0=, $0{{$}} -; CHECK-NEXT: return $pop0{{$}} +; CHECK: f64.nearest $push[[LR:[0-9]+]]=, $pop{{[0-9]+}}{{$}} +; CHECK-NEXT: return $pop[[LR]]{{$}} define double @nearest64(double %x) { %a = call double @llvm.nearbyint.f64(double %x) ret double %a } ; CHECK-LABEL: nearest64_via_rint: -; CHECK: f64.nearest $push0=, $0{{$}} -; CHECK-NEXT: return $pop0{{$}} +; CHECK: f64.nearest $push[[LR:[0-9]+]]=, $pop{{[0-9]+}}{{$}} +; CHECK-NEXT: return $pop[[LR]]{{$}} define double @nearest64_via_rint(double %x) { %a = call double @llvm.rint.f64(double %x) ret double %a @@ -128,7 +130,7 @@ define double @nearest64_via_rint(double %x) { ; tests. ; CHECK-LABEL: fmin64: -; CHECK: f64.min $push1=, $0, $pop0{{$}} +; CHECK: f64.min $push1=, $pop{{[0-9]+}}, $pop[[LR]]{{$}} ; CHECK-NEXT: return $pop1{{$}} define double @fmin64(double %x) { %a = fcmp ult double %x, 0.0 @@ -137,7 +139,7 @@ define double @fmin64(double %x) { } ; CHECK-LABEL: fmax64: -; CHECK: f64.max $push1=, $0, $pop0{{$}} +; CHECK: f64.max $push1=, $pop{{[0-9]+}}, $pop[[LR]]{{$}} ; CHECK-NEXT: return $pop1{{$}} define double @fmax64(double %x) { %a = fcmp ugt double %x, 0.0 @@ -146,8 +148,8 @@ define double @fmax64(double %x) { } ; CHECK-LABEL: fma64: -; CHECK: {{^}} f64.call $push0=, fma@FUNCTION, $0, $1, $2{{$}} -; CHECK-NEXT: return $pop0{{$}} +; CHECK: {{^}} f64.call $push[[LR:[0-9]+]]=, fma@FUNCTION, $pop{{[0-9]+}}, $pop{{[0-9]+}}, $pop{{[0-9]+}}{{$}} +; CHECK-NEXT: return $pop[[LR]]{{$}} define double @fma64(double %a, double %b, double %c) { %d = call double @llvm.fma.f64(double %a, double %b, double %c) ret double %d diff --git a/test/CodeGen/WebAssembly/fast-isel-noreg.ll b/test/CodeGen/WebAssembly/fast-isel-noreg.ll index a2504822dd1c..229651d093f0 100644 --- a/test/CodeGen/WebAssembly/fast-isel-noreg.ll +++ b/test/CodeGen/WebAssembly/fast-isel-noreg.ll @@ -4,7 +4,7 @@ ; Test that FastISel does not generate instructions with NoReg target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" -target triple = "wasm32-unknown-unknown" +target triple = "wasm32-unknown-unknown-wasm" ; CHECK: i32.const $push0=, 0 define hidden i32 @a() #0 { diff --git a/test/CodeGen/WebAssembly/fast-isel.ll b/test/CodeGen/WebAssembly/fast-isel.ll index 953bd610b1bc..457c5874e493 100644 --- a/test/CodeGen/WebAssembly/fast-isel.ll +++ b/test/CodeGen/WebAssembly/fast-isel.ll @@ -1,9 +1,10 @@ ; RUN: llc < %s -asm-verbose=false \ ; RUN: -fast-isel -fast-isel-abort=1 -verify-machineinstrs \ +; RUN: -disable-wasm-explicit-locals \ ; RUN: | FileCheck %s target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" -target triple = "wasm32-unknown-unknown" +target triple = "wasm32-unknown-unknown-wasm" ; This tests very minimal fast-isel functionality. diff --git a/test/CodeGen/WebAssembly/frem.ll b/test/CodeGen/WebAssembly/frem.ll index b8745224ab82..1a9c13417b67 100644 --- a/test/CodeGen/WebAssembly/frem.ll +++ b/test/CodeGen/WebAssembly/frem.ll @@ -1,9 +1,9 @@ -; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt | FileCheck %s +; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals | FileCheck %s ; Test that the frem instruction works. target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" -target triple = "wasm32-unknown-unknown" +target triple = "wasm32-unknown-unknown-wasm" ; CHECK-LABEL: frem32: ; CHECK-NEXT: .param f32, f32{{$}} diff --git a/test/CodeGen/WebAssembly/func.ll b/test/CodeGen/WebAssembly/func.ll index 71c00a46de86..994ef62bf54d 100644 --- a/test/CodeGen/WebAssembly/func.ll +++ b/test/CodeGen/WebAssembly/func.ll @@ -1,13 +1,13 @@ -; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt | FileCheck %s +; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals | FileCheck %s ; Test that basic functions assemble as expected. target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" -target triple = "wasm32-unknown-unknown" +target triple = "wasm32-unknown-unknown-wasm" ; CHECK-LABEL: f0: ; CHECK: return{{$}} -; CHECK: .endfunc{{$}} +; CHECK: end_function{{$}} ; CHECK: .size f0, define void @f0() { ret void diff --git a/test/CodeGen/WebAssembly/function-bitcasts.ll b/test/CodeGen/WebAssembly/function-bitcasts.ll index e4f8f3fb6ca9..3f20aef08115 100644 --- a/test/CodeGen/WebAssembly/function-bitcasts.ll +++ b/test/CodeGen/WebAssembly/function-bitcasts.ll @@ -1,9 +1,9 @@ -; RUN: llc < %s -asm-verbose=false | FileCheck %s +; RUN: llc < %s -asm-verbose=false -disable-wasm-explicit-locals | FileCheck %s ; Test that function pointer casts are replaced with wrappers. target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" -target triple = "wasm32-unknown-unknown" +target triple = "wasm32-unknown-unknown-wasm" ; CHECK-LABEL: test: ; CHECK-NEXT: call .Lbitcast@FUNCTION{{$}} @@ -20,31 +20,39 @@ target triple = "wasm32-unknown-unknown" ; CHECK-NEXT: call foo2@FUNCTION{{$}} ; CHECK-NEXT: call foo1@FUNCTION{{$}} ; CHECK-NEXT: call foo3@FUNCTION{{$}} -; CHECK-NEXT: .endfunc +; CHECK-NEXT: end_function + +; CHECK-LABEL: test_varargs: +; CHECK: set_global +; CHECK: i32.const $push[[L3:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: call vararg@FUNCTION, $pop[[L3]]{{$}} +; CHECK-NEXT: i32.const $push[[L4:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: i32.store 0($[[L5:[0-9]+]]), $pop[[L4]]{{$}} +; CHECK-NEXT: call plain@FUNCTION, $[[L5]]{{$}} ; CHECK-LABEL: .Lbitcast: -; CHECK-NEXT: .local i32 ; CHECK-NEXT: call has_i32_arg@FUNCTION, $0{{$}} -; CHECK-NEXT: .endfunc +; CHECK-NEXT: end_function ; CHECK-LABEL: .Lbitcast.1: ; CHECK-NEXT: call $drop=, has_i32_ret@FUNCTION{{$}} -; CHECK-NEXT: .endfunc +; CHECK-NEXT: end_function ; CHECK-LABEL: .Lbitcast.2: ; CHECK-NEXT: .param i32 ; CHECK-NEXT: call foo0@FUNCTION{{$}} -; CHECK-NEXT: .endfunc +; CHECK-NEXT: end_function ; CHECK-LABEL: .Lbitcast.3: ; CHECK-NEXT: .result i32 -; CHECK-NEXT: .local i32 ; CHECK-NEXT: call foo1@FUNCTION{{$}} ; CHECK-NEXT: copy_local $push0=, $0 -; CHECK-NEXT: .endfunc +; CHECK-NEXT: end_function declare void @has_i32_arg(i32) declare i32 @has_i32_ret() +declare void @vararg(...) +declare void @plain(i32) declare void @foo0() declare void @foo1() @@ -70,3 +78,9 @@ entry: ret void } + +define void @test_varargs() { + call void bitcast (void (...)* @vararg to void (i32)*)(i32 0) + call void (...) bitcast (void (i32)* @plain to void (...)*)(i32 0) + ret void +} diff --git a/test/CodeGen/WebAssembly/global.ll b/test/CodeGen/WebAssembly/global.ll index 1d24035d8dd4..599eb53b431b 100644 --- a/test/CodeGen/WebAssembly/global.ll +++ b/test/CodeGen/WebAssembly/global.ll @@ -1,9 +1,9 @@ -; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt | FileCheck %s +; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals | FileCheck %s ; Test that globals assemble as expected. target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" -target triple = "wasm32-unknown-unknown" +target triple = "wasm32-unknown-unknown-wasm" ; CHECK-NOT: llvm.used ; CHECK-NOT: llvm.metadata @@ -42,15 +42,21 @@ define i8* @call_memcpy(i8* %p, i8* nocapture readonly %q, i32 %n) { @ud = internal global i32 undef ; CHECK: .type nil,@object -; CHECK-NEXT: .lcomm nil,4,2{{$}} +; CHECK: .p2align 2 +; CHECK: nil: +; CHECK: .int32 0 +; CHECK: .size nil, 4 @nil = internal global i32 zeroinitializer ; CHECK: .type z,@object -; CHECK-NEXT: .lcomm z,4,2{{$}} +; CHECK: .p2align 2 +; CHECK: z: +; CHECK: .int32 0 +; CHECK: .size z, 4 @z = internal global i32 0 -; CHECK-NEXT: .type one,@object -; CHECK-NEXT: .p2align 2{{$}} +; CHECK: .type one,@object +; CHECK: .p2align 2{{$}} ; CHECK-NEXT: one: ; CHECK-NEXT: .int32 1{{$}} ; CHECK-NEXT: .size one, 4{{$}} @@ -78,11 +84,17 @@ define i8* @call_memcpy(i8* %p, i8* nocapture readonly %q, i32 %n) { @ud64 = internal global i64 undef ; CHECK: .type nil64,@object -; CHECK: .lcomm nil64,8,3{{$}} +; CHECK: .p2align 3{{$}} +; CHECK-NEXT: nil64: +; CHECK-NEXT: .int64 0{{$}} +; CHECK-NEXT: .size nil64, 8{{$}} @nil64 = internal global i64 zeroinitializer ; CHECK: .type z64,@object -; CHECK: .lcomm z64,8,3{{$}} +; CHECK: .p2align 3{{$}} +; CHECK-NEXT: z64: +; CHECK-NEXT: .int64 0{{$}} +; CHECK-NEXT: .size z64, 8{{$}} @z64 = internal global i64 0 ; CHECK: .type twoP32,@object @@ -107,11 +119,17 @@ define i8* @call_memcpy(i8* %p, i8* nocapture readonly %q, i32 %n) { @f32ud = internal global float undef ; CHECK: .type f32nil,@object -; CHECK: .lcomm f32nil,4,2{{$}} +; CHECK: .p2align 2{{$}} +; CHECK-NEXT: f32nil: +; CHECK-NEXT: .int32 0{{$}} +; CHECK-NEXT: .size f32nil, 4{{$}} @f32nil = internal global float zeroinitializer ; CHECK: .type f32z,@object -; CHECK: .lcomm f32z,4,2{{$}} +; CHECK: .p2align 2{{$}} +; CHECK-NEXT: f32z: +; CHECK-NEXT: .int32 0{{$}} +; CHECK-NEXT: .size f32z, 4{{$}} @f32z = internal global float 0.0 ; CHECK: .type f32nz,@object @@ -136,11 +154,17 @@ define i8* @call_memcpy(i8* %p, i8* nocapture readonly %q, i32 %n) { @f64ud = internal global double undef ; CHECK: .type f64nil,@object -; CHECK: .lcomm f64nil,8,3{{$}} +; CHECK: .p2align 3{{$}} +; CHECK-NEXT: f64nil: +; CHECK-NEXT: .int64 0{{$}} +; CHECK-NEXT: .size f64nil, 8{{$}} @f64nil = internal global double zeroinitializer ; CHECK: .type f64z,@object -; CHECK: .lcomm f64z,8,3{{$}} +; CHECK: .p2align 3{{$}} +; CHECK-NEXT: f64z: +; CHECK-NEXT: .int64 0{{$}} +; CHECK-NEXT: .size f64z, 8{{$}} @f64z = internal global double 0.0 ; CHECK: .type f64nz,@object @@ -168,7 +192,7 @@ define i8* @call_memcpy(i8* %p, i8* nocapture readonly %q, i32 %n) { ; Constant global. ; CHECK: .type rom,@object{{$}} -; CHECK: .section .rodata,"a",@progbits{{$}} +; CHECK: .section .rodata.rom, ; CHECK: .globl rom{{$}} ; CHECK: .p2align 4{{$}} ; CHECK: rom: @@ -177,11 +201,11 @@ define i8* @call_memcpy(i8* %p, i8* nocapture readonly %q, i32 %n) { @rom = constant [128 x i32] zeroinitializer, align 16 ; CHECK: .type array,@object -; CHECK-NEXT: array: +; CHECK: array: ; CHECK-NEXT: .skip 8 ; CHECK-NEXT: .size array, 8 ; CHECK: .type pointer_to_array,@object -; CHECK-NEXT: .section .data.rel.ro,"aw",@progbits +; CHECK-NEXT: .section .data.rel.ro.pointer_to_array, ; CHECK-NEXT: .globl pointer_to_array ; CHECK-NEXT: .p2align 2 ; CHECK-NEXT: pointer_to_array: diff --git a/test/CodeGen/WebAssembly/globl.ll b/test/CodeGen/WebAssembly/globl.ll index 3ebd3d88fb4e..ba9f6659d7d7 100644 --- a/test/CodeGen/WebAssembly/globl.ll +++ b/test/CodeGen/WebAssembly/globl.ll @@ -1,7 +1,7 @@ ; RUN: llc < %s -asm-verbose=false | FileCheck %s target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" -target triple = "wasm32-unknown-unknown" +target triple = "wasm32-unknown-unknown-wasm" ; CHECK: .globl foo ; CHECK-LABEL: foo: diff --git a/test/CodeGen/WebAssembly/i128.ll b/test/CodeGen/WebAssembly/i128.ll index 29bf787863d5..2e44af9c5184 100644 --- a/test/CodeGen/WebAssembly/i128.ll +++ b/test/CodeGen/WebAssembly/i128.ll @@ -3,7 +3,7 @@ ; Test that basic 128-bit integer operations assemble as expected. target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" -target triple = "wasm32-unknown-unknown" +target triple = "wasm32-unknown-unknown-wasm" declare i128 @llvm.ctlz.i128(i128, i1) declare i128 @llvm.cttz.i128(i128, i1) diff --git a/test/CodeGen/WebAssembly/i32-load-store-alignment.ll b/test/CodeGen/WebAssembly/i32-load-store-alignment.ll index fb7deecff33a..661d1b7bfc3e 100644 --- a/test/CodeGen/WebAssembly/i32-load-store-alignment.ll +++ b/test/CodeGen/WebAssembly/i32-load-store-alignment.ll @@ -1,9 +1,9 @@ -; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt | FileCheck %s +; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals | FileCheck %s ; Test loads and stores with custom alignment values. target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" -target triple = "wasm32-unknown-unknown" +target triple = "wasm32-unknown-unknown-wasm" ; CHECK-LABEL: ldi32_a1: ; CHECK-NEXT: .param i32{{$}} diff --git a/test/CodeGen/WebAssembly/i32.ll b/test/CodeGen/WebAssembly/i32.ll index a07dd02beced..e451695d8903 100644 --- a/test/CodeGen/WebAssembly/i32.ll +++ b/test/CodeGen/WebAssembly/i32.ll @@ -3,7 +3,7 @@ ; Test that basic 32-bit integer operations assemble as expected. target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" -target triple = "wasm32-unknown-unknown" +target triple = "wasm32-unknown-unknown-wasm" declare i32 @llvm.ctlz.i32(i32, i1) declare i32 @llvm.cttz.i32(i32, i1) @@ -12,7 +12,9 @@ declare i32 @llvm.ctpop.i32(i32) ; CHECK-LABEL: add32: ; CHECK-NEXT: .param i32, i32{{$}} ; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: i32.add $push0=, $0, $1{{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: i32.add $push0=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i32 @add32(i32 %x, i32 %y) { %a = add i32 %x, %y @@ -22,7 +24,9 @@ define i32 @add32(i32 %x, i32 %y) { ; CHECK-LABEL: sub32: ; CHECK-NEXT: .param i32, i32{{$}} ; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: i32.sub $push0=, $0, $1{{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: i32.sub $push0=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i32 @sub32(i32 %x, i32 %y) { %a = sub i32 %x, %y @@ -32,7 +36,9 @@ define i32 @sub32(i32 %x, i32 %y) { ; CHECK-LABEL: mul32: ; CHECK-NEXT: .param i32, i32{{$}} ; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: i32.mul $push0=, $0, $1{{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: i32.mul $push0=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i32 @mul32(i32 %x, i32 %y) { %a = mul i32 %x, %y @@ -42,7 +48,9 @@ define i32 @mul32(i32 %x, i32 %y) { ; CHECK-LABEL: sdiv32: ; CHECK-NEXT: .param i32, i32{{$}} ; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: i32.div_s $push0=, $0, $1{{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: i32.div_s $push0=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i32 @sdiv32(i32 %x, i32 %y) { %a = sdiv i32 %x, %y @@ -52,7 +60,9 @@ define i32 @sdiv32(i32 %x, i32 %y) { ; CHECK-LABEL: udiv32: ; CHECK-NEXT: .param i32, i32{{$}} ; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: i32.div_u $push0=, $0, $1{{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: i32.div_u $push0=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i32 @udiv32(i32 %x, i32 %y) { %a = udiv i32 %x, %y @@ -62,7 +72,9 @@ define i32 @udiv32(i32 %x, i32 %y) { ; CHECK-LABEL: srem32: ; CHECK-NEXT: .param i32, i32{{$}} ; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: i32.rem_s $push0=, $0, $1{{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: i32.rem_s $push0=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i32 @srem32(i32 %x, i32 %y) { %a = srem i32 %x, %y @@ -72,7 +84,9 @@ define i32 @srem32(i32 %x, i32 %y) { ; CHECK-LABEL: urem32: ; CHECK-NEXT: .param i32, i32{{$}} ; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: i32.rem_u $push0=, $0, $1{{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: i32.rem_u $push0=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i32 @urem32(i32 %x, i32 %y) { %a = urem i32 %x, %y @@ -82,7 +96,9 @@ define i32 @urem32(i32 %x, i32 %y) { ; CHECK-LABEL: and32: ; CHECK-NEXT: .param i32, i32{{$}} ; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: i32.and $push0=, $0, $1{{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: i32.and $push0=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i32 @and32(i32 %x, i32 %y) { %a = and i32 %x, %y @@ -92,7 +108,9 @@ define i32 @and32(i32 %x, i32 %y) { ; CHECK-LABEL: or32: ; CHECK-NEXT: .param i32, i32{{$}} ; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: i32.or $push0=, $0, $1{{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: i32.or $push0=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i32 @or32(i32 %x, i32 %y) { %a = or i32 %x, %y @@ -102,7 +120,9 @@ define i32 @or32(i32 %x, i32 %y) { ; CHECK-LABEL: xor32: ; CHECK-NEXT: .param i32, i32{{$}} ; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: i32.xor $push0=, $0, $1{{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: i32.xor $push0=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i32 @xor32(i32 %x, i32 %y) { %a = xor i32 %x, %y @@ -112,7 +132,9 @@ define i32 @xor32(i32 %x, i32 %y) { ; CHECK-LABEL: shl32: ; CHECK-NEXT: .param i32, i32{{$}} ; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: i32.shl $push0=, $0, $1{{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: i32.shl $push0=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i32 @shl32(i32 %x, i32 %y) { %a = shl i32 %x, %y @@ -122,7 +144,9 @@ define i32 @shl32(i32 %x, i32 %y) { ; CHECK-LABEL: shr32: ; CHECK-NEXT: .param i32, i32{{$}} ; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: i32.shr_u $push0=, $0, $1{{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: i32.shr_u $push0=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i32 @shr32(i32 %x, i32 %y) { %a = lshr i32 %x, %y @@ -132,7 +156,9 @@ define i32 @shr32(i32 %x, i32 %y) { ; CHECK-LABEL: sar32: ; CHECK-NEXT: .param i32, i32{{$}} ; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: i32.shr_s $push0=, $0, $1{{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: i32.shr_s $push0=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i32 @sar32(i32 %x, i32 %y) { %a = ashr i32 %x, %y @@ -142,7 +168,8 @@ define i32 @sar32(i32 %x, i32 %y) { ; CHECK-LABEL: clz32: ; CHECK-NEXT: .param i32{{$}} ; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: i32.clz $push0=, $0{{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: i32.clz $push0=, $pop[[L0]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i32 @clz32(i32 %x) { %a = call i32 @llvm.ctlz.i32(i32 %x, i1 false) @@ -152,7 +179,8 @@ define i32 @clz32(i32 %x) { ; CHECK-LABEL: clz32_zero_undef: ; CHECK-NEXT: .param i32{{$}} ; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: i32.clz $push0=, $0{{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: i32.clz $push0=, $pop[[L0]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i32 @clz32_zero_undef(i32 %x) { %a = call i32 @llvm.ctlz.i32(i32 %x, i1 true) @@ -162,7 +190,8 @@ define i32 @clz32_zero_undef(i32 %x) { ; CHECK-LABEL: ctz32: ; CHECK-NEXT: .param i32{{$}} ; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: i32.ctz $push0=, $0{{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: i32.ctz $push0=, $pop[[L0]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i32 @ctz32(i32 %x) { %a = call i32 @llvm.cttz.i32(i32 %x, i1 false) @@ -172,7 +201,8 @@ define i32 @ctz32(i32 %x) { ; CHECK-LABEL: ctz32_zero_undef: ; CHECK-NEXT: .param i32{{$}} ; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: i32.ctz $push0=, $0{{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: i32.ctz $push0=, $pop[[L0]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i32 @ctz32_zero_undef(i32 %x) { %a = call i32 @llvm.cttz.i32(i32 %x, i1 true) @@ -182,7 +212,8 @@ define i32 @ctz32_zero_undef(i32 %x) { ; CHECK-LABEL: popcnt32: ; CHECK-NEXT: .param i32{{$}} ; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: i32.popcnt $push0=, $0{{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: i32.popcnt $push0=, $pop[[L0]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i32 @popcnt32(i32 %x) { %a = call i32 @llvm.ctpop.i32(i32 %x) @@ -192,7 +223,8 @@ define i32 @popcnt32(i32 %x) { ; CHECK-LABEL: eqz32: ; CHECK-NEXT: .param i32{{$}} ; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: i32.eqz $push0=, $0{{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: i32.eqz $push0=, $pop[[L0]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i32 @eqz32(i32 %x) { %a = icmp eq i32 %x, 0 @@ -203,7 +235,9 @@ define i32 @eqz32(i32 %x) { ; CHECK-LABEL: rotl: ; CHECK-NEXT: .param i32, i32{{$}} ; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: i32.rotl $push0=, $0, $1 +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: i32.rotl $push0=, $pop[[L0]], $pop[[L1]] ; CHECK-NEXT: return $pop0{{$}} define i32 @rotl(i32 %x, i32 %y) { %z = sub i32 32, %y @@ -216,7 +250,9 @@ define i32 @rotl(i32 %x, i32 %y) { ; CHECK-LABEL: masked_rotl: ; CHECK-NEXT: .param i32, i32{{$}} ; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: i32.rotl $push0=, $0, $1 +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: i32.rotl $push0=, $pop[[L0]], $pop[[L1]] ; CHECK-NEXT: return $pop0{{$}} define i32 @masked_rotl(i32 %x, i32 %y) { %a = and i32 %y, 31 @@ -230,7 +266,9 @@ define i32 @masked_rotl(i32 %x, i32 %y) { ; CHECK-LABEL: rotr: ; CHECK-NEXT: .param i32, i32{{$}} ; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: i32.rotr $push0=, $0, $1 +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: i32.rotr $push0=, $pop[[L0]], $pop[[L1]] ; CHECK-NEXT: return $pop0{{$}} define i32 @rotr(i32 %x, i32 %y) { %z = sub i32 32, %y @@ -243,7 +281,9 @@ define i32 @rotr(i32 %x, i32 %y) { ; CHECK-LABEL: masked_rotr: ; CHECK-NEXT: .param i32, i32{{$}} ; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: i32.rotr $push0=, $0, $1 +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: i32.rotr $push0=, $pop[[L0]], $pop[[L1]] ; CHECK-NEXT: return $pop0{{$}} define i32 @masked_rotr(i32 %x, i32 %y) { %a = and i32 %y, 31 diff --git a/test/CodeGen/WebAssembly/i64-load-store-alignment.ll b/test/CodeGen/WebAssembly/i64-load-store-alignment.ll index a3901dfc079a..1ccb74cb9d28 100644 --- a/test/CodeGen/WebAssembly/i64-load-store-alignment.ll +++ b/test/CodeGen/WebAssembly/i64-load-store-alignment.ll @@ -1,9 +1,9 @@ -; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt | FileCheck %s +; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals | FileCheck %s ; Test loads and stores with custom alignment values. target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" -target triple = "wasm32-unknown-unknown" +target triple = "wasm32-unknown-unknown-wasm" ; CHECK-LABEL: ldi64_a1: ; CHECK-NEXT: .param i32{{$}} diff --git a/test/CodeGen/WebAssembly/i64.ll b/test/CodeGen/WebAssembly/i64.ll index 93e32bfc0e1d..4386bed4ebf7 100644 --- a/test/CodeGen/WebAssembly/i64.ll +++ b/test/CodeGen/WebAssembly/i64.ll @@ -3,7 +3,7 @@ ; Test that basic 64-bit integer operations assemble as expected. target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" -target triple = "wasm32-unknown-unknown" +target triple = "wasm32-unknown-unknown-wasm" declare i64 @llvm.ctlz.i64(i64, i1) declare i64 @llvm.cttz.i64(i64, i1) @@ -12,7 +12,9 @@ declare i64 @llvm.ctpop.i64(i64) ; CHECK-LABEL: add64: ; CHECK-NEXT: .param i64, i64{{$}} ; CHECK-NEXT: .result i64{{$}} -; CHECK-NEXT: i64.add $push0=, $0, $1{{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: i64.add $push0=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i64 @add64(i64 %x, i64 %y) { %a = add i64 %x, %y @@ -22,7 +24,9 @@ define i64 @add64(i64 %x, i64 %y) { ; CHECK-LABEL: sub64: ; CHECK-NEXT: .param i64, i64{{$}} ; CHECK-NEXT: .result i64{{$}} -; CHECK-NEXT: i64.sub $push0=, $0, $1{{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: i64.sub $push0=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i64 @sub64(i64 %x, i64 %y) { %a = sub i64 %x, %y @@ -32,7 +36,9 @@ define i64 @sub64(i64 %x, i64 %y) { ; CHECK-LABEL: mul64: ; CHECK-NEXT: .param i64, i64{{$}} ; CHECK-NEXT: .result i64{{$}} -; CHECK-NEXT: i64.mul $push0=, $0, $1{{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: i64.mul $push0=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i64 @mul64(i64 %x, i64 %y) { %a = mul i64 %x, %y @@ -42,7 +48,9 @@ define i64 @mul64(i64 %x, i64 %y) { ; CHECK-LABEL: sdiv64: ; CHECK-NEXT: .param i64, i64{{$}} ; CHECK-NEXT: .result i64{{$}} -; CHECK-NEXT: i64.div_s $push0=, $0, $1{{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: i64.div_s $push0=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i64 @sdiv64(i64 %x, i64 %y) { %a = sdiv i64 %x, %y @@ -52,7 +60,9 @@ define i64 @sdiv64(i64 %x, i64 %y) { ; CHECK-LABEL: udiv64: ; CHECK-NEXT: .param i64, i64{{$}} ; CHECK-NEXT: .result i64{{$}} -; CHECK-NEXT: i64.div_u $push0=, $0, $1{{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: i64.div_u $push0=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i64 @udiv64(i64 %x, i64 %y) { %a = udiv i64 %x, %y @@ -62,7 +72,9 @@ define i64 @udiv64(i64 %x, i64 %y) { ; CHECK-LABEL: srem64: ; CHECK-NEXT: .param i64, i64{{$}} ; CHECK-NEXT: .result i64{{$}} -; CHECK-NEXT: i64.rem_s $push0=, $0, $1{{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: i64.rem_s $push0=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i64 @srem64(i64 %x, i64 %y) { %a = srem i64 %x, %y @@ -72,7 +84,9 @@ define i64 @srem64(i64 %x, i64 %y) { ; CHECK-LABEL: urem64: ; CHECK-NEXT: .param i64, i64{{$}} ; CHECK-NEXT: .result i64{{$}} -; CHECK-NEXT: i64.rem_u $push0=, $0, $1{{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: i64.rem_u $push0=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i64 @urem64(i64 %x, i64 %y) { %a = urem i64 %x, %y @@ -82,7 +96,9 @@ define i64 @urem64(i64 %x, i64 %y) { ; CHECK-LABEL: and64: ; CHECK-NEXT: .param i64, i64{{$}} ; CHECK-NEXT: .result i64{{$}} -; CHECK-NEXT: i64.and $push0=, $0, $1{{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: i64.and $push0=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i64 @and64(i64 %x, i64 %y) { %a = and i64 %x, %y @@ -92,7 +108,9 @@ define i64 @and64(i64 %x, i64 %y) { ; CHECK-LABEL: or64: ; CHECK-NEXT: .param i64, i64{{$}} ; CHECK-NEXT: .result i64{{$}} -; CHECK-NEXT: i64.or $push0=, $0, $1{{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: i64.or $push0=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i64 @or64(i64 %x, i64 %y) { %a = or i64 %x, %y @@ -102,7 +120,9 @@ define i64 @or64(i64 %x, i64 %y) { ; CHECK-LABEL: xor64: ; CHECK-NEXT: .param i64, i64{{$}} ; CHECK-NEXT: .result i64{{$}} -; CHECK-NEXT: i64.xor $push0=, $0, $1{{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: i64.xor $push0=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i64 @xor64(i64 %x, i64 %y) { %a = xor i64 %x, %y @@ -112,7 +132,9 @@ define i64 @xor64(i64 %x, i64 %y) { ; CHECK-LABEL: shl64: ; CHECK-NEXT: .param i64, i64{{$}} ; CHECK-NEXT: .result i64{{$}} -; CHECK-NEXT: i64.shl $push0=, $0, $1{{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: i64.shl $push0=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i64 @shl64(i64 %x, i64 %y) { %a = shl i64 %x, %y @@ -122,7 +144,9 @@ define i64 @shl64(i64 %x, i64 %y) { ; CHECK-LABEL: shr64: ; CHECK-NEXT: .param i64, i64{{$}} ; CHECK-NEXT: .result i64{{$}} -; CHECK-NEXT: i64.shr_u $push0=, $0, $1{{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: i64.shr_u $push0=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i64 @shr64(i64 %x, i64 %y) { %a = lshr i64 %x, %y @@ -132,7 +156,9 @@ define i64 @shr64(i64 %x, i64 %y) { ; CHECK-LABEL: sar64: ; CHECK-NEXT: .param i64, i64{{$}} ; CHECK-NEXT: .result i64{{$}} -; CHECK-NEXT: i64.shr_s $push0=, $0, $1{{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: i64.shr_s $push0=, $pop[[L0]], $pop[[L1]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i64 @sar64(i64 %x, i64 %y) { %a = ashr i64 %x, %y @@ -142,7 +168,8 @@ define i64 @sar64(i64 %x, i64 %y) { ; CHECK-LABEL: clz64: ; CHECK-NEXT: .param i64{{$}} ; CHECK-NEXT: .result i64{{$}} -; CHECK-NEXT: i64.clz $push0=, $0{{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: i64.clz $push0=, $pop[[L0]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i64 @clz64(i64 %x) { %a = call i64 @llvm.ctlz.i64(i64 %x, i1 false) @@ -152,7 +179,8 @@ define i64 @clz64(i64 %x) { ; CHECK-LABEL: clz64_zero_undef: ; CHECK-NEXT: .param i64{{$}} ; CHECK-NEXT: .result i64{{$}} -; CHECK-NEXT: i64.clz $push0=, $0{{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: i64.clz $push0=, $pop[[L0]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i64 @clz64_zero_undef(i64 %x) { %a = call i64 @llvm.ctlz.i64(i64 %x, i1 true) @@ -162,7 +190,8 @@ define i64 @clz64_zero_undef(i64 %x) { ; CHECK-LABEL: ctz64: ; CHECK-NEXT: .param i64{{$}} ; CHECK-NEXT: .result i64{{$}} -; CHECK-NEXT: i64.ctz $push0=, $0{{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: i64.ctz $push0=, $pop[[L0]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i64 @ctz64(i64 %x) { %a = call i64 @llvm.cttz.i64(i64 %x, i1 false) @@ -172,7 +201,8 @@ define i64 @ctz64(i64 %x) { ; CHECK-LABEL: ctz64_zero_undef: ; CHECK-NEXT: .param i64{{$}} ; CHECK-NEXT: .result i64{{$}} -; CHECK-NEXT: i64.ctz $push0=, $0{{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: i64.ctz $push0=, $pop[[L0]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i64 @ctz64_zero_undef(i64 %x) { %a = call i64 @llvm.cttz.i64(i64 %x, i1 true) @@ -182,7 +212,8 @@ define i64 @ctz64_zero_undef(i64 %x) { ; CHECK-LABEL: popcnt64: ; CHECK-NEXT: .param i64{{$}} ; CHECK-NEXT: .result i64{{$}} -; CHECK-NEXT: i64.popcnt $push0=, $0{{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: i64.popcnt $push0=, $pop[[L0]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i64 @popcnt64(i64 %x) { %a = call i64 @llvm.ctpop.i64(i64 %x) @@ -192,7 +223,8 @@ define i64 @popcnt64(i64 %x) { ; CHECK-LABEL: eqz64: ; CHECK-NEXT: .param i64{{$}} ; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: i64.eqz $push0=, $0{{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: i64.eqz $push0=, $pop[[L0]]{{$}} ; CHECK-NEXT: return $pop0{{$}} define i32 @eqz64(i64 %x) { %a = icmp eq i64 %x, 0 @@ -203,7 +235,9 @@ define i32 @eqz64(i64 %x) { ; CHECK-LABEL: rotl: ; CHECK-NEXT: .param i64, i64{{$}} ; CHECK-NEXT: .result i64{{$}} -; CHECK-NEXT: i64.rotl $push0=, $0, $1 +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: i64.rotl $push0=, $pop[[L0]], $pop[[L1]] ; CHECK-NEXT: return $pop0{{$}} define i64 @rotl(i64 %x, i64 %y) { %z = sub i64 64, %y @@ -216,7 +250,9 @@ define i64 @rotl(i64 %x, i64 %y) { ; CHECK-LABEL: masked_rotl: ; CHECK-NEXT: .param i64, i64{{$}} ; CHECK-NEXT: .result i64{{$}} -; CHECK-NEXT: i64.rotl $push0=, $0, $1 +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: i64.rotl $push0=, $pop[[L0]], $pop[[L1]] ; CHECK-NEXT: return $pop0{{$}} define i64 @masked_rotl(i64 %x, i64 %y) { %a = and i64 %y, 63 @@ -230,7 +266,9 @@ define i64 @masked_rotl(i64 %x, i64 %y) { ; CHECK-LABEL: rotr: ; CHECK-NEXT: .param i64, i64{{$}} ; CHECK-NEXT: .result i64{{$}} -; CHECK-NEXT: i64.rotr $push0=, $0, $1 +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: i64.rotr $push0=, $pop[[L0]], $pop[[L1]] ; CHECK-NEXT: return $pop0{{$}} define i64 @rotr(i64 %x, i64 %y) { %z = sub i64 64, %y @@ -243,7 +281,9 @@ define i64 @rotr(i64 %x, i64 %y) { ; CHECK-LABEL: masked_rotr: ; CHECK-NEXT: .param i64, i64{{$}} ; CHECK-NEXT: .result i64{{$}} -; CHECK-NEXT: i64.rotr $push0=, $0, $1 +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: i64.rotr $push0=, $pop[[L0]], $pop[[L1]] ; CHECK-NEXT: return $pop0{{$}} define i64 @masked_rotr(i64 %x, i64 %y) { %a = and i64 %y, 63 diff --git a/test/CodeGen/WebAssembly/ident.ll b/test/CodeGen/WebAssembly/ident.ll index 49c188ec2578..e5d85d090f11 100644 --- a/test/CodeGen/WebAssembly/ident.ll +++ b/test/CodeGen/WebAssembly/ident.ll @@ -3,7 +3,7 @@ ; Test llvm.ident. target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" -target triple = "wasm32-unknown-unknown" +target triple = "wasm32-unknown-unknown-wasm" ; CHECK: .ident "hello world" diff --git a/test/CodeGen/WebAssembly/immediates.ll b/test/CodeGen/WebAssembly/immediates.ll index 3d11f9410a79..1182423a594e 100644 --- a/test/CodeGen/WebAssembly/immediates.ll +++ b/test/CodeGen/WebAssembly/immediates.ll @@ -3,7 +3,7 @@ ; Test that basic immediates assemble as expected. target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" -target triple = "wasm32-unknown-unknown" +target triple = "wasm32-unknown-unknown-wasm" ; CHECK-LABEL: zero_i32: ; CHECK-NEXT: .result i32{{$}} diff --git a/test/CodeGen/WebAssembly/implicit-def.ll b/test/CodeGen/WebAssembly/implicit-def.ll index 01ee171b449b..1f9f74887e8a 100644 --- a/test/CodeGen/WebAssembly/implicit-def.ll +++ b/test/CodeGen/WebAssembly/implicit-def.ll @@ -1,6 +1,6 @@ ; RUN: llc -o - %s | FileCheck %s target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" -target triple = "wasm32-unknown-unknown" +target triple = "wasm32-unknown-unknown-wasm" ; Test that stackified IMPLICIT_DEF instructions are converted into ; CONST_I32 to provide an explicit push. diff --git a/test/CodeGen/WebAssembly/inline-asm.ll b/test/CodeGen/WebAssembly/inline-asm.ll index 9b72eb65e0d5..56576305d9e2 100644 --- a/test/CodeGen/WebAssembly/inline-asm.ll +++ b/test/CodeGen/WebAssembly/inline-asm.ll @@ -1,10 +1,10 @@ -; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -no-integrated-as | FileCheck %s +; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals -no-integrated-as | FileCheck %s ; Test basic inline assembly. Pass -no-integrated-as since these aren't ; actually valid assembly syntax. target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" -target triple = "wasm32-unknown-unknown" +target triple = "wasm32-unknown-unknown-wasm" ; CHECK-LABEL: foo: ; CHECK-NEXT: .param i32{{$}} @@ -33,7 +33,6 @@ entry: ; CHECK-LABEL: imm: ; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: .local i32{{$}} ; CHECK-NEXT: #APP{{$}} ; CHECK-NEXT: # $0 = ccc(42){{$}} ; CHECK-NEXT: #NO_APP{{$}} diff --git a/test/CodeGen/WebAssembly/irreducible-cfg.ll b/test/CodeGen/WebAssembly/irreducible-cfg.ll index 8fe7d10c5f31..dd47b5827d5b 100644 --- a/test/CodeGen/WebAssembly/irreducible-cfg.ll +++ b/test/CodeGen/WebAssembly/irreducible-cfg.ll @@ -1,9 +1,9 @@ -; RUN: llc < %s -asm-verbose=false -verify-machineinstrs -disable-block-placement | FileCheck %s +; RUN: llc < %s -asm-verbose=false -verify-machineinstrs -disable-block-placement -disable-wasm-explicit-locals | FileCheck %s ; Test irreducible CFG handling. target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" -target triple = "wasm32-unknown-unknown" +target triple = "wasm32-unknown-unknown-wasm" ; A simple loop with two entries. diff --git a/test/CodeGen/WebAssembly/legalize.ll b/test/CodeGen/WebAssembly/legalize.ll index 5cbfb8ace9ed..978e72b5b85b 100644 --- a/test/CodeGen/WebAssembly/legalize.ll +++ b/test/CodeGen/WebAssembly/legalize.ll @@ -1,9 +1,9 @@ -; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt | FileCheck %s +; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals | FileCheck %s ; Test various types and operators that need to be legalized. target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" -target triple = "wasm32-unknown-unknown" +target triple = "wasm32-unknown-unknown-wasm" ; CHECK-LABEL: shl_i3: ; CHECK: i32.const $push0=, 7{{$}} diff --git a/test/CodeGen/WebAssembly/load-ext.ll b/test/CodeGen/WebAssembly/load-ext.ll index 48a7ce7c4bd2..a624995ea625 100644 --- a/test/CodeGen/WebAssembly/load-ext.ll +++ b/test/CodeGen/WebAssembly/load-ext.ll @@ -1,9 +1,9 @@ -; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt | FileCheck %s +; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals | FileCheck %s ; Test that extending loads are assembled properly. target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" -target triple = "wasm32-unknown-unknown" +target triple = "wasm32-unknown-unknown-wasm" ; CHECK-LABEL: sext_i8_i32: ; CHECK: i32.load8_s $push0=, 0($0){{$}} diff --git a/test/CodeGen/WebAssembly/load-store-i1.ll b/test/CodeGen/WebAssembly/load-store-i1.ll index ea0ec717c7a0..9882609d773b 100644 --- a/test/CodeGen/WebAssembly/load-store-i1.ll +++ b/test/CodeGen/WebAssembly/load-store-i1.ll @@ -1,9 +1,9 @@ -; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt | FileCheck %s +; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals | FileCheck %s ; Test that i1 extending loads and truncating stores are assembled properly. target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" -target triple = "wasm32-unknown-unknown" +target triple = "wasm32-unknown-unknown-wasm" ; CHECK-LABEL: load_u_i1_i32: ; CHECK: i32.load8_u $push[[NUM0:[0-9]+]]=, 0($0){{$}} diff --git a/test/CodeGen/WebAssembly/load.ll b/test/CodeGen/WebAssembly/load.ll index a8e174e914e1..165d145fde1a 100644 --- a/test/CodeGen/WebAssembly/load.ll +++ b/test/CodeGen/WebAssembly/load.ll @@ -4,12 +4,13 @@ ; Test that basic loads are assembled properly. target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" -target triple = "wasm32-unknown-unknown" +target triple = "wasm32-unknown-unknown-wasm" ; CHECK-LABEL: ldi32: ; CHECK-NEXT: .param i32{{$}} ; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: i32.load $push[[NUM:[0-9]+]]=, 0($0){{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: i32.load $push[[NUM:[0-9]+]]=, 0($pop[[L0]]){{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define i32 @ldi32(i32 *%p) { %v = load i32, i32* %p @@ -19,7 +20,8 @@ define i32 @ldi32(i32 *%p) { ; CHECK-LABEL: ldi64: ; CHECK-NEXT: .param i32{{$}} ; CHECK-NEXT: .result i64{{$}} -; CHECK-NEXT: i64.load $push[[NUM:[0-9]+]]=, 0($0){{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: i64.load $push[[NUM:[0-9]+]]=, 0($pop[[L0]]){{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define i64 @ldi64(i64 *%p) { %v = load i64, i64* %p @@ -29,7 +31,8 @@ define i64 @ldi64(i64 *%p) { ; CHECK-LABEL: ldf32: ; CHECK-NEXT: .param i32{{$}} ; CHECK-NEXT: .result f32{{$}} -; CHECK-NEXT: f32.load $push[[NUM:[0-9]+]]=, 0($0){{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: f32.load $push[[NUM:[0-9]+]]=, 0($pop[[L0]]){{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define float @ldf32(float *%p) { %v = load float, float* %p @@ -39,7 +42,8 @@ define float @ldf32(float *%p) { ; CHECK-LABEL: ldf64: ; CHECK-NEXT: .param i32{{$}} ; CHECK-NEXT: .result f64{{$}} -; CHECK-NEXT: f64.load $push[[NUM:[0-9]+]]=, 0($0){{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: f64.load $push[[NUM:[0-9]+]]=, 0($pop[[L0]]){{$}} ; CHECK-NEXT: return $pop[[NUM]]{{$}} define double @ldf64(double *%p) { %v = load double, double* %p diff --git a/test/CodeGen/WebAssembly/lower-em-ehsjlj-options.ll b/test/CodeGen/WebAssembly/lower-em-ehsjlj-options.ll index 8283b49cd584..91fde29ea59e 100644 --- a/test/CodeGen/WebAssembly/lower-em-ehsjlj-options.ll +++ b/test/CodeGen/WebAssembly/lower-em-ehsjlj-options.ll @@ -3,7 +3,7 @@ ; RUN: llc < %s | FileCheck %s --check-prefix=NONE target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" -target triple = "wasm32-unknown-unknown" +target triple = "wasm32-unknown-unknown-wasm" %struct.__jmp_buf_tag = type { [6 x i32], i32, [32 x i32] } diff --git a/test/CodeGen/WebAssembly/lower-em-exceptions-whitelist.ll b/test/CodeGen/WebAssembly/lower-em-exceptions-whitelist.ll index 5fcc39909b05..3864e445f639 100644 --- a/test/CodeGen/WebAssembly/lower-em-exceptions-whitelist.ll +++ b/test/CodeGen/WebAssembly/lower-em-exceptions-whitelist.ll @@ -1,7 +1,7 @@ ; RUN: opt < %s -wasm-lower-em-ehsjlj -emscripten-cxx-exceptions-whitelist=do_catch -S | FileCheck %s target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" -target triple = "wasm32-unknown-unknown" +target triple = "wasm32-unknown-unknown-wasm" define void @dont_catch() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) { ; CHECK-LABEL: @dont_catch( diff --git a/test/CodeGen/WebAssembly/lower-em-exceptions.ll b/test/CodeGen/WebAssembly/lower-em-exceptions.ll index 60953cdb6efe..060f481c3265 100644 --- a/test/CodeGen/WebAssembly/lower-em-exceptions.ll +++ b/test/CodeGen/WebAssembly/lower-em-exceptions.ll @@ -1,7 +1,7 @@ ; RUN: opt < %s -wasm-lower-em-ehsjlj -S | FileCheck %s target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" -target triple = "wasm32-unknown-unknown" +target triple = "wasm32-unknown-unknown-wasm" @_ZTIi = external constant i8* @_ZTIc = external constant i8* diff --git a/test/CodeGen/WebAssembly/lower-em-sjlj.ll b/test/CodeGen/WebAssembly/lower-em-sjlj.ll index 40b9d62a0360..cf42219c0114 100644 --- a/test/CodeGen/WebAssembly/lower-em-sjlj.ll +++ b/test/CodeGen/WebAssembly/lower-em-sjlj.ll @@ -1,7 +1,7 @@ ; RUN: opt < %s -wasm-lower-em-ehsjlj -S | FileCheck %s target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" -target triple = "wasm32-unknown-unknown" +target triple = "wasm32-unknown-unknown-wasm" %struct.__jmp_buf_tag = type { [6 x i32], i32, [32 x i32] } diff --git a/test/CodeGen/WebAssembly/mem-intrinsics.ll b/test/CodeGen/WebAssembly/mem-intrinsics.ll index 0ac1e1e182cd..32a7117a1ea6 100644 --- a/test/CodeGen/WebAssembly/mem-intrinsics.ll +++ b/test/CodeGen/WebAssembly/mem-intrinsics.ll @@ -1,9 +1,9 @@ -; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -tail-dup-placement=0| FileCheck %s +; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals -tail-dup-placement=0 | FileCheck %s ; Test memcpy, memmove, and memset intrinsics. target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" -target triple = "wasm32-unknown-unknown" +target triple = "wasm32-unknown-unknown-wasm" declare void @llvm.memcpy.p0i8.p0i8.i32(i8* nocapture, i8* nocapture readonly, i32, i32, i1) declare void @llvm.memmove.p0i8.p0i8.i32(i8* nocapture, i8* nocapture readonly, i32, i32, i1) diff --git a/test/CodeGen/WebAssembly/memory-addr32.ll b/test/CodeGen/WebAssembly/memory-addr32.ll index 583201b15f99..ad599b1b3f17 100644 --- a/test/CodeGen/WebAssembly/memory-addr32.ll +++ b/test/CodeGen/WebAssembly/memory-addr32.ll @@ -1,12 +1,12 @@ -; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt | FileCheck %s +; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals | FileCheck %s ; Test that basic memory operations assemble as expected with 32-bit addresses. target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" -target triple = "wasm32-unknown-unknown" +target triple = "wasm32-unknown-unknown-wasm" declare i32 @llvm.wasm.current.memory.i32() nounwind readonly -declare void @llvm.wasm.grow.memory.i32(i32) nounwind +declare i32 @llvm.wasm.grow.memory.i32(i32) nounwind ; CHECK-LABEL: current_memory: ; CHECK-NEXT: .result i32{{$}} @@ -19,9 +19,10 @@ define i32 @current_memory() { ; CHECK-LABEL: grow_memory: ; CHECK-NEXT: .param i32{{$}} -; CHECK: grow_memory $0{{$}} -; CHECK-NEXT: return{{$}} -define void @grow_memory(i32 %n) { - call void @llvm.wasm.grow.memory.i32(i32 %n) - ret void +; CHECK-NEXT: .result i32{{$}} +; CHECK: grow_memory $push0=, $0{{$}} +; CHECK-NEXT: return $pop0{{$}} +define i32 @grow_memory(i32 %n) { + %a = call i32 @llvm.wasm.grow.memory.i32(i32 %n) + ret i32 %a } diff --git a/test/CodeGen/WebAssembly/non-executable-stack.ll b/test/CodeGen/WebAssembly/non-executable-stack.ll index b81063724e9c..f1e1ba36a790 100644 --- a/test/CodeGen/WebAssembly/non-executable-stack.ll +++ b/test/CodeGen/WebAssembly/non-executable-stack.ll @@ -4,6 +4,6 @@ ; because wasm's stack is always non-executable. target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" -target triple = "wasm32-unknown-unknown" +target triple = "wasm32-unknown-unknown-wasm" ; CHECK-NOT: .note.GNU-stack diff --git a/test/CodeGen/WebAssembly/offset-folding.ll b/test/CodeGen/WebAssembly/offset-folding.ll index 863549fc20fc..e8e98ecc3307 100644 --- a/test/CodeGen/WebAssembly/offset-folding.ll +++ b/test/CodeGen/WebAssembly/offset-folding.ll @@ -3,7 +3,7 @@ ; Test that constant offsets can be folded into global addresses. target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" -target triple = "wasm32-unknown-unknown" +target triple = "wasm32-unknown-unknown-wasm" @x = external global [0 x i32] @y = global [50 x i32] zeroinitializer diff --git a/test/CodeGen/WebAssembly/offset.ll b/test/CodeGen/WebAssembly/offset.ll index 37f08abc9fa8..27c71873302a 100644 --- a/test/CodeGen/WebAssembly/offset.ll +++ b/test/CodeGen/WebAssembly/offset.ll @@ -1,9 +1,9 @@ -; RUN: llc < %s -asm-verbose=false | FileCheck %s +; RUN: llc < %s -asm-verbose=false -disable-wasm-explicit-locals | FileCheck %s ; Test constant load and store address offsets. target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" -target triple = "wasm32-unknown-unknown" +target triple = "wasm32-unknown-unknown-wasm" ; With an nuw add, we can fold an offset. diff --git a/test/CodeGen/WebAssembly/phi.ll b/test/CodeGen/WebAssembly/phi.ll index 747ae5cb15d4..4aae92df54d9 100644 --- a/test/CodeGen/WebAssembly/phi.ll +++ b/test/CodeGen/WebAssembly/phi.ll @@ -1,15 +1,16 @@ -; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -verify-machineinstrs | FileCheck %s +; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals -verify-machineinstrs | FileCheck %s ; Test that phis are lowered. target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" -target triple = "wasm32-unknown-unknown" +target triple = "wasm32-unknown-unknown-wasm" ; Basic phi triangle. ; CHECK-LABEL: test0: -; CHECK: div_s $[[NUM0:[0-9]+]]=, $0, $pop[[NUM1:[0-9]+]]{{$}} -; CHECK: return $[[NUM0]]{{$}} +; CHECK: return $0 +; CHECK: div_s $push[[NUM0:[0-9]+]]=, $0, $pop[[NUM1:[0-9]+]]{{$}} +; CHECK: return $pop[[NUM0]]{{$}} define i32 @test0(i32 %p) { entry: %t = icmp slt i32 %p, 0 diff --git a/test/CodeGen/WebAssembly/reg-stackify.ll b/test/CodeGen/WebAssembly/reg-stackify.ll index 00469132c953..d1423b5db395 100644 --- a/test/CodeGen/WebAssembly/reg-stackify.ll +++ b/test/CodeGen/WebAssembly/reg-stackify.ll @@ -1,9 +1,9 @@ -; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -verify-machineinstrs | FileCheck %s +; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals -verify-machineinstrs | FileCheck %s ; Test the register stackifier pass. target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" -target triple = "wasm32-unknown-unknown" +target triple = "wasm32-unknown-unknown-wasm" ; No because of pointer aliasing. @@ -126,7 +126,6 @@ false: ; CHECK-LABEL: multiple_uses: ; CHECK: .param i32, i32, i32{{$}} -; CHECK-NEXT: .local i32{{$}} ; CHECK-NEXT: block {{$}} ; CHECK-NEXT: i32.load $push[[NUM0:[0-9]+]]=, 0($2){{$}} ; CHECK-NEXT: tee_local $push[[NUM1:[0-9]+]]=, $3=, $pop[[NUM0]]{{$}} @@ -449,8 +448,7 @@ bb10: ; preds = %bb9, %bb ; CHECK-LABEL: stackpointer_dependency: ; CHECK: call {{.+}}, stackpointer_callee@FUNCTION, -; CHECK: i32.const $push[[L0:.+]]=, 0 -; CHECK-NEXT: i32.store __stack_pointer($pop[[L0]]), +; CHECK-NEXT: set_global 0, declare i32 @stackpointer_callee(i8* readnone, i8* readnone) declare i8* @llvm.frameaddress(i32) define i32 @stackpointer_dependency(i8* readnone) { diff --git a/test/CodeGen/WebAssembly/return-int32.ll b/test/CodeGen/WebAssembly/return-int32.ll index 9e663b969e14..a6634b740cfc 100644 --- a/test/CodeGen/WebAssembly/return-int32.ll +++ b/test/CodeGen/WebAssembly/return-int32.ll @@ -2,13 +2,13 @@ ; RUN: llc < %s -asm-verbose=false -fast-isel -fast-isel-abort=1 | FileCheck %s target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" -target triple = "wasm32-unknown-unknown" +target triple = "wasm32-unknown-unknown-wasm" ; CHECK-LABEL: return_i32: ; CHECK-NEXT: .param i32{{$}} ; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: copy_local $push0=, $0 -; CHECK-NEXT: .endfunc{{$}} +; CHECK-NEXT: get_local $push0=, 0 +; CHECK-NEXT: end_function{{$}} define i32 @return_i32(i32 %p) { ret i32 %p } @@ -19,7 +19,7 @@ define i32 @return_i32(i32 %p) { ; CHECK-NEXT: return $pop[[L0]]{{$}} ; CHECK: store ; CHECK-NEXT: i32.const $push{{[^,]+}}=, 3{{$}} -; CHECK-NEXT: .endfunc{{$}} +; CHECK-NEXT: end_function{{$}} define i32 @return_i32_twice(i32 %a) { %b = icmp ne i32 %a, 0 br i1 %b, label %true, label %false diff --git a/test/CodeGen/WebAssembly/return-void.ll b/test/CodeGen/WebAssembly/return-void.ll index c3a600f7838d..90cf37fd2c69 100644 --- a/test/CodeGen/WebAssembly/return-void.ll +++ b/test/CodeGen/WebAssembly/return-void.ll @@ -2,10 +2,10 @@ ; RUN: llc < %s -asm-verbose=false -fast-isel -fast-isel-abort=1 | FileCheck %s target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" -target triple = "wasm32-unknown-unknown" +target triple = "wasm32-unknown-unknown-wasm" ; CHECK-LABEL: return_void: -; CHECK-NEXT: .endfunc{{$}} +; CHECK-NEXT: end_function{{$}} define void @return_void() { ret void } @@ -14,7 +14,7 @@ define void @return_void() { ; CHECK: store ; CHECK-NEXT: return{{$}} ; CHECK: store -; CHECK-NEXT: .endfunc{{$}} +; CHECK-NEXT: end_function{{$}} define void @return_void_twice(i32 %a) { %b = icmp ne i32 %a, 0 br i1 %b, label %true, label %false diff --git a/test/CodeGen/WebAssembly/returned.ll b/test/CodeGen/WebAssembly/returned.ll index a277928ae400..b059fd8a5987 100644 --- a/test/CodeGen/WebAssembly/returned.ll +++ b/test/CodeGen/WebAssembly/returned.ll @@ -1,9 +1,9 @@ -; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt | FileCheck %s +; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals | FileCheck %s ; Test that the "returned" attribute is optimized effectively. target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" -target triple = "wasm32-unknown-unknown" +target triple = "wasm32-unknown-unknown-wasm" ; CHECK-LABEL: _Z3foov: ; CHECK-NEXT: .result i32{{$}} diff --git a/test/CodeGen/WebAssembly/select.ll b/test/CodeGen/WebAssembly/select.ll index 06837e4c2368..b25f16c499a8 100644 --- a/test/CodeGen/WebAssembly/select.ll +++ b/test/CodeGen/WebAssembly/select.ll @@ -1,10 +1,10 @@ -; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt | FileCheck %s -; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -fast-isel -fast-isel-abort=1 | FileCheck %s +; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals | FileCheck %s +; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals -fast-isel -fast-isel-abort=1 | FileCheck %s ; Test that wasm select instruction is selected from LLVM select instruction. target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" -target triple = "wasm32-unknown-unknown" +target triple = "wasm32-unknown-unknown-wasm" ; CHECK-LABEL: select_i32_bool: ; CHECK-NEXT: .param i32, i32, i32{{$}} diff --git a/test/CodeGen/WebAssembly/signext-zeroext.ll b/test/CodeGen/WebAssembly/signext-zeroext.ll index f9561da5363d..b07c7f669c37 100644 --- a/test/CodeGen/WebAssembly/signext-zeroext.ll +++ b/test/CodeGen/WebAssembly/signext-zeroext.ll @@ -1,9 +1,9 @@ -; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt | FileCheck %s +; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals | FileCheck %s ; Test zeroext and signext ABI keywords target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" -target triple = "wasm32-unknown-unknown" +target triple = "wasm32-unknown-unknown-wasm" ; CHECK-LABEL: z2s_func: ; CHECK-NEXT: .param i32{{$}} diff --git a/test/CodeGen/WebAssembly/simd-arith.ll b/test/CodeGen/WebAssembly/simd-arith.ll index f0e71f2cc104..62c659b7c01c 100644 --- a/test/CodeGen/WebAssembly/simd-arith.ll +++ b/test/CodeGen/WebAssembly/simd-arith.ll @@ -1,12 +1,12 @@ -; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -mattr=+simd128 | FileCheck %s --check-prefixes CHECK,SIMD128 -; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -mattr=+simd128 -fast-isel | FileCheck %s --check-prefixes CHECK,SIMD128 -; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -mattr=-simd128 | FileCheck %s --check-prefixes CHECK,NO-SIMD128 -; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -mattr=-simd128 -fast-isel | FileCheck %s --check-prefixes CHECK,NO-SIMD128 +; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals -mattr=+simd128 | FileCheck %s --check-prefixes CHECK,SIMD128 +; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals -mattr=+simd128 -fast-isel | FileCheck %s --check-prefixes CHECK,SIMD128 +; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals -mattr=-simd128 | FileCheck %s --check-prefixes CHECK,NO-SIMD128 +; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals -mattr=-simd128 -fast-isel | FileCheck %s --check-prefixes CHECK,NO-SIMD128 ; Test that basic SIMD128 arithmetic operations assemble as expected. target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" -target triple = "wasm32-unknown-unknown" +target triple = "wasm32-unknown-unknown-wasm" declare i32 @llvm.ctlz.i32(i32, i1) declare i32 @llvm.cttz.i32(i32, i1) diff --git a/test/CodeGen/WebAssembly/stack-alignment.ll b/test/CodeGen/WebAssembly/stack-alignment.ll index 3bb6617f8779..95aa1f9dbf07 100644 --- a/test/CodeGen/WebAssembly/stack-alignment.ll +++ b/test/CodeGen/WebAssembly/stack-alignment.ll @@ -1,21 +1,23 @@ ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt | FileCheck %s target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" -target triple = "wasm32-unknown-unknown" +target triple = "wasm32-unknown-unknown-wasm" declare void @somefunc(i32*) ; CHECK-LABEL: underalign: -; CHECK: i32.load $push[[L1:.+]]=, __stack_pointer{{.+}} +; CHECK: get_global $push[[L1:.+]]=, 0{{$}} ; CHECK-NEXT: i32.const $push[[L2:.+]]=, 16 ; CHECK-NEXT: i32.sub $push[[L10:.+]]=, $pop[[L1]], $pop[[L2]] -; CHECK-NEXT: tee_local $push{{.+}}=, $[[SP:.+]]=, $pop[[L10]] +; CHECK-NEXT: tee_local $push{{.+}}=, [[SP:.+]], $pop[[L10]] -; CHECK: i32.add $push[[underaligned:.+]]=, $[[SP]], $pop{{.+}} +; CHECK: get_local $push[[L3:.+]]=, [[SP]]{{$}} +; CHECK: i32.add $push[[underaligned:.+]]=, $pop[[L3]], $pop{{.+}} ; CHECK-NEXT: call somefunc@FUNCTION, $pop[[underaligned]] -; CHECK: i32.add $push[[L5:.+]]=, $[[SP]], $pop{{.+}} -; CHECK-NEXT: i32.store __stack_pointer($pop{{.+}}), $pop[[L5]] +; CHECK: get_local $push[[M4:.+]]=, [[SP]]{{$}} +; CHECK: i32.add $push[[L5:.+]]=, $pop[[M4]], $pop{{.+}} +; CHECK-NEXT: set_global 0, $pop[[L5]] define void @underalign() { entry: %underaligned = alloca i32, align 8 @@ -24,18 +26,19 @@ entry: } ; CHECK-LABEL: overalign: -; CHECK: i32.load $push[[L10:.+]]=, __stack_pointer -; CHECK-NEXT: tee_local $push[[L9:.+]]=, $[[BP:.+]]=, $pop[[L10]] +; CHECK: get_global $push[[L10:.+]]=, 0{{$}} +; CHECK-NEXT: tee_local $push[[L9:.+]]=, [[BP:.+]], $pop[[L10]] ; CHECK-NEXT: i32.const $push[[L2:.+]]=, 32 ; CHECK-NEXT: i32.sub $push[[L8:.+]]=, $pop[[L9]], $pop[[L2]] ; CHECK-NEXT: i32.const $push[[L3:.+]]=, -32 ; CHECK-NEXT: i32.and $push[[L7:.+]]=, $pop[[L8]], $pop[[L3]] -; CHECK-NEXT: tee_local $push{{.+}}=, $[[SP:.+]]=, $pop[[L7]] +; CHECK-NEXT: tee_local $push{{.+}}=, [[SP:.+]], $pop[[L7]] -; CHECK: call somefunc@FUNCTION, $[[SP]] +; CHECK: get_local $push[[M5:.+]]=, [[SP]]{{$}} +; CHECK: call somefunc@FUNCTION, $pop[[M5]]{{$}} -; CHECK: copy_local $push[[L5:.+]]=, $[[BP]] -; CHECK-NEXT: i32.store __stack_pointer($pop{{.+}}), $pop[[L5]] +; CHECK: get_local $push[[M6:.+]]=, [[BP]]{{$}} +; CHECK-NEXT: set_global 0, $pop[[M6]] define void @overalign() { entry: %overaligned = alloca i32, align 32 @@ -44,19 +47,21 @@ entry: } ; CHECK-LABEL: over_and_normal_align: -; CHECK: i32.load $push[[L14:.+]]=, __stack_pointer -; CHECK-NEXT: tee_local $push[[L13:.+]]=, $[[BP:.+]]=, $pop[[L14]] +; CHECK: get_global $push[[L14:.+]]=, 0{{$}} +; CHECK-NEXT: tee_local $push[[L13:.+]]=, [[BP:.+]], $pop[[L14]] ; CHECK: i32.sub $push[[L12:.+]]=, $pop[[L13]], $pop{{.+}} ; CHECK: i32.and $push[[L11:.+]]=, $pop[[L12]], $pop{{.+}} -; CHECK-NEXT: tee_local $push{{.+}}=, $[[SP]]=, $pop[[L11]] +; CHECK-NEXT: tee_local $push{{.+}}=, [[SP:.+]], $pop[[L11]] -; CHECK: i32.add $push[[L6:.+]]=, $[[SP]], $pop{{.+}} +; CHECK: get_local $push[[M6:.+]]=, [[SP]]{{$}} +; CHECK: i32.add $push[[L6:.+]]=, $pop[[M6]], $pop{{.+}} ; CHECK-NEXT: call somefunc@FUNCTION, $pop[[L6]] -; CHECK: i32.add $push[[L8:.+]]=, $[[SP]], $pop{{.+}} +; CHECK: get_local $push[[M7:.+]]=, [[SP]]{{$}} +; CHECK: i32.add $push[[L8:.+]]=, $pop[[M7]], $pop{{.+}} ; CHECK-NEXT: call somefunc@FUNCTION, $pop[[L8]] -; CHECK: copy_local $push[[L9:.+]]=, $[[BP]] -; CHECK-NEXT: i32.store __stack_pointer({{.+}}), $pop[[L9]] +; CHECK: get_local $push[[L6:.+]]=, [[BP]]{{$}} +; CHECK-NEXT: set_global 0, $pop[[L6]] define void @over_and_normal_align() { entry: %over = alloca i32, align 32 @@ -67,14 +72,16 @@ entry: } ; CHECK-LABEL: dynamic_overalign: -; CHECK: i32.load $push[[L18:.+]]=, __stack_pointer -; CHECK-NEXT: tee_local $push[[L17:.+]]=, $[[SP:.+]]=, $pop[[L18]] -; CHECK-NEXT: copy_local $[[BP:.+]]=, $pop[[L17]] -; CHECK: tee_local $push{{.+}}=, $[[SP_2:.+]]=, $pop{{.+}} +; CHECK: get_global $push[[L18:.+]]=, 0{{$}} +; CHECK-NEXT: tee_local $push[[L17:.+]]=, [[SP:.+]], $pop[[L18]] +; CHECK-NEXT: set_local [[BP:.+]], $pop[[L17]] +; CHECK: tee_local $push{{.+}}=, [[SP_2:.+]], $pop{{.+}} -; CHECK: call somefunc@FUNCTION, $[[SP_2]] +; CHECK: get_local $push[[M8:.+]]=, [[SP_2]]{{$}} +; CHECK: call somefunc@FUNCTION, $pop[[M8]] -; CHECK: i32.store __stack_pointer($pop{{.+}}), $[[BP]] +; CHECK: get_local $push[[M9:.+]]=, [[BP]]{{$}} +; CHECK-NEXT: set_global 0, $pop[[M9]] define void @dynamic_overalign(i32 %num) { entry: %dynamic = alloca i32, i32 %num, align 32 @@ -83,20 +90,22 @@ entry: } ; CHECK-LABEL: overalign_and_dynamic: -; CHECK: i32.load $push[[L21:.+]]=, __stack_pointer -; CHECK-NEXT: tee_local $push[[L20:.+]]=, $[[BP:.+]]=, $pop[[L21]] +; CHECK: get_global $push[[L21:.+]]=, 0{{$}} +; CHECK-NEXT: tee_local $push[[L20:.+]]=, [[BP:.+]], $pop[[L21]] ; CHECK: i32.sub $push[[L19:.+]]=, $pop[[L20]], $pop{{.+}} ; CHECK: i32.and $push[[L18:.+]]=, $pop[[L19]], $pop{{.+}} -; CHECK: tee_local $push{{.+}}=, $[[FP:.+]]=, $pop[[L18]] -; CHECK: i32.sub $push[[L16:.+]]=, $[[FP]], $pop{{.+}} -; CHECK-NEXT: tee_local $push{{.+}}=, $[[SP:.+]]=, $pop[[L16]] +; CHECK: tee_local $push{{.+}}=, [[FP:.+]], $pop[[L18]] +; CHECK: get_local $push[[M10:.+]]=, [[FP]]{{$}} +; CHECK: i32.sub $push[[L16:.+]]=, $pop[[M10]], $pop{{.+}} +; CHECK-NEXT: tee_local $push{{.+}}=, [[SP:.+]], $pop[[L16]] -; CHECK: copy_local $push[[over:.+]]=, $[[FP]] +; CHECK: get_local $push[[over:.+]]=, [[FP]] ; CHECK-NEXT: call somefunc@FUNCTION, $pop[[over]] -; CHECK-NEXT: call somefunc@FUNCTION, $[[SP]] +; CHECK: get_local $push[[another:.+]]=, [[SP]] +; CHECK-NEXT: call somefunc@FUNCTION, $pop[[another]] -; CHECK: copy_local $push[[L12:.+]]=, $[[BP]] -; CHECK-NEXT: i32.store __stack_pointer($pop{{.+}}), $pop[[L12]] +; CHECK: get_local $push[[M11:.+]]=, [[BP]]{{$}} +; CHECK-NEXT: set_global 0, $pop[[M11]] define void @overalign_and_dynamic(i32 %num) { entry: %over = alloca i32, align 32 @@ -107,24 +116,27 @@ entry: } ; CHECK-LABEL: overalign_static_and_dynamic: -; CHECK: i32.load $push[[L26:.+]]=, __stack_pointer -; CHECK-NEXT: tee_local $push[[L25:.+]]=, $[[BP:.+]]=, $pop[[L26]] +; CHECK: get_global $push[[L26:.+]]=, 0{{$}} +; CHECK-NEXT: tee_local $push[[L25:.+]]=, [[BP:.+]], $pop[[L26]] ; CHECK: i32.sub $push[[L24:.+]]=, $pop[[L25]], $pop{{.+}} ; CHECK: i32.and $push[[L23:.+]]=, $pop[[L24]], $pop{{.+}} -; CHECK: tee_local $push{{.+}}=, $[[FP:.+]]=, $pop[[L23]] -; CHECK: i32.sub $push[[L21:.+]]=, $[[FP]], $pop{{.+}} -; CHECK-NEXT: tee_local $push{{.+}}=, $[[SP:.+]]=, $pop[[L21]] +; CHECK: tee_local $push{{.+}}=, [[FP:.+]], $pop[[L23]] +; CHECK: get_local $push[[M12:.+]]=, [[FP]]{{$}} +; CHECK: i32.sub $push[[L21:.+]]=, $pop[[M12]], $pop{{.+}} +; CHECK-NEXT: tee_local $push{{.+}}=, [[SP:.+]], $pop[[L21]] -; CHECK: copy_local $push[[L19:.+]]=, $[[FP]] -; CHECK: tee_local $push[[L18:.+]]=, $[[FP_2:.+]]=, $pop[[L19]] +; CHECK: get_local $push[[L19:.+]]=, [[FP]] +; CHECK: tee_local $push[[L18:.+]]=, [[FP_2:.+]], $pop[[L19]] ; CHECK: i32.add $push[[over:.+]]=, $pop[[L18]], $pop{{.+}} ; CHECK-NEXT: call somefunc@FUNCTION, $pop[[over]] -; CHECK: call somefunc@FUNCTION, $[[SP]] -; CHECK: i32.add $push[[static:.+]]=, $[[FP_2]], $pop{{.+}} +; CHECK: get_local $push[[M12:.+]]=, [[SP]] +; CHECK: call somefunc@FUNCTION, $pop[[M12]] +; CHECK: get_local $push[[M13:.+]]=, [[FP_2]] +; CHECK: i32.add $push[[static:.+]]=, $pop[[M13]], $pop{{.+}} ; CHECK-NEXT: call somefunc@FUNCTION, $pop[[static]] -; CHECK: copy_local $push[[L16:.+]]=, $[[BP]] -; CHECK-NEXT: i32.store __stack_pointer({{.+}}), $pop[[L16]] +; CHECK: get_local $push[[M14:.+]]=, [[BP]]{{$}} +; CHECK-NEXT: set_global 0, $pop[[M14]] define void @overalign_static_and_dynamic(i32 %num) { entry: %over = alloca i32, align 32 diff --git a/test/CodeGen/WebAssembly/store-trunc.ll b/test/CodeGen/WebAssembly/store-trunc.ll index 436933880481..ff358227d987 100644 --- a/test/CodeGen/WebAssembly/store-trunc.ll +++ b/test/CodeGen/WebAssembly/store-trunc.ll @@ -1,9 +1,9 @@ -; RUN: llc < %s -asm-verbose=false | FileCheck %s +; RUN: llc < %s -asm-verbose=false -disable-wasm-explicit-locals | FileCheck %s ; Test that truncating stores are assembled properly. target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" -target triple = "wasm32-unknown-unknown" +target triple = "wasm32-unknown-unknown-wasm" ; CHECK-LABEL: trunc_i8_i32: ; CHECK: i32.store8 0($0), $1{{$}} diff --git a/test/CodeGen/WebAssembly/store.ll b/test/CodeGen/WebAssembly/store.ll index 3852b6e420ca..153d7d9addf7 100644 --- a/test/CodeGen/WebAssembly/store.ll +++ b/test/CodeGen/WebAssembly/store.ll @@ -4,11 +4,13 @@ ; Test that basic stores are assembled properly. target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" -target triple = "wasm32-unknown-unknown" +target triple = "wasm32-unknown-unknown-wasm" ; CHECK-LABEL: sti32: ; CHECK-NEXT: .param i32, i32{{$}} -; CHECK-NEXT: i32.store 0($0), $1{{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: i32.store 0($pop[[L0]]), $pop[[L1]]{{$}} ; CHECK-NEXT: return{{$}} define void @sti32(i32 *%p, i32 %v) { store i32 %v, i32* %p @@ -17,7 +19,9 @@ define void @sti32(i32 *%p, i32 %v) { ; CHECK-LABEL: sti64: ; CHECK-NEXT: .param i32, i64{{$}} -; CHECK-NEXT: i64.store 0($0), $1{{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: i64.store 0($pop[[L0]]), $pop[[L1]]{{$}} ; CHECK-NEXT: return{{$}} define void @sti64(i64 *%p, i64 %v) { store i64 %v, i64* %p @@ -26,7 +30,9 @@ define void @sti64(i64 *%p, i64 %v) { ; CHECK-LABEL: stf32: ; CHECK-NEXT: .param i32, f32{{$}} -; CHECK-NEXT: f32.store 0($0), $1{{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: f32.store 0($pop[[L0]]), $pop[[L1]]{{$}} ; CHECK-NEXT: return{{$}} define void @stf32(float *%p, float %v) { store float %v, float* %p @@ -35,7 +41,9 @@ define void @stf32(float *%p, float %v) { ; CHECK-LABEL: stf64: ; CHECK-NEXT: .param i32, f64{{$}} -; CHECK-NEXT: f64.store 0($0), $1{{$}} +; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} +; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 1{{$}} +; CHECK-NEXT: f64.store 0($pop[[L0]]), $pop[[L1]]{{$}} ; CHECK-NEXT: return{{$}} define void @stf64(double *%p, double %v) { store double %v, double* %p diff --git a/test/CodeGen/WebAssembly/switch.ll b/test/CodeGen/WebAssembly/switch.ll index c6354baa57a6..18eac5534a45 100644 --- a/test/CodeGen/WebAssembly/switch.ll +++ b/test/CodeGen/WebAssembly/switch.ll @@ -4,7 +4,7 @@ ; the blocks in a way that isn't interesting here. target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" -target triple = "wasm32-unknown-unknown" +target triple = "wasm32-unknown-unknown-wasm" declare void @foo0() declare void @foo1() diff --git a/test/CodeGen/WebAssembly/unreachable.ll b/test/CodeGen/WebAssembly/unreachable.ll index 77fda44d5ff3..de96b0927563 100644 --- a/test/CodeGen/WebAssembly/unreachable.ll +++ b/test/CodeGen/WebAssembly/unreachable.ll @@ -5,7 +5,7 @@ ; wasm unreachable target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" -target triple = "wasm32-unknown-unknown" +target triple = "wasm32-unknown-unknown-wasm" declare void @llvm.trap() declare void @llvm.debugtrap() diff --git a/test/CodeGen/WebAssembly/unsupported-function-bitcasts.ll b/test/CodeGen/WebAssembly/unsupported-function-bitcasts.ll index ef4318ec299b..c3d420a6ece6 100644 --- a/test/CodeGen/WebAssembly/unsupported-function-bitcasts.ll +++ b/test/CodeGen/WebAssembly/unsupported-function-bitcasts.ll @@ -5,13 +5,14 @@ ; conversions are implemented. target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" -target triple = "wasm32-unknown-unknown" +target triple = "wasm32-unknown-unknown-wasm" ; CHECK-LABEL: test: ; CHECK-NEXT: i32.const $push[[L0:[0-9]+]]=, 0{{$}} ; CHECK-NEXT: call has_i64_arg@FUNCTION, $pop[[L0]]{{$}} -; CHECK-NEXT: i32.call $drop=, has_i64_ret@FUNCTION{{$}} -; CHECK-NEXT: .endfunc +; CHECK-NEXT: i32.call $push{{[0-9]+}}=, has_i64_ret@FUNCTION{{$}} +; CHECK-NEXT: drop +; CHECK-NEXT: end_function ; CHECK-NOT: .Lbitcast diff --git a/test/CodeGen/WebAssembly/unused-argument.ll b/test/CodeGen/WebAssembly/unused-argument.ll index ff943b215438..a70fc4bd2a46 100644 --- a/test/CodeGen/WebAssembly/unused-argument.ll +++ b/test/CodeGen/WebAssembly/unused-argument.ll @@ -1,9 +1,9 @@ -; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt | FileCheck %s +; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals | FileCheck %s ; Make sure that argument offsets are correct even if some arguments are unused. target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" -target triple = "wasm32-unknown-unknown" +target triple = "wasm32-unknown-unknown-wasm" ; CHECK-LABEL: unused_first: ; CHECK-NEXT: .param i32, i32{{$}} diff --git a/test/CodeGen/WebAssembly/userstack.ll b/test/CodeGen/WebAssembly/userstack.ll index a163f879f6df..57ca75705e5e 100644 --- a/test/CodeGen/WebAssembly/userstack.ll +++ b/test/CodeGen/WebAssembly/userstack.ll @@ -1,7 +1,7 @@ ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt | FileCheck %s target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" -target triple = "wasm32-unknown-unknown" +target triple = "wasm32-unknown-unknown-wasm" declare void @ext_func(i64* %ptr) declare void @ext_func_i32(i32* %ptr) @@ -10,39 +10,38 @@ declare void @ext_func_i32(i32* %ptr) ; Check that there is an extra local for the stack pointer. ; CHECK: .local i32{{$}} define void @alloca32() noredzone { - ; CHECK: i32.const $push[[L4:.+]]=, 0{{$}} - ; CHECK: i32.const $push[[L1:.+]]=, 0{{$}} - ; CHECK-NEXT: i32.load $push[[L2:.+]]=, __stack_pointer($pop[[L1]]) + ; CHECK-NEXT: get_global $push[[L2:.+]]=, 0{{$}} ; CHECK-NEXT: i32.const $push[[L3:.+]]=, 16 ; CHECK-NEXT: i32.sub $push[[L9:.+]]=, $pop[[L2]], $pop[[L3]] - ; CHECK-NEXT: tee_local $push[[L8:.+]]=, $[[SP:.+]]=, $pop[[L9]]{{$}} - ; CHECK-NEXT: i32.store __stack_pointer($pop[[L4]]), $pop[[L8]]{{$}} + ; CHECK-NEXT: tee_local $push[[L8:.+]]=, [[SP:.+]], $pop[[L9]]{{$}} + ; CHECK-NEXT: set_global 0, $pop[[L8]]{{$}} %retval = alloca i32 + ; CHECK: get_local $push[[L4:.+]]=, [[SP]]{{$}} ; CHECK: i32.const $push[[L0:.+]]=, 0 - ; CHECK: i32.store 12($[[SP]]), $pop[[L0]] + ; CHECK: i32.store 12($pop[[L4]]), $pop[[L0]] store i32 0, i32* %retval - ; CHECK: i32.const $push[[L6:.+]]=, 0 + ; CHECK: get_local $push[[L6:.+]]=, [[SP]]{{$}} ; CHECK-NEXT: i32.const $push[[L5:.+]]=, 16 - ; CHECK-NEXT: i32.add $push[[L7:.+]]=, $[[SP]], $pop[[L5]] - ; CHECK-NEXT: i32.store __stack_pointer($pop[[L6]]), $pop[[L7]] + ; CHECK-NEXT: i32.add $push[[L7:.+]]=, $pop[[L6]], $pop[[L5]] + ; CHECK-NEXT: set_global 0, $pop[[L7]] ret void } ; CHECK-LABEL: alloca3264: ; CHECK: .local i32{{$}} define void @alloca3264() { - ; CHECK: i32.const $push[[L2:.+]]=, 0{{$}} - ; CHECK-NEXT: i32.load $push[[L3:.+]]=, __stack_pointer($pop[[L2]]) + ; CHECK: get_global $push[[L3:.+]]=, 0{{$}} ; CHECK-NEXT: i32.const $push[[L4:.+]]=, 16 ; CHECK-NEXT: i32.sub $push[[L6:.+]]=, $pop[[L3]], $pop[[L4]] - ; CHECK-NEXT: tee_local $push[[L5:.+]]=, $[[SP:.+]]=, $pop[[L6]] + ; CHECK-NEXT: tee_local $push[[L5:.+]]=, [[SP:.+]], $pop[[L6]] %r1 = alloca i32 %r2 = alloca double ; CHECK-NEXT: i32.const $push[[L0:.+]]=, 0 ; CHECK-NEXT: i32.store 12($pop[[L5]]), $pop[[L0]] store i32 0, i32* %r1 + ; CHECK-NEXT: get_local $push[[L2:.+]]=, [[SP]]{{$}} ; CHECK-NEXT: i64.const $push[[L1:.+]]=, 0 - ; CHECK-NEXT: i64.store 0($[[SP]]), $pop[[L1]] + ; CHECK-NEXT: i64.store 0($pop[[L2]]), $pop[[L1]] store double 0.0, double* %r2 ; CHECK-NEXT: return ret void @@ -51,30 +50,29 @@ define void @alloca3264() { ; CHECK-LABEL: allocarray: ; CHECK: .local i32{{$}} define void @allocarray() { - ; CHECK: i32.const $push[[L6:.+]]=, 0{{$}} - ; CHECK: i32.const $push[[L3:.+]]=, 0{{$}} - ; CHECK-NEXT: i32.load $push[[L4:.+]]=, __stack_pointer($pop[[L3]]) + ; CHECK-NEXT: get_global $push[[L4:.+]]=, 0{{$}} ; CHECK-NEXT: i32.const $push[[L5:.+]]=, 144{{$}} ; CHECK-NEXT: i32.sub $push[[L12:.+]]=, $pop[[L4]], $pop[[L5]] - ; CHECK-NEXT: tee_local $push[[L11:.+]]=, $0=, $pop[[L12]] - ; CHECK-NEXT: i32.store __stack_pointer($pop[[L6]]), $pop[[L11]] + ; CHECK-NEXT: tee_local $push[[L11:.+]]=, 0, $pop[[L12]] + ; CHECK-NEXT: set_global 0, $pop[[L11]] %r = alloca [33 x i32] ; CHECK: i32.const $push{{.+}}=, 24 - ; CHECK-NEXT: i32.add $push[[L3:.+]]=, $[[SP]], $pop{{.+}} + ; CHECK-NEXT: i32.add $push[[L3:.+]]=, $pop{{.+}}, $pop{{.+}} ; CHECK-NEXT: i32.const $push[[L1:.+]]=, 1{{$}} ; CHECK-NEXT: i32.store 0($pop[[L3]]), $pop[[L1]]{{$}} + ; CHECK-NEXT: get_local $push[[L4:.+]]=, 0{{$}} ; CHECK-NEXT: i32.const $push[[L10:.+]]=, 1{{$}} - ; CHECK-NEXT: i32.store 12(${{.+}}), $pop[[L10]]{{$}} + ; CHECK-NEXT: i32.store 12($pop[[L4]]), $pop[[L10]]{{$}} %p = getelementptr [33 x i32], [33 x i32]* %r, i32 0, i32 0 store i32 1, i32* %p %p2 = getelementptr [33 x i32], [33 x i32]* %r, i32 0, i32 3 store i32 1, i32* %p2 - ; CHECK: i32.const $push[[L9:.+]]=, 0{{$}} + ; CHECK-NEXT: get_local $push[[L2:.+]]=, [[SP]]{{$}} ; CHECK-NEXT: i32.const $push[[L7:.+]]=, 144 - ; CHECK-NEXT: i32.add $push[[L8:.+]]=, $[[SP]], $pop[[L7]] - ; CHECK-NEXT: i32.store __stack_pointer($pop[[L9]]), $pop[[L8]] + ; CHECK-NEXT: i32.add $push[[L8:.+]]=, $pop[[L2]], $pop[[L7]] + ; CHECK-NEXT: set_global 0, $pop[[L8]] ret void } @@ -82,24 +80,27 @@ define void @allocarray() { define void @non_mem_use(i8** %addr) { ; CHECK: i32.const $push[[L2:.+]]=, 48 ; CHECK-NEXT: i32.sub $push[[L12:.+]]=, {{.+}}, $pop[[L2]] - ; CHECK-NEXT: tee_local $push[[L11:.+]]=, $[[SP:.+]]=, $pop[[L12]] - ; CHECK-NEXT: i32.store {{.+}}, $pop[[L11]] + ; CHECK-NEXT: tee_local $push[[L11:.+]]=, [[SP:.+]], $pop[[L12]] + ; CHECK-NEXT: set_global 0, $pop[[L11]] %buf = alloca [27 x i8], align 16 %r = alloca i64 %r2 = alloca i64 ; %r is at SP+8 + ; CHECK: get_local $push[[L3:.+]]=, [[SP]] ; CHECK: i32.const $push[[OFF:.+]]=, 8 - ; CHECK-NEXT: i32.add $push[[ARG1:.+]]=, $[[SP]], $pop[[OFF]] + ; CHECK-NEXT: i32.add $push[[ARG1:.+]]=, $pop[[L3]], $pop[[OFF]] ; CHECK-NEXT: call ext_func@FUNCTION, $pop[[ARG1]] call void @ext_func(i64* %r) ; %r2 is at SP+0, no add needed - ; CHECK-NEXT: call ext_func@FUNCTION, $[[SP]] + ; CHECK: get_local $push[[L4:.+]]=, [[SP]] + ; CHECK-NEXT: call ext_func@FUNCTION, $pop[[L4]] call void @ext_func(i64* %r2) ; Use as a value, but in a store ; %buf is at SP+16 + ; CHECK: get_local $push[[L5:.+]]=, [[SP]] ; CHECK: i32.const $push[[OFF:.+]]=, 16 - ; CHECK-NEXT: i32.add $push[[VAL:.+]]=, $[[SP]], $pop[[OFF]] - ; CHECK-NEXT: i32.store 0($0), $pop[[VAL]] + ; CHECK-NEXT: i32.add $push[[VAL:.+]]=, $pop[[L5]], $pop[[OFF]] + ; CHECK-NEXT: i32.store 0($pop{{.+}}), $pop[[VAL]] %gep = getelementptr inbounds [27 x i8], [27 x i8]* %buf, i32 0, i32 0 store i8* %gep, i8** %addr ret void @@ -108,13 +109,11 @@ define void @non_mem_use(i8** %addr) { ; CHECK-LABEL: allocarray_inbounds: ; CHECK: .local i32{{$}} define void @allocarray_inbounds() { - ; CHECK: i32.const $push[[L5:.+]]=, 0{{$}} - ; CHECK: i32.const $push[[L2:.+]]=, 0{{$}} - ; CHECK-NEXT: i32.load $push[[L3:.+]]=, __stack_pointer($pop[[L2]]) + ; CHECK: get_global $push[[L3:.+]]=, 0{{$}} ; CHECK-NEXT: i32.const $push[[L4:.+]]=, 32{{$}} ; CHECK-NEXT: i32.sub $push[[L11:.+]]=, $pop[[L3]], $pop[[L4]] - ; CHECK-NEXT: tee_local $push[[L10:.+]]=, $[[SP:.+]]=, $pop[[L11]] - ; CHECK-NEXT: i32.store __stack_pointer($pop[[L5]]), $pop[[L10]]{{$}} + ; CHECK-NEXT: tee_local $push[[L10:.+]]=, [[SP:.+]], $pop[[L11]] + ; CHECK-NEXT: set_global 0, $pop[[L10]]{{$}} %r = alloca [5 x i32] ; CHECK: i32.const $push[[L3:.+]]=, 1 ; CHECK-DAG: i32.store 24(${{.+}}), $pop[[L3]] @@ -126,45 +125,39 @@ define void @allocarray_inbounds() { store i32 1, i32* %p2 call void @ext_func(i64* null); ; CHECK: call ext_func - ; CHECK: i32.const $push[[L6:.+]]=, 0{{$}} - ; CHECK-NEXT: i32.const $push[[L5:.+]]=, 32{{$}} + ; CHECK: i32.const $push[[L5:.+]]=, 32{{$}} ; CHECK-NEXT: i32.add $push[[L7:.+]]=, ${{.+}}, $pop[[L5]] - ; CHECK-NEXT: i32.store __stack_pointer($pop[[L6]]), $pop[[L7]] + ; CHECK-NEXT: set_global 0, $pop[[L7]] ret void } ; CHECK-LABEL: dynamic_alloca: define void @dynamic_alloca(i32 %alloc) { - ; CHECK: i32.const $push[[L7:.+]]=, 0{{$}} - ; CHECK: i32.const $push[[L1:.+]]=, 0{{$}} - ; CHECK-NEXT: i32.load $push[[L13:.+]]=, __stack_pointer($pop[[L1]]) + ; CHECK: get_global $push[[L13:.+]]=, 0{{$}} ; CHECK-NEXT: tee_local $push[[L12:.+]]=, [[SP:.+]], $pop[[L13]]{{$}} ; Target independent codegen bumps the stack pointer. ; CHECK: i32.sub ; Check that SP is written back to memory after decrement - ; CHECK: i32.store __stack_pointer($pop{{.+}}), + ; CHECK: set_global 0, %r = alloca i32, i32 %alloc ; Target-independent codegen also calculates the store addr ; CHECK: call ext_func_i32@FUNCTION call void @ext_func_i32(i32* %r) - ; CHECK: i32.const $push[[L3:.+]]=, 0{{$}} - ; CHECK: i32.store __stack_pointer($pop[[L3]]), $pop{{.+}} + ; CHECK: set_global 0, $pop{{.+}} ret void } ; CHECK-LABEL: dynamic_alloca_redzone: define void @dynamic_alloca_redzone(i32 %alloc) { - ; CHECK: i32.const $push[[L8:.+]]=, 0{{$}} - ; CHECK-NEXT: i32.load $push[[L13:.+]]=, __stack_pointer($pop[[L1]]) + ; CHECK: get_global $push[[L13:.+]]=, 0{{$}} ; CHECK-NEXT: tee_local $push[[L12:.+]]=, [[SP:.+]], $pop[[L13]]{{$}} - ; CHECK-NEXT: copy_local [[FP:.+]]=, $pop[[L12]]{{$}} ; Target independent codegen bumps the stack pointer ; CHECK: i32.sub %r = alloca i32, i32 %alloc - ; CHECK-NEXT: tee_local $push[[L8:.+]]=, $0=, $pop - ; CHECK-NEXT: copy_local $drop=, $pop[[L8]]{{$}} + ; CHECK-NEXT: tee_local $push[[L8:.+]]=, {{.+}}, $pop + ; CHECK: get_local $push[[L7:.+]]=, 0{{$}} ; CHECK-NEXT: i32.const $push[[L6:.+]]=, 0{{$}} - ; CHECK-NEXT: i32.store 0($0), $pop[[L6]]{{$}} + ; CHECK-NEXT: i32.store 0($pop[[L7]]), $pop[[L6]]{{$}} store i32 0, i32* %r ; CHECK-NEXT: return ret void @@ -173,17 +166,15 @@ define void @dynamic_alloca_redzone(i32 %alloc) { ; CHECK-LABEL: dynamic_static_alloca: define void @dynamic_static_alloca(i32 %alloc) noredzone { ; Decrement SP in the prolog by the static amount and writeback to memory. - ; CHECK: i32.const $push[[L13:.+]]=, 0{{$}} - ; CHECK: i32.const $push[[L10:.+]]=, 0{{$}} - ; CHECK-NEXT: i32.load $push[[L11:.+]]=, __stack_pointer($pop[[L10]]) + ; CHECK: get_global $push[[L11:.+]]=, 0{{$}} ; CHECK-NEXT: i32.const $push[[L12:.+]]=, 16 ; CHECK-NEXT: i32.sub $push[[L23:.+]]=, $pop[[L11]], $pop[[L12]] - ; CHECK-NEXT: tee_local $push[[L22:.+]]=, $[[SP:.+]]=, $pop[[L23]] - ; CHECK-NEXT: i32.store __stack_pointer($pop{{.+}}), $pop[[L22]] + ; CHECK-NEXT: tee_local $push[[L22:.+]]=, [[SP:.+]], $pop[[L23]] + ; CHECK-NEXT: set_global 0, $pop[[L22]] ; Alloc and write to a static alloca - ; CHECK: copy_local $push[[L21:.+]]=, $[[SP]] - ; CHECK-NEXT: tee_local $push[[pushedFP:.+]]=, $[[FP:.+]]=, $pop[[L21]] + ; CHECK: get_local $push[[L21:.+]]=, [[SP:.+]] + ; CHECK-NEXT: tee_local $push[[pushedFP:.+]]=, [[FP:.+]], $pop[[L21]] ; CHECK-NEXT: i32.const $push[[L0:.+]]=, 101 ; CHECK-NEXT: i32.store [[static_offset:.+]]($pop[[pushedFP]]), $pop[[L0]] %static = alloca i32 @@ -191,44 +182,51 @@ define void @dynamic_static_alloca(i32 %alloc) noredzone { ; Decrement SP in the body by the dynamic amount. ; CHECK: i32.sub - ; CHECK: tee_local $push{{.+}}=, $[[dynamic_local:.+]]=, $pop{{.+}} - ; CHECK: i32.store __stack_pointer + ; CHECK: tee_local $push[[L16:.+]]=, [[dynamic_local:.+]], $pop{{.+}} + ; CHECK: tee_local $push[[L15:.+]]=, [[other:.+]], $pop[[L16]]{{$}} + ; CHECK: set_global 0, $pop[[L15]]{{$}} %dynamic = alloca i32, i32 %alloc ; Ensure we don't modify the frame pointer after assigning it. ; CHECK-NOT: $[[FP]]= ; Ensure the static address doesn't change after modifying the stack pointer. + ; CHECK: get_local $push[[L17:.+]]=, [[FP]] ; CHECK: i32.const $push[[L7:.+]]=, 102 - ; CHECK-NEXT: i32.store [[static_offset]]($[[FP]]), $pop[[L7]] + ; CHECK-NEXT: i32.store [[static_offset]]($pop[[L17]]), $pop[[L7]] + ; CHECK-NEXT: get_local $push[[L9:.+]]=, [[dynamic_local]]{{$}} ; CHECK-NEXT: i32.const $push[[L8:.+]]=, 103 - ; CHECK-NEXT: i32.store 0($[[dynamic_local]]), $pop[[L8]] + ; CHECK-NEXT: i32.store 0($pop[[L9]]), $pop[[L8]] store volatile i32 102, i32* %static store volatile i32 103, i32* %dynamic ; Decrement SP in the body by the dynamic amount. ; CHECK: i32.sub - ; CHECK: tee_local $push{{.+}}=, $[[dynamic2_local:.+]]=, $pop{{.+}} + ; CHECK: tee_local $push{{.+}}=, [[dynamic2_local:.+]], $pop{{.+}} %dynamic.2 = alloca i32, i32 %alloc ; CHECK-NOT: $[[FP]]= ; Ensure neither the static nor dynamic address changes after the second ; modification of the stack pointer. + ; CHECK: get_local $push[[L22:.+]]=, [[FP]] ; CHECK: i32.const $push[[L9:.+]]=, 104 - ; CHECK-NEXT: i32.store [[static_offset]]($[[FP]]), $pop[[L9]] + ; CHECK-NEXT: i32.store [[static_offset]]($pop[[L22]]), $pop[[L9]] + ; CHECK-NEXT: get_local $push[[L23:.+]]=, [[dynamic_local]] ; CHECK-NEXT: i32.const $push[[L10:.+]]=, 105 - ; CHECK-NEXT: i32.store 0($[[dynamic_local]]), $pop[[L10]] + ; CHECK-NEXT: i32.store 0($pop[[L23]]), $pop[[L10]] + ; CHECK-NEXT: get_local $push[[L23:.+]]=, [[dynamic2_local]] ; CHECK-NEXT: i32.const $push[[L11:.+]]=, 106 - ; CHECK-NEXT: i32.store 0($[[dynamic2_local]]), $pop[[L11]] + ; CHECK-NEXT: i32.store 0($pop[[L23]]), $pop[[L11]] store volatile i32 104, i32* %static store volatile i32 105, i32* %dynamic store volatile i32 106, i32* %dynamic.2 ; Writeback to memory. - ; CHECK: i32.const $push[[L17:.+]]=, 16 - ; CHECK-NEXT: i32.add $push[[L18:.+]]=, $[[FP]], $pop[[L17]] - ; CHECK-NEXT: i32.store __stack_pointer($pop{{.+}}), $pop[[L18]] + ; CHECK: get_local $push[[L24:.+]]=, [[FP]]{{$}} + ; CHECK: i32.const $push[[L18:.+]]=, 16 + ; CHECK-NEXT: i32.add $push[[L19:.+]]=, $pop[[L24]], $pop[[L18]] + ; CHECK-NEXT: set_global 0, $pop[[L19]] ret void } @@ -237,16 +235,17 @@ declare void @llvm.stackrestore(i8*) ; CHECK-LABEL: llvm_stack_builtins: define void @llvm_stack_builtins(i32 %alloc) noredzone { - ; CHECK: i32.load $push[[L11:.+]]=, __stack_pointer($pop{{.+}}) - ; CHECK-NEXT: tee_local $push[[L10:.+]]=, ${{.+}}=, $pop[[L11]] - ; CHECK-NEXT: copy_local $[[STACK:.+]]=, $pop[[L10]] + ; CHECK: get_global $push[[L11:.+]]=, 0{{$}} + ; CHECK-NEXT: tee_local $push[[L10:.+]]=, {{.+}}, $pop[[L11]] + ; CHECK-NEXT: set_local [[STACK:.+]], $pop[[L10]] %stack = call i8* @llvm.stacksave() ; Ensure we don't reassign the stacksave local - ; CHECK-NOT: $[[STACK]]= + ; CHECK-NOT: set_local [[STACK]], %dynamic = alloca i32, i32 %alloc - ; CHECK: i32.store __stack_pointer($pop{{.+}}), $[[STACK]] + ; CHECK: get_local $push[[L12:.+]]=, [[STACK]] + ; CHECK-NEXT: set_global 0, $pop[[L12]] call void @llvm.stackrestore(i8* %stack) ret void @@ -257,14 +256,15 @@ define void @llvm_stack_builtins(i32 %alloc) noredzone { ; moved after the stack pointer was updated for the dynamic alloca. ; CHECK-LABEL: dynamic_alloca_nouse: define void @dynamic_alloca_nouse(i32 %alloc) noredzone { - ; CHECK: i32.load $push[[L11:.+]]=, __stack_pointer($pop{{.+}}) - ; CHECK-NEXT: tee_local $push[[L10:.+]]=, ${{.+}}=, $pop[[L11]] - ; CHECK-NEXT: copy_local $[[FP:.+]]=, $pop[[L10]] + ; CHECK: get_global $push[[L11:.+]]=, 0{{$}} + ; CHECK-NEXT: tee_local $push[[L10:.+]]=, {{.+}}, $pop[[L11]] + ; CHECK-NEXT: set_local [[FP:.+]], $pop[[L10]] %dynamic = alloca i32, i32 %alloc - ; CHECK-NOT: $[[FP]]=, + ; CHECK-NOT: set_local [[FP]], - ; CHECK: i32.store __stack_pointer($pop{{.+}}), $[[FP]] + ; CHECK: get_local $push[[L12:.+]]=, [[FP]] + ; CHECK-NEXT: set_global 0, $pop[[L12]] ret void } @@ -278,12 +278,13 @@ entry: %addr = alloca i32 ; CHECK: i32.const $push[[OFF:.+]]=, 12 ; CHECK-NEXT: i32.add $push[[ADDR:.+]]=, $pop[[L3]], $pop[[OFF]] - ; CHECK-NEXT: copy_local [[COPY:.+]]=, $pop[[ADDR]] + ; CHECK-NEXT: set_local [[COPY:.+]], $pop[[ADDR]] br label %body body: %a = phi i32* [%addr, %entry], [%b, %body] store i32 1, i32* %a - ; CHECK: i32.store 0([[COPY]]), + ; CHECK: get_local $push[[L12:.+]]=, [[COPY]] + ; CHECK: i32.store 0($pop[[L12]]), br i1 %cond, label %body, label %exit exit: ret void @@ -294,13 +295,11 @@ declare i8* @llvm.frameaddress(i32) ; Test __builtin_frame_address(0). ; CHECK-LABEL: frameaddress_0: -; CHECK: i32.const $push[[L0:.+]]=, 0{{$}} -; CHECK-NEXT: i32.load $push[[L3:.+]]=, __stack_pointer($pop[[L0]]) -; CHECK-NEXT: copy_local $push[[L4:.+]]=, $pop[[L3]]{{$}} -; CHECK-NEXT: tee_local $push[[L2:.+]]=, $[[FP:.+]]=, $pop[[L4]]{{$}} +; CHECK: get_global $push[[L3:.+]]=, 0{{$}} +; CHECK-NEXT: tee_local $push[[L2:.+]]=, [[FP:.+]], $pop[[L3]]{{$}} ; CHECK-NEXT: call use_i8_star@FUNCTION, $pop[[L2]] -; CHECK-NEXT: i32.const $push[[L1:.+]]=, 0{{$}} -; CHECK-NEXT: i32.store __stack_pointer($pop[[L1]]), $[[FP]] +; CHECK-NEXT: get_local $push[[L5:.+]]=, [[FP]] +; CHECK-NEXT: set_global 0, $pop[[L5]] define void @frameaddress_0() { %t = call i8* @llvm.frameaddress(i32 0) call void @use_i8_star(i8* %t) @@ -321,7 +320,7 @@ define void @frameaddress_1() { ; Test a stack address passed to an inline asm. ; CHECK-LABEL: inline_asm: -; CHECK: __stack_pointer +; CHECK: get_global {{.+}}, 0{{$}} ; CHECK: #APP ; CHECK-NEXT: # %{{[0-9]+}}{{$}} ; CHECK-NEXT: #NO_APP diff --git a/test/CodeGen/WebAssembly/varargs.ll b/test/CodeGen/WebAssembly/varargs.ll index c77ed10c2584..3f04700131cc 100644 --- a/test/CodeGen/WebAssembly/varargs.ll +++ b/test/CodeGen/WebAssembly/varargs.ll @@ -1,9 +1,9 @@ -; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -verify-machineinstrs | FileCheck %s +; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-wasm-explicit-locals -verify-machineinstrs | FileCheck %s ; Test varargs constructs. target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" -target triple = "wasm32-unknown-unknown" +target triple = "wasm32-unknown-unknown-wasm" ; Test va_start. @@ -52,7 +52,6 @@ entry: ; CHECK-LABEL: arg_i8: ; CHECK-NEXT: .param i32{{$}} ; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: .local i32{{$}} ; CHECK-NEXT: i32.load $push[[NUM0:[0-9]+]]=, 0($0){{$}} ; CHECK-NEXT: tee_local $push[[NUM1:[0-9]+]]=, $1=, $pop[[NUM0]]{{$}} ; CHECK-NEXT: i32.const $push[[NUM2:[0-9]+]]=, 4{{$}} @@ -71,7 +70,6 @@ entry: ; CHECK-LABEL: arg_i32: ; CHECK-NEXT: .param i32{{$}} ; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: .local i32{{$}} ; CHECK-NEXT: i32.load $push[[NUM0:[0-9]+]]=, 0($0){{$}} ; CHECK-NEXT: i32.const $push[[NUM1:[0-9]+]]=, 3{{$}} ; CHECK-NEXT: i32.add $push[[NUM2:[0-9]+]]=, $pop[[NUM0]], $pop[[NUM1]]{{$}} @@ -93,7 +91,6 @@ entry: ; CHECK-LABEL: arg_i128: ; CHECK-NEXT: .param i32, i32{{$}} -; CHECK-NEXT: .local ; CHECK: i32.and ; CHECK: i64.load ; CHECK: i64.load @@ -123,8 +120,8 @@ define void @caller_none() { ; disabling it. ; CHECK-LABEL: caller_some -; CHECK: i32.store -; CHECK: i64.store +; CHECK-DAG: i32.store +; CHECK-DAG: i64.store define void @caller_some() { call void (...) @callee(i32 0, double 2.0) ret void diff --git a/test/CodeGen/WebAssembly/vtable.ll b/test/CodeGen/WebAssembly/vtable.ll index 739ba2aaf5a5..b39e7bc0f7f2 100644 --- a/test/CodeGen/WebAssembly/vtable.ll +++ b/test/CodeGen/WebAssembly/vtable.ll @@ -1,6 +1,6 @@ -; RUN: llc < %s -asm-verbose=false | FileCheck %s --check-prefix=TYPEINFONAME -; RUN: llc < %s -asm-verbose=false | FileCheck %s --check-prefix=VTABLE -; RUN: llc < %s -asm-verbose=false | FileCheck %s --check-prefix=TYPEINFO +; RUN: llc < %s -asm-verbose=false -disable-wasm-explicit-locals | FileCheck %s --check-prefix=TYPEINFONAME +; RUN: llc < %s -asm-verbose=false -disable-wasm-explicit-locals | FileCheck %s --check-prefix=VTABLE +; RUN: llc < %s -asm-verbose=false -disable-wasm-explicit-locals | FileCheck %s --check-prefix=TYPEINFO ; Test that simple vtables assemble as expected. ; @@ -12,7 +12,7 @@ ; Each with a virtual dtor and method foo. target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" -target triple = "wasm32-unknown-unknown" +target triple = "wasm32-unknown-unknown-wasm" %struct.A = type { i32 (...)** } %struct.B = type { %struct.A } @@ -36,7 +36,7 @@ target triple = "wasm32-unknown-unknown" @_ZTS1D = constant [3 x i8] c"1D\00" ; VTABLE: .type _ZTV1A,@object -; VTABLE-NEXT: .section .data.rel.ro,"aw",@progbits +; VTABLE-NEXT: .section .data.rel.ro._ZTV1A, ; VTABLE-NEXT: .globl _ZTV1A ; VTABLE-LABEL: _ZTV1A: ; VTABLE-NEXT: .int32 0 @@ -47,6 +47,7 @@ target triple = "wasm32-unknown-unknown" ; VTABLE-NEXT: .size _ZTV1A, 20 @_ZTV1A = constant [5 x i8*] [i8* null, i8* bitcast ({ i8*, i8* }* @_ZTI1A to i8*), i8* bitcast (%struct.A* (%struct.A*)* @_ZN1AD2Ev to i8*), i8* bitcast (void (%struct.A*)* @_ZN1AD0Ev to i8*), i8* bitcast (void (%struct.A*)* @_ZN1A3fooEv to i8*)], align 4 ; VTABLE: .type _ZTV1B,@object +; VTABLE-NEXT: .section .data.rel.ro._ZTV1B, ; VTABLE-NEXT: .globl _ZTV1B ; VTABLE-LABEL: _ZTV1B: ; VTABLE-NEXT: .int32 0 @@ -57,6 +58,7 @@ target triple = "wasm32-unknown-unknown" ; VTABLE-NEXT: .size _ZTV1B, 20 @_ZTV1B = constant [5 x i8*] [i8* null, i8* bitcast ({ i8*, i8*, i8* }* @_ZTI1B to i8*), i8* bitcast (%struct.A* (%struct.A*)* @_ZN1AD2Ev to i8*), i8* bitcast (void (%struct.B*)* @_ZN1BD0Ev to i8*), i8* bitcast (void (%struct.B*)* @_ZN1B3fooEv to i8*)], align 4 ; VTABLE: .type _ZTV1C,@object +; VTABLE-NEXT: .section .data.rel.ro._ZTV1C, ; VTABLE-NEXT: .globl _ZTV1C ; VTABLE-LABEL: _ZTV1C: ; VTABLE-NEXT: .int32 0 @@ -67,6 +69,7 @@ target triple = "wasm32-unknown-unknown" ; VTABLE-NEXT: .size _ZTV1C, 20 @_ZTV1C = constant [5 x i8*] [i8* null, i8* bitcast ({ i8*, i8*, i8* }* @_ZTI1C to i8*), i8* bitcast (%struct.A* (%struct.A*)* @_ZN1AD2Ev to i8*), i8* bitcast (void (%struct.C*)* @_ZN1CD0Ev to i8*), i8* bitcast (void (%struct.C*)* @_ZN1C3fooEv to i8*)], align 4 ; VTABLE: .type _ZTV1D,@object +; VTABLE-NEXT: .section .data.rel.ro._ZTV1D, ; VTABLE-NEXT: .globl _ZTV1D ; VTABLE-LABEL: _ZTV1D: ; VTABLE-NEXT: .int32 0 |