diff options
Diffstat (limited to 'test/CodeGen/WebAssembly')
69 files changed, 0 insertions, 10035 deletions
diff --git a/test/CodeGen/WebAssembly/address-offsets.ll b/test/CodeGen/WebAssembly/address-offsets.ll deleted file mode 100644 index da198978fc2f..000000000000 --- a/test/CodeGen/WebAssembly/address-offsets.ll +++ /dev/null @@ -1,676 +0,0 @@ -; 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-wasm" - -@g = external global [0 x i32], align 4 - -; CHECK-LABEL: load_test0: -; CHECK-NEXT: result i32{{$}} -; CHECK-NEXT: i32.const $push0=, 0{{$}} -; CHECK-NEXT: i32.load $push1=, g+40($pop0){{$}} -; CHECK-NEXT: return $pop1{{$}} -define i32 @load_test0() { - %t = load i32, i32* getelementptr inbounds ([0 x i32], [0 x i32]* @g, i32 0, i32 10), align 4 - ret i32 %t -} - -; CHECK-LABEL: load_test0_noinbounds: -; CHECK-NEXT: result i32{{$}} -; CHECK-NEXT: i32.const $push0=, 0{{$}} -; CHECK-NEXT: i32.load $push1=, g+40($pop0){{$}} -; CHECK-NEXT: return $pop1{{$}} -define i32 @load_test0_noinbounds() { - %t = load i32, i32* getelementptr ([0 x i32], [0 x i32]* @g, i32 0, i32 10), align 4 - ret i32 %t -} - -; TODO: load_test1 - load_test8 are disabled because folding GA+reg is disabled -; (there are cases where the value in the reg can be negative). -; Likewise for stores. - -; CHECK-LABEL: load_test1: -; CHECK-NEXT: param i32{{$}} -; CHECK-NEXT: result i32{{$}} -; CHECK-NEXT: i32.const $push0=, 2{{$}} -; CHECK-NEX T: i32.shl $push1=, $0, $pop0{{$}} -; CHECK-NEX T: i32.load $push2=, g+40($pop1){{$}} -; CHECK-NEX T: return $pop2{{$}} -define i32 @load_test1(i32 %n) { - %add = add nsw i32 %n, 10 - %arrayidx = getelementptr inbounds [0 x i32], [0 x i32]* @g, i32 0, i32 %add - %t = load i32, i32* %arrayidx, align 4 - ret i32 %t -} - -; CHECK-LABEL: load_test2: -; CHECK-NEXT: param i32{{$}} -; CHECK-NEXT: result i32{{$}} -; CHECK-NEXT: i32.const $push0=, 2{{$}} -; CHECK-NEX T: i32.shl $push1=, $0, $pop0{{$}} -; CHECK-NEX T: i32.load $push2=, g+40($pop1){{$}} -; CHECK-NEX T: return $pop2{{$}} -define i32 @load_test2(i32 %n) { - %add = add nsw i32 10, %n - %arrayidx = getelementptr inbounds [0 x i32], [0 x i32]* @g, i32 0, i32 %add - %t = load i32, i32* %arrayidx, align 4 - ret i32 %t -} - -; CHECK-LABEL: load_test3: -; CHECK-NEXT: param i32{{$}} -; CHECK-NEXT: result i32{{$}} -; CHECK-NEXT: i32.const $push0=, 2{{$}} -; CHECK-NEX T: i32.shl $push1=, $0, $pop0{{$}} -; CHECK-NEX T: i32.load $push2=, g+40($pop1){{$}} -; CHECK-NEX T: return $pop2{{$}} -define i32 @load_test3(i32 %n) { - %add.ptr = getelementptr inbounds [0 x i32], [0 x i32]* @g, i32 0, i32 %n - %add.ptr1 = getelementptr inbounds i32, i32* %add.ptr, i32 10 - %t = load i32, i32* %add.ptr1, align 4 - ret i32 %t -} - -; CHECK-LABEL: load_test4: -; CHECK-NEXT: param i32{{$}} -; CHECK-NEXT: result i32{{$}} -; CHECK-NEXT: i32.const $push0=, 2{{$}} -; CHECK-NEX T: i32.shl $push1=, $0, $pop0{{$}} -; CHECK-NEX T: i32.load $push2=, g+40($pop1){{$}} -; CHECK-NEX T: return $pop2{{$}} -define i32 @load_test4(i32 %n) { - %add.ptr = getelementptr inbounds i32, i32* getelementptr inbounds ([0 x i32], [0 x i32]* @g, i32 0, i32 10), i32 %n - %t = load i32, i32* %add.ptr, align 4 - ret i32 %t -} - -; CHECK-LABEL: load_test5: -; CHECK-NEXT: param i32{{$}} -; CHECK-NEXT: result i32{{$}} -; CHECK-NEXT: i32.const $push0=, 2{{$}} -; CHECK-NEX T: i32.shl $push1=, $0, $pop0{{$}} -; CHECK-NEX T: i32.load $push2=, g+40($pop1){{$}} -; CHECK-NEX T: return $pop2{{$}} -define i32 @load_test5(i32 %n) { - %add.ptr = getelementptr inbounds i32, i32* getelementptr inbounds ([0 x i32], [0 x i32]* @g, i32 0, i32 10), i32 %n - %t = load i32, i32* %add.ptr, align 4 - ret i32 %t -} - -; CHECK-LABEL: load_test6: -; CHECK-NEXT: param i32{{$}} -; CHECK-NEXT: result i32{{$}} -; CHECK-NEXT: i32.const $push0=, 2{{$}} -; CHECK-NEX T: i32.shl $push1=, $0, $pop0{{$}} -; CHECK-NEX T: i32.load $push2=, g+40($pop1){{$}} -; CHECK-NEX T: return $pop2{{$}} -define i32 @load_test6(i32 %n) { - %add = add nsw i32 %n, 10 - %add.ptr = getelementptr inbounds [0 x i32], [0 x i32]* @g, i32 0, i32 %add - %t = load i32, i32* %add.ptr, align 4 - ret i32 %t -} - -; CHECK-LABEL: load_test7: -; CHECK-NEXT: param i32{{$}} -; CHECK-NEXT: result i32{{$}} -; CHECK-NEXT: i32.const $push0=, 2{{$}} -; CHECK-NEX T: i32.shl $push1=, $0, $pop0{{$}} -; CHECK-NEX T: i32.load $push2=, g+40($pop1){{$}} -; CHECK-NEX T: return $pop2{{$}} -define i32 @load_test7(i32 %n) { - %add.ptr = getelementptr inbounds [0 x i32], [0 x i32]* @g, i32 0, i32 %n - %add.ptr1 = getelementptr inbounds i32, i32* %add.ptr, i32 10 - %t = load i32, i32* %add.ptr1, align 4 - ret i32 %t -} - -; CHECK-LABEL: load_test8: -; CHECK-NEXT: param i32{{$}} -; CHECK-NEXT: result i32{{$}} -; CHECK-NEXT: i32.const $push0=, 2{{$}} -; CHECK-NEX T: i32.shl $push1=, $0, $pop0{{$}} -; CHECK-NEX T: i32.load $push2=, g+40($pop1){{$}} -; CHECK-NEX T: return $pop2{{$}} -define i32 @load_test8(i32 %n) { - %add = add nsw i32 10, %n - %add.ptr = getelementptr inbounds [0 x i32], [0 x i32]* @g, i32 0, i32 %add - %t = load i32, i32* %add.ptr, align 4 - ret i32 %t -} - -; CHECK-LABEL: load_test9: -; CHECK-NEXT: result i32{{$}} -; CHECK-NEXT: i32.const $push0=, 0{{$}} -; CHECK-NEXT: i32.load $push1=, g-40($pop0){{$}} -; CHECK-NEXT: return $pop1{{$}} -define i32 @load_test9() { - %t = load i32, i32* getelementptr inbounds ([0 x i32], [0 x i32]* @g, i32 0, i32 1073741814), align 4 - ret i32 %t -} - -; CHECK-LABEL: load_test10: -; CHECK-NEXT: param i32{{$}} -; CHECK-NEXT: result i32{{$}} -; CHECK-NEXT: i32.const $push0=, 2{{$}} -; CHECK-NEXT: i32.shl $push1=, $0, $pop0{{$}} -; CHECK-NEXT: i32.const $push2=, g-40{{$}} -; CHECK-NEXT: i32.add $push3=, $pop1, $pop2{{$}} -; CHECK-NEXT: i32.load $push4=, 0($pop3){{$}} -; CHECK-NEXT: return $pop4{{$}} -define i32 @load_test10(i32 %n) { - %add = add nsw i32 %n, -10 - %arrayidx = getelementptr inbounds [0 x i32], [0 x i32]* @g, i32 0, i32 %add - %t = load i32, i32* %arrayidx, align 4 - ret i32 %t -} - -; CHECK-LABEL: load_test11: -; CHECK-NEXT: param i32{{$}} -; CHECK-NEXT: result i32{{$}} -; CHECK-NEXT: i32.load $push0=, 40($0){{$}} -; CHECK-NEXT: return $pop0{{$}} -define i32 @load_test11(i32* %p) { - %arrayidx = getelementptr inbounds i32, i32* %p, i32 10 - %t = load i32, i32* %arrayidx, align 4 - ret i32 %t -} - -; CHECK-LABEL: load_test11_noinbounds: -; CHECK-NEXT: param i32{{$}} -; CHECK-NEXT: result i32{{$}} -; CHECK-NEXT: i32.const $push0=, 40{{$}} -; CHECK-NEXT: i32.add $push1=, $0, $pop0{{$}} -; CHECK-NEXT: i32.load $push2=, 0($pop1){{$}} -; CHECK-NEXT: return $pop2{{$}} -define i32 @load_test11_noinbounds(i32* %p) { - %arrayidx = getelementptr i32, i32* %p, i32 10 - %t = load i32, i32* %arrayidx, align 4 - ret i32 %t -} - -; CHECK-LABEL: load_test12: -; CHECK-NEXT: param i32, i32{{$}} -; CHECK-NEXT: result i32{{$}} -; CHECK-NEXT: i32.const $push0=, 2{{$}} -; CHECK-NEXT: i32.shl $push1=, $1, $pop0{{$}} -; CHECK-NEXT: i32.add $push2=, $0, $pop1{{$}} -; CHECK-NEXT: i32.const $push3=, 40{{$}} -; CHECK-NEXT: i32.add $push4=, $pop2, $pop3{{$}} -; CHECK-NEXT: i32.load $push5=, 0($pop4){{$}} -; CHECK-NEXT: return $pop5{{$}} -define i32 @load_test12(i32* %p, i32 %n) { - %add = add nsw i32 %n, 10 - %arrayidx = getelementptr inbounds i32, i32* %p, i32 %add - %t = load i32, i32* %arrayidx, align 4 - ret i32 %t -} - -; CHECK-LABEL: load_test13: -; CHECK-NEXT: param i32, i32{{$}} -; CHECK-NEXT: result i32{{$}} -; CHECK-NEXT: i32.const $push0=, 2{{$}} -; CHECK-NEXT: i32.shl $push1=, $1, $pop0{{$}} -; CHECK-NEXT: i32.add $push2=, $0, $pop1{{$}} -; CHECK-NEXT: i32.const $push3=, 40{{$}} -; CHECK-NEXT: i32.add $push4=, $pop2, $pop3{{$}} -; CHECK-NEXT: i32.load $push5=, 0($pop4){{$}} -; CHECK-NEXT: return $pop5{{$}} -define i32 @load_test13(i32* %p, i32 %n) { - %add = add nsw i32 10, %n - %arrayidx = getelementptr inbounds i32, i32* %p, i32 %add - %t = load i32, i32* %arrayidx, align 4 - ret i32 %t -} - -; CHECK-LABEL: load_test14: -; CHECK-NEXT: param i32, i32{{$}} -; CHECK-NEXT: result i32{{$}} -; CHECK-NEXT: i32.const $push0=, 2{{$}} -; CHECK-NEXT: i32.shl $push1=, $1, $pop0{{$}} -; CHECK-NEXT: i32.add $push2=, $0, $pop1{{$}} -; CHECK-NEXT: i32.load $push3=, 40($pop2){{$}} -; CHECK-NEXT: return $pop3{{$}} -define i32 @load_test14(i32* %p, i32 %n) { - %add.ptr = getelementptr inbounds i32, i32* %p, i32 %n - %add.ptr1 = getelementptr inbounds i32, i32* %add.ptr, i32 10 - %t = load i32, i32* %add.ptr1, align 4 - ret i32 %t -} - -; CHECK-LABEL: load_test15: -; CHECK-NEXT: param i32, i32{{$}} -; CHECK-NEXT: result i32{{$}} -; CHECK-NEXT: i32.const $push0=, 2{{$}} -; CHECK-NEXT: i32.shl $push1=, $1, $pop0{{$}} -; CHECK-NEXT: i32.add $push2=, $0, $pop1{{$}} -; CHECK-NEXT: i32.const $push3=, 40{{$}} -; CHECK-NEXT: i32.add $push4=, $pop2, $pop3{{$}} -; CHECK-NEXT: i32.load $push5=, 0($pop4){{$}} -; CHECK-NEXT: return $pop5{{$}} -define i32 @load_test15(i32* %p, i32 %n) { - %add.ptr = getelementptr inbounds i32, i32* %p, i32 10 - %add.ptr1 = getelementptr inbounds i32, i32* %add.ptr, i32 %n - %t = load i32, i32* %add.ptr1, align 4 - ret i32 %t -} - -; CHECK-LABEL: load_test16: -; CHECK-NEXT: param i32, i32{{$}} -; CHECK-NEXT: result i32{{$}} -; CHECK-NEXT: i32.const $push0=, 2{{$}} -; CHECK-NEXT: i32.shl $push1=, $1, $pop0{{$}} -; CHECK-NEXT: i32.add $push2=, $0, $pop1{{$}} -; CHECK-NEXT: i32.const $push3=, 40{{$}} -; CHECK-NEXT: i32.add $push4=, $pop2, $pop3{{$}} -; CHECK-NEXT: i32.load $push5=, 0($pop4){{$}} -; CHECK-NEXT: return $pop5{{$}} -define i32 @load_test16(i32* %p, i32 %n) { - %add.ptr = getelementptr inbounds i32, i32* %p, i32 10 - %add.ptr1 = getelementptr inbounds i32, i32* %add.ptr, i32 %n - %t = load i32, i32* %add.ptr1, align 4 - ret i32 %t -} - -; CHECK-LABEL: load_test17: -; CHECK-NEXT: param i32, i32{{$}} -; CHECK-NEXT: result i32{{$}} -; CHECK-NEXT: i32.const $push0=, 2{{$}} -; CHECK-NEXT: i32.shl $push1=, $1, $pop0{{$}} -; CHECK-NEXT: i32.add $push2=, $0, $pop1{{$}} -; CHECK-NEXT: i32.const $push3=, 40{{$}} -; CHECK-NEXT: i32.add $push4=, $pop2, $pop3{{$}} -; CHECK-NEXT: i32.load $push5=, 0($pop4){{$}} -; CHECK-NEXT: return $pop5{{$}} -define i32 @load_test17(i32* %p, i32 %n) { - %add = add nsw i32 %n, 10 - %add.ptr = getelementptr inbounds i32, i32* %p, i32 %add - %t = load i32, i32* %add.ptr, align 4 - ret i32 %t -} - -; CHECK-LABEL: load_test18: -; CHECK-NEXT: param i32, i32{{$}} -; CHECK-NEXT: result i32{{$}} -; CHECK-NEXT: i32.const $push0=, 2{{$}} -; CHECK-NEXT: i32.shl $push1=, $1, $pop0{{$}} -; CHECK-NEXT: i32.add $push2=, $0, $pop1{{$}} -; CHECK-NEXT: i32.load $push3=, 40($pop2){{$}} -; CHECK-NEXT: return $pop3{{$}} -define i32 @load_test18(i32* %p, i32 %n) { - %add.ptr = getelementptr inbounds i32, i32* %p, i32 %n - %add.ptr1 = getelementptr inbounds i32, i32* %add.ptr, i32 10 - %t = load i32, i32* %add.ptr1, align 4 - ret i32 %t -} - -; CHECK-LABEL: load_test19: -; CHECK-NEXT: param i32, i32{{$}} -; CHECK-NEXT: result i32{{$}} -; CHECK-NEXT: i32.const $push0=, 2{{$}} -; CHECK-NEXT: i32.shl $push1=, $1, $pop0{{$}} -; CHECK-NEXT: i32.add $push2=, $0, $pop1{{$}} -; CHECK-NEXT: i32.const $push3=, 40{{$}} -; CHECK-NEXT: i32.add $push4=, $pop2, $pop3{{$}} -; CHECK-NEXT: i32.load $push5=, 0($pop4){{$}} -; CHECK-NEXT: return $pop5{{$}} -define i32 @load_test19(i32* %p, i32 %n) { - %add = add nsw i32 10, %n - %add.ptr = getelementptr inbounds i32, i32* %p, i32 %add - %t = load i32, i32* %add.ptr, align 4 - ret i32 %t -} - -; CHECK-LABEL: load_test20: -; CHECK-NEXT: param i32{{$}} -; CHECK-NEXT: result i32{{$}} -; CHECK-NEXT: i32.const $push0=, -40{{$}} -; CHECK-NEXT: i32.add $push1=, $0, $pop0{{$}} -; CHECK-NEXT: i32.load $push2=, 0($pop1){{$}} -; CHECK-NEXT: return $pop2{{$}} -define i32 @load_test20(i32* %p) { - %arrayidx = getelementptr inbounds i32, i32* %p, i32 -10 - %t = load i32, i32* %arrayidx, align 4 - ret i32 %t -} - -; CHECK-LABEL: load_test21: -; CHECK-NEXT: param i32, i32{{$}} -; CHECK-NEXT: result i32{{$}} -; CHECK-NEXT: i32.const $push0=, 2{{$}} -; CHECK-NEXT: i32.shl $push1=, $1, $pop0{{$}} -; CHECK-NEXT: i32.add $push2=, $0, $pop1{{$}} -; CHECK-NEXT: i32.const $push3=, -40{{$}} -; CHECK-NEXT: i32.add $push4=, $pop2, $pop3{{$}} -; CHECK-NEXT: i32.load $push5=, 0($pop4){{$}} -; CHECK-NEXT: return $pop5{{$}} -define i32 @load_test21(i32* %p, i32 %n) { - %add = add nsw i32 %n, -10 - %arrayidx = getelementptr inbounds i32, i32* %p, i32 %add - %t = load i32, i32* %arrayidx, align 4 - ret i32 %t -} - -; CHECK-LABEL: store_test0: -; CHECK-NEXT: param i32{{$}} -; CHECK-NEXT: i32.const $push0=, 0{{$}} -; CHECK-NEXT: i32.store g+40($pop0), $0{{$}} -; CHECK-NEXT: return{{$}} -define void @store_test0(i32 %i) { - store i32 %i, i32* getelementptr inbounds ([0 x i32], [0 x i32]* @g, i32 0, i32 10), align 4 - ret void -} - -; CHECK-LABEL: store_test0_noinbounds: -; CHECK-NEXT: param i32{{$}} -; CHECK-NEXT: i32.const $push0=, 0{{$}} -; CHECK-NEXT: i32.store g+40($pop0), $0{{$}} -; CHECK-NEXT: return{{$}} -define void @store_test0_noinbounds(i32 %i) { - store i32 %i, i32* getelementptr ([0 x i32], [0 x i32]* @g, i32 0, i32 10), align 4 - ret void -} - -; CHECK-LABEL: store_test1: -; CHECK-NEXT: param i32, i32{{$}} -; CHECK-NEXT: i32.const $push0=, 2{{$}} -; CHECK-NEXT: i32.shl $push1=, $0, $pop0{{$}} -; CHECK-NEX T: i32.store g+40($pop1), $1{{$}} -; CHECK-NEX T: return{{$}} -define void @store_test1(i32 %n, i32 %i) { - %add = add nsw i32 %n, 10 - %arrayidx = getelementptr inbounds [0 x i32], [0 x i32]* @g, i32 0, i32 %add - store i32 %i, i32* %arrayidx, align 4 - ret void -} - -; CHECK-LABEL: store_test2: -; CHECK-NEXT: param i32, i32{{$}} -; CHECK-NEXT: i32.const $push0=, 2{{$}} -; CHECK-NEXT: i32.shl $push1=, $0, $pop0{{$}} -; CHECK-NEX T: i32.store g+40($pop1), $1{{$}} -; CHECK-NEX T: return{{$}} -define void @store_test2(i32 %n, i32 %i) { - %add = add nsw i32 10, %n - %arrayidx = getelementptr inbounds [0 x i32], [0 x i32]* @g, i32 0, i32 %add - store i32 %i, i32* %arrayidx, align 4 - ret void -} - -; CHECK-LABEL: store_test3: -; CHECK-NEXT: param i32, i32{{$}} -; CHECK-NEXT: i32.const $push0=, 2{{$}} -; CHECK-NEXT: i32.shl $push1=, $0, $pop0{{$}} -; CHECK-NEX T: i32.store g+40($pop1), $1{{$}} -; CHECK-NEX T: return{{$}} -define void @store_test3(i32 %n, i32 %i) { - %add.ptr = getelementptr inbounds [0 x i32], [0 x i32]* @g, i32 0, i32 %n - %add.ptr1 = getelementptr inbounds i32, i32* %add.ptr, i32 10 - store i32 %i, i32* %add.ptr1, align 4 - ret void -} - -; CHECK-LABEL: store_test4: -; CHECK-NEXT: param i32, i32{{$}} -; CHECK-NEXT: i32.const $push0=, 2{{$}} -; CHECK-NEXT: i32.shl $push1=, $0, $pop0{{$}} -; CHECK-NEX T: i32.store g+40($pop1), $1{{$}} -; CHECK-NEX T: return{{$}} -define void @store_test4(i32 %n, i32 %i) { - %add.ptr = getelementptr inbounds i32, i32* getelementptr inbounds ([0 x i32], [0 x i32]* @g, i32 0, i32 10), i32 %n - store i32 %i, i32* %add.ptr, align 4 - ret void -} - -; CHECK-LABEL: store_test5: -; CHECK-NEXT: param i32, i32{{$}} -; CHECK-NEXT: i32.const $push0=, 2{{$}} -; CHECK-NEXT: i32.shl $push1=, $0, $pop0{{$}} -; CHECK-NEX T: i32.store g+40($pop1), $1{{$}} -; CHECK-NEX T: return{{$}} -define void @store_test5(i32 %n, i32 %i) { - %add.ptr = getelementptr inbounds i32, i32* getelementptr inbounds ([0 x i32], [0 x i32]* @g, i32 0, i32 10), i32 %n - store i32 %i, i32* %add.ptr, align 4 - ret void -} - -; CHECK-LABEL: store_test6: -; CHECK-NEXT: param i32, i32{{$}} -; CHECK-NEXT: i32.const $push0=, 2{{$}} -; CHECK-NEXT: i32.shl $push1=, $0, $pop0{{$}} -; CHECK-NEX T: i32.store g+40($pop1), $1{{$}} -; CHECK-NEX T: return{{$}} -define void @store_test6(i32 %n, i32 %i) { - %add = add nsw i32 %n, 10 - %add.ptr = getelementptr inbounds [0 x i32], [0 x i32]* @g, i32 0, i32 %add - store i32 %i, i32* %add.ptr, align 4 - ret void -} - -; CHECK-LABEL: store_test7: -; CHECK-NEXT: param i32, i32{{$}} -; CHECK-NEXT: i32.const $push0=, 2{{$}} -; CHECK-NEXT: i32.shl $push1=, $0, $pop0{{$}} -; CHECK-NEX T: i32.store g+40($pop1), $1{{$}} -; CHECK-NEX T: return{{$}} -define void @store_test7(i32 %n, i32 %i) { - %add.ptr = getelementptr inbounds [0 x i32], [0 x i32]* @g, i32 0, i32 %n - %add.ptr1 = getelementptr inbounds i32, i32* %add.ptr, i32 10 - store i32 %i, i32* %add.ptr1, align 4 - ret void -} - -; CHECK-LABEL: store_test8: -; CHECK-NEXT: param i32, i32{{$}} -; CHECK-NEXT: i32.const $push0=, 2{{$}} -; CHECK-NEXT: i32.shl $push1=, $0, $pop0{{$}} -; CHECK-NEX T: i32.store g+40($pop1), $1{{$}} -; CHECK-NEX T: return{{$}} -define void @store_test8(i32 %n, i32 %i) { - %add = add nsw i32 10, %n - %add.ptr = getelementptr inbounds [0 x i32], [0 x i32]* @g, i32 0, i32 %add - store i32 %i, i32* %add.ptr, align 4 - ret void -} - -; CHECK-LABEL: store_test9: -; CHECK-NEXT: param i32{{$}} -; CHECK-NEXT: i32.const $push0=, 0{{$}} -; CHECK-NEXT: i32.store g-40($pop0), $0{{$}} -; CHECK-NEXT: return{{$}} -define void @store_test9(i32 %i) { - store i32 %i, i32* getelementptr inbounds ([0 x i32], [0 x i32]* @g, i32 0, i32 1073741814), align 4 - ret void -} - -; CHECK-LABEL: store_test10: -; CHECK-NEXT: param i32, i32{{$}} -; CHECK-NEXT: i32.const $push0=, 2{{$}} -; CHECK-NEXT: i32.shl $push1=, $0, $pop0{{$}} -; CHECK-NEXT: i32.const $push2=, g-40{{$}} -; CHECK-NEXT: i32.add $push3=, $pop1, $pop2{{$}} -; CHECK-NEXT: i32.store 0($pop3), $1{{$}} -; CHECK-NEXT: return{{$}} -define void @store_test10(i32 %n, i32 %i) { - %add = add nsw i32 %n, -10 - %arrayidx = getelementptr inbounds [0 x i32], [0 x i32]* @g, i32 0, i32 %add - store i32 %i, i32* %arrayidx, align 4 - ret void -} - -; CHECK-LABEL: store_test11: -; CHECK-NEXT: param i32, i32{{$}} -; CHECK-NEXT: i32.store 40($0), $1{{$}} -; CHECK-NEXT: return{{$}} -define void @store_test11(i32* %p, i32 %i) { - %arrayidx = getelementptr inbounds i32, i32* %p, i32 10 - store i32 %i, i32* %arrayidx, align 4 - ret void -} - -; CHECK-LABEL: store_test11_noinbounds: -; CHECK-NEXT: param i32, i32{{$}} -; CHECK-NEXT: i32.const $push0=, 40{{$}} -; CHECK-NEXT: i32.add $push1=, $0, $pop0{{$}} -; CHECK-NEXT: i32.store 0($pop1), $1{{$}} -; CHECK-NEXT: return{{$}} -define void @store_test11_noinbounds(i32* %p, i32 %i) { - %arrayidx = getelementptr i32, i32* %p, i32 10 - store i32 %i, i32* %arrayidx, align 4 - ret void -} - -; CHECK-LABEL: store_test12: -; CHECK-NEXT: param i32, i32, i32{{$}} -; CHECK-NEXT: i32.const $push0=, 2{{$}} -; CHECK-NEXT: i32.shl $push1=, $1, $pop0{{$}} -; CHECK-NEXT: i32.add $push2=, $0, $pop1{{$}} -; CHECK-NEXT: i32.const $push3=, 40{{$}} -; CHECK-NEXT: i32.add $push4=, $pop2, $pop3{{$}} -; CHECK-NEXT: i32.store 0($pop4), $2{{$}} -; CHECK-NEXT: return{{$}} -define void @store_test12(i32* %p, i32 %n, i32 %i) { - %add = add nsw i32 %n, 10 - %arrayidx = getelementptr inbounds i32, i32* %p, i32 %add - store i32 %i, i32* %arrayidx, align 4 - ret void -} - -; CHECK-LABEL: store_test13: -; CHECK-NEXT: param i32, i32, i32{{$}} -; CHECK-NEXT: i32.const $push0=, 2{{$}} -; CHECK-NEXT: i32.shl $push1=, $1, $pop0{{$}} -; CHECK-NEXT: i32.add $push2=, $0, $pop1{{$}} -; CHECK-NEXT: i32.const $push3=, 40{{$}} -; CHECK-NEXT: i32.add $push4=, $pop2, $pop3{{$}} -; CHECK-NEXT: i32.store 0($pop4), $2{{$}} -; CHECK-NEXT: return{{$}} -define void @store_test13(i32* %p, i32 %n, i32 %i) { - %add = add nsw i32 10, %n - %arrayidx = getelementptr inbounds i32, i32* %p, i32 %add - store i32 %i, i32* %arrayidx, align 4 - ret void -} - -; CHECK-LABEL: store_test14: -; CHECK-NEXT: param i32, i32, i32{{$}} -; CHECK-NEXT: i32.const $push0=, 2{{$}} -; CHECK-NEXT: i32.shl $push1=, $1, $pop0{{$}} -; CHECK-NEXT: i32.add $push2=, $0, $pop1{{$}} -; CHECK-NEXT: i32.store 40($pop2), $2{{$}} -; CHECK-NEXT: return{{$}} -define void @store_test14(i32* %p, i32 %n, i32 %i) { - %add.ptr = getelementptr inbounds i32, i32* %p, i32 %n - %add.ptr1 = getelementptr inbounds i32, i32* %add.ptr, i32 10 - store i32 %i, i32* %add.ptr1, align 4 - ret void -} - -; CHECK-LABEL: store_test15: -; CHECK-NEXT: param i32, i32, i32{{$}} -; CHECK-NEXT: i32.const $push0=, 2{{$}} -; CHECK-NEXT: i32.shl $push1=, $1, $pop0{{$}} -; CHECK-NEXT: i32.add $push2=, $0, $pop1{{$}} -; CHECK-NEXT: i32.const $push3=, 40{{$}} -; CHECK-NEXT: i32.add $push4=, $pop2, $pop3{{$}} -; CHECK-NEXT: i32.store 0($pop4), $2{{$}} -; CHECK-NEXT: return{{$}} -define void @store_test15(i32* %p, i32 %n, i32 %i) { - %add.ptr = getelementptr inbounds i32, i32* %p, i32 10 - %add.ptr1 = getelementptr inbounds i32, i32* %add.ptr, i32 %n - store i32 %i, i32* %add.ptr1, align 4 - ret void -} - -; CHECK-LABEL: store_test16: -; CHECK-NEXT: param i32, i32, i32{{$}} -; CHECK-NEXT: i32.const $push0=, 2{{$}} -; CHECK-NEXT: i32.shl $push1=, $1, $pop0{{$}} -; CHECK-NEXT: i32.add $push2=, $0, $pop1{{$}} -; CHECK-NEXT: i32.const $push3=, 40{{$}} -; CHECK-NEXT: i32.add $push4=, $pop2, $pop3{{$}} -; CHECK-NEXT: i32.store 0($pop4), $2{{$}} -; CHECK-NEXT: return{{$}} -define void @store_test16(i32* %p, i32 %n, i32 %i) { - %add.ptr = getelementptr inbounds i32, i32* %p, i32 10 - %add.ptr1 = getelementptr inbounds i32, i32* %add.ptr, i32 %n - store i32 %i, i32* %add.ptr1, align 4 - ret void -} - -; CHECK-LABEL: store_test17: -; CHECK-NEXT: param i32, i32, i32{{$}} -; CHECK-NEXT: i32.const $push0=, 2{{$}} -; CHECK-NEXT: i32.shl $push1=, $1, $pop0{{$}} -; CHECK-NEXT: i32.add $push2=, $0, $pop1{{$}} -; CHECK-NEXT: i32.const $push3=, 40{{$}} -; CHECK-NEXT: i32.add $push4=, $pop2, $pop3{{$}} -; CHECK-NEXT: i32.store 0($pop4), $2{{$}} -; CHECK-NEXT: return{{$}} -define void @store_test17(i32* %p, i32 %n, i32 %i) { - %add = add nsw i32 %n, 10 - %add.ptr = getelementptr inbounds i32, i32* %p, i32 %add - store i32 %i, i32* %add.ptr, align 4 - ret void -} - -; CHECK-LABEL: store_test18: -; CHECK-NEXT: param i32, i32, i32{{$}} -; CHECK-NEXT: i32.const $push0=, 2{{$}} -; CHECK-NEXT: i32.shl $push1=, $1, $pop0{{$}} -; CHECK-NEXT: i32.add $push2=, $0, $pop1{{$}} -; CHECK-NEXT: i32.store 40($pop2), $2{{$}} -; CHECK-NEXT: return{{$}} -define void @store_test18(i32* %p, i32 %n, i32 %i) { - %add.ptr = getelementptr inbounds i32, i32* %p, i32 %n - %add.ptr1 = getelementptr inbounds i32, i32* %add.ptr, i32 10 - store i32 %i, i32* %add.ptr1, align 4 - ret void -} - -; CHECK-LABEL: store_test19: -; CHECK-NEXT: param i32, i32, i32{{$}} -; CHECK-NEXT: i32.const $push0=, 2{{$}} -; CHECK-NEXT: i32.shl $push1=, $1, $pop0{{$}} -; CHECK-NEXT: i32.add $push2=, $0, $pop1{{$}} -; CHECK-NEXT: i32.const $push3=, 40{{$}} -; CHECK-NEXT: i32.add $push4=, $pop2, $pop3{{$}} -; CHECK-NEXT: i32.store 0($pop4), $2{{$}} -; CHECK-NEXT: return{{$}} -define void @store_test19(i32* %p, i32 %n, i32 %i) { - %add = add nsw i32 10, %n - %add.ptr = getelementptr inbounds i32, i32* %p, i32 %add - store i32 %i, i32* %add.ptr, align 4 - ret void -} - -; CHECK-LABEL: store_test20: -; CHECK-NEXT: param i32, i32{{$}} -; CHECK-NEXT: i32.const $push0=, -40{{$}} -; CHECK-NEXT: i32.add $push1=, $0, $pop0{{$}} -; CHECK-NEXT: i32.store 0($pop1), $1{{$}} -; CHECK-NEXT: return{{$}} -define void @store_test20(i32* %p, i32 %i) { - %arrayidx = getelementptr inbounds i32, i32* %p, i32 -10 - store i32 %i, i32* %arrayidx, align 4 - ret void -} - -; CHECK-LABEL: store_test21: -; CHECK-NEXT: param i32, i32, i32{{$}} -; CHECK-NEXT: i32.const $push0=, 2{{$}} -; CHECK-NEXT: i32.shl $push1=, $1, $pop0{{$}} -; CHECK-NEXT: i32.add $push2=, $0, $pop1{{$}} -; CHECK-NEXT: i32.const $push3=, -40{{$}} -; CHECK-NEXT: i32.add $push4=, $pop2, $pop3{{$}} -; CHECK-NEXT: i32.store 0($pop4), $2{{$}} -; CHECK-NEXT: return{{$}} -define void @store_test21(i32* %p, i32 %n, i32 %i) { - %add = add nsw i32 %n, -10 - %arrayidx = getelementptr inbounds i32, i32* %p, i32 %add - store i32 %i, i32* %arrayidx, align 4 - ret void -} diff --git a/test/CodeGen/WebAssembly/byval.ll b/test/CodeGen/WebAssembly/byval.ll deleted file mode 100644 index 907320d7977c..000000000000 --- a/test/CodeGen/WebAssembly/byval.ll +++ /dev/null @@ -1,127 +0,0 @@ -; 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-wasm" - -%SmallStruct = type { i32 } -%OddStruct = type { i32, i8, i32 } -%AlignedStruct = type { double, double } -%BigStruct = type { double, double, double, double, double, double, double, double, double, double, double, i8, i8, i8 } -%EmptyStruct = type { } - -%BigArray = type { [33 x i8] } - -declare void @ext_func(%SmallStruct*) -declare void @ext_func_empty(%EmptyStruct* byval) -declare void @ext_byval_func(%SmallStruct* byval) -declare void @ext_byval_func_align8(%SmallStruct* byval align 8) -declare void @ext_byval_func_alignedstruct(%AlignedStruct* byval) -declare void @ext_byval_func_bigarray(%BigArray* byval) -declare void @ext_byval_func_empty(%EmptyStruct* byval) - -; CHECK-LABEL: byval_arg -define void @byval_arg(%SmallStruct* %ptr) { - ; CHECK: .param i32 - ; Subtract 16 from SP (SP is 16-byte aligned) - ; 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: 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]] - ; Pass a pointer to the stack slot to the function - ; CHECK-NEXT: i32.const $push[[L5:.+]]=, 12{{$}} - ; CHECK-NEXT: i32.add $push[[ARG:.+]]=, $[[SP]], $pop[[L5]]{{$}} - ; 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[[L6:.+]]=, 16 - ; CHECK-NEXT: i32.add $push[[L8:.+]]=, $[[SP]], $pop[[L6]] - ; CHECK-NEXT: set_global 0, $pop[[L8]] - ; CHECK-NEXT: return - ret void -} - -; CHECK-LABEL: byval_arg_align8 -define void @byval_arg_align8(%SmallStruct* %ptr) { - ; CHECK: .param i32 - ; Don't check the entire SP sequence, just enough to get the alignment. - ; 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: 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]]{{$}} - ; Pass a pointer to the stack slot to the function - ; CHECK-NEXT: i32.const $push[[L5:.+]]=, 8{{$}} - ; CHECK-NEXT: i32.add $push[[ARG:.+]]=, $[[SP]], $pop[[L5]]{{$}} - ; CHECK-NEXT: call ext_byval_func_align8@FUNCTION, $pop[[ARG]]{{$}} - call void @ext_byval_func_align8(%SmallStruct* byval align 8 %ptr) - ret void -} - -; CHECK-LABEL: byval_arg_double -define void @byval_arg_double(%AlignedStruct* %ptr) { - ; CHECK: .param i32 - ; Subtract 16 from SP (SP is 16-byte aligned) - ; 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: 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) - ; CHECK-NEXT: i64.store 0($[[SP]]), $pop[[L4]] - ; Pass a pointer to the stack slot to the function - ; CHECK-NEXT: call ext_byval_func_alignedstruct@FUNCTION, $[[SP]] - tail call void @ext_byval_func_alignedstruct(%AlignedStruct* byval %ptr) - ret void -} - -; CHECK-LABEL: byval_param -define void @byval_param(%SmallStruct* byval align 32 %ptr) { - ; CHECK: .param i32 - ; %ptr is just a pointer to a struct, so pass it directly through - ; CHECK: call ext_func@FUNCTION, $0 - call void @ext_func(%SmallStruct* %ptr) - ret void -} - -; CHECK-LABEL: byval_empty_caller -define void @byval_empty_caller(%EmptyStruct* %ptr) { - ; CHECK: .param i32 - ; CHECK: call ext_byval_func_empty@FUNCTION, $0 - call void @ext_byval_func_empty(%EmptyStruct* byval %ptr) - ret void -} - -; CHECK-LABEL: byval_empty_callee -define void @byval_empty_callee(%EmptyStruct* byval %ptr) { - ; CHECK: .param i32 - ; CHECK: call ext_func_empty@FUNCTION, $0 - call void @ext_func_empty(%EmptyStruct* %ptr) - ret void -} - -; Call memcpy for "big" byvals. -; CHECK-LABEL: big_byval: -; 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: 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]]{{$}} -; CHECK-NEXT: call big_byval_callee@FUNCTION, -%big = type [131072 x i8] -declare void @big_byval_callee(%big* byval align 1) -define void @big_byval(%big* byval align 1 %x) { - call void @big_byval_callee(%big* byval align 1 %x) - ret void -} diff --git a/test/CodeGen/WebAssembly/call.ll b/test/CodeGen/WebAssembly/call.ll deleted file mode 100644 index 1cf42242a6cc..000000000000 --- a/test/CodeGen/WebAssembly/call.ll +++ /dev/null @@ -1,157 +0,0 @@ -; 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 - -; 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-wasm" - -declare i32 @i32_nullary() -declare i32 @i32_unary(i32) -declare i32 @i32_binary(i32, i32) -declare i64 @i64_nullary() -declare float @float_nullary() -declare double @double_nullary() -declare void @void_nullary() - -; CHECK-LABEL: call_i32_nullary: -; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: {{^}} i32.call $push[[NUM:[0-9]+]]=, i32_nullary@FUNCTION{{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define i32 @call_i32_nullary() { - %r = call i32 @i32_nullary() - ret i32 %r -} - -; CHECK-LABEL: call_i64_nullary: -; CHECK-NEXT: .result i64{{$}} -; CHECK-NEXT: {{^}} i64.call $push[[NUM:[0-9]+]]=, i64_nullary@FUNCTION{{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define i64 @call_i64_nullary() { - %r = call i64 @i64_nullary() - ret i64 %r -} - -; CHECK-LABEL: call_float_nullary: -; CHECK-NEXT: .result f32{{$}} -; CHECK-NEXT: {{^}} f32.call $push[[NUM:[0-9]+]]=, float_nullary@FUNCTION{{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define float @call_float_nullary() { - %r = call float @float_nullary() - ret float %r -} - -; CHECK-LABEL: call_double_nullary: -; CHECK-NEXT: .result f64{{$}} -; CHECK-NEXT: {{^}} f64.call $push[[NUM:[0-9]+]]=, double_nullary@FUNCTION{{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define double @call_double_nullary() { - %r = call double @double_nullary() - ret double %r -} - -; CHECK-LABEL: call_void_nullary: -; CHECK-NEXT: {{^}} call void_nullary@FUNCTION{{$}} -; CHECK-NEXT: return{{$}} -define void @call_void_nullary() { - call void @void_nullary() - ret void -} - -; CHECK-LABEL: call_i32_unary: -; CHECK-NEXT: .param i32{{$}} -; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: 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) - ret i32 %r -} - -; CHECK-LABEL: call_i32_binary: -; CHECK-NEXT: .param i32, i32{{$}} -; CHECK-NEXT: .result i32{{$}} -; 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) - ret i32 %r -} - -; CHECK-LABEL: call_indirect_void: -; CHECK-NEXT: .param i32{{$}} -; 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() - ret void -} - -; CHECK-LABEL: call_indirect_i32: -; CHECK-NEXT: .param i32{{$}} -; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: {{^}} i32.call_indirect $push[[NUM:[0-9]+]]=, $pop[[L0]]{{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define i32 @call_indirect_i32(i32 ()* %callee) { - %t = call i32 %callee() - ret i32 %t -} - -; CHECK-LABEL: call_indirect_arg: -; CHECK-NEXT: .param i32, i32{{$}} -; CHECK-NEXT: get_local $push[[L0:[0-9]+]]=, 1{{$}} -; CHECK-NEXT: get_local $push[[L1:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: {{^}} call_indirect $pop[[L0]], $pop[[L1]]{{$}} -; CHECK-NEXT: return{{$}} -define void @call_indirect_arg(void (i32)* %callee, i32 %arg) { - call void %callee(i32 %arg) - ret void -} - -; CHECK-LABEL: call_indirect_arg_2: -; CHECK-NEXT: .param i32, i32, i32{{$}} -; 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) - ret void -} - -; CHECK-LABEL: tail_call_void_nullary: -; CHECK-NEXT: {{^}} call void_nullary@FUNCTION{{$}} -; CHECK-NEXT: return{{$}} -define void @tail_call_void_nullary() { - tail call void @void_nullary() - ret void -} - -; CHECK-LABEL: fastcc_tail_call_void_nullary: -; CHECK-NEXT: {{^}} call void_nullary@FUNCTION{{$}} -; CHECK-NEXT: return{{$}} -define void @fastcc_tail_call_void_nullary() { - tail call fastcc void @void_nullary() - ret void -} - -; CHECK-LABEL: coldcc_tail_call_void_nullary: -; CHECK-NEXT: {{^}} call void_nullary@FUNCTION{{$}} -; CHECK-NEXT: return{{$}} -define void @coldcc_tail_call_void_nullary() { - tail call coldcc void @void_nullary() - ret void -} - -; TODO: test the following: -; - More argument combinations. -; - Tail call. -; - Interesting returns (struct, multiple). -; - Vararg. diff --git a/test/CodeGen/WebAssembly/cfg-stackify.ll b/test/CodeGen/WebAssembly/cfg-stackify.ll deleted file mode 100644 index ae6dd7a34ef8..000000000000 --- a/test/CodeGen/WebAssembly/cfg-stackify.ll +++ /dev/null @@ -1,1334 +0,0 @@ -; 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. - -; Explicitly disable fast-isel, since it gets implicitly enabled in the -; optnone test. - -target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" -target triple = "wasm32-unknown-unknown-wasm" - -declare void @something() - -; Test that loops are made contiguous, even in the presence of split backedges. - -; CHECK-LABEL: test0: -; CHECK: loop -; CHECK-NEXT: block -; CHECK: i32.lt_s -; CHECK-NEXT: br_if -; CHECK-NEXT: return -; CHECK-NEXT: .LBB0_3: -; CHECK-NEXT: end_block -; CHECK-NEXT: i32.const -; CHECK-NEXT: i32.add -; CHECK-NEXT: call -; CHECK-NEXT: br -; CHECK-NEXT: .LBB0_4: -; CHECK-NEXT: end_loop -; OPT-LABEL: test0: -; OPT: loop -; OPT: i32.ge_s -; OPT-NEXT: br_if -; OPT-NEXT: i32.const -; OPT-NEXT: i32.add -; OPT-NOT: br -; OPT: call -; OPT: br 0{{$}} -; OPT: return{{$}} -define void @test0(i32 %n) { -entry: - br label %header - -header: - %i = phi i32 [ 0, %entry ], [ %i.next, %back ] - %i.next = add i32 %i, 1 - - %c = icmp slt i32 %i.next, %n - br i1 %c, label %back, label %exit - -exit: - ret void - -back: - call void @something() - br label %header -} - -; Same as test0, but the branch condition is reversed. - -; CHECK-LABEL: test1: -; CHECK: loop -; CHECK-NEXT: block -; CHECK: i32.lt_s -; CHECK-NEXT: br_if -; CHECK-NEXT: return -; CHECK-NEXT: .LBB1_3: -; CHECK-NEXT: end_block -; CHECK-NEXT: i32.const -; CHECK-NEXT: i32.add -; CHECK-NEXT: call -; CHECK-NEXT: br -; CHECK-NEXT: .LBB1_4: -; CHECK-NEXT: end_loop -; OPT-LABEL: test1: -; OPT: loop -; OPT: i32.ge_s -; OPT-NEXT: br_if -; OPT-NEXT: i32.const -; OPT-NEXT: i32.add -; OPT-NOT: br -; OPT: call -; OPT: br 0{{$}} -; OPT: return{{$}} -define void @test1(i32 %n) { -entry: - br label %header - -header: - %i = phi i32 [ 0, %entry ], [ %i.next, %back ] - %i.next = add i32 %i, 1 - - %c = icmp sge i32 %i.next, %n - br i1 %c, label %exit, label %back - -exit: - ret void - -back: - call void @something() - br label %header -} - -; Test that a simple loop is handled as expected. - -; CHECK-LABEL: test2: -; CHECK-NOT: local -; CHECK: block {{$}} -; CHECK: br_if 0, {{[^,]+}}{{$}} -; CHECK: .LBB2_{{[0-9]+}}: -; CHECK: loop -; CHECK: br_if 0, $pop{{[0-9]+}}{{$}} -; CHECK: .LBB2_{{[0-9]+}}: -; CHECK: end_loop -; CHECK: end_block -; CHECK: return{{$}} -; OPT-LABEL: test2: -; OPT-NOT: local -; OPT: block {{$}} -; OPT: br_if 0, {{[^,]+}}{{$}} -; OPT: .LBB2_{{[0-9]+}}: -; OPT: loop -; OPT: br_if 0, $pop{{[0-9]+}}{{$}} -; OPT: .LBB2_{{[0-9]+}}: -; OPT: end_loop -; OPT: end_block -; OPT: return{{$}} -define void @test2(double* nocapture %p, i32 %n) { -entry: - %cmp.4 = icmp sgt i32 %n, 0 - br i1 %cmp.4, label %for.body.preheader, label %for.end - -for.body.preheader: - br label %for.body - -for.body: - %i.05 = phi i32 [ %inc, %for.body ], [ 0, %for.body.preheader ] - %arrayidx = getelementptr inbounds double, double* %p, i32 %i.05 - %0 = load double, double* %arrayidx, align 8 - %mul = fmul double %0, 3.200000e+00 - store double %mul, double* %arrayidx, align 8 - %inc = add nuw nsw i32 %i.05, 1 - %exitcond = icmp eq i32 %inc, %n - br i1 %exitcond, label %for.end.loopexit, label %for.body - -for.end.loopexit: - br label %for.end - -for.end: - ret void -} - -; CHECK-LABEL: doublediamond: -; CHECK: block {{$}} -; CHECK-NEXT: block {{$}} -; CHECK: br_if 0, ${{[^,]+}}{{$}} -; CHECK: br 1{{$}} -; CHECK: .LBB3_2: -; CHECK-NEXT: end_block{{$}} -; CHECK: block {{$}} -; CHECK: br_if 0, ${{[^,]+}}{{$}} -; CHECK: br 1{{$}} -; CHECK: .LBB3_4: -; CHECK-NEXT: end_block{{$}} -; CHECK: .LBB3_5: -; CHECK-NEXT: end_block{{$}} -; CHECK: i32.const $push{{[0-9]+}}=, 0{{$}} -; CHECK-NEXT: return $pop{{[0-9]+}}{{$}} -; OPT-LABEL: doublediamond: -; OPT: block {{$}} -; OPT-NEXT: block {{$}} -; OPT-NEXT: block {{$}} -; OPT: br_if 0, ${{[^,]+}}{{$}} -; OPT: br_if 1, ${{[^,]+}}{{$}} -; OPT: br 2{{$}} -; OPT-NEXT: .LBB3_3: -; OPT-NEXT: end_block -; OPT: br 1{{$}} -; OPT-NEXT: .LBB3_4: -; OPT: .LBB3_5: -; OPT-NEXT: end_block -; OPT: return $pop{{[0-9]+}}{{$}} -define i32 @doublediamond(i32 %a, i32 %b, i32* %p) { -entry: - %c = icmp eq i32 %a, 0 - %d = icmp eq i32 %b, 0 - store volatile i32 0, i32* %p - br i1 %c, label %true, label %false -true: - store volatile i32 1, i32* %p - br label %exit -false: - store volatile i32 2, i32* %p - br i1 %d, label %ft, label %ff -ft: - store volatile i32 3, i32* %p - br label %exit -ff: - store volatile i32 4, i32* %p - br label %exit -exit: - store volatile i32 5, i32* %p - ret i32 0 -} - -; CHECK-LABEL: triangle: -; CHECK: block {{$}} -; CHECK: br_if 0, $1{{$}} -; CHECK: .LBB4_2: -; CHECK: return -; OPT-LABEL: triangle: -; OPT: block {{$}} -; OPT: br_if 0, $1{{$}} -; OPT: .LBB4_2: -; OPT: return -define i32 @triangle(i32* %p, i32 %a) { -entry: - %c = icmp eq i32 %a, 0 - store volatile i32 0, i32* %p - br i1 %c, label %true, label %exit -true: - store volatile i32 1, i32* %p - br label %exit -exit: - store volatile i32 2, i32* %p - ret i32 0 -} - -; CHECK-LABEL: diamond: -; CHECK: block {{$}} -; CHECK: block {{$}} -; CHECK: br_if 0, $1{{$}} -; CHECK: br 1{{$}} -; CHECK: .LBB5_2: -; CHECK: .LBB5_3: -; CHECK: i32.const $push{{[0-9]+}}=, 0{{$}} -; CHECK-NEXT: return $pop{{[0-9]+}}{{$}} -; OPT-LABEL: diamond: -; OPT: block {{$}} -; OPT: block {{$}} -; OPT: br_if 0, {{[^,]+}}{{$}} -; OPT: br 1{{$}} -; OPT: .LBB5_2: -; OPT: .LBB5_3: -; OPT: i32.const $push{{[0-9]+}}=, 0{{$}} -; OPT-NEXT: return $pop{{[0-9]+}}{{$}} -define i32 @diamond(i32* %p, i32 %a) { -entry: - %c = icmp eq i32 %a, 0 - store volatile i32 0, i32* %p - br i1 %c, label %true, label %false -true: - store volatile i32 1, i32* %p - br label %exit -false: - store volatile i32 2, i32* %p - br label %exit -exit: - store volatile i32 3, i32* %p - ret i32 0 -} - -; CHECK-LABEL: single_block: -; CHECK-NOT: br -; CHECK: return $pop{{[0-9]+}}{{$}} -; OPT-LABEL: single_block: -; OPT-NOT: br -; OPT: return $pop{{[0-9]+}}{{$}} -define i32 @single_block(i32* %p) { -entry: - store volatile i32 0, i32* %p - ret i32 0 -} - -; CHECK-LABEL: minimal_loop: -; CHECK-NOT: br -; CHECK: .LBB7_1: -; CHECK: loop i32 -; CHECK: i32.store 0($0), $pop{{[0-9]+}}{{$}} -; CHECK: br 0{{$}} -; CHECK: .LBB7_2: -; OPT-LABEL: minimal_loop: -; OPT-NOT: br -; OPT: .LBB7_1: -; OPT: loop i32 -; OPT: i32.store 0($0), $pop{{[0-9]+}}{{$}} -; OPT: br 0{{$}} -; OPT: .LBB7_2: -define i32 @minimal_loop(i32* %p) { -entry: - store volatile i32 0, i32* %p - br label %loop -loop: - store volatile i32 1, i32* %p - br label %loop -} - -; CHECK-LABEL: simple_loop: -; CHECK-NOT: br -; CHECK: .LBB8_1: -; CHECK: loop {{$}} -; CHECK: br_if 0, $pop{{[0-9]+}}{{$}} -; CHECK-NEXT: end_loop{{$}} -; CHECK: i32.const $push{{[0-9]+}}=, 0{{$}} -; CHECK-NEXT: return $pop{{[0-9]+}}{{$}} -; OPT-LABEL: simple_loop: -; OPT-NOT: br -; OPT: .LBB8_1: -; OPT: loop {{$}} -; OPT: br_if 0, {{[^,]+}}{{$}} -; OPT-NEXT: end_loop{{$}} -; OPT: i32.const $push{{[0-9]+}}=, 0{{$}} -; OPT-NEXT: return $pop{{[0-9]+}}{{$}} -define i32 @simple_loop(i32* %p, i32 %a) { -entry: - %c = icmp eq i32 %a, 0 - store volatile i32 0, i32* %p - br label %loop -loop: - store volatile i32 1, i32* %p - br i1 %c, label %loop, label %exit -exit: - store volatile i32 2, i32* %p - ret i32 0 -} - -; CHECK-LABEL: doubletriangle: -; CHECK: block {{$}} -; CHECK: br_if 0, $0{{$}} -; CHECK: block {{$}} -; CHECK: br_if 0, $1{{$}} -; CHECK: .LBB9_3: -; CHECK: .LBB9_4: -; CHECK: return -; OPT-LABEL: doubletriangle: -; OPT: block {{$}} -; OPT: br_if 0, $0{{$}} -; OPT: block {{$}} -; OPT: br_if 0, $1{{$}} -; OPT: .LBB9_3: -; OPT: .LBB9_4: -; OPT: return -define i32 @doubletriangle(i32 %a, i32 %b, i32* %p) { -entry: - %c = icmp eq i32 %a, 0 - %d = icmp eq i32 %b, 0 - store volatile i32 0, i32* %p - br i1 %c, label %true, label %exit -true: - store volatile i32 2, i32* %p - br i1 %d, label %tt, label %tf -tt: - store volatile i32 3, i32* %p - br label %tf -tf: - store volatile i32 4, i32* %p - br label %exit -exit: - store volatile i32 5, i32* %p - ret i32 0 -} - -; CHECK-LABEL: ifelse_earlyexits: -; CHECK: block {{$}} -; CHECK: block {{$}} -; CHECK: br_if 0, $0{{$}} -; CHECK: br 1{{$}} -; CHECK: .LBB10_2: -; CHECK: br_if 0, $1{{$}} -; CHECK: .LBB10_4: -; CHECK: i32.const $push{{[0-9]+}}=, 0{{$}} -; CHECK-NEXT: return $pop{{[0-9]+}}{{$}} -; OPT-LABEL: ifelse_earlyexits: -; OPT: block {{$}} -; OPT: block {{$}} -; OPT: br_if 0, {{[^,]+}}{{$}} -; OPT: br_if 1, $1{{$}} -; OPT: br 1{{$}} -; OPT: .LBB10_3: -; OPT: .LBB10_4: -; OPT: i32.const $push{{[0-9]+}}=, 0{{$}} -; OPT-NEXT: return $pop{{[0-9]+}}{{$}} -define i32 @ifelse_earlyexits(i32 %a, i32 %b, i32* %p) { -entry: - %c = icmp eq i32 %a, 0 - %d = icmp eq i32 %b, 0 - store volatile i32 0, i32* %p - br i1 %c, label %true, label %false -true: - store volatile i32 1, i32* %p - br label %exit -false: - store volatile i32 2, i32* %p - br i1 %d, label %ft, label %exit -ft: - store volatile i32 3, i32* %p - br label %exit -exit: - store volatile i32 4, i32* %p - ret i32 0 -} - -; CHECK-LABEL: doublediamond_in_a_loop: -; CHECK: .LBB11_1: -; CHECK: loop i32{{$}} -; CHECK: block {{$}} -; CHECK: br_if 0, $0{{$}} -; CHECK: br 1{{$}} -; CHECK: .LBB11_3: -; CHECK: end_block{{$}} -; CHECK: block {{$}} -; CHECK: br_if 0, $1{{$}} -; CHECK: br 1{{$}} -; CHECK: .LBB11_5: -; CHECK: br 0{{$}} -; CHECK: .LBB11_6: -; CHECK-NEXT: end_loop{{$}} -; OPT-LABEL: doublediamond_in_a_loop: -; OPT: .LBB11_1: -; OPT: loop i32{{$}} -; OPT: block {{$}} -; OPT: br_if 0, {{[^,]+}}{{$}} -; OPT: block {{$}} -; OPT: br_if 0, {{[^,]+}}{{$}} -; OPT: br 2{{$}} -; OPT-NEXT: .LBB11_4: -; OPT-NEXT: end_block{{$}} -; OPT: br 1{{$}} -; OPT: .LBB11_5: -; OPT-NEXT: end_block{{$}} -; OPT: br 0{{$}} -; OPT: .LBB11_6: -; OPT-NEXT: end_loop{{$}} -define i32 @doublediamond_in_a_loop(i32 %a, i32 %b, i32* %p) { -entry: - br label %header -header: - %c = icmp eq i32 %a, 0 - %d = icmp eq i32 %b, 0 - store volatile i32 0, i32* %p - br i1 %c, label %true, label %false -true: - store volatile i32 1, i32* %p - br label %exit -false: - store volatile i32 2, i32* %p - br i1 %d, label %ft, label %ff -ft: - store volatile i32 3, i32* %p - br label %exit -ff: - store volatile i32 4, i32* %p - br label %exit -exit: - store volatile i32 5, i32* %p - br label %header -} - -; Test that nested loops are handled. - -; CHECK-LABEL: test3: -; CHECK: loop -; CHECK-NEXT: br_if -; CHECK-NEXT: .LBB{{[0-9]+}}_{{[0-9]+}}: -; CHECK-NEXT: loop -; OPT-LABEL: test3: -; OPT: block -; OPT: br_if -; OPT: .LBB{{[0-9]+}}_{{[0-9]+}}: -; OPT-NEXT: loop -; OPT-NEXT: block -; OPT-NEXT: block -; OPT-NEXT: br_if -; OPT-NEXT: .LBB{{[0-9]+}}_{{[0-9]+}}: -; OPT-NEXT: loop -; OPT: br_if -; OPT-NEXT: br -; OPT-NEXT: .LBB{{[0-9]+}}_{{[0-9]+}}: -; OPT-NEXT: end_loop -; OPT-NEXT: end_block -; OPT-NEXT: unreachable -; OPT-NEXT: .LBB{{[0-9]+}}_{{[0-9]+}}: -; OPT-NEXT: end_block -; OPT: br -; OPT-NEXT: .LBB{{[0-9]+}}_{{[0-9]+}}: -; OPT-NEXT: end_loop -declare void @bar() -define void @test3(i32 %w) { -entry: - br i1 undef, label %outer.ph, label %exit - -outer.ph: - br label %outer - -outer: - %tobool = icmp eq i32 undef, 0 - br i1 %tobool, label %inner, label %unreachable - -unreachable: - unreachable - -inner: - %c = icmp eq i32 undef, %w - br i1 %c, label %if.end, label %inner - -exit: - ret void - -if.end: - call void @bar() - br label %outer -} - -; Test switch lowering and block placement. - -; CHECK-LABEL: test4: -; CHECK-NEXT: .param i32{{$}} -; CHECK: block {{$}} -; CHECK-NEXT: block {{$}} -; CHECK: br_if 0, $pop{{[0-9]+}}{{$}} -; CHECK: br_if 1, $pop{{[0-9]+}}{{$}} -; CHECK: br 1{{$}} -; CHECK-NEXT: .LBB13_3: -; CHECK-NEXT: end_block{{$}} -; CHECK-NEXT: block {{$}} -; CHECK: br_if 0, $pop{{[0-9]+}}{{$}} -; CHECK: br_if 1, $pop{{[0-9]+}}{{$}} -; CHECK-NEXT: .LBB13_5: -; CHECK-NEXT: end_block{{$}} -; CHECK-NEXT: return{{$}} -; CHECK-NEXT: .LBB13_6: -; CHECK-NEXT: end_block{{$}} -; CHECK-NEXT: return{{$}} -; OPT-LABEL: test4: -; OPT-NEXT: .param i32{{$}} -; OPT: block {{$}} -; OPT-NEXT: block {{$}} -; OPT: br_if 0, $pop{{[0-9]+}}{{$}} -; OPT: br_if 1, $pop{{[0-9]+}}{{$}} -; OPT: br 1{{$}} -; OPT-NEXT: .LBB13_3: -; OPT-NEXT: end_block{{$}} -; OPT-NEXT: block {{$}} -; OPT: br_if 0, $pop{{[0-9]+}}{{$}} -; OPT: br_if 1, $pop{{[0-9]+}}{{$}} -; OPT-NEXT: .LBB13_5: -; OPT-NEXT: end_block{{$}} -; OPT-NEXT: return{{$}} -; OPT-NEXT: .LBB13_6: -; OPT-NEXT: end_block{{$}} -; OPT-NEXT: return{{$}} -define void @test4(i32 %t) { -entry: - switch i32 %t, label %default [ - i32 0, label %bb2 - i32 2, label %bb2 - i32 4, label %bb1 - i32 622, label %bb0 - ] - -bb0: - ret void - -bb1: - ret void - -bb2: - ret void - -default: - ret void -} - -; Test a case where the BLOCK needs to be placed before the LOOP in the -; same basic block. - -; CHECK-LABEL: test5: -; CHECK: .LBB14_1: -; CHECK-NEXT: block {{$}} -; CHECK-NEXT: loop {{$}} -; CHECK: br_if 1, {{[^,]+}}{{$}} -; CHECK: br_if 0, {{[^,]+}}{{$}} -; CHECK-NEXT: end_loop{{$}} -; CHECK: return{{$}} -; CHECK-NEXT: .LBB14_4: -; CHECK: return{{$}} -; OPT-LABEL: test5: -; OPT: .LBB14_1: -; OPT-NEXT: block {{$}} -; OPT-NEXT: loop {{$}} -; OPT: br_if 1, {{[^,]+}}{{$}} -; OPT: br_if 0, {{[^,]+}}{{$}} -; OPT-NEXT: end_loop{{$}} -; OPT: return{{$}} -; OPT-NEXT: .LBB14_4: -; OPT: return{{$}} -define void @test5(i1 %p, i1 %q) { -entry: - br label %header - -header: - store volatile i32 0, i32* null - br i1 %p, label %more, label %alt - -more: - store volatile i32 1, i32* null - br i1 %q, label %header, label %return - -alt: - store volatile i32 2, i32* null - ret void - -return: - store volatile i32 3, i32* null - ret void -} - -; Test an interesting case of a loop with multiple exits, which -; aren't to layout successors of the loop, and one of which is to a successors -; which has another predecessor. - -; CHECK-LABEL: test6: -; CHECK: .LBB15_1: -; CHECK-NEXT: block {{$}} -; CHECK-NEXT: block {{$}} -; CHECK-NEXT: loop {{$}} -; CHECK-NOT: block -; CHECK: br_if 2, {{[^,]+}}{{$}} -; CHECK-NOT: block -; CHECK: br_if 1, {{[^,]+}}{{$}} -; CHECK-NOT: block -; CHECK: br_if 0, {{[^,]+}}{{$}} -; CHECK-NEXT: end_loop{{$}} -; CHECK-NOT: block -; CHECK: return{{$}} -; CHECK-NEXT: .LBB15_5: -; CHECK-NEXT: end_block{{$}} -; CHECK-NOT: block -; CHECK: .LBB15_6: -; CHECK-NEXT: end_block{{$}} -; CHECK-NOT: block -; CHECK: return{{$}} -; OPT-LABEL: test6: -; OPT: .LBB15_1: -; OPT-NEXT: block {{$}} -; OPT-NEXT: block {{$}} -; OPT-NEXT: loop {{$}} -; OPT-NOT: block -; OPT: br_if 2, {{[^,]+}}{{$}} -; OPT-NOT: block -; OPT: br_if 1, {{[^,]+}}{{$}} -; OPT-NOT: block -; OPT: br_if 0, {{[^,]+}}{{$}} -; OPT-NEXT: end_loop{{$}} -; OPT-NOT: block -; OPT: return{{$}} -; OPT-NEXT: .LBB15_5: -; OPT-NEXT: end_block{{$}} -; OPT-NOT: block -; OPT: .LBB15_6: -; OPT-NEXT: end_block{{$}} -; OPT-NOT: block -; OPT: return{{$}} -define void @test6(i1 %p, i1 %q) { -entry: - br label %header - -header: - store volatile i32 0, i32* null - br i1 %p, label %more, label %second - -more: - store volatile i32 1, i32* null - br i1 %q, label %evenmore, label %first - -evenmore: - store volatile i32 1, i32* null - br i1 %q, label %header, label %return - -return: - store volatile i32 2, i32* null - ret void - -first: - store volatile i32 3, i32* null - br label %second - -second: - store volatile i32 4, i32* null - ret void -} - -; Test a case where there are multiple backedges and multiple loop exits -; that end in unreachable. - -; CHECK-LABEL: test7: -; CHECK: .LBB16_1: -; CHECK-NEXT: loop {{$}} -; CHECK-NOT: block -; CHECK: block {{$}} -; CHECK: br_if 0, {{[^,]+}}{{$}} -; CHECK-NOT: block -; CHECK: br_if 1, {{[^,]+}}{{$}} -; CHECK-NOT: block -; CHECK: unreachable -; CHECK-NEXT: .LBB16_4: -; CHECK-NEXT: end_block{{$}} -; CHECK-NOT: block -; CHECK: br_if 0, {{[^,]+}}{{$}} -; CHECK-NEXT: end_loop{{$}} -; CHECK-NOT: block -; CHECK: unreachable -; OPT-LABEL: test7: -; OPT: .LBB16_1: -; OPT-NEXT: block -; OPT-NEXT: loop {{$}} -; OPT-NOT: block -; OPT: block {{$}} -; OPT-NOT: block -; OPT: br_if 0, {{[^,]+}}{{$}} -; OPT-NOT: block -; OPT: br_if 1, {{[^,]+}}{{$}} -; OPT: br 2{{$}} -; OPT-NEXT: .LBB16_3: -; OPT-NEXT: end_block -; OPT-NOT: block -; OPT: br_if 0, {{[^,]+}}{{$}} -; OPT-NEXT: end_loop -; OPT-NOT: block -; OPT: unreachable -; OPT-NEXT: .LBB16_5: -; OPT-NEXT: end_block -; OPT-NOT: block -; OPT: unreachable -define void @test7(i1 %tobool2, i1 %tobool9) { -entry: - store volatile i32 0, i32* null - br label %loop - -loop: - store volatile i32 1, i32* null - br i1 %tobool2, label %l1, label %l0 - -l0: - store volatile i32 2, i32* null - br i1 %tobool9, label %loop, label %u0 - -l1: - store volatile i32 3, i32* null - br i1 %tobool9, label %loop, label %u1 - -u0: - store volatile i32 4, i32* null - unreachable - -u1: - store volatile i32 5, i32* null - unreachable -} - -; Test an interesting case using nested loops and switches. - -; CHECK-LABEL: test8: -; CHECK: .LBB17_1: -; CHECK-NEXT: loop i32{{$}} -; CHECK-NEXT: i32.const $push{{[^,]+}}, 0{{$}} -; CHECK-NEXT: br_if 0, {{[^,]+}}{{$}} -; CHECK-NEXT: br 0{{$}} -; CHECK-NEXT: .LBB17_2: -; CHECK-NEXT: end_loop{{$}} -; OPT-LABEL: test8: -; OPT: .LBB17_1: -; OPT-NEXT: loop i32{{$}} -; OPT-NEXT: i32.const $push{{[^,]+}}, 0{{$}} -; OPT-NEXT: br_if 0, {{[^,]+}}{{$}} -; OPT-NEXT: br 0{{$}} -; OPT-NEXT: .LBB17_2: -; OPT-NEXT: end_loop{{$}} -define i32 @test8() { -bb: - br label %bb1 - -bb1: - br i1 undef, label %bb2, label %bb3 - -bb2: - switch i8 undef, label %bb1 [ - i8 44, label %bb2 - ] - -bb3: - switch i8 undef, label %bb1 [ - i8 44, label %bb2 - ] -} - -; Test an interesting case using nested loops that share a bottom block. - -; CHECK-LABEL: test9: -; CHECK: .LBB18_1: -; CHECK-NEXT: block {{$}} -; CHECK-NEXT: loop {{$}} -; CHECK-NOT: block -; CHECK: br_if 1, {{[^,]+}}{{$}} -; CHECK-NEXT: .LBB18_2: -; CHECK-NEXT: loop {{$}} -; CHECK-NOT: block -; CHECK: block {{$}} -; CHECK-NOT: block -; CHECK: br_if 0, {{[^,]+}}{{$}} -; CHECK-NOT: block -; CHECK: br_if 2, {{[^,]+}}{{$}} -; CHECK-NEXT: br 1{{$}} -; CHECK-NEXT: .LBB18_4: -; CHECK-NEXT: end_block{{$}} -; CHECK-NOT: block -; CHECK: br_if 1, {{[^,]+}}{{$}} -; CHECK-NEXT: br 0{{$}} -; CHECK-NEXT: .LBB18_5: -; CHECK-NOT: block -; CHECK: end_block -; CHECK-NOT: block -; CHECK: return{{$}} -; OPT-LABEL: test9: -; OPT: .LBB18_1: -; OPT-NEXT: block {{$}} -; OPT-NEXT: loop {{$}} -; OPT-NOT: block -; OPT: br_if 1, {{[^,]+}}{{$}} -; OPT-NEXT: .LBB18_2: -; OPT-NEXT: loop {{$}} -; OPT-NOT: block -; OPT: block {{$}} -; OPT-NOT: block -; OPT: br_if 0, {{[^,]+}}{{$}} -; OPT-NOT: block -; OPT: br_if 1, {{[^,]+}}{{$}} -; OPT-NEXT: br 2{{$}} -; OPT-NEXT: .LBB18_4: -; OPT-NEXT: end_block{{$}} -; OPT-NOT: block -; OPT: br_if 0, {{[^,]+}}{{$}} -; OPT-NEXT: br 1{{$}} -; OPT-NEXT: .LBB18_5: -; OPT-NOT: block -; OPT: end_block -; OPT-NOT: block -; OPT: return{{$}} -declare i1 @a() -define void @test9() { -entry: - store volatile i32 0, i32* null - br label %header - -header: - store volatile i32 1, i32* null - %call4 = call i1 @a() - br i1 %call4, label %header2, label %end - -header2: - store volatile i32 2, i32* null - %call = call i1 @a() - br i1 %call, label %if.then, label %if.else - -if.then: - store volatile i32 3, i32* null - %call3 = call i1 @a() - br i1 %call3, label %header2, label %header - -if.else: - store volatile i32 4, i32* null - %call2 = call i1 @a() - br i1 %call2, label %header2, label %header - -end: - store volatile i32 5, i32* null - ret void -} - -; Test an interesting case involving nested loops sharing a loop bottom, -; and loop exits to a block with unreachable. - -; CHECK-LABEL: test10: -; CHECK: .LBB19_1: -; CHECK-NEXT: loop {{$}} -; CHECK-NOT: block -; CHECK: br_if 0, {{[^,]+}}{{$}} -; CHECK: .LBB19_3: -; CHECK-NEXT: block {{$}} -; CHECK-NEXT: loop {{$}} -; CHECK-NOT: block -; CHECK: .LBB19_4: -; CHECK-NEXT: loop {{$}} -; CHECK-NOT: block -; CHECK: br_if 3, {{[^,]+}}{{$}} -; CHECK: block {{$}} -; CHECK: br_table {{[^,]+}}, 1, 0, 4, 2, 3, 1{{$}} -; CHECK-NEXT: .LBB19_6: -; CHECK-NEXT: end_block{{$}} -; CHECK-NEXT: end_loop{{$}} -; CHECK-NEXT: end_loop{{$}} -; CHECK-NEXT: return{{$}} -; CHECK-NEXT: .LBB19_7: -; CHECK-NEXT: end_block{{$}} -; CHECK-NOT: block -; CHECK: br 0{{$}} -; CHECK-NEXT: .LBB19_8: -; OPT-LABEL: test10: -; OPT: .LBB19_1: -; OPT-NEXT: loop {{$}} -; OPT-NOT: block -; OPT: br_if 0, {{[^,]+}}{{$}} -; OPT: .LBB19_3: -; OPT-NEXT: block {{$}} -; OPT-NEXT: loop {{$}} -; OPT-NOT: block -; OPT: .LBB19_4: -; OPT-NEXT: loop {{$}} -; OPT-NOT: block -; OPT: br_if 3, {{[^,]+}}{{$}} -; OPT: block -; OPT: br_table {{[^,]+}}, 1, 0, 4, 2, 3, 1{{$}} -; OPT-NEXT: .LBB19_6: -; OPT-NEXT: end_block{{$}} -; OPT-NEXT: end_loop{{$}} -; OPT-NEXT: end_loop{{$}} -; OPT-NEXT: return{{$}} -; OPT-NEXT: .LBB19_7: -; OPT-NEXT: end_block{{$}} -; OPT-NOT: block -; OPT: br 0{{$}} -; OPT-NEXT: .LBB19_8: -define void @test10() { -bb0: - br label %bb1 - -bb1: - %tmp = phi i32 [ 2, %bb0 ], [ 3, %bb3 ] - %tmp3 = phi i32 [ undef, %bb0 ], [ %tmp11, %bb3 ] - %tmp4 = icmp eq i32 %tmp3, 0 - br i1 %tmp4, label %bb4, label %bb2 - -bb2: - br label %bb3 - -bb3: - %tmp11 = phi i32 [ 1, %bb5 ], [ 0, %bb2 ] - br label %bb1 - -bb4: - %tmp6 = phi i32 [ %tmp9, %bb5 ], [ 4, %bb1 ] - %tmp7 = phi i32 [ %tmp6, %bb5 ], [ %tmp, %bb1 ] - br label %bb5 - -bb5: - %tmp9 = phi i32 [ %tmp6, %bb5 ], [ %tmp7, %bb4 ] - switch i32 %tmp9, label %bb2 [ - i32 0, label %bb5 - i32 1, label %bb6 - i32 3, label %bb4 - i32 4, label %bb3 - ] - -bb6: - ret void -} - -; Test a CFG DAG with interesting merging. - -; CHECK-LABEL: test11: -; CHECK: block {{$}} -; CHECK-NEXT: block {{$}} -; CHECK-NEXT: block {{$}} -; CHECK-NEXT: block {{$}} -; CHECK: br_if 0, {{[^,]+}}{{$}} -; CHECK-NOT: block -; CHECK: block {{$}} -; CHECK-NEXT: i32.const -; CHECK-NEXT: br_if 0, {{[^,]+}}{{$}} -; CHECK-NOT: block -; CHECK: br_if 2, {{[^,]+}}{{$}} -; CHECK-NEXT: .LBB20_3: -; CHECK-NEXT: end_block{{$}} -; CHECK-NOT: block -; CHECK: return{{$}} -; CHECK-NEXT: .LBB20_4: -; CHECK-NEXT: end_block{{$}} -; CHECK-NOT: block -; CHECK: br_if 1, {{[^,]+}}{{$}} -; CHECK-NOT: block -; CHECK: br_if 2, {{[^,]+}}{{$}} -; CHECK-NEXT: .LBB20_6: -; CHECK-NEXT: end_block{{$}} -; CHECK-NOT: block -; CHECK: return{{$}} -; CHECK-NEXT: .LBB20_7: -; CHECK-NEXT: end_block{{$}} -; CHECK-NOT: block -; CHECK: return{{$}} -; CHECK-NEXT: .LBB20_8: -; CHECK-NEXT: end_block{{$}} -; CHECK-NOT: block -; CHECK: return{{$}} -; OPT-LABEL: test11: -; OPT: block {{$}} -; OPT-NEXT: block {{$}} -; OPT: br_if 0, $pop{{[0-9]+}}{{$}} -; OPT-NOT: block -; OPT: block {{$}} -; OPT-NEXT: i32.const -; OPT-NEXT: br_if 0, {{[^,]+}}{{$}} -; OPT-NOT: block -; OPT: br_if 2, {{[^,]+}}{{$}} -; OPT-NEXT: .LBB20_3: -; OPT-NEXT: end_block{{$}} -; OPT-NOT: block -; OPT: return{{$}} -; OPT-NEXT: .LBB20_4: -; OPT-NEXT: end_block{{$}} -; OPT-NOT: block -; OPT: block {{$}} -; OPT-NOT: block -; OPT: br_if 0, $pop{{[0-9]+}}{{$}} -; OPT-NOT: block -; OPT: return{{$}} -; OPT-NEXT: .LBB20_6: -; OPT-NEXT: end_block{{$}} -; OPT-NOT: block -; OPT: br_if 0, $pop{{[0-9]+}}{{$}} -; OPT-NOT: block -; OPT: return{{$}} -; OPT-NEXT: .LBB20_8: -; OPT-NEXT: end_block{{$}} -; OPT-NOT: block -; OPT: return{{$}} -define void @test11() { -bb0: - store volatile i32 0, i32* null - br i1 undef, label %bb1, label %bb4 -bb1: - store volatile i32 1, i32* null - br i1 undef, label %bb3, label %bb2 -bb2: - store volatile i32 2, i32* null - br i1 undef, label %bb3, label %bb7 -bb3: - store volatile i32 3, i32* null - ret void -bb4: - store volatile i32 4, i32* null - br i1 undef, label %bb8, label %bb5 -bb5: - store volatile i32 5, i32* null - br i1 undef, label %bb6, label %bb7 -bb6: - store volatile i32 6, i32* null - ret void -bb7: - store volatile i32 7, i32* null - ret void -bb8: - store volatile i32 8, i32* null - ret void -} - -; CHECK-LABEL: test12: -; CHECK: .LBB21_1: -; CHECK-NEXT: block {{$}} -; CHECK-NEXT: loop {{$}} -; CHECK-NOT: block -; CHECK: block {{$}} -; CHECK-NEXT: block {{$}} -; CHECK: br_if 0, {{[^,]+}}{{$}} -; CHECK-NOT: block -; CHECK: br_if 1, {{[^,]+}}{{$}} -; CHECK-NOT: block -; CHECK: br_if 1, {{[^,]+}}{{$}} -; CHECK-NEXT: br 3{{$}} -; CHECK-NEXT: .LBB21_4: -; CHECK-NEXT: end_block{{$}} -; CHECK-NOT: block -; CHECK: br_if 0, {{[^,]+}}{{$}} -; CHECK-NOT: block -; CHECK: br_if 2, {{[^,]+}}{{$}} -; CHECK-NEXT: .LBB21_6: -; CHECK-NEXT: end_block{{$}} -; CHECK-NOT: block -; CHECK: br 0{{$}} -; CHECK-NEXT: .LBB21_7: -; CHECK-NEXT: end_loop{{$}} -; CHECK-NEXT: end_block{{$}} -; CHECK-NEXT: return{{$}} -; OPT-LABEL: test12: -; OPT: .LBB21_1: -; OPT-NEXT: block {{$}} -; OPT-NEXT: loop {{$}} -; OPT-NOT: block -; OPT: block {{$}} -; OPT-NEXT: block {{$}} -; OPT: br_if 0, {{[^,]+}}{{$}} -; OPT-NOT: block -; OPT: br_if 1, {{[^,]+}}{{$}} -; OPT-NOT: block -; OPT: br_if 1, {{[^,]+}}{{$}} -; OPT-NEXT: br 3{{$}} -; OPT-NEXT: .LBB21_4: -; OPT-NEXT: end_block{{$}} -; OPT-NOT: block -; OPT: br_if 0, {{[^,]+}}{{$}} -; OPT-NOT: block -; OPT: br_if 2, {{[^,]+}}{{$}} -; OPT-NEXT: .LBB21_6: -; OPT-NEXT: end_block{{$}} -; OPT: br 0{{$}} -; OPT-NEXT: .LBB21_7: -; OPT-NEXT: end_loop{{$}} -; OPT-NEXT: end_block{{$}} -; OPT-NEXT: return{{$}} -define void @test12(i8* %arg) { -bb: - br label %bb1 - -bb1: - %tmp = phi i32 [ 0, %bb ], [ %tmp5, %bb4 ] - %tmp2 = getelementptr i8, i8* %arg, i32 %tmp - %tmp3 = load i8, i8* %tmp2 - switch i8 %tmp3, label %bb7 [ - i8 42, label %bb4 - i8 76, label %bb4 - i8 108, label %bb4 - i8 104, label %bb4 - ] - -bb4: - %tmp5 = add i32 %tmp, 1 - br label %bb1 - -bb7: - ret void -} - -; A block can be "branched to" from another even if it is also reachable via -; fallthrough from the other. This would normally be optimized away, so use -; optnone to disable optimizations to test this case. - -; CHECK-LABEL: test13: -; CHECK-NEXT: block {{$}} -; CHECK-NEXT: block {{$}} -; CHECK: br_if 0, $pop0{{$}} -; CHECK: block {{$}} -; CHECK: br_if 0, $pop3{{$}} -; CHECK: .LBB22_3: -; CHECK-NEXT: end_block{{$}} -; CHECK: br_if 1, $pop{{[0-9]+}}{{$}} -; CHECK-NEXT: br 1{{$}} -; CHECK-NEXT: .LBB22_4: -; CHECK-NEXT: end_block{{$}} -; CHECK-NEXT: return{{$}} -; CHECK-NEXT: .LBB22_5: -; CHECK-NEXT: end_block{{$}} -; CHECK-NEXT: unreachable{{$}} -; OPT-LABEL: test13: -; OPT-NEXT: block {{$}} -; OPT-NEXT: block {{$}} -; OPT: br_if 0, $pop0{{$}} -; OPT: block {{$}} -; OPT: br_if 0, $pop3{{$}} -; OPT: .LBB22_3: -; OPT-NEXT: end_block{{$}} -; OPT: br_if 1, $pop{{[0-9]+}}{{$}} -; OPT-NEXT: br 1{{$}} -; OPT-NEXT: .LBB22_4: -; OPT-NEXT: end_block -; OPT-NEXT: return -; OPT-NEXT: .LBB22_5: -; OPT-NEXT: end_block{{$}} -; OPT-NEXT: unreachable{{$}} -define void @test13() noinline optnone { -bb: - br i1 undef, label %bb5, label %bb2 -bb1: - unreachable -bb2: - br i1 undef, label %bb3, label %bb4 -bb3: - br label %bb4 -bb4: - %tmp = phi i1 [ false, %bb2 ], [ false, %bb3 ] - br i1 %tmp, label %bb1, label %bb1 -bb5: - ret void -} - -; Test a case with a single-block loop that has another loop -; as a successor. The end_loop for the first loop should go -; before the loop for the second. - -; CHECK-LABEL: test14: -; CHECK-NEXT: .LBB23_1:{{$}} -; CHECK-NEXT: loop {{$}} -; CHECK-NEXT: i32.const $push0=, 0{{$}} -; CHECK-NEXT: br_if 0, $pop0{{$}} -; CHECK-NEXT: end_loop{{$}} -; CHECK-NEXT: .LBB23_3:{{$}} -; CHECK-NEXT: loop {{$}} -; CHECK-NEXT: i32.const $push1=, 0{{$}} -; CHECK-NEXT: br_if 0, $pop1{{$}} -; CHECK-NEXT: end_loop{{$}} -; CHECK-NEXT: return{{$}} -define void @test14() { -bb: - br label %bb1 - -bb1: - %tmp = bitcast i1 undef to i1 - br i1 %tmp, label %bb3, label %bb1 - -bb3: - br label %bb4 - -bb4: - br i1 undef, label %bb7, label %bb48 - -bb7: - br i1 undef, label %bb12, label %bb12 - -bb12: - br i1 undef, label %bb17, label %bb17 - -bb17: - br i1 undef, label %bb22, label %bb22 - -bb22: - br i1 undef, label %bb27, label %bb27 - -bb27: - br i1 undef, label %bb30, label %bb30 - -bb30: - br i1 undef, label %bb35, label %bb35 - -bb35: - br i1 undef, label %bb38, label %bb38 - -bb38: - br i1 undef, label %bb48, label %bb48 - -bb48: - %tmp49 = bitcast i1 undef to i1 - br i1 %tmp49, label %bb3, label %bb50 - -bb50: - ret void -} - -; Test that a block boundary which ends one block, begins another block, and -; also begins a loop, has the markers placed in the correct order. - -; CHECK-LABEL: test15: -; CHECK: block -; CHECK-NEXT: block -; CHECK: br_if 0, $pop{{.*}}{{$}} -; CHECK: .LBB24_2: -; CHECK-NEXT: block {{$}} -; CHECK-NEXT: block {{$}} -; CHECK-NEXT: loop {{$}} -; CHECK: br_if 1, $pop{{.*}}{{$}} -; CHECK: br_if 0, ${{.*}}{{$}} -; CHECK-NEXT: br 2{{$}} -; CHECK-NEXT: .LBB24_4: -; CHECK-NEXT: end_loop{{$}} -; CHECK: .LBB24_5: -; CHECK-NEXT: end_block{{$}} -; CHECK: br_if 1, $pop{{.*}}{{$}} -; CHECK: return{{$}} -; CHECK: .LBB24_7: -; CHECK-NEXT: end_block{{$}} -; CHECK: .LBB24_8: -; CHECK-NEXT: end_block{{$}} -; CHECK-NEXT: return{{$}} -; OPT-LABEL: test15: -; OPT: block -; OPT: block -; OPT-NEXT: i32.const $push -; OPT-NEXT: i32.eqz $push{{.*}}=, $pop{{.*}}{{$}} -; OPT-NEXT: br_if 0, $pop{{.*}}{{$}} -; OPT-NEXT: call test15_callee1@FUNCTION{{$}} -; OPT-NEXT: br 1{{$}} -; OPT-NEXT: .LBB24_2: -; OPT-NEXT: end_block -; OPT-NEXT: i32.const -; OPT-NEXT: .LBB24_3: -; OPT-NEXT: block -; OPT-NEXT: block -; OPT-NEXT: loop -%0 = type { i8, i32 } -declare void @test15_callee0() -declare void @test15_callee1() -define void @test15() { -bb: - %tmp1 = icmp eq i8 1, 0 - br i1 %tmp1, label %bb2, label %bb14 - -bb2: - %tmp3 = phi %0** [ %tmp6, %bb5 ], [ null, %bb ] - %tmp4 = icmp eq i32 0, 11 - br i1 %tmp4, label %bb5, label %bb8 - -bb5: - %tmp = bitcast i8* null to %0** - %tmp6 = getelementptr %0*, %0** %tmp3, i32 1 - %tmp7 = icmp eq %0** %tmp6, null - br i1 %tmp7, label %bb10, label %bb2 - -bb8: - %tmp9 = icmp eq %0** null, undef - br label %bb10 - -bb10: - %tmp11 = phi %0** [ null, %bb8 ], [ %tmp, %bb5 ] - %tmp12 = icmp eq %0** null, %tmp11 - br i1 %tmp12, label %bb15, label %bb13 - -bb13: - call void @test15_callee0() - ret void - -bb14: - call void @test15_callee1() - ret void - -bb15: - ret void -} diff --git a/test/CodeGen/WebAssembly/cfi.ll b/test/CodeGen/WebAssembly/cfi.ll deleted file mode 100644 index 992e0f0c63d8..000000000000 --- a/test/CodeGen/WebAssembly/cfi.ll +++ /dev/null @@ -1,53 +0,0 @@ -; RUN: opt -S -lowertypetests < %s | llc -asm-verbose=false -disable-wasm-fallthrough-return-opt | FileCheck %s - -; 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-wasm" - -@0 = private unnamed_addr constant [2 x void (...)*] [void (...)* bitcast (void ()* @f to void (...)*), void (...)* bitcast (void ()* @g to void (...)*)], align 16 - -; CHECK-LABEL: h: -; CHECK-NOT: .indidx -define void @h() !type !0 { - ret void -} - -; CHECK-LABEL: f: -; CHECK: .indidx 1 -define void @f() !type !0 { - ret void -} - -; CHECK-LABEL: g: -; CHECK: .indidx 2 -define void @g() !type !1 { - ret void -} - -!0 = !{i32 0, !"typeid1"} -!1 = !{i32 0, !"typeid2"} - -declare i1 @llvm.type.test(i8* %ptr, metadata %bitset) nounwind readnone -declare void @llvm.trap() nounwind noreturn - -; CHECK-LABEL: foo: -; CHECK: br_if -; CHECK: br_if -; CHECK: unreachable -define i1 @foo(i8* %p) { - %x = call i1 @llvm.type.test(i8* %p, metadata !"typeid1") - br i1 %x, label %contx, label %trap - -trap: - tail call void @llvm.trap() #1 - unreachable - -contx: - %y = call i1 @llvm.type.test(i8* %p, metadata !"typeid2") - br i1 %y, label %conty, label %trap - -conty: - %z = add i1 %x, %y - ret i1 %z -} diff --git a/test/CodeGen/WebAssembly/comparisons_f32.ll b/test/CodeGen/WebAssembly/comparisons_f32.ll deleted file mode 100644 index 8051b25689dd..000000000000 --- a/test/CodeGen/WebAssembly/comparisons_f32.ll +++ /dev/null @@ -1,227 +0,0 @@ -; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt | FileCheck %s - -; Test that basic 32-bit floating-point comparison operations assemble as -; expected. - -target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" -target triple = "wasm32-unknown-unknown-wasm" - -; CHECK-LABEL: ord_f32: -; CHECK-NEXT: .param f32, f32{{$}} -; CHECK-NEXT: .result i32{{$}} -; 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) { - %a = fcmp ord float %x, %y - %b = zext i1 %a to i32 - ret i32 %b -} - -; CHECK-LABEL: uno_f32: -; CHECK-NEXT: .param f32, f32{{$}} -; CHECK-NEXT: .result i32{{$}} -; 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) { - %a = fcmp uno float %x, %y - %b = zext i1 %a to i32 - ret i32 %b -} - -; CHECK-LABEL: oeq_f32: -; CHECK-NEXT: .param f32, f32{{$}} -; CHECK-NEXT: .result i32{{$}} -; 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 - %b = zext i1 %a to i32 - ret i32 %b -} - -; CHECK-LABEL: une_f32: -; 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 - %b = zext i1 %a to i32 - ret i32 %b -} - -; CHECK-LABEL: olt_f32: -; 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 - %b = zext i1 %a to i32 - ret i32 %b -} - -; CHECK-LABEL: ole_f32: -; 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 - %b = zext i1 %a to i32 - ret i32 %b -} - -; CHECK-LABEL: ogt_f32: -; 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 - %b = zext i1 %a to i32 - ret i32 %b -} - -; CHECK-LABEL: oge_f32: -; 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 - %b = zext i1 %a to i32 - ret i32 %b -} - -; Expanded comparisons, which also check for NaN. - -; CHECK-LABEL: ueq_f32: -; CHECK-NEXT: .param f32, f32{{$}} -; CHECK-NEXT: .result i32{{$}} -; 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]]{{$}} -define i32 @ueq_f32(float %x, float %y) { - %a = fcmp ueq float %x, %y - %b = zext i1 %a to i32 - ret i32 %b -} - -; CHECK-LABEL: one_f32: -; CHECK-NEXT: .param f32, f32{{$}} -; CHECK-NEXT: .result i32{{$}} -; 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]] -define i32 @one_f32(float %x, float %y) { - %a = fcmp one float %x, %y - %b = zext i1 %a to i32 - ret i32 %b -} - -; CHECK-LABEL: ult_f32: -; CHECK-NEXT: .param f32, f32{{$}} -; CHECK-NEXT: .result i32{{$}} -; 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]]{{$}} -define i32 @ult_f32(float %x, float %y) { - %a = fcmp ult float %x, %y - %b = zext i1 %a to i32 - ret i32 %b -} - -; CHECK-LABEL: ule_f32: -; CHECK-NEXT: .param f32, f32{{$}} -; CHECK-NEXT: .result i32{{$}} -; 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]]{{$}} -define i32 @ule_f32(float %x, float %y) { - %a = fcmp ule float %x, %y - %b = zext i1 %a to i32 - ret i32 %b -} - -; CHECK-LABEL: ugt_f32: -; CHECK-NEXT: .param f32, f32{{$}} -; CHECK-NEXT: .result i32{{$}} -; 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]]{{$}} -define i32 @ugt_f32(float %x, float %y) { - %a = fcmp ugt float %x, %y - %b = zext i1 %a to i32 - ret i32 %b -} - -; CHECK-LABEL: uge_f32: -; CHECK-NEXT: .param f32, f32{{$}} -; CHECK-NEXT: .result i32{{$}} -; 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]]{{$}} -define i32 @uge_f32(float %x, float %y) { - %a = fcmp uge float %x, %y - %b = zext i1 %a to i32 - ret i32 %b -} diff --git a/test/CodeGen/WebAssembly/comparisons_f64.ll b/test/CodeGen/WebAssembly/comparisons_f64.ll deleted file mode 100644 index 6694f989627f..000000000000 --- a/test/CodeGen/WebAssembly/comparisons_f64.ll +++ /dev/null @@ -1,227 +0,0 @@ -; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt | FileCheck %s - -; Test that basic 64-bit floating-point comparison operations assemble as -; expected. - -target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" -target triple = "wasm32-unknown-unknown-wasm" - -; CHECK-LABEL: ord_f64: -; CHECK-NEXT: .param f64, f64{{$}} -; CHECK-NEXT: .result i32{{$}} -; 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) { - %a = fcmp ord double %x, %y - %b = zext i1 %a to i32 - ret i32 %b -} - -; CHECK-LABEL: uno_f64: -; CHECK-NEXT: .param f64, f64{{$}} -; CHECK-NEXT: .result i32{{$}} -; 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) { - %a = fcmp uno double %x, %y - %b = zext i1 %a to i32 - ret i32 %b -} - -; CHECK-LABEL: oeq_f64: -; CHECK-NEXT: .param f64, f64{{$}} -; CHECK-NEXT: .result i32{{$}} -; 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 - %b = zext i1 %a to i32 - ret i32 %b -} - -; CHECK-LABEL: une_f64: -; 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 - %b = zext i1 %a to i32 - ret i32 %b -} - -; CHECK-LABEL: olt_f64: -; 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 - %b = zext i1 %a to i32 - ret i32 %b -} - -; CHECK-LABEL: ole_f64: -; 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 - %b = zext i1 %a to i32 - ret i32 %b -} - -; CHECK-LABEL: ogt_f64: -; 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 - %b = zext i1 %a to i32 - ret i32 %b -} - -; CHECK-LABEL: oge_f64: -; 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 - %b = zext i1 %a to i32 - ret i32 %b -} - -; Expanded comparisons, which also check for NaN. - -; CHECK-LABEL: ueq_f64: -; CHECK-NEXT: .param f64, f64{{$}} -; CHECK-NEXT: .result i32{{$}} -; 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]]{{$}} -define i32 @ueq_f64(double %x, double %y) { - %a = fcmp ueq double %x, %y - %b = zext i1 %a to i32 - ret i32 %b -} - -; CHECK-LABEL: one_f64: -; CHECK-NEXT: .param f64, f64{{$}} -; CHECK-NEXT: .result i32{{$}} -; 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]] -define i32 @one_f64(double %x, double %y) { - %a = fcmp one double %x, %y - %b = zext i1 %a to i32 - ret i32 %b -} - -; CHECK-LABEL: ult_f64: -; CHECK-NEXT: .param f64, f64{{$}} -; CHECK-NEXT: .result i32{{$}} -; 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]]{{$}} -define i32 @ult_f64(double %x, double %y) { - %a = fcmp ult double %x, %y - %b = zext i1 %a to i32 - ret i32 %b -} - -; CHECK-LABEL: ule_f64: -; CHECK-NEXT: .param f64, f64{{$}} -; CHECK-NEXT: .result i32{{$}} -; 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]]{{$}} -define i32 @ule_f64(double %x, double %y) { - %a = fcmp ule double %x, %y - %b = zext i1 %a to i32 - ret i32 %b -} - -; CHECK-LABEL: ugt_f64: -; CHECK-NEXT: .param f64, f64{{$}} -; CHECK-NEXT: .result i32{{$}} -; 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]]{{$}} -define i32 @ugt_f64(double %x, double %y) { - %a = fcmp ugt double %x, %y - %b = zext i1 %a to i32 - ret i32 %b -} - -; CHECK-LABEL: uge_f64: -; CHECK-NEXT: .param f64, f64{{$}} -; CHECK-NEXT: .result i32{{$}} -; 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]]{{$}} -define i32 @uge_f64(double %x, double %y) { - %a = fcmp uge double %x, %y - %b = zext i1 %a to i32 - ret i32 %b -} diff --git a/test/CodeGen/WebAssembly/comparisons_i32.ll b/test/CodeGen/WebAssembly/comparisons_i32.ll deleted file mode 100644 index a9a79c24fb47..000000000000 --- a/test/CodeGen/WebAssembly/comparisons_i32.ll +++ /dev/null @@ -1,101 +0,0 @@ -; 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 - -; 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-wasm" - -; CHECK-LABEL: eq_i32: -; CHECK-NEXT: .param i32, i32{{$}} -; CHECK-NEXT: .result i32{{$}} -; 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 - %b = zext i1 %a to i32 - ret i32 %b -} - -; CHECK-LABEL: ne_i32: -; 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 - %b = zext i1 %a to i32 - ret i32 %b -} - -; CHECK-LABEL: slt_i32: -; 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 - %b = zext i1 %a to i32 - ret i32 %b -} - -; CHECK-LABEL: sle_i32: -; 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 - %b = zext i1 %a to i32 - ret i32 %b -} - -; CHECK-LABEL: ult_i32: -; 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 - %b = zext i1 %a to i32 - ret i32 %b -} - -; CHECK-LABEL: ule_i32: -; 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 - %b = zext i1 %a to i32 - ret i32 %b -} - -; CHECK-LABEL: sgt_i32: -; 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 - %b = zext i1 %a to i32 - ret i32 %b -} - -; CHECK-LABEL: sge_i32: -; 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 - %b = zext i1 %a to i32 - ret i32 %b -} - -; CHECK-LABEL: ugt_i32: -; 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 - %b = zext i1 %a to i32 - ret i32 %b -} - -; CHECK-LABEL: uge_i32: -; 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 - %b = zext i1 %a to i32 - ret i32 %b -} diff --git a/test/CodeGen/WebAssembly/comparisons_i64.ll b/test/CodeGen/WebAssembly/comparisons_i64.ll deleted file mode 100644 index 106520483c8f..000000000000 --- a/test/CodeGen/WebAssembly/comparisons_i64.ll +++ /dev/null @@ -1,101 +0,0 @@ -; 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 - -; 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-wasm" - -; CHECK-LABEL: eq_i64: -; CHECK-NEXT: .param i64, i64{{$}} -; CHECK-NEXT: .result i32{{$}} -; 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 - %b = zext i1 %a to i32 - ret i32 %b -} - -; CHECK-LABEL: ne_i64: -; 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 - %b = zext i1 %a to i32 - ret i32 %b -} - -; CHECK-LABEL: slt_i64: -; 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 - %b = zext i1 %a to i32 - ret i32 %b -} - -; CHECK-LABEL: sle_i64: -; 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 - %b = zext i1 %a to i32 - ret i32 %b -} - -; CHECK-LABEL: ult_i64: -; 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 - %b = zext i1 %a to i32 - ret i32 %b -} - -; CHECK-LABEL: ule_i64: -; 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 - %b = zext i1 %a to i32 - ret i32 %b -} - -; CHECK-LABEL: sgt_i64: -; 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 - %b = zext i1 %a to i32 - ret i32 %b -} - -; CHECK-LABEL: sge_i64: -; 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 - %b = zext i1 %a to i32 - ret i32 %b -} - -; CHECK-LABEL: ugt_i64: -; 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 - %b = zext i1 %a to i32 - ret i32 %b -} - -; CHECK-LABEL: uge_i64: -; 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 - %b = zext i1 %a to i32 - ret i32 %b -} diff --git a/test/CodeGen/WebAssembly/conv.ll b/test/CodeGen/WebAssembly/conv.ll deleted file mode 100644 index 913c4b0b19ea..000000000000 --- a/test/CodeGen/WebAssembly/conv.ll +++ /dev/null @@ -1,255 +0,0 @@ -; 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-wasm" - -; CHECK-LABEL: i32_wrap_i64: -; CHECK-NEXT: .param i64{{$}} -; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: i32.wrap/i64 $push[[NUM:[0-9]+]]=, $0{{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define i32 @i32_wrap_i64(i64 %x) { - %a = trunc i64 %x to i32 - ret i32 %a -} - -; CHECK-LABEL: i64_extend_s_i32: -; CHECK-NEXT: .param i32{{$}} -; CHECK-NEXT: .result i64{{$}} -; CHECK-NEXT: i64.extend_s/i32 $push[[NUM:[0-9]+]]=, $0{{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define i64 @i64_extend_s_i32(i32 %x) { - %a = sext i32 %x to i64 - ret i64 %a -} - -; CHECK-LABEL: i64_extend_u_i32: -; CHECK-NEXT: .param i32{{$}} -; CHECK-NEXT: .result i64{{$}} -; CHECK-NEXT: i64.extend_u/i32 $push[[NUM:[0-9]+]]=, $0{{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define i64 @i64_extend_u_i32(i32 %x) { - %a = zext i32 %x to i64 - ret i64 %a -} - -; CHECK-LABEL: i32_trunc_s_f32: -; CHECK-NEXT: .param f32{{$}} -; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: i32.trunc_s/f32 $push[[NUM:[0-9]+]]=, $0{{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define i32 @i32_trunc_s_f32(float %x) { - %a = fptosi float %x to i32 - ret i32 %a -} - -; CHECK-LABEL: i32_trunc_u_f32: -; CHECK-NEXT: .param f32{{$}} -; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: i32.trunc_u/f32 $push[[NUM:[0-9]+]]=, $0{{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define i32 @i32_trunc_u_f32(float %x) { - %a = fptoui float %x to i32 - ret i32 %a -} - -; CHECK-LABEL: i32_trunc_s_f64: -; CHECK-NEXT: .param f64{{$}} -; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: i32.trunc_s/f64 $push[[NUM:[0-9]+]]=, $0{{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define i32 @i32_trunc_s_f64(double %x) { - %a = fptosi double %x to i32 - ret i32 %a -} - -; CHECK-LABEL: i32_trunc_u_f64: -; CHECK-NEXT: .param f64{{$}} -; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: i32.trunc_u/f64 $push[[NUM:[0-9]+]]=, $0{{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define i32 @i32_trunc_u_f64(double %x) { - %a = fptoui double %x to i32 - ret i32 %a -} - -; CHECK-LABEL: i64_trunc_s_f32: -; CHECK-NEXT: .param f32{{$}} -; CHECK-NEXT: .result i64{{$}} -; CHECK-NEXT: i64.trunc_s/f32 $push[[NUM:[0-9]+]]=, $0{{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define i64 @i64_trunc_s_f32(float %x) { - %a = fptosi float %x to i64 - ret i64 %a -} - -; CHECK-LABEL: i64_trunc_u_f32: -; CHECK-NEXT: .param f32{{$}} -; CHECK-NEXT: .result i64{{$}} -; CHECK-NEXT: i64.trunc_u/f32 $push[[NUM:[0-9]+]]=, $0{{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define i64 @i64_trunc_u_f32(float %x) { - %a = fptoui float %x to i64 - ret i64 %a -} - -; CHECK-LABEL: i64_trunc_s_f64: -; CHECK-NEXT: .param f64{{$}} -; CHECK-NEXT: .result i64{{$}} -; CHECK-NEXT: i64.trunc_s/f64 $push[[NUM:[0-9]+]]=, $0{{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define i64 @i64_trunc_s_f64(double %x) { - %a = fptosi double %x to i64 - ret i64 %a -} - -; CHECK-LABEL: i64_trunc_u_f64: -; CHECK-NEXT: .param f64{{$}} -; CHECK-NEXT: .result i64{{$}} -; CHECK-NEXT: i64.trunc_u/f64 $push[[NUM:[0-9]+]]=, $0{{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define i64 @i64_trunc_u_f64(double %x) { - %a = fptoui double %x to i64 - ret i64 %a -} - -; CHECK-LABEL: f32_convert_s_i32: -; CHECK-NEXT: .param i32{{$}} -; CHECK-NEXT: .result f32{{$}} -; CHECK-NEXT: f32.convert_s/i32 $push[[NUM:[0-9]+]]=, $0{{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define float @f32_convert_s_i32(i32 %x) { - %a = sitofp i32 %x to float - ret float %a -} - -; CHECK-LABEL: f32_convert_u_i32: -; CHECK-NEXT: .param i32{{$}} -; CHECK-NEXT: .result f32{{$}} -; CHECK-NEXT: f32.convert_u/i32 $push[[NUM:[0-9]+]]=, $0{{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define float @f32_convert_u_i32(i32 %x) { - %a = uitofp i32 %x to float - ret float %a -} - -; CHECK-LABEL: f64_convert_s_i32: -; CHECK-NEXT: .param i32{{$}} -; CHECK-NEXT: .result f64{{$}} -; CHECK-NEXT: f64.convert_s/i32 $push[[NUM:[0-9]+]]=, $0{{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define double @f64_convert_s_i32(i32 %x) { - %a = sitofp i32 %x to double - ret double %a -} - -; CHECK-LABEL: f64_convert_u_i32: -; CHECK-NEXT: .param i32{{$}} -; CHECK-NEXT: .result f64{{$}} -; CHECK-NEXT: f64.convert_u/i32 $push[[NUM:[0-9]+]]=, $0{{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define double @f64_convert_u_i32(i32 %x) { - %a = uitofp i32 %x to double - ret double %a -} - -; CHECK-LABEL: f32_convert_s_i64: -; CHECK-NEXT: .param i64{{$}} -; CHECK-NEXT: .result f32{{$}} -; CHECK-NEXT: f32.convert_s/i64 $push[[NUM:[0-9]+]]=, $0{{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define float @f32_convert_s_i64(i64 %x) { - %a = sitofp i64 %x to float - ret float %a -} - -; CHECK-LABEL: f32_convert_u_i64: -; CHECK-NEXT: .param i64{{$}} -; CHECK-NEXT: .result f32{{$}} -; CHECK-NEXT: f32.convert_u/i64 $push[[NUM:[0-9]+]]=, $0{{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define float @f32_convert_u_i64(i64 %x) { - %a = uitofp i64 %x to float - ret float %a -} - -; CHECK-LABEL: f64_convert_s_i64: -; CHECK-NEXT: .param i64{{$}} -; CHECK-NEXT: .result f64{{$}} -; CHECK-NEXT: f64.convert_s/i64 $push[[NUM:[0-9]+]]=, $0{{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define double @f64_convert_s_i64(i64 %x) { - %a = sitofp i64 %x to double - ret double %a -} - -; CHECK-LABEL: f64_convert_u_i64: -; CHECK-NEXT: .param i64{{$}} -; CHECK-NEXT: .result f64{{$}} -; CHECK-NEXT: f64.convert_u/i64 $push[[NUM:[0-9]+]]=, $0{{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define double @f64_convert_u_i64(i64 %x) { - %a = uitofp i64 %x to double - ret double %a -} - -; CHECK-LABEL: f64_promote_f32: -; CHECK-NEXT: .param f32{{$}} -; CHECK-NEXT: .result f64{{$}} -; CHECK-NEXT: f64.promote/f32 $push[[NUM:[0-9]+]]=, $0{{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define double @f64_promote_f32(float %x) { - %a = fpext float %x to double - ret double %a -} - -; CHECK-LABEL: f32_demote_f64: -; CHECK-NEXT: .param f64{{$}} -; CHECK-NEXT: .result f32{{$}} -; CHECK-NEXT: f32.demote/f64 $push[[NUM:[0-9]+]]=, $0{{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define float @f32_demote_f64(double %x) { - %a = fptrunc double %x to float - ret float %a -} - -; If the high its are unused, LLVM will optimize sext/zext into anyext, which -; we need to patterm-match back to a specific instruction. - -; CHECK-LABEL: anyext: -; CHECK: i64.extend_u/i32 $push0=, $0{{$}} -define i64 @anyext(i32 %x) { - %y = sext i32 %x to i64 - %w = shl i64 %y, 32 - ret i64 %w -} - -; CHECK-LABEL: bitcast_i32_to_float: -; CHECK: f32.reinterpret/i32 $push0=, $0{{$}} -define float @bitcast_i32_to_float(i32 %a) { - %t = bitcast i32 %a to float - ret float %t -} - -; CHECK-LABEL: bitcast_float_to_i32: -; CHECK: i32.reinterpret/f32 $push0=, $0{{$}} -define i32 @bitcast_float_to_i32(float %a) { - %t = bitcast float %a to i32 - ret i32 %t -} - -; CHECK-LABEL: bitcast_i64_to_double: -; CHECK: f64.reinterpret/i64 $push0=, $0{{$}} -define double @bitcast_i64_to_double(i64 %a) { - %t = bitcast i64 %a to double - ret double %t -} - -; CHECK-LABEL: bitcast_double_to_i64: -; CHECK: i64.reinterpret/f64 $push0=, $0{{$}} -define i64 @bitcast_double_to_i64(double %a) { - %t = bitcast double %a to i64 - ret i64 %t -} diff --git a/test/CodeGen/WebAssembly/copysign-casts.ll b/test/CodeGen/WebAssembly/copysign-casts.ll deleted file mode 100644 index 7cd40efafcd5..000000000000 --- a/test/CodeGen/WebAssembly/copysign-casts.ll +++ /dev/null @@ -1,28 +0,0 @@ -; RUN: llc < %s -asm-verbose=false | FileCheck %s - -; DAGCombiner oddly folds casts into the rhs of copysign. Test that they get -; unfolded. - -target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" -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=, $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) - ret double %t -} - -; CHECK-LABEL: fold_demote:{{$}} -; 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) - ret float %t -} diff --git a/test/CodeGen/WebAssembly/cpus.ll b/test/CodeGen/WebAssembly/cpus.ll deleted file mode 100644 index 9b4ac4425ca9..000000000000 --- a/test/CodeGen/WebAssembly/cpus.ll +++ /dev/null @@ -1,17 +0,0 @@ -; This tests that llc accepts all valid WebAssembly CPUs. - -; 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 - -define i32 @f(i32 %i_like_the_web) { - ret i32 %i_like_the_web -} diff --git a/test/CodeGen/WebAssembly/dbgvalue.ll b/test/CodeGen/WebAssembly/dbgvalue.ll deleted file mode 100644 index eb39c6da1c99..000000000000 --- a/test/CodeGen/WebAssembly/dbgvalue.ll +++ /dev/null @@ -1,72 +0,0 @@ -; RUN: llc < %s -O0 -verify-machineinstrs -mtriple=wasm32-unknown-unknown-wasm | FileCheck %s - -; CHECK: BB#0 -; CHECK: #DEBUG_VALUE: usage:self <- %vreg4 -; CHECK: BB#1 -; 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-wasm" - -@key = external local_unnamed_addr global [15 x i8], align 1 -@.str = external unnamed_addr constant [33 x i8], align 1 - -define internal i32 @0(i8*) local_unnamed_addr !dbg !15 !type !23 { - tail call void @llvm.dbg.value(metadata i8* %0, i64 0, metadata !22, metadata !24), !dbg !25 - %2 = tail call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str, i32 0, i32 0), i8* %0), !dbg !26 - br i1 true, label %a, label %b - -a: ; preds = %1 - %3 = add i32 %2, %2 - br label %c - -b: ; preds = %1 - %4 = sub i32 %2, %2 - br label %c - -c: ; preds = %b, %a - %5 = phi i32 [ %3, %a ], [ %4, %b ] - %6 = add i32 ptrtoint (i32 (i8*)* @0 to i32), %5 - ret i32 %6, !dbg !27 -} - -declare i32 @printf(i8* nocapture readonly, ...) local_unnamed_addr - -; Function Attrs: nounwind readnone -declare void @llvm.dbg.value(metadata, i64, metadata, metadata) #0 - -attributes #0 = { nounwind readnone } - -!llvm.dbg.cu = !{!0} -!llvm.module.flags = !{!12, !13} -!llvm.ident = !{!14} - -!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 3.9.0 (trunk 273884) (llvm/trunk 273897)", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, globals: !3) -!1 = !DIFile(filename: "crash.c", directory: "wasm/tests") -!2 = !{} -!3 = !{!4} -!4 = !DIGlobalVariableExpression(var: !5) -!5 = !DIGlobalVariable(name: "key", scope: !0, file: !1, line: 7, type: !6, isLocal: false, isDefinition: true) -!6 = !DICompositeType(tag: DW_TAG_array_type, baseType: !7, size: 120, align: 8, elements: !10) -!7 = !DIDerivedType(tag: DW_TAG_typedef, name: "uint8_t", file: !8, line: 185, baseType: !9) -!8 = !DIFile(filename: "wasm/emscripten/system/include/libc/bits/alltypes.h", directory: "wasm/tests") -!9 = !DIBasicType(name: "unsigned char", size: 8, align: 8, encoding: DW_ATE_unsigned_char) -!10 = !{!11} -!11 = !DISubrange(count: 15) -!12 = !{i32 2, !"Dwarf Version", i32 4} -!13 = !{i32 2, !"Debug Info Version", i32 3} -!14 = !{!"clang version 3.9.0 (trunk 273884) (llvm/trunk 273897)"} -!15 = distinct !DISubprogram(name: "usage", scope: !1, file: !1, line: 15, type: !16, isLocal: false, isDefinition: true, scopeLine: 15, flags: DIFlagPrototyped, isOptimized: true, unit: !0, variables: !21) -!16 = !DISubroutineType(types: !17) -!17 = !{!18, !19} -!18 = !DIBasicType(name: "int", size: 32, align: 32, encoding: DW_ATE_signed) -!19 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !20, size: 32, align: 32) -!20 = !DIBasicType(name: "char", size: 8, align: 8, encoding: DW_ATE_signed_char) -!21 = !{!22} -!22 = !DILocalVariable(name: "self", arg: 1, scope: !15, file: !1, line: 15, type: !19) -!23 = !{i64 0, !"_ZTSFiPcE"} -!24 = !DIExpression() -!25 = !DILocation(line: 15, column: 17, scope: !15) -!26 = !DILocation(line: 16, column: 3, scope: !15) -!27 = !DILocation(line: 17, column: 3, scope: !15) - diff --git a/test/CodeGen/WebAssembly/dead-vreg.ll b/test/CodeGen/WebAssembly/dead-vreg.ll deleted file mode 100644 index 06487e4cd363..000000000000 --- a/test/CodeGen/WebAssembly/dead-vreg.ll +++ /dev/null @@ -1,51 +0,0 @@ -; RUN: llc < %s -asm-verbose=false -verify-machineinstrs | FileCheck %s - -; 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-wasm" - -define void @foo(i32* nocapture %a, i32 %w, i32 %h) { -; CHECK-LABEL: foo: -; CHECK-NEXT: .param i32, i32, i32{{$}} -; CHECK-NEXT: .local i32, i32, i32, i32, i32, i32{{$}} -entry: - %cmp.19 = icmp sgt i32 %h, 0 - br i1 %cmp.19, label %for.cond.1.preheader.lr.ph, label %for.end.7 - -for.cond.1.preheader.lr.ph: - %cmp2.17 = icmp sgt i32 %w, 0 - br label %for.cond.1.preheader - -for.cond.1.preheader: - %y.020 = phi i32 [ 0, %for.cond.1.preheader.lr.ph ], [ %inc6, %for.inc.5 ] - br i1 %cmp2.17, label %for.body.3.lr.ph, label %for.inc.5 - -for.body.3.lr.ph: - %mul4 = mul nsw i32 %y.020, %w - br label %for.body.3 - -for.body.3: - %x.018 = phi i32 [ 0, %for.body.3.lr.ph ], [ %inc, %for.body.3 ] - %mul = mul nsw i32 %x.018, %y.020 - %add = add nsw i32 %x.018, %mul4 - %arrayidx = getelementptr inbounds i32, i32* %a, i32 %add - store i32 %mul, i32* %arrayidx, align 4 - %inc = add nuw nsw i32 %x.018, 1 - %exitcond = icmp eq i32 %inc, %w - br i1 %exitcond, label %for.inc.5.loopexit, label %for.body.3 - -for.inc.5.loopexit: - br label %for.inc.5 - -for.inc.5: - %inc6 = add nuw nsw i32 %y.020, 1 - %exitcond22 = icmp eq i32 %inc6, %h - br i1 %exitcond22, label %for.end.7.loopexit, label %for.cond.1.preheader - -for.end.7.loopexit: - br label %for.end.7 - -for.end.7: - ret void -} diff --git a/test/CodeGen/WebAssembly/divrem-constant.ll b/test/CodeGen/WebAssembly/divrem-constant.ll deleted file mode 100644 index 1b4d30ad9493..000000000000 --- a/test/CodeGen/WebAssembly/divrem-constant.ll +++ /dev/null @@ -1,62 +0,0 @@ -; RUN: llc < %s -asm-verbose=false | FileCheck %s - -; 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-wasm" - -; CHECK-LABEL: test_udiv_2: -; CHECK: i32.shr_u -define i32 @test_udiv_2(i32 %x) { - %t = udiv i32 %x, 2 - ret i32 %t -} - -; CHECK-LABEL: test_udiv_5: -; CHECK: i32.div_u -define i32 @test_udiv_5(i32 %x) { - %t = udiv i32 %x, 5 - ret i32 %t -} - -; CHECK-LABEL: test_sdiv_2: -; CHECK: i32.div_s -define i32 @test_sdiv_2(i32 %x) { - %t = sdiv i32 %x, 2 - ret i32 %t -} - -; CHECK-LABEL: test_sdiv_5: -; CHECK: i32.div_s -define i32 @test_sdiv_5(i32 %x) { - %t = sdiv i32 %x, 5 - ret i32 %t -} - -; CHECK-LABEL: test_urem_2: -; CHECK: i32.and -define i32 @test_urem_2(i32 %x) { - %t = urem i32 %x, 2 - ret i32 %t -} - -; CHECK-LABEL: test_urem_5: -; CHECK: i32.rem_u -define i32 @test_urem_5(i32 %x) { - %t = urem i32 %x, 5 - ret i32 %t -} - -; CHECK-LABEL: test_srem_2: -; CHECK: i32.rem_s -define i32 @test_srem_2(i32 %x) { - %t = srem i32 %x, 2 - ret i32 %t -} - -; CHECK-LABEL: test_srem_5: -; CHECK: i32.rem_s -define i32 @test_srem_5(i32 %x) { - %t = srem i32 %x, 5 - ret i32 %t -} diff --git a/test/CodeGen/WebAssembly/f16.ll b/test/CodeGen/WebAssembly/f16.ll deleted file mode 100644 index 6915f93e9b96..000000000000 --- a/test/CodeGen/WebAssembly/f16.ll +++ /dev/null @@ -1,29 +0,0 @@ -; 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 deleted file mode 100644 index 45f00aa5a01f..000000000000 --- a/test/CodeGen/WebAssembly/f32.ll +++ /dev/null @@ -1,156 +0,0 @@ -; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt | FileCheck %s - -; 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-wasm" - -declare float @llvm.fabs.f32(float) -declare float @llvm.copysign.f32(float, float) -declare float @llvm.sqrt.f32(float) -declare float @llvm.ceil.f32(float) -declare float @llvm.floor.f32(float) -declare float @llvm.trunc.f32(float) -declare float @llvm.nearbyint.f32(float) -declare float @llvm.rint.f32(float) -declare float @llvm.fma.f32(float, float, float) - -; CHECK-LABEL: fadd32: -; CHECK-NEXT: .param f32, f32{{$}} -; CHECK-NEXT: .result f32{{$}} -; 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 $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 $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 $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 $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 $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 $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 $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 $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 $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 $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 $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 $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 -} - -; Min and max tests. LLVM currently only forms fminnan and fmaxnan nodes in -; cases where there's a single fcmp with a select and it can prove that one -; of the arms is never NaN, so we only test that case. In the future if LLVM -; learns to form fminnan/fmaxnan in more cases, we can write more general -; tests. - -; CHECK-LABEL: fmin32: -; 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 - %b = select i1 %a, float %x, float 0.0 - ret float %b -} - -; CHECK-LABEL: fmax32: -; 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 - %b = select i1 %a, float %x, float 0.0 - ret float %b -} - -; CHECK-LABEL: fma32: -; 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 deleted file mode 100644 index fb52c3f92ad6..000000000000 --- a/test/CodeGen/WebAssembly/f64.ll +++ /dev/null @@ -1,156 +0,0 @@ -; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt | FileCheck %s - -; 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-wasm" - -declare double @llvm.fabs.f64(double) -declare double @llvm.copysign.f64(double, double) -declare double @llvm.sqrt.f64(double) -declare double @llvm.ceil.f64(double) -declare double @llvm.floor.f64(double) -declare double @llvm.trunc.f64(double) -declare double @llvm.nearbyint.f64(double) -declare double @llvm.rint.f64(double) -declare double @llvm.fma.f64(double, double, double) - -; CHECK-LABEL: fadd64: -; CHECK-NEXT: .param f64, f64{{$}} -; CHECK-NEXT: .result f64{{$}} -; 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 $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 $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 $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 $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 $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 $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 $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 $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 $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 $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 $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 $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 -} - -; Min and max tests. LLVM currently only forms fminnan and fmaxnan nodes in -; cases where there's a single fcmp with a select and it can prove that one -; of the arms is never NaN, so we only test that case. In the future if LLVM -; learns to form fminnan/fmaxnan in more cases, we can write more general -; tests. - -; CHECK-LABEL: fmin64: -; 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 - %b = select i1 %a, double %x, double 0.0 - ret double %b -} - -; CHECK-LABEL: fmax64: -; 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 - %b = select i1 %a, double %x, double 0.0 - ret double %b -} - -; CHECK-LABEL: fma64: -; 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 deleted file mode 100644 index 229651d093f0..000000000000 --- a/test/CodeGen/WebAssembly/fast-isel-noreg.ll +++ /dev/null @@ -1,35 +0,0 @@ -; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -verify-machineinstrs | FileCheck %s -; RUN: llc < %s -asm-verbose=false -fast-isel -verify-machineinstrs | FileCheck %s - -; 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-wasm" - -; CHECK: i32.const $push0=, 0 -define hidden i32 @a() #0 { -entry: - ret i32 zext (i1 icmp eq (void (...)* inttoptr (i32 10 to void (...)*), void (...)* null) to i32) -} - -; CHECK: i32.const $push0=, 1 -; CHECK: br_if 0, $pop0 -define hidden i32 @b() #0 { -entry: - br i1 icmp eq (void (...)* inttoptr (i32 10 to void (...)*), void (...)* null), label %a, label %b -a: - unreachable -b: - ret i32 0 -} - -; CHECK: i32.const $push1=, 0 -; CHECK: i32.const $push2=, 0 -; CHECK: i32.store 0($pop1), $pop2 -define hidden i32 @c() #0 { -entry: - store i32 zext (i1 icmp eq (void (...)* inttoptr (i32 10 to void (...)*), void (...)* null) to i32), i32* inttoptr (i32 0 to i32 *) - ret i32 0 -} - -attributes #0 = { noinline optnone } diff --git a/test/CodeGen/WebAssembly/fast-isel.ll b/test/CodeGen/WebAssembly/fast-isel.ll deleted file mode 100644 index 457c5874e493..000000000000 --- a/test/CodeGen/WebAssembly/fast-isel.ll +++ /dev/null @@ -1,79 +0,0 @@ -; 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-wasm" - -; This tests very minimal fast-isel functionality. - -; CHECK-LABEL: immediate_f32: -; CHECK: f32.const $push{{[0-9]+}}=, 0x1.4p1{{$}} -define float @immediate_f32() { - ret float 2.5 -} - -; CHECK-LABEL: immediate_f64: -; CHECK: f64.const $push{{[0-9]+}}=, 0x1.4p1{{$}} -define double @immediate_f64() { - ret double 2.5 -} - -; CHECK-LABEL: bitcast_i32_f32: -; CHECK: i32.reinterpret/f32 $push{{[0-9]+}}=, $0{{$}} -define i32 @bitcast_i32_f32(float %x) { - %y = bitcast float %x to i32 - ret i32 %y -} - -; CHECK-LABEL: bitcast_f32_i32: -; CHECK: f32.reinterpret/i32 $push{{[0-9]+}}=, $0{{$}} -define float @bitcast_f32_i32(i32 %x) { - %y = bitcast i32 %x to float - ret float %y -} - -; CHECK-LABEL: bitcast_i64_f64: -; CHECK: i64.reinterpret/f64 $push{{[0-9]+}}=, $0{{$}} -define i64 @bitcast_i64_f64(double %x) { - %y = bitcast double %x to i64 - ret i64 %y -} - -; CHECK-LABEL: bitcast_f64_i64: -; CHECK: f64.reinterpret/i64 $push{{[0-9]+}}=, $0{{$}} -define double @bitcast_f64_i64(i64 %x) { - %y = bitcast i64 %x to double - ret double %y -} - -; Do fold offsets into geps. -; CHECK-LABEL: do_fold_offset_into_gep: -; CHECK: i64.load $push{{[0-9]+}}=, 8($0) -define i64 @do_fold_offset_into_gep(i64* %p) { -bb: - %tmp = getelementptr inbounds i64, i64* %p, i32 1 - %tmp2 = load i64, i64* %tmp, align 8 - ret i64 %tmp2 -} - -; Don't fold negative offsets into geps. -; CHECK-LABEL: dont_fold_negative_offset: -; CHECK: i64.load $push{{[0-9]+}}=, 0($pop{{[0-9]+}}) -define i64 @dont_fold_negative_offset(i64* %p) { -bb: - %tmp = getelementptr inbounds i64, i64* %p, i32 -1 - %tmp2 = load i64, i64* %tmp, align 8 - ret i64 %tmp2 -} - -; Don't fold non-inbounds geps. -; CHECK-LABEL: dont_fold_non_inbounds_gep: -; CHECK: i64.load $push{{[0-9]+}}=, 0($pop{{[0-9]+}}) -define i64 @dont_fold_non_inbounds_gep(i64* %p) { -bb: - %tmp = getelementptr i64, i64* %p, i32 1 - %tmp2 = load i64, i64* %tmp, align 8 - ret i64 %tmp2 -} diff --git a/test/CodeGen/WebAssembly/frem.ll b/test/CodeGen/WebAssembly/frem.ll deleted file mode 100644 index 1a9c13417b67..000000000000 --- a/test/CodeGen/WebAssembly/frem.ll +++ /dev/null @@ -1,26 +0,0 @@ -; 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-wasm" - -; CHECK-LABEL: frem32: -; CHECK-NEXT: .param f32, f32{{$}} -; CHECK-NEXT: .result f32{{$}} -; CHECK-NEXT: {{^}} f32.call $push0=, fmodf@FUNCTION, $0, $1{{$}} -; CHECK-NEXT: return $pop0{{$}} -define float @frem32(float %x, float %y) { - %a = frem float %x, %y - ret float %a -} - -; CHECK-LABEL: frem64: -; CHECK-NEXT: .param f64, f64{{$}} -; CHECK-NEXT: .result f64{{$}} -; CHECK-NEXT: {{^}} f64.call $push0=, fmod@FUNCTION, $0, $1{{$}} -; CHECK-NEXT: return $pop0{{$}} -define double @frem64(double %x, double %y) { - %a = frem double %x, %y - ret double %a -} diff --git a/test/CodeGen/WebAssembly/func.ll b/test/CodeGen/WebAssembly/func.ll deleted file mode 100644 index 994ef62bf54d..000000000000 --- a/test/CodeGen/WebAssembly/func.ll +++ /dev/null @@ -1,64 +0,0 @@ -; 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-wasm" - -; CHECK-LABEL: f0: -; CHECK: return{{$}} -; CHECK: end_function{{$}} -; CHECK: .size f0, -define void @f0() { - ret void -} - -; CHECK-LABEL: f1: -; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: i32.const $push[[NUM:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -; CHECK: .size f1, -define i32 @f1() { - ret i32 0 -} - -; CHECK-LABEL: f2: -; CHECK-NEXT: .param i32, f32{{$}} -; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: i32.const $push[[NUM:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -; CHECK: .size f2, -define i32 @f2(i32 %p1, float %p2) { - ret i32 0 -} - -; CHECK-LABEL: f3: -; CHECK-NEXT: .param i32, f32{{$}} -; CHECK-NOT: local -; CHECK-NEXT: return{{$}} -; CHECK: .size f3, -define void @f3(i32 %p1, float %p2) { - ret void -} - -; CHECK-LABEL: f4: -; CHECK-NEXT: .param i32{{$}} -; CHECK-NEXT: .result i32{{$}} -; CHECK-NOT: local -; CHECK: .size f4, -define i32 @f4(i32 %x) { -entry: - %c = trunc i32 %x to i1 - br i1 %c, label %true, label %false -true: - ret i32 0 -false: - ret i32 1 -} - -; CHECK-LABEL: f5: -; CHECK-NEXT: .result f32{{$}} -; CHECK-NEXT: unreachable -define float @f5() { - unreachable -} diff --git a/test/CodeGen/WebAssembly/function-bitcasts.ll b/test/CodeGen/WebAssembly/function-bitcasts.ll deleted file mode 100644 index 3f20aef08115..000000000000 --- a/test/CodeGen/WebAssembly/function-bitcasts.ll +++ /dev/null @@ -1,86 +0,0 @@ -; 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-wasm" - -; CHECK-LABEL: test: -; CHECK-NEXT: call .Lbitcast@FUNCTION{{$}} -; CHECK-NEXT: call .Lbitcast@FUNCTION{{$}} -; CHECK-NEXT: call .Lbitcast.1@FUNCTION{{$}} -; CHECK-NEXT: i32.const $push[[L0:[0-9]+]]=, 0 -; CHECK-NEXT: call .Lbitcast.2@FUNCTION, $pop[[L0]]{{$}} -; CHECK-NEXT: i32.const $push[[L1:[0-9]+]]=, 0 -; CHECK-NEXT: call .Lbitcast.2@FUNCTION, $pop[[L1]]{{$}} -; CHECK-NEXT: i32.const $push[[L2:[0-9]+]]=, 0 -; CHECK-NEXT: call .Lbitcast.2@FUNCTION, $pop[[L2]]{{$}} -; CHECK-NEXT: call foo0@FUNCTION -; CHECK-NEXT: i32.call $drop=, .Lbitcast.3@FUNCTION{{$}} -; CHECK-NEXT: call foo2@FUNCTION{{$}} -; CHECK-NEXT: call foo1@FUNCTION{{$}} -; CHECK-NEXT: call foo3@FUNCTION{{$}} -; 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: call has_i32_arg@FUNCTION, $0{{$}} -; CHECK-NEXT: end_function - -; CHECK-LABEL: .Lbitcast.1: -; CHECK-NEXT: call $drop=, has_i32_ret@FUNCTION{{$}} -; CHECK-NEXT: end_function - -; CHECK-LABEL: .Lbitcast.2: -; CHECK-NEXT: .param i32 -; CHECK-NEXT: call foo0@FUNCTION{{$}} -; CHECK-NEXT: end_function - -; CHECK-LABEL: .Lbitcast.3: -; CHECK-NEXT: .result i32 -; CHECK-NEXT: call foo1@FUNCTION{{$}} -; CHECK-NEXT: copy_local $push0=, $0 -; 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() -declare void @foo2() -declare void @foo3() - -define void @test() { -entry: - call void bitcast (void (i32)* @has_i32_arg to void ()*)() - call void bitcast (void (i32)* @has_i32_arg to void ()*)() - call void bitcast (i32 ()* @has_i32_ret to void ()*)() - call void bitcast (void ()* @foo0 to void (i32)*)(i32 0) - %p = bitcast void ()* @foo0 to void (i32)* - call void %p(i32 0) - %q = bitcast void ()* @foo0 to void (i32)* - call void %q(i32 0) - %r = bitcast void (i32)* %q to void ()* - call void %r() - %t = call i32 bitcast (void ()* @foo1 to i32 ()*)() - call void bitcast (void ()* @foo2 to void ()*)() - call void @foo1() - call void @foo3() - - 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 deleted file mode 100644 index 599eb53b431b..000000000000 --- a/test/CodeGen/WebAssembly/global.ll +++ /dev/null @@ -1,215 +0,0 @@ -; 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-wasm" - -; CHECK-NOT: llvm.used -; CHECK-NOT: llvm.metadata -@llvm.used = appending global [1 x i32*] [i32* @g], section "llvm.metadata" - -; CHECK: foo: -; CHECK: i32.const $push0=, 0{{$}} -; CHECK-NEXT: i32.load $push1=, answer($pop0){{$}} -; CHECK-NEXT: return $pop1{{$}} -define i32 @foo() { - %a = load i32, i32* @answer - ret i32 %a -} - -; CHECK-LABEL: call_memcpy: -; CHECK-NEXT: .param i32, i32, i32{{$}} -; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: i32.call $push0=, memcpy@FUNCTION, $0, $1, $2{{$}} -; CHECK-NEXT: return $pop0{{$}} -declare void @llvm.memcpy.p0i8.p0i8.i32(i8* nocapture, i8* nocapture readonly, i32, i32, i1) -define i8* @call_memcpy(i8* %p, i8* nocapture readonly %q, i32 %n) { - tail call void @llvm.memcpy.p0i8.p0i8.i32(i8* %p, i8* %q, i32 %n, i32 1, i1 false) - ret i8* %p -} - -; CHECK: .type .Lg,@object -; CHECK: .p2align 2{{$}} -; CHECK-NEXT: .Lg: -; CHECK-NEXT: .int32 1337{{$}} -; CHECK-NEXT: .size .Lg, 4{{$}} -@g = private global i32 1337 - -; CHECK-LABEL: ud: -; CHECK-NEXT: .skip 4{{$}} -; CHECK-NEXT: .size ud, 4{{$}} -@ud = internal global i32 undef - -; CHECK: .type nil,@object -; CHECK: .p2align 2 -; CHECK: nil: -; CHECK: .int32 0 -; CHECK: .size nil, 4 -@nil = internal global i32 zeroinitializer - -; CHECK: .type z,@object -; CHECK: .p2align 2 -; CHECK: z: -; CHECK: .int32 0 -; CHECK: .size z, 4 -@z = internal global i32 0 - -; CHECK: .type one,@object -; CHECK: .p2align 2{{$}} -; CHECK-NEXT: one: -; CHECK-NEXT: .int32 1{{$}} -; CHECK-NEXT: .size one, 4{{$}} -@one = internal global i32 1 - -; CHECK: .type answer,@object -; CHECK: .p2align 2{{$}} -; CHECK-NEXT: answer: -; CHECK-NEXT: .int32 42{{$}} -; CHECK-NEXT: .size answer, 4{{$}} -@answer = internal global i32 42 - -; CHECK: .type u32max,@object -; CHECK: .p2align 2{{$}} -; CHECK-NEXT: u32max: -; CHECK-NEXT: .int32 4294967295{{$}} -; CHECK-NEXT: .size u32max, 4{{$}} -@u32max = internal global i32 -1 - -; CHECK: .type ud64,@object -; CHECK: .p2align 3{{$}} -; CHECK-NEXT: ud64: -; CHECK-NEXT: .skip 8{{$}} -; CHECK-NEXT: .size ud64, 8{{$}} -@ud64 = internal global i64 undef - -; CHECK: .type nil64,@object -; 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: .p2align 3{{$}} -; CHECK-NEXT: z64: -; CHECK-NEXT: .int64 0{{$}} -; CHECK-NEXT: .size z64, 8{{$}} -@z64 = internal global i64 0 - -; CHECK: .type twoP32,@object -; CHECK: .p2align 3{{$}} -; CHECK-NEXT: twoP32: -; CHECK-NEXT: .int64 4294967296{{$}} -; CHECK-NEXT: .size twoP32, 8{{$}} -@twoP32 = internal global i64 4294967296 - -; CHECK: .type u64max,@object -; CHECK: .p2align 3{{$}} -; CHECK-NEXT: u64max: -; CHECK-NEXT: .int64 -1{{$}} -; CHECK-NEXT: .size u64max, 8{{$}} -@u64max = internal global i64 -1 - -; CHECK: .type f32ud,@object -; CHECK: .p2align 2{{$}} -; CHECK-NEXT: f32ud: -; CHECK-NEXT: .skip 4{{$}} -; CHECK-NEXT: .size f32ud, 4{{$}} -@f32ud = internal global float undef - -; CHECK: .type f32nil,@object -; 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: .p2align 2{{$}} -; CHECK-NEXT: f32z: -; CHECK-NEXT: .int32 0{{$}} -; CHECK-NEXT: .size f32z, 4{{$}} -@f32z = internal global float 0.0 - -; CHECK: .type f32nz,@object -; CHECK: .p2align 2{{$}} -; CHECK: f32nz: -; CHECK: .int32 2147483648{{$}} -; CHECK: .size f32nz, 4{{$}} -@f32nz = internal global float -0.0 - -; CHECK: .type f32two,@object -; CHECK: .p2align 2{{$}} -; CHECK-NEXT: f32two: -; CHECK-NEXT: .int32 1073741824{{$}} -; CHECK-NEXT: .size f32two, 4{{$}} -@f32two = internal global float 2.0 - -; CHECK: .type f64ud,@object -; CHECK: .p2align 3{{$}} -; CHECK-NEXT: f64ud: -; CHECK-NEXT: .skip 8{{$}} -; CHECK-NEXT: .size f64ud, 8{{$}} -@f64ud = internal global double undef - -; CHECK: .type f64nil,@object -; 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: .p2align 3{{$}} -; CHECK-NEXT: f64z: -; CHECK-NEXT: .int64 0{{$}} -; CHECK-NEXT: .size f64z, 8{{$}} -@f64z = internal global double 0.0 - -; CHECK: .type f64nz,@object -; CHECK: .p2align 3{{$}} -; CHECK-NEXT: f64nz: -; CHECK-NEXT: .int64 -9223372036854775808{{$}} -; CHECK-NEXT: .size f64nz, 8{{$}} -@f64nz = internal global double -0.0 - -; CHECK: .type f64two,@object -; CHECK: .p2align 3{{$}} -; CHECK-NEXT: f64two: -; CHECK-NEXT: .int64 4611686018427387904{{$}} -; CHECK-NEXT: .size f64two, 8{{$}} -@f64two = internal global double 2.0 - -; Indexing into a global array produces a relocation. -; CHECK: .type arr,@object -; CHECK: .type ptr,@object -; CHECK: ptr: -; CHECK-NEXT: .int32 arr+80 -; CHECK-NEXT: .size ptr, 4 -@arr = global [128 x i32] zeroinitializer, align 16 -@ptr = global i32* getelementptr inbounds ([128 x i32], [128 x i32]* @arr, i32 0, i32 20), align 4 - -; Constant global. -; CHECK: .type rom,@object{{$}} -; CHECK: .section .rodata.rom, -; CHECK: .globl rom{{$}} -; CHECK: .p2align 4{{$}} -; CHECK: rom: -; CHECK: .skip 512{{$}} -; CHECK: .size rom, 512{{$}} -@rom = constant [128 x i32] zeroinitializer, align 16 - -; CHECK: .type array,@object -; CHECK: array: -; CHECK-NEXT: .skip 8 -; CHECK-NEXT: .size array, 8 -; CHECK: .type pointer_to_array,@object -; CHECK-NEXT: .section .data.rel.ro.pointer_to_array, -; CHECK-NEXT: .globl pointer_to_array -; CHECK-NEXT: .p2align 2 -; CHECK-NEXT: pointer_to_array: -; CHECK-NEXT: .int32 array+4 -; CHECK-NEXT: .size pointer_to_array, 4 -@array = internal constant [8 x i8] zeroinitializer, align 1 -@pointer_to_array = constant i8* getelementptr inbounds ([8 x i8], [8 x i8]* @array, i32 0, i32 4), align 4 diff --git a/test/CodeGen/WebAssembly/globl.ll b/test/CodeGen/WebAssembly/globl.ll deleted file mode 100644 index ba9f6659d7d7..000000000000 --- a/test/CodeGen/WebAssembly/globl.ll +++ /dev/null @@ -1,14 +0,0 @@ -; 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-wasm" - -; CHECK: .globl foo -; CHECK-LABEL: foo: -define void @foo() { - ret void -} - -; Check import directives - must be at the end of the file -; CHECK: .import_global bar{{$}} -@bar = external global i32 diff --git a/test/CodeGen/WebAssembly/i128.ll b/test/CodeGen/WebAssembly/i128.ll deleted file mode 100644 index 2e44af9c5184..000000000000 --- a/test/CodeGen/WebAssembly/i128.ll +++ /dev/null @@ -1,280 +0,0 @@ -; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt | FileCheck %s - -; 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-wasm" - -declare i128 @llvm.ctlz.i128(i128, i1) -declare i128 @llvm.cttz.i128(i128, i1) -declare i128 @llvm.ctpop.i128(i128) - -; CHECK-LABEL: add128: -; CHECK-NEXT: .param i32, i64, i64, i64, i64{{$}} -; CHECK-NOT: .result -; CHECK: i64.add -; CHECK: i64.store -; CHECK: i64.add -; CHECK: i64.store -; CHECK-NEXT: return{{$}} -define i128 @add128(i128 %x, i128 %y) { - %a = add i128 %x, %y - ret i128 %a -} - -; CHECK-LABEL: sub128: -; CHECK-NEXT: .param i32, i64, i64, i64, i64{{$}} -; CHECK-NOT: .result -; CHECK: i64.sub -; CHECK: i64.store -; CHECK: i64.sub -; CHECK: i64.store -; CHECK-NEXT: return{{$}} -define i128 @sub128(i128 %x, i128 %y) { - %a = sub i128 %x, %y - ret i128 %a -} - -; CHECK-LABEL: mul128: -; CHECK-NEXT: .param i32, i64, i64, i64, i64{{$}} -; CHECK-NOT: .result -; CHECK: call __multi3@FUNCTION, ${{.+}}, ${{.+}}, ${{.+}}, ${{.+}}, ${{.+}}{{$}} -; CHECK: return{{$}} -define i128 @mul128(i128 %x, i128 %y) { - %a = mul i128 %x, %y - ret i128 %a -} - -; CHECK-LABEL: sdiv128: -; CHECK-NEXT: .param i32, i64, i64, i64, i64{{$}} -; CHECK-NOT: .result -; CHECK: call __divti3@FUNCTION, ${{.+}}, ${{.+}}, ${{.+}}, ${{.+}}, ${{.+}}{{$}} -; CHECK: return{{$}} -define i128 @sdiv128(i128 %x, i128 %y) { - %a = sdiv i128 %x, %y - ret i128 %a -} - -; CHECK-LABEL: udiv128: -; CHECK-NEXT: .param i32, i64, i64, i64, i64{{$}} -; CHECK-NOT: .result -; CHECK: call __udivti3@FUNCTION, ${{.+}}, ${{.+}}, ${{.+}}, ${{.+}}, ${{.+}}{{$}} -; CHECK: return{{$}} -define i128 @udiv128(i128 %x, i128 %y) { - %a = udiv i128 %x, %y - ret i128 %a -} - -; CHECK-LABEL: srem128: -; CHECK-NEXT: .param i32, i64, i64, i64, i64{{$}} -; CHECK-NOT: .result -; CHECK: call __modti3@FUNCTION, ${{.+}}, ${{.+}}, ${{.+}}, ${{.+}}, ${{.+}}{{$}} -; CHECK: return{{$}} -define i128 @srem128(i128 %x, i128 %y) { - %a = srem i128 %x, %y - ret i128 %a -} - -; CHECK-LABEL: urem128: -; CHECK-NEXT: .param i32, i64, i64, i64, i64{{$}} -; CHECK-NOT: .result -; CHECK: call __umodti3@FUNCTION, ${{.+}}, ${{.+}}, ${{.+}}, ${{.+}}, ${{.+}}{{$}} -; CHECK: return{{$}} -define i128 @urem128(i128 %x, i128 %y) { - %a = urem i128 %x, %y - ret i128 %a -} - -; CHECK-LABEL: and128: -; CHECK-NEXT: .param i32, i64, i64, i64, i64{{$}} -; CHECK-NOT: .result -; CHECK: i64.and -; CHECK: i64.store -; CHECK: i64.and -; CHECK: i64.store -; CHECK-NEXT: return{{$}} -define i128 @and128(i128 %x, i128 %y) { - %a = and i128 %x, %y - ret i128 %a -} - -; CHECK-LABEL: or128: -; CHECK-NEXT: .param i32, i64, i64, i64, i64{{$}} -; CHECK-NOT: .result -; CHECK: i64.or -; CHECK: i64.store -; CHECK: i64.or -; CHECK: i64.store -; CHECK-NEXT: return{{$}} -define i128 @or128(i128 %x, i128 %y) { - %a = or i128 %x, %y - ret i128 %a -} - -; CHECK-LABEL: xor128: -; CHECK-NEXT: .param i32, i64, i64, i64, i64{{$}} -; CHECK-NOT: .result -; CHECK: i64.xor -; CHECK: i64.store -; CHECK: i64.xor -; CHECK: i64.store -; CHECK-NEXT: return{{$}} -define i128 @xor128(i128 %x, i128 %y) { - %a = xor i128 %x, %y - ret i128 %a -} - -; CHECK-LABEL: shl128: -; CHECK-NEXT: .param i32, i64, i64, i64, i64{{$}} -; CHECK-NOT: .result -; CHECK: call __ashlti3@FUNCTION, ${{.+}}, ${{.+}}, ${{.+}}, ${{.+}}{{$}} -; CHECK: return{{$}} -define i128 @shl128(i128 %x, i128 %y) { - %a = shl i128 %x, %y - ret i128 %a -} - -; CHECK-LABEL: shr128: -; CHECK-NEXT: .param i32, i64, i64, i64, i64{{$}} -; CHECK-NOT: .result -; CHECK: call __lshrti3@FUNCTION, ${{.+}}, ${{.+}}, ${{.+}}, ${{.+}}{{$}} -; CHECK: return{{$}} -define i128 @shr128(i128 %x, i128 %y) { - %a = lshr i128 %x, %y - ret i128 %a -} - -; CHECK-LABEL: sar128: -; CHECK-NEXT: .param i32, i64, i64, i64, i64{{$}} -; CHECK-NOT: .result -; CHECK: call __ashrti3@FUNCTION, ${{.+}}, ${{.+}}, ${{.+}}, ${{.+}}{{$}} -; CHECK: return{{$}} -define i128 @sar128(i128 %x, i128 %y) { - %a = ashr i128 %x, %y - ret i128 %a -} - -; CHECK-LABEL: clz128: -; CHECK-NEXT: .param i32, i64, i64{{$}} -; CHECK-NOT: .result -; CHECK: i64.clz -; CHECK: i64.clz -; CHECK: return{{$}} -define i128 @clz128(i128 %x) { - %a = call i128 @llvm.ctlz.i128(i128 %x, i1 false) - ret i128 %a -} - -; CHECK-LABEL: clz128_zero_undef: -; CHECK-NEXT: .param i32, i64, i64{{$}} -; CHECK-NOT: .result -; CHECK: i64.clz -; CHECK: i64.clz -; CHECK: return{{$}} -define i128 @clz128_zero_undef(i128 %x) { - %a = call i128 @llvm.ctlz.i128(i128 %x, i1 true) - ret i128 %a -} - -; CHECK-LABEL: ctz128: -; CHECK-NEXT: .param i32, i64, i64{{$}} -; CHECK-NOT: .result -; CHECK: i64.ctz -; CHECK: i64.ctz -; CHECK: return{{$}} -define i128 @ctz128(i128 %x) { - %a = call i128 @llvm.cttz.i128(i128 %x, i1 false) - ret i128 %a -} - -; CHECK-LABEL: ctz128_zero_undef: -; CHECK-NEXT: .param i32, i64, i64{{$}} -; CHECK-NOT: .result -; CHECK: i64.ctz -; CHECK: i64.ctz -; CHECK: return{{$}} -define i128 @ctz128_zero_undef(i128 %x) { - %a = call i128 @llvm.cttz.i128(i128 %x, i1 true) - ret i128 %a -} - -; CHECK-LABEL: popcnt128: -; CHECK-NEXT: .param i32, i64, i64{{$}} -; CHECK-NOT: .result -; CHECK: i64.popcnt -; CHECK: i64.popcnt -; CHECK: return{{$}} -define i128 @popcnt128(i128 %x) { - %a = call i128 @llvm.ctpop.i128(i128 %x) - ret i128 %a -} - -; CHECK-LABEL: eqz128: -; CHECK-NEXT: .param i64, i64{{$}} -; CHECK-NEXT: .result i32{{$}} -; CHECK: i64.or -; CHECK: i64.eqz -; CHECK: return $ -define i32 @eqz128(i128 %x) { - %a = icmp eq i128 %x, 0 - %b = zext i1 %a to i32 - ret i32 %b -} - -; CHECK-LABEL: rotl: -; CHECK-NEXT: .param i32, i64, i64, i64, i64{{$}} -; CHECK-NOT: .result -; CHECK: call __ashlti3@FUNCTION, ${{.+}}, ${{.+}}, ${{.+}}, ${{.+}}{{$}} -; CHECK: call __lshrti3@FUNCTION, ${{.+}}, ${{.+}}, ${{.+}}, ${{.+}}{{$}} -; CHECK: return{{$}} -define i128 @rotl(i128 %x, i128 %y) { - %z = sub i128 128, %y - %b = shl i128 %x, %y - %c = lshr i128 %x, %z - %d = or i128 %b, %c - ret i128 %d -} - -; CHECK-LABEL: masked_rotl: -; CHECK-NEXT: .param i32, i64, i64, i64, i64{{$}} -; CHECK-NOT: .result -; CHECK: call __ashlti3@FUNCTION, ${{.+}}, ${{.+}}, ${{.+}}, ${{.+}}{{$}} -; CHECK: call __lshrti3@FUNCTION, ${{.+}}, ${{.+}}, ${{.+}}, ${{.+}}{{$}} -; CHECK: return{{$}} -define i128 @masked_rotl(i128 %x, i128 %y) { - %a = and i128 %y, 127 - %z = sub i128 128, %a - %b = shl i128 %x, %a - %c = lshr i128 %x, %z - %d = or i128 %b, %c - ret i128 %d -} - -; CHECK-LABEL: rotr: -; CHECK-NEXT: .param i32, i64, i64, i64, i64{{$}} -; CHECK-NOT: .result -; CHECK: call __lshrti3@FUNCTION, ${{.+}}, ${{.+}}, ${{.+}}, ${{.+}}{{$}} -; CHECK: call __ashlti3@FUNCTION, ${{.+}}, ${{.+}}, ${{.+}}, ${{.+}}{{$}} -; CHECK: return{{$}} -define i128 @rotr(i128 %x, i128 %y) { - %z = sub i128 128, %y - %b = lshr i128 %x, %y - %c = shl i128 %x, %z - %d = or i128 %b, %c - ret i128 %d -} - -; CHECK-LABEL: masked_rotr: -; CHECK-NEXT: .param i32, i64, i64, i64, i64{{$}} -; CHECK-NOT: .result -; CHECK: call __lshrti3@FUNCTION, ${{.+}}, ${{.+}}, ${{.+}}, ${{.+}}{{$}} -; CHECK: call __ashlti3@FUNCTION, ${{.+}}, ${{.+}}, ${{.+}}, ${{.+}}{{$}} -; CHECK: return{{$}} -define i128 @masked_rotr(i128 %x, i128 %y) { - %a = and i128 %y, 127 - %z = sub i128 128, %a - %b = lshr i128 %x, %a - %c = shl i128 %x, %z - %d = or i128 %b, %c - ret i128 %d -} diff --git a/test/CodeGen/WebAssembly/i32-load-store-alignment.ll b/test/CodeGen/WebAssembly/i32-load-store-alignment.ll deleted file mode 100644 index 661d1b7bfc3e..000000000000 --- a/test/CodeGen/WebAssembly/i32-load-store-alignment.ll +++ /dev/null @@ -1,212 +0,0 @@ -; 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-wasm" - -; CHECK-LABEL: ldi32_a1: -; CHECK-NEXT: .param i32{{$}} -; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: i32.load $push[[NUM:[0-9]+]]=, 0($0):p2align=0{{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define i32 @ldi32_a1(i32 *%p) { - %v = load i32, i32* %p, align 1 - ret i32 %v -} - -; CHECK-LABEL: ldi32_a2: -; CHECK-NEXT: .param i32{{$}} -; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: i32.load $push[[NUM:[0-9]+]]=, 0($0):p2align=1{{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define i32 @ldi32_a2(i32 *%p) { - %v = load i32, i32* %p, align 2 - ret i32 %v -} - -; 4 is the default alignment for i32 so no attribute is needed. - -; CHECK-LABEL: ldi32_a4: -; CHECK-NEXT: .param i32{{$}} -; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: i32.load $push[[NUM:[0-9]+]]=, 0($0){{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define i32 @ldi32_a4(i32 *%p) { - %v = load i32, i32* %p, align 4 - ret i32 %v -} - -; The default alignment in LLVM is the same as the defualt alignment in wasm. - -; CHECK-LABEL: ldi32: -; CHECK-NEXT: .param i32{{$}} -; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: i32.load $push[[NUM:[0-9]+]]=, 0($0){{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define i32 @ldi32(i32 *%p) { - %v = load i32, i32* %p - ret i32 %v -} - -; 8 is greater than the default alignment so it is ignored. - -; CHECK-LABEL: ldi32_a8: -; CHECK-NEXT: .param i32{{$}} -; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: i32.load $push[[NUM:[0-9]+]]=, 0($0){{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define i32 @ldi32_a8(i32 *%p) { - %v = load i32, i32* %p, align 8 - ret i32 %v -} - -; Extending loads. - -; CHECK-LABEL: ldi8_a1: -; CHECK-NEXT: .param i32{{$}} -; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: i32.load8_u $push[[NUM:[0-9]+]]=, 0($0){{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define i8 @ldi8_a1(i8 *%p) { - %v = load i8, i8* %p, align 1 - ret i8 %v -} - -; CHECK-LABEL: ldi8_a2: -; CHECK-NEXT: .param i32{{$}} -; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: i32.load8_u $push[[NUM:[0-9]+]]=, 0($0){{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define i8 @ldi8_a2(i8 *%p) { - %v = load i8, i8* %p, align 2 - ret i8 %v -} - -; CHECK-LABEL: ldi16_a1: -; CHECK-NEXT: .param i32{{$}} -; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: i32.load16_u $push[[NUM:[0-9]+]]=, 0($0):p2align=0{{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define i16 @ldi16_a1(i16 *%p) { - %v = load i16, i16* %p, align 1 - ret i16 %v -} - -; CHECK-LABEL: ldi16_a2: -; CHECK-NEXT: .param i32{{$}} -; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: i32.load16_u $push[[NUM:[0-9]+]]=, 0($0){{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define i16 @ldi16_a2(i16 *%p) { - %v = load i16, i16* %p, align 2 - ret i16 %v -} - -; CHECK-LABEL: ldi16_a4: -; CHECK-NEXT: .param i32{{$}} -; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: i32.load16_u $push[[NUM:[0-9]+]]=, 0($0){{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define i16 @ldi16_a4(i16 *%p) { - %v = load i16, i16* %p, align 4 - ret i16 %v -} - -; Stores. - -; CHECK-LABEL: sti32_a1: -; CHECK-NEXT: .param i32, i32{{$}} -; CHECK-NEXT: i32.store 0($0):p2align=0, $1{{$}} -; CHECK-NEXT: return{{$}} -define void @sti32_a1(i32 *%p, i32 %v) { - store i32 %v, i32* %p, align 1 - ret void -} - -; CHECK-LABEL: sti32_a2: -; CHECK-NEXT: .param i32, i32{{$}} -; CHECK-NEXT: i32.store 0($0):p2align=1, $1{{$}} -; CHECK-NEXT: return{{$}} -define void @sti32_a2(i32 *%p, i32 %v) { - store i32 %v, i32* %p, align 2 - ret void -} - -; 4 is the default alignment for i32 so no attribute is needed. - -; CHECK-LABEL: sti32_a4: -; CHECK-NEXT: .param i32, i32{{$}} -; CHECK-NEXT: i32.store 0($0), $1{{$}} -; CHECK-NEXT: return{{$}} -define void @sti32_a4(i32 *%p, i32 %v) { - store i32 %v, i32* %p, align 4 - ret void -} - -; The default alignment in LLVM is the same as the defualt alignment in wasm. - -; CHECK-LABEL: sti32: -; CHECK-NEXT: .param i32, i32{{$}} -; CHECK-NEXT: i32.store 0($0), $1{{$}} -; CHECK-NEXT: return{{$}} -define void @sti32(i32 *%p, i32 %v) { - store i32 %v, i32* %p - ret void -} - -; CHECK-LABEL: sti32_a8: -; CHECK-NEXT: .param i32, i32{{$}} -; CHECK-NEXT: i32.store 0($0), $1{{$}} -; CHECK-NEXT: return{{$}} -define void @sti32_a8(i32 *%p, i32 %v) { - store i32 %v, i32* %p, align 8 - ret void -} - -; Truncating stores. - -; CHECK-LABEL: sti8_a1: -; CHECK-NEXT: .param i32, i32{{$}} -; CHECK-NEXT: i32.store8 0($0), $1{{$}} -; CHECK-NEXT: return{{$}} -define void @sti8_a1(i8 *%p, i8 %v) { - store i8 %v, i8* %p, align 1 - ret void -} - -; CHECK-LABEL: sti8_a2: -; CHECK-NEXT: .param i32, i32{{$}} -; CHECK-NEXT: i32.store8 0($0), $1{{$}} -; CHECK-NEXT: return{{$}} -define void @sti8_a2(i8 *%p, i8 %v) { - store i8 %v, i8* %p, align 2 - ret void -} - -; CHECK-LABEL: sti16_a1: -; CHECK-NEXT: .param i32, i32{{$}} -; CHECK-NEXT: i32.store16 0($0):p2align=0, $1{{$}} -; CHECK-NEXT: return{{$}} -define void @sti16_a1(i16 *%p, i16 %v) { - store i16 %v, i16* %p, align 1 - ret void -} - -; CHECK-LABEL: sti16_a2: -; CHECK-NEXT: .param i32, i32{{$}} -; CHECK-NEXT: i32.store16 0($0), $1{{$}} -; CHECK-NEXT: return{{$}} -define void @sti16_a2(i16 *%p, i16 %v) { - store i16 %v, i16* %p, align 2 - ret void -} - -; CHECK-LABEL: sti16_a4: -; CHECK-NEXT: .param i32, i32{{$}} -; CHECK-NEXT: i32.store16 0($0), $1{{$}} -; CHECK-NEXT: return{{$}} -define void @sti16_a4(i16 *%p, i16 %v) { - store i16 %v, i16* %p, align 4 - ret void -} diff --git a/test/CodeGen/WebAssembly/i32.ll b/test/CodeGen/WebAssembly/i32.ll deleted file mode 100644 index e451695d8903..000000000000 --- a/test/CodeGen/WebAssembly/i32.ll +++ /dev/null @@ -1,295 +0,0 @@ -; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt | FileCheck %s - -; 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-wasm" - -declare i32 @llvm.ctlz.i32(i32, i1) -declare i32 @llvm.cttz.i32(i32, i1) -declare i32 @llvm.ctpop.i32(i32) - -; CHECK-LABEL: add32: -; CHECK-NEXT: .param i32, i32{{$}} -; CHECK-NEXT: .result i32{{$}} -; 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 - ret i32 %a -} - -; CHECK-LABEL: sub32: -; CHECK-NEXT: .param i32, i32{{$}} -; CHECK-NEXT: .result i32{{$}} -; 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 - ret i32 %a -} - -; CHECK-LABEL: mul32: -; CHECK-NEXT: .param i32, i32{{$}} -; CHECK-NEXT: .result i32{{$}} -; 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 - ret i32 %a -} - -; CHECK-LABEL: sdiv32: -; CHECK-NEXT: .param i32, i32{{$}} -; CHECK-NEXT: .result i32{{$}} -; 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 - ret i32 %a -} - -; CHECK-LABEL: udiv32: -; CHECK-NEXT: .param i32, i32{{$}} -; CHECK-NEXT: .result i32{{$}} -; 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 - ret i32 %a -} - -; CHECK-LABEL: srem32: -; CHECK-NEXT: .param i32, i32{{$}} -; CHECK-NEXT: .result i32{{$}} -; 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 - ret i32 %a -} - -; CHECK-LABEL: urem32: -; CHECK-NEXT: .param i32, i32{{$}} -; CHECK-NEXT: .result i32{{$}} -; 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 - ret i32 %a -} - -; CHECK-LABEL: and32: -; CHECK-NEXT: .param i32, i32{{$}} -; CHECK-NEXT: .result i32{{$}} -; 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 - ret i32 %a -} - -; CHECK-LABEL: or32: -; CHECK-NEXT: .param i32, i32{{$}} -; CHECK-NEXT: .result i32{{$}} -; 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 - ret i32 %a -} - -; CHECK-LABEL: xor32: -; CHECK-NEXT: .param i32, i32{{$}} -; CHECK-NEXT: .result i32{{$}} -; 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 - ret i32 %a -} - -; CHECK-LABEL: shl32: -; CHECK-NEXT: .param i32, i32{{$}} -; CHECK-NEXT: .result i32{{$}} -; 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 - ret i32 %a -} - -; CHECK-LABEL: shr32: -; CHECK-NEXT: .param i32, i32{{$}} -; CHECK-NEXT: .result i32{{$}} -; 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 - ret i32 %a -} - -; CHECK-LABEL: sar32: -; CHECK-NEXT: .param i32, i32{{$}} -; CHECK-NEXT: .result i32{{$}} -; 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 - ret i32 %a -} - -; CHECK-LABEL: clz32: -; CHECK-NEXT: .param i32{{$}} -; CHECK-NEXT: .result i32{{$}} -; 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) - ret i32 %a -} - -; CHECK-LABEL: clz32_zero_undef: -; CHECK-NEXT: .param i32{{$}} -; CHECK-NEXT: .result i32{{$}} -; 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) - ret i32 %a -} - -; CHECK-LABEL: ctz32: -; CHECK-NEXT: .param i32{{$}} -; CHECK-NEXT: .result i32{{$}} -; 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) - ret i32 %a -} - -; CHECK-LABEL: ctz32_zero_undef: -; CHECK-NEXT: .param i32{{$}} -; CHECK-NEXT: .result i32{{$}} -; 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) - ret i32 %a -} - -; CHECK-LABEL: popcnt32: -; CHECK-NEXT: .param i32{{$}} -; CHECK-NEXT: .result i32{{$}} -; 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) - ret i32 %a -} - -; CHECK-LABEL: eqz32: -; CHECK-NEXT: .param i32{{$}} -; CHECK-NEXT: .result i32{{$}} -; 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 - %b = zext i1 %a to i32 - ret i32 %b -} - -; CHECK-LABEL: rotl: -; CHECK-NEXT: .param i32, i32{{$}} -; CHECK-NEXT: .result i32{{$}} -; 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 - %b = shl i32 %x, %y - %c = lshr i32 %x, %z - %d = or i32 %b, %c - ret i32 %d -} - -; CHECK-LABEL: masked_rotl: -; CHECK-NEXT: .param i32, i32{{$}} -; CHECK-NEXT: .result i32{{$}} -; 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 - %z = sub i32 32, %a - %b = shl i32 %x, %a - %c = lshr i32 %x, %z - %d = or i32 %b, %c - ret i32 %d -} - -; CHECK-LABEL: rotr: -; CHECK-NEXT: .param i32, i32{{$}} -; CHECK-NEXT: .result i32{{$}} -; 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 - %b = lshr i32 %x, %y - %c = shl i32 %x, %z - %d = or i32 %b, %c - ret i32 %d -} - -; CHECK-LABEL: masked_rotr: -; CHECK-NEXT: .param i32, i32{{$}} -; CHECK-NEXT: .result i32{{$}} -; 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 - %z = sub i32 32, %a - %b = lshr i32 %x, %a - %c = shl i32 %x, %z - %d = or i32 %b, %c - ret i32 %d -} diff --git a/test/CodeGen/WebAssembly/i64-load-store-alignment.ll b/test/CodeGen/WebAssembly/i64-load-store-alignment.ll deleted file mode 100644 index 1ccb74cb9d28..000000000000 --- a/test/CodeGen/WebAssembly/i64-load-store-alignment.ll +++ /dev/null @@ -1,325 +0,0 @@ -; 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-wasm" - -; CHECK-LABEL: ldi64_a1: -; CHECK-NEXT: .param i32{{$}} -; CHECK-NEXT: .result i64{{$}} -; CHECK-NEXT: i64.load $push[[NUM:[0-9]+]]=, 0($0):p2align=0{{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define i64 @ldi64_a1(i64 *%p) { - %v = load i64, i64* %p, align 1 - ret i64 %v -} - -; CHECK-LABEL: ldi64_a2: -; CHECK-NEXT: .param i32{{$}} -; CHECK-NEXT: .result i64{{$}} -; CHECK-NEXT: i64.load $push[[NUM:[0-9]+]]=, 0($0):p2align=1{{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define i64 @ldi64_a2(i64 *%p) { - %v = load i64, i64* %p, align 2 - ret i64 %v -} - -; CHECK-LABEL: ldi64_a4: -; CHECK-NEXT: .param i32{{$}} -; CHECK-NEXT: .result i64{{$}} -; CHECK-NEXT: i64.load $push[[NUM:[0-9]+]]=, 0($0):p2align=2{{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define i64 @ldi64_a4(i64 *%p) { - %v = load i64, i64* %p, align 4 - ret i64 %v -} - -; 8 is the default alignment for i64 so no attribute is needed. - -; CHECK-LABEL: ldi64_a8: -; CHECK-NEXT: .param i32{{$}} -; CHECK-NEXT: .result i64{{$}} -; CHECK-NEXT: i64.load $push[[NUM:[0-9]+]]=, 0($0){{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define i64 @ldi64_a8(i64 *%p) { - %v = load i64, i64* %p, align 8 - ret i64 %v -} - -; The default alignment in LLVM is the same as the defualt alignment in wasm. - -; CHECK-LABEL: ldi64: -; CHECK-NEXT: .param i32{{$}} -; CHECK-NEXT: .result i64{{$}} -; CHECK-NEXT: i64.load $push[[NUM:[0-9]+]]=, 0($0){{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define i64 @ldi64(i64 *%p) { - %v = load i64, i64* %p - ret i64 %v -} - -; 16 is greater than the default alignment so it is ignored. - -; CHECK-LABEL: ldi64_a16: -; CHECK-NEXT: .param i32{{$}} -; CHECK-NEXT: .result i64{{$}} -; CHECK-NEXT: i64.load $push[[NUM:[0-9]+]]=, 0($0){{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define i64 @ldi64_a16(i64 *%p) { - %v = load i64, i64* %p, align 16 - ret i64 %v -} - -; Extending loads. - -; CHECK-LABEL: ldi8_a1: -; CHECK-NEXT: .param i32{{$}} -; CHECK-NEXT: .result i64{{$}} -; CHECK-NEXT: i64.load8_u $push[[NUM:[0-9]+]]=, 0($0){{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define i64 @ldi8_a1(i8 *%p) { - %v = load i8, i8* %p, align 1 - %w = zext i8 %v to i64 - ret i64 %w -} - -; CHECK-LABEL: ldi8_a2: -; CHECK-NEXT: .param i32{{$}} -; CHECK-NEXT: .result i64{{$}} -; CHECK-NEXT: i64.load8_u $push[[NUM:[0-9]+]]=, 0($0){{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define i64 @ldi8_a2(i8 *%p) { - %v = load i8, i8* %p, align 2 - %w = zext i8 %v to i64 - ret i64 %w -} - -; CHECK-LABEL: ldi16_a1: -; CHECK-NEXT: .param i32{{$}} -; CHECK-NEXT: .result i64{{$}} -; CHECK-NEXT: i64.load16_u $push[[NUM:[0-9]+]]=, 0($0):p2align=0{{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define i64 @ldi16_a1(i16 *%p) { - %v = load i16, i16* %p, align 1 - %w = zext i16 %v to i64 - ret i64 %w -} - -; CHECK-LABEL: ldi16_a2: -; CHECK-NEXT: .param i32{{$}} -; CHECK-NEXT: .result i64{{$}} -; CHECK-NEXT: i64.load16_u $push[[NUM:[0-9]+]]=, 0($0){{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define i64 @ldi16_a2(i16 *%p) { - %v = load i16, i16* %p, align 2 - %w = zext i16 %v to i64 - ret i64 %w -} - -; CHECK-LABEL: ldi16_a4: -; CHECK-NEXT: .param i32{{$}} -; CHECK-NEXT: .result i64{{$}} -; CHECK-NEXT: i64.load16_u $push[[NUM:[0-9]+]]=, 0($0){{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define i64 @ldi16_a4(i16 *%p) { - %v = load i16, i16* %p, align 4 - %w = zext i16 %v to i64 - ret i64 %w -} - -; CHECK-LABEL: ldi32_a1: -; CHECK-NEXT: .param i32{{$}} -; CHECK-NEXT: .result i64{{$}} -; CHECK-NEXT: i64.load32_u $push[[NUM:[0-9]+]]=, 0($0):p2align=0{{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define i64 @ldi32_a1(i32 *%p) { - %v = load i32, i32* %p, align 1 - %w = zext i32 %v to i64 - ret i64 %w -} - -; CHECK-LABEL: ldi32_a2: -; CHECK-NEXT: .param i32{{$}} -; CHECK-NEXT: .result i64{{$}} -; CHECK-NEXT: i64.load32_u $push[[NUM:[0-9]+]]=, 0($0):p2align=1{{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define i64 @ldi32_a2(i32 *%p) { - %v = load i32, i32* %p, align 2 - %w = zext i32 %v to i64 - ret i64 %w -} - -; CHECK-LABEL: ldi32_a4: -; CHECK-NEXT: .param i32{{$}} -; CHECK-NEXT: .result i64{{$}} -; CHECK-NEXT: i64.load32_u $push[[NUM:[0-9]+]]=, 0($0){{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define i64 @ldi32_a4(i32 *%p) { - %v = load i32, i32* %p, align 4 - %w = zext i32 %v to i64 - ret i64 %w -} - -; CHECK-LABEL: ldi32_a8: -; CHECK-NEXT: .param i32{{$}} -; CHECK-NEXT: .result i64{{$}} -; CHECK-NEXT: i64.load32_u $push[[NUM:[0-9]+]]=, 0($0){{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define i64 @ldi32_a8(i32 *%p) { - %v = load i32, i32* %p, align 8 - %w = zext i32 %v to i64 - ret i64 %w -} - -; Stores. - -; CHECK-LABEL: sti64_a1: -; CHECK-NEXT: .param i32, i64{{$}} -; CHECK-NEXT: i64.store 0($0):p2align=0, $1{{$}} -; CHECK-NEXT: return{{$}} -define void @sti64_a1(i64 *%p, i64 %v) { - store i64 %v, i64* %p, align 1 - ret void -} - -; CHECK-LABEL: sti64_a2: -; CHECK-NEXT: .param i32, i64{{$}} -; CHECK-NEXT: i64.store 0($0):p2align=1, $1{{$}} -; CHECK-NEXT: return{{$}} -define void @sti64_a2(i64 *%p, i64 %v) { - store i64 %v, i64* %p, align 2 - ret void -} - -; CHECK-LABEL: sti64_a4: -; CHECK-NEXT: .param i32, i64{{$}} -; CHECK-NEXT: i64.store 0($0):p2align=2, $1{{$}} -; CHECK-NEXT: return{{$}} -define void @sti64_a4(i64 *%p, i64 %v) { - store i64 %v, i64* %p, align 4 - ret void -} - -; 8 is the default alignment for i32 so no attribute is needed. - -; CHECK-LABEL: sti64_a8: -; CHECK-NEXT: .param i32, i64{{$}} -; CHECK-NEXT: i64.store 0($0), $1{{$}} -; CHECK-NEXT: return{{$}} -define void @sti64_a8(i64 *%p, i64 %v) { - store i64 %v, i64* %p, align 8 - ret void -} - -; The default alignment in LLVM is the same as the defualt alignment in wasm. - -; CHECK-LABEL: sti64: -; CHECK-NEXT: .param i32, i64{{$}} -; CHECK-NEXT: i64.store 0($0), $1{{$}} -; CHECK-NEXT: return{{$}} -define void @sti64(i64 *%p, i64 %v) { - store i64 %v, i64* %p - ret void -} - -; CHECK-LABEL: sti64_a16: -; CHECK-NEXT: .param i32, i64{{$}} -; CHECK-NEXT: i64.store 0($0), $1{{$}} -; CHECK-NEXT: return{{$}} -define void @sti64_a16(i64 *%p, i64 %v) { - store i64 %v, i64* %p, align 16 - ret void -} - -; Truncating stores. - -; CHECK-LABEL: sti8_a1: -; CHECK-NEXT: .param i32, i64{{$}} -; CHECK-NEXT: i64.store8 0($0), $1{{$}} -; CHECK-NEXT: return{{$}} -define void @sti8_a1(i8 *%p, i64 %w) { - %v = trunc i64 %w to i8 - store i8 %v, i8* %p, align 1 - ret void -} - -; CHECK-LABEL: sti8_a2: -; CHECK-NEXT: .param i32, i64{{$}} -; CHECK-NEXT: i64.store8 0($0), $1{{$}} -; CHECK-NEXT: return{{$}} -define void @sti8_a2(i8 *%p, i64 %w) { - %v = trunc i64 %w to i8 - store i8 %v, i8* %p, align 2 - ret void -} - -; CHECK-LABEL: sti16_a1: -; CHECK-NEXT: .param i32, i64{{$}} -; CHECK-NEXT: i64.store16 0($0):p2align=0, $1{{$}} -; CHECK-NEXT: return{{$}} -define void @sti16_a1(i16 *%p, i64 %w) { - %v = trunc i64 %w to i16 - store i16 %v, i16* %p, align 1 - ret void -} - -; CHECK-LABEL: sti16_a2: -; CHECK-NEXT: .param i32, i64{{$}} -; CHECK-NEXT: i64.store16 0($0), $1{{$}} -; CHECK-NEXT: return{{$}} -define void @sti16_a2(i16 *%p, i64 %w) { - %v = trunc i64 %w to i16 - store i16 %v, i16* %p, align 2 - ret void -} - -; CHECK-LABEL: sti16_a4: -; CHECK-NEXT: .param i32, i64{{$}} -; CHECK-NEXT: i64.store16 0($0), $1{{$}} -; CHECK-NEXT: return{{$}} -define void @sti16_a4(i16 *%p, i64 %w) { - %v = trunc i64 %w to i16 - store i16 %v, i16* %p, align 4 - ret void -} - -; CHECK-LABEL: sti32_a1: -; CHECK-NEXT: .param i32, i64{{$}} -; CHECK-NEXT: i64.store32 0($0):p2align=0, $1{{$}} -; CHECK-NEXT: return{{$}} -define void @sti32_a1(i32 *%p, i64 %w) { - %v = trunc i64 %w to i32 - store i32 %v, i32* %p, align 1 - ret void -} - -; CHECK-LABEL: sti32_a2: -; CHECK-NEXT: .param i32, i64{{$}} -; CHECK-NEXT: i64.store32 0($0):p2align=1, $1{{$}} -; CHECK-NEXT: return{{$}} -define void @sti32_a2(i32 *%p, i64 %w) { - %v = trunc i64 %w to i32 - store i32 %v, i32* %p, align 2 - ret void -} - -; CHECK-LABEL: sti32_a4: -; CHECK-NEXT: .param i32, i64{{$}} -; CHECK-NEXT: i64.store32 0($0), $1{{$}} -; CHECK-NEXT: return{{$}} -define void @sti32_a4(i32 *%p, i64 %w) { - %v = trunc i64 %w to i32 - store i32 %v, i32* %p, align 4 - ret void -} - -; CHECK-LABEL: sti32_a8: -; CHECK-NEXT: .param i32, i64{{$}} -; CHECK-NEXT: i64.store32 0($0), $1{{$}} -; CHECK-NEXT: return{{$}} -define void @sti32_a8(i32 *%p, i64 %w) { - %v = trunc i64 %w to i32 - store i32 %v, i32* %p, align 8 - ret void -} diff --git a/test/CodeGen/WebAssembly/i64.ll b/test/CodeGen/WebAssembly/i64.ll deleted file mode 100644 index 4386bed4ebf7..000000000000 --- a/test/CodeGen/WebAssembly/i64.ll +++ /dev/null @@ -1,295 +0,0 @@ -; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt | FileCheck %s - -; 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-wasm" - -declare i64 @llvm.ctlz.i64(i64, i1) -declare i64 @llvm.cttz.i64(i64, i1) -declare i64 @llvm.ctpop.i64(i64) - -; CHECK-LABEL: add64: -; CHECK-NEXT: .param i64, i64{{$}} -; CHECK-NEXT: .result i64{{$}} -; 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 - ret i64 %a -} - -; CHECK-LABEL: sub64: -; CHECK-NEXT: .param i64, i64{{$}} -; CHECK-NEXT: .result i64{{$}} -; 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 - ret i64 %a -} - -; CHECK-LABEL: mul64: -; CHECK-NEXT: .param i64, i64{{$}} -; CHECK-NEXT: .result i64{{$}} -; 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 - ret i64 %a -} - -; CHECK-LABEL: sdiv64: -; CHECK-NEXT: .param i64, i64{{$}} -; CHECK-NEXT: .result i64{{$}} -; 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 - ret i64 %a -} - -; CHECK-LABEL: udiv64: -; CHECK-NEXT: .param i64, i64{{$}} -; CHECK-NEXT: .result i64{{$}} -; 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 - ret i64 %a -} - -; CHECK-LABEL: srem64: -; CHECK-NEXT: .param i64, i64{{$}} -; CHECK-NEXT: .result i64{{$}} -; 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 - ret i64 %a -} - -; CHECK-LABEL: urem64: -; CHECK-NEXT: .param i64, i64{{$}} -; CHECK-NEXT: .result i64{{$}} -; 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 - ret i64 %a -} - -; CHECK-LABEL: and64: -; CHECK-NEXT: .param i64, i64{{$}} -; CHECK-NEXT: .result i64{{$}} -; 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 - ret i64 %a -} - -; CHECK-LABEL: or64: -; CHECK-NEXT: .param i64, i64{{$}} -; CHECK-NEXT: .result i64{{$}} -; 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 - ret i64 %a -} - -; CHECK-LABEL: xor64: -; CHECK-NEXT: .param i64, i64{{$}} -; CHECK-NEXT: .result i64{{$}} -; 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 - ret i64 %a -} - -; CHECK-LABEL: shl64: -; CHECK-NEXT: .param i64, i64{{$}} -; CHECK-NEXT: .result i64{{$}} -; 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 - ret i64 %a -} - -; CHECK-LABEL: shr64: -; CHECK-NEXT: .param i64, i64{{$}} -; CHECK-NEXT: .result i64{{$}} -; 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 - ret i64 %a -} - -; CHECK-LABEL: sar64: -; CHECK-NEXT: .param i64, i64{{$}} -; CHECK-NEXT: .result i64{{$}} -; 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 - ret i64 %a -} - -; CHECK-LABEL: clz64: -; CHECK-NEXT: .param i64{{$}} -; CHECK-NEXT: .result i64{{$}} -; 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) - ret i64 %a -} - -; CHECK-LABEL: clz64_zero_undef: -; CHECK-NEXT: .param i64{{$}} -; CHECK-NEXT: .result i64{{$}} -; 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) - ret i64 %a -} - -; CHECK-LABEL: ctz64: -; CHECK-NEXT: .param i64{{$}} -; CHECK-NEXT: .result i64{{$}} -; 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) - ret i64 %a -} - -; CHECK-LABEL: ctz64_zero_undef: -; CHECK-NEXT: .param i64{{$}} -; CHECK-NEXT: .result i64{{$}} -; 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) - ret i64 %a -} - -; CHECK-LABEL: popcnt64: -; CHECK-NEXT: .param i64{{$}} -; CHECK-NEXT: .result i64{{$}} -; 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) - ret i64 %a -} - -; CHECK-LABEL: eqz64: -; CHECK-NEXT: .param i64{{$}} -; CHECK-NEXT: .result i32{{$}} -; 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 - %b = zext i1 %a to i32 - ret i32 %b -} - -; CHECK-LABEL: rotl: -; CHECK-NEXT: .param i64, i64{{$}} -; CHECK-NEXT: .result i64{{$}} -; 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 - %b = shl i64 %x, %y - %c = lshr i64 %x, %z - %d = or i64 %b, %c - ret i64 %d -} - -; CHECK-LABEL: masked_rotl: -; CHECK-NEXT: .param i64, i64{{$}} -; CHECK-NEXT: .result i64{{$}} -; 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 - %z = sub i64 64, %a - %b = shl i64 %x, %a - %c = lshr i64 %x, %z - %d = or i64 %b, %c - ret i64 %d -} - -; CHECK-LABEL: rotr: -; CHECK-NEXT: .param i64, i64{{$}} -; CHECK-NEXT: .result i64{{$}} -; 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 - %b = lshr i64 %x, %y - %c = shl i64 %x, %z - %d = or i64 %b, %c - ret i64 %d -} - -; CHECK-LABEL: masked_rotr: -; CHECK-NEXT: .param i64, i64{{$}} -; CHECK-NEXT: .result i64{{$}} -; 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 - %z = sub i64 64, %a - %b = lshr i64 %x, %a - %c = shl i64 %x, %z - %d = or i64 %b, %c - ret i64 %d -} diff --git a/test/CodeGen/WebAssembly/ident.ll b/test/CodeGen/WebAssembly/ident.ll deleted file mode 100644 index e5d85d090f11..000000000000 --- a/test/CodeGen/WebAssembly/ident.ll +++ /dev/null @@ -1,12 +0,0 @@ -; RUN: llc < %s -asm-verbose=false | FileCheck %s - -; Test llvm.ident. - -target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" -target triple = "wasm32-unknown-unknown-wasm" - -; CHECK: .ident "hello world" - -!llvm.ident = !{!0} - -!0 = !{!"hello world"} diff --git a/test/CodeGen/WebAssembly/immediates.ll b/test/CodeGen/WebAssembly/immediates.ll deleted file mode 100644 index 1182423a594e..000000000000 --- a/test/CodeGen/WebAssembly/immediates.ll +++ /dev/null @@ -1,233 +0,0 @@ -; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt | FileCheck %s - -; 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-wasm" - -; CHECK-LABEL: zero_i32: -; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: i32.const $push[[NUM:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define i32 @zero_i32() { - ret i32 0 -} - -; CHECK-LABEL: one_i32: -; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: i32.const $push[[NUM:[0-9]+]]=, 1{{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define i32 @one_i32() { - ret i32 1 -} - -; CHECK-LABEL: max_i32: -; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: i32.const $push[[NUM:[0-9]+]]=, 2147483647{{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define i32 @max_i32() { - ret i32 2147483647 -} - -; CHECK-LABEL: min_i32: -; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: i32.const $push[[NUM:[0-9]+]]=, -2147483648{{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define i32 @min_i32() { - ret i32 -2147483648 -} - -; CHECK-LABEL: zero_i64: -; CHECK-NEXT: .result i64{{$}} -; CHECK-NEXT: i64.const $push[[NUM:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define i64 @zero_i64() { - ret i64 0 -} - -; CHECK-LABEL: one_i64: -; CHECK-NEXT: .result i64{{$}} -; CHECK-NEXT: i64.const $push[[NUM:[0-9]+]]=, 1{{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define i64 @one_i64() { - ret i64 1 -} - -; CHECK-LABEL: max_i64: -; CHECK-NEXT: .result i64{{$}} -; CHECK-NEXT: i64.const $push[[NUM:[0-9]+]]=, 9223372036854775807{{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define i64 @max_i64() { - ret i64 9223372036854775807 -} - -; CHECK-LABEL: min_i64: -; CHECK-NEXT: .result i64{{$}} -; CHECK-NEXT: i64.const $push[[NUM:[0-9]+]]=, -9223372036854775808{{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define i64 @min_i64() { - ret i64 -9223372036854775808 -} - -; CHECK-LABEL: negzero_f32: -; CHECK-NEXT: .result f32{{$}} -; CHECK-NEXT: f32.const $push[[NUM:[0-9]+]]=, -0x0p0{{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define float @negzero_f32() { - ret float -0.0 -} - -; CHECK-LABEL: zero_f32: -; CHECK-NEXT: .result f32{{$}} -; CHECK-NEXT: f32.const $push[[NUM:[0-9]+]]=, 0x0p0{{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define float @zero_f32() { - ret float 0.0 -} - -; CHECK-LABEL: one_f32: -; CHECK-NEXT: .result f32{{$}} -; CHECK-NEXT: f32.const $push[[NUM:[0-9]+]]=, 0x1p0{{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define float @one_f32() { - ret float 1.0 -} - -; CHECK-LABEL: two_f32: -; CHECK-NEXT: .result f32{{$}} -; CHECK-NEXT: f32.const $push[[NUM:[0-9]+]]=, 0x1p1{{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define float @two_f32() { - ret float 2.0 -} - -; CHECK-LABEL: nan_f32: -; CHECK-NEXT: .result f32{{$}} -; CHECK-NEXT: f32.const $push[[NUM:[0-9]+]]=, nan{{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define float @nan_f32() { - ret float 0x7FF8000000000000 -} - -; CHECK-LABEL: negnan_f32: -; CHECK-NEXT: .result f32{{$}} -; CHECK-NEXT: f32.const $push[[NUM:[0-9]+]]=, -nan{{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define float @negnan_f32() { - ret float 0xFFF8000000000000 -} - -; CHECK-LABEL: inf_f32: -; CHECK-NEXT: .result f32{{$}} -; CHECK-NEXT: f32.const $push[[NUM:[0-9]+]]=, infinity{{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define float @inf_f32() { - ret float 0x7FF0000000000000 -} - -; CHECK-LABEL: neginf_f32: -; CHECK-NEXT: .result f32{{$}} -; CHECK-NEXT: f32.const $push[[NUM:[0-9]+]]=, -infinity{{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define float @neginf_f32() { - ret float 0xFFF0000000000000 -} - -; CHECK-LABEL: custom_nan_f32: -; CHECK-NEXT: .result f32{{$}} -; CHECK-NEXT: f32.const $push[[NUM:[0-9]+]]=, -nan:0x6bcdef{{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define float @custom_nan_f32() { - ret float 0xFFFD79BDE0000000 -} - -; TODO: LLVM's MC layer stores f32 operands as host doubles, requiring a -; conversion, so the bits of the NaN are not fully preserved. - -; CHECK-LABEL: custom_nans_f32: -; CHECK-NEXT: .result f32{{$}} -; CHECK-NEXT: f32.const $push[[NUM:[0-9]+]]=, -nan:0x6bcdef{{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define float @custom_nans_f32() { - ret float 0xFFF579BDE0000000 -} - -; CHECK-LABEL: negzero_f64: -; CHECK-NEXT: .result f64{{$}} -; CHECK-NEXT: f64.const $push[[NUM:[0-9]+]]=, -0x0p0{{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define double @negzero_f64() { - ret double -0.0 -} - -; CHECK-LABEL: zero_f64: -; CHECK-NEXT: .result f64{{$}} -; CHECK-NEXT: f64.const $push[[NUM:[0-9]+]]=, 0x0p0{{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define double @zero_f64() { - ret double 0.0 -} - -; CHECK-LABEL: one_f64: -; CHECK-NEXT: .result f64{{$}} -; CHECK-NEXT: f64.const $push[[NUM:[0-9]+]]=, 0x1p0{{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define double @one_f64() { - ret double 1.0 -} - -; CHECK-LABEL: two_f64: -; CHECK-NEXT: .result f64{{$}} -; CHECK-NEXT: f64.const $push[[NUM:[0-9]+]]=, 0x1p1{{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define double @two_f64() { - ret double 2.0 -} - -; CHECK-LABEL: nan_f64: -; CHECK-NEXT: .result f64{{$}} -; CHECK-NEXT: f64.const $push[[NUM:[0-9]+]]=, nan{{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define double @nan_f64() { - ret double 0x7FF8000000000000 -} - -; CHECK-LABEL: negnan_f64: -; CHECK-NEXT: .result f64{{$}} -; CHECK-NEXT: f64.const $push[[NUM:[0-9]+]]=, -nan{{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define double @negnan_f64() { - ret double 0xFFF8000000000000 -} - -; CHECK-LABEL: inf_f64: -; CHECK-NEXT: .result f64{{$}} -; CHECK-NEXT: f64.const $push[[NUM:[0-9]+]]=, infinity{{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define double @inf_f64() { - ret double 0x7FF0000000000000 -} - -; CHECK-LABEL: neginf_f64: -; CHECK-NEXT: .result f64{{$}} -; CHECK-NEXT: f64.const $push[[NUM:[0-9]+]]=, -infinity{{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define double @neginf_f64() { - ret double 0xFFF0000000000000 -} - -; CHECK-LABEL: custom_nan_f64: -; CHECK-NEXT: .result f64{{$}} -; CHECK-NEXT: f64.const $push[[NUM:[0-9]+]]=, -nan:0xabcdef0123456{{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define double @custom_nan_f64() { - ret double 0xFFFABCDEF0123456 -} - -; CHECK-LABEL: custom_nans_f64: -; CHECK-NEXT: .result f64{{$}} -; CHECK-NEXT: f64.const $push[[NUM:[0-9]+]]=, -nan:0x2bcdef0123456{{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define double @custom_nans_f64() { - ret double 0xFFF2BCDEF0123456 -} diff --git a/test/CodeGen/WebAssembly/implicit-def.ll b/test/CodeGen/WebAssembly/implicit-def.ll deleted file mode 100644 index 1f9f74887e8a..000000000000 --- a/test/CodeGen/WebAssembly/implicit-def.ll +++ /dev/null @@ -1,50 +0,0 @@ -; RUN: llc -o - %s | FileCheck %s -target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" -target triple = "wasm32-unknown-unknown-wasm" - -; Test that stackified IMPLICIT_DEF instructions are converted into -; CONST_I32 to provide an explicit push. - -; CHECK: br_if 2, -; CHECK: i32.const $push[[L0:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: return $pop[[L0]]{{$}} -define i1 @f() { - %a = xor i1 0, 0 - switch i1 %a, label %C [ - i1 0, label %A - i1 1, label %B - ] - -A: - %b = xor i1 0, 0 - br label %X - -B: - %c = xor i1 0, 0 - br i1 %c, label %D, label %X - -C: - %d = icmp slt i32 0, 0 - br i1 %d, label %G, label %F - -D: - %e = xor i1 0, 0 - br i1 %e, label %E, label %X - -E: - %f = xor i1 0, 0 - br label %X - -F: - %g = xor i1 0, 0 - br label %G - -G: - %h = phi i1 [ undef, %C ], [ false, %F ] - br label %X - -X: - %i = phi i1 [ true, %A ], [ true, %B ], [ true, %D ], [ true, %E ], [ %h, %G ] - ret i1 %i -} - diff --git a/test/CodeGen/WebAssembly/indirect-import.ll b/test/CodeGen/WebAssembly/indirect-import.ll deleted file mode 100644 index 1bde65bcbbba..000000000000 --- a/test/CodeGen/WebAssembly/indirect-import.ll +++ /dev/null @@ -1,73 +0,0 @@ -; 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 - -; ModuleID = 'test/dot_s/indirect-import.c' -source_filename = "test/dot_s/indirect-import.c" -target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" -target triple = "wasm32" - -%struct.big = type { float, double, i32 } - -; Function Attrs: nounwind -; CHECK: bar: -define hidden i32 @bar() #0 { -entry: - %fd = alloca float (double)*, align 4 - %vj = alloca void (i64)*, align 4 - %v = alloca void ()*, align 4 - %ijidf = alloca i32 (i64, i32, double, float)*, align 4 - %vs = alloca void (%struct.big*)*, align 4 - %s = alloca void (%struct.big*)*, align 4 - -; CHECK: i32.const {{.+}}=, extern_fd@FUNCTION - store float (double)* @extern_fd, float (double)** %fd, align 4 -; CHECK: i32.const {{.+}}=, extern_vj@FUNCTION - store void (i64)* @extern_vj, void (i64)** %vj, align 4 - %0 = load void (i64)*, void (i64)** %vj, align 4 - call void %0(i64 1) - -; CHECK: i32.const {{.+}}=, extern_v@FUNCTION - store void ()* @extern_v, void ()** %v, align 4 - %1 = load void ()*, void ()** %v, align 4 - call void %1() - -; CHECK: i32.const {{.+}}=, extern_ijidf@FUNCTION - store i32 (i64, i32, double, float)* @extern_ijidf, i32 (i64, i32, double, float)** %ijidf, align 4 - %2 = load i32 (i64, i32, double, float)*, i32 (i64, i32, double, float)** %ijidf, align 4 - %call = call i32 %2(i64 1, i32 2, double 3.000000e+00, float 4.000000e+00) - -; CHECK: i32.const {{.+}}=, extern_struct@FUNCTION - store void (%struct.big*)* @extern_struct, void (%struct.big*)** %vs, align 4 - -; CHECK: i32.const {{.+}}=, extern_sret@FUNCTION - store void (%struct.big*)* @extern_sret, void (%struct.big*)** %s, align 4 - %3 = load float (double)*, float (double)** %fd, align 4 - %4 = ptrtoint float (double)* %3 to i32 - ret i32 %4 -} - -declare float @extern_fd(double) #1 - -declare void @extern_vj(i64) #1 - -declare void @extern_v() #1 - -declare i32 @extern_ijidf(i64, i32, double, float) #1 - -declare void @extern_struct(%struct.big* byval align 8) #1 - -declare void @extern_sret(%struct.big* sret) #1 - -declare i128 @extern_i128ret(i64) #1 - -attributes #0 = { nounwind "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="generic" "unsafe-fp-math"="false" "use-soft-float"="false" } -attributes #1 = { "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="generic" "unsafe-fp-math"="false" "use-soft-float"="false" } - - -; CHECK: .functype extern_fd, f32, f64 -; CHECK: .functype extern_vj, void, i64 -; CHECK: .functype extern_v, void -; CHECK: .functype extern_ijidf, i32, i64, i32, f64, f32 -; CHECK: .functype extern_struct, void, i32 -; CHECK: .functype extern_sret, void, i32 -; CHECK: .functype extern_i128ret, void, i32, i64 diff --git a/test/CodeGen/WebAssembly/inline-asm.ll b/test/CodeGen/WebAssembly/inline-asm.ll deleted file mode 100644 index 56576305d9e2..000000000000 --- a/test/CodeGen/WebAssembly/inline-asm.ll +++ /dev/null @@ -1,94 +0,0 @@ -; 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-wasm" - -; CHECK-LABEL: foo: -; CHECK-NEXT: .param i32{{$}} -; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: #APP{{$}} -; CHECK-NEXT: # $0 = aaa($0){{$}} -; CHECK-NEXT: #NO_APP{{$}} -; CHECK-NEXT: return $0{{$}} -define i32 @foo(i32 %r) { -entry: - %0 = tail call i32 asm sideeffect "# $0 = aaa($1)", "=r,r"(i32 %r) #0, !srcloc !0 - ret i32 %0 -} - -; CHECK-LABEL: bar: -; CHECK-NEXT: .param i32, i32{{$}} -; CHECK-NEXT: #APP{{$}} -; CHECK-NEXT: # 0($1) = bbb(0($0)){{$}} -; CHECK-NEXT: #NO_APP{{$}} -; CHECK-NEXT: return{{$}} -define void @bar(i32* %r, i32* %s) { -entry: - tail call void asm sideeffect "# $0 = bbb($1)", "=*m,*m"(i32* %s, i32* %r) #0, !srcloc !1 - ret void -} - -; CHECK-LABEL: imm: -; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: #APP{{$}} -; CHECK-NEXT: # $0 = ccc(42){{$}} -; CHECK-NEXT: #NO_APP{{$}} -; CHECK-NEXT: return $0{{$}} -define i32 @imm() { -entry: - %0 = tail call i32 asm sideeffect "# $0 = ccc($1)", "=r,i"(i32 42) #0, !srcloc !2 - ret i32 %0 -} - -; CHECK-LABEL: foo_i64: -; CHECK-NEXT: .param i64{{$}} -; CHECK-NEXT: .result i64{{$}} -; CHECK-NEXT: #APP{{$}} -; CHECK-NEXT: # $0 = aaa($0){{$}} -; CHECK-NEXT: #NO_APP{{$}} -; CHECK-NEXT: return $0{{$}} -define i64 @foo_i64(i64 %r) { -entry: - %0 = tail call i64 asm sideeffect "# $0 = aaa($1)", "=r,r"(i64 %r) #0, !srcloc !0 - ret i64 %0 -} - -; CHECK-LABEL: X_i16: -; CHECK: foo $1{{$}} -; CHECK: i32.store16 0($0), $1{{$}} -define void @X_i16(i16 * %t) { - call void asm sideeffect "foo $0", "=*X,~{dirflag},~{fpsr},~{flags},~{memory}"(i16* %t) - ret void -} - -; CHECK-LABEL: X_ptr: -; CHECK: foo $1{{$}} -; CHECK: i32.store 0($0), $1{{$}} -define void @X_ptr(i16 ** %t) { - call void asm sideeffect "foo $0", "=*X,~{dirflag},~{fpsr},~{flags},~{memory}"(i16** %t) - ret void -} - -; CHECK-LABEL: funcname: -; CHECK: foo funcname{{$}} -define void @funcname() { - tail call void asm sideeffect "foo $0", "i"(void ()* nonnull @funcname) #0, !srcloc !0 - ret void -} - -; CHECK-LABEL: varname: -; CHECK: foo gv+37{{$}} -@gv = global [0 x i8] zeroinitializer -define void @varname() { - tail call void asm sideeffect "foo $0", "i"(i8* getelementptr inbounds ([0 x i8], [0 x i8]* @gv, i64 0, i64 37)) #0, !srcloc !0 - ret void -} - -attributes #0 = { nounwind } - -!0 = !{i32 47} -!1 = !{i32 145} -!2 = !{i32 231} diff --git a/test/CodeGen/WebAssembly/irreducible-cfg.ll b/test/CodeGen/WebAssembly/irreducible-cfg.ll deleted file mode 100644 index dd47b5827d5b..000000000000 --- a/test/CodeGen/WebAssembly/irreducible-cfg.ll +++ /dev/null @@ -1,94 +0,0 @@ -; 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-wasm" - -; A simple loop with two entries. - -; CHECK-LABEL: test0: -; CHECK: f64.load -; CHECK: i32.const $[[REG:[^,]+]]=, 0{{$}} -; CHECK: br_table $[[REG]], -define void @test0(double* %arg, i32 %arg1, i32 %arg2, i32 %arg3) { -bb: - %tmp = icmp eq i32 %arg2, 0 - br i1 %tmp, label %bb6, label %bb3 - -bb3: - %tmp4 = getelementptr double, double* %arg, i32 %arg3 - %tmp5 = load double, double* %tmp4, align 4 - br label %bb13 - -bb6: - %tmp7 = phi i32 [ %tmp18, %bb13 ], [ 0, %bb ] - %tmp8 = icmp slt i32 %tmp7, %arg1 - br i1 %tmp8, label %bb9, label %bb19 - -bb9: - %tmp10 = getelementptr double, double* %arg, i32 %tmp7 - %tmp11 = load double, double* %tmp10, align 4 - %tmp12 = fmul double %tmp11, 2.300000e+00 - store double %tmp12, double* %tmp10, align 4 - br label %bb13 - -bb13: - %tmp14 = phi double [ %tmp5, %bb3 ], [ %tmp12, %bb9 ] - %tmp15 = phi i32 [ undef, %bb3 ], [ %tmp7, %bb9 ] - %tmp16 = getelementptr double, double* %arg, i32 %tmp15 - %tmp17 = fadd double %tmp14, 1.300000e+00 - store double %tmp17, double* %tmp16, align 4 - %tmp18 = add nsw i32 %tmp15, 1 - br label %bb6 - -bb19: - ret void -} - -; A simple loop with two entries and an inner natural loop. - -; CHECK-LABEL: test1: -; CHECK: f64.load -; CHECK: i32.const $[[REG:[^,]+]]=, 0{{$}} -; CHECK: br_table $[[REG]], -define void @test1(double* %arg, i32 %arg1, i32 %arg2, i32 %arg3) { -bb: - %tmp = icmp eq i32 %arg2, 0 - br i1 %tmp, label %bb6, label %bb3 - -bb3: - %tmp4 = getelementptr double, double* %arg, i32 %arg3 - %tmp5 = load double, double* %tmp4, align 4 - br label %bb13 - -bb6: - %tmp7 = phi i32 [ %tmp18, %bb13 ], [ 0, %bb ] - %tmp8 = icmp slt i32 %tmp7, %arg1 - br i1 %tmp8, label %bb9, label %bb19 - -bb9: - %tmp10 = getelementptr double, double* %arg, i32 %tmp7 - %tmp11 = load double, double* %tmp10, align 4 - %tmp12 = fmul double %tmp11, 2.300000e+00 - store double %tmp12, double* %tmp10, align 4 - br label %bb10 - -bb10: - %p = phi i32 [ 0, %bb9 ], [ %pn, %bb10 ] - %pn = add i32 %p, 1 - %c = icmp slt i32 %pn, 256 - br i1 %c, label %bb10, label %bb13 - -bb13: - %tmp14 = phi double [ %tmp5, %bb3 ], [ %tmp12, %bb10 ] - %tmp15 = phi i32 [ undef, %bb3 ], [ %tmp7, %bb10 ] - %tmp16 = getelementptr double, double* %arg, i32 %tmp15 - %tmp17 = fadd double %tmp14, 1.300000e+00 - store double %tmp17, double* %tmp16, align 4 - %tmp18 = add nsw i32 %tmp15, 1 - br label %bb6 - -bb19: - ret void -} diff --git a/test/CodeGen/WebAssembly/legalize.ll b/test/CodeGen/WebAssembly/legalize.ll deleted file mode 100644 index 978e72b5b85b..000000000000 --- a/test/CodeGen/WebAssembly/legalize.ll +++ /dev/null @@ -1,62 +0,0 @@ -; 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-wasm" - -; CHECK-LABEL: shl_i3: -; CHECK: i32.const $push0=, 7{{$}} -; CHECK: i32.and $push1=, $1, $pop0{{$}} -; CHECK: i32.shl $push2=, $0, $pop1{{$}} -define i3 @shl_i3(i3 %a, i3 %b, i3* %p) { - %t = shl i3 %a, %b - ret i3 %t -} - -; CHECK-LABEL: shl_i53: -; CHECK: i64.const $push0=, 9007199254740991{{$}} -; CHECK: i64.and $push1=, $1, $pop0{{$}} -; CHECK: i64.shl $push2=, $0, $pop1{{$}} -define i53 @shl_i53(i53 %a, i53 %b, i53* %p) { - %t = shl i53 %a, %b - ret i53 %t -} - -; CHECK-LABEL: sext_in_reg_i32_i64: -; CHECK: i64.shl -; CHECK: i64.shr_s -define i64 @sext_in_reg_i32_i64(i64 %a) { - %b = shl i64 %a, 32 - %c = ashr i64 %b, 32 - ret i64 %c -} - -; CHECK-LABEL: fpext_f32_f64: -; CHECK: f32.load $push0=, 0($0){{$}} -; CHECK: f64.promote/f32 $push1=, $pop0{{$}} -; CHECK: return $pop1{{$}} -define double @fpext_f32_f64(float *%p) { - %v = load float, float* %p - %e = fpext float %v to double - ret double %e -} - -; CHECK-LABEL: fpconv_f64_f32: -; CHECK: f64.load $push0=, 0($0){{$}} -; CHECK: f32.demote/f64 $push1=, $pop0{{$}} -; CHECK: return $pop1{{$}} -define float @fpconv_f64_f32(double *%p) { - %v = load double, double* %p - %e = fptrunc double %v to float - ret float %e -} - -; Check that big shifts work. This generates a big pile of code from the -; legalizer; the main thing here is that we don't abort. - -; CHECK-LABEL: bigshift: -define i1024 @bigshift(i1024 %a, i1024 %b) { - %c = shl i1024 %a, %b - ret i1024 %c -} diff --git a/test/CodeGen/WebAssembly/lit.local.cfg b/test/CodeGen/WebAssembly/lit.local.cfg deleted file mode 100644 index 743473517cd0..000000000000 --- a/test/CodeGen/WebAssembly/lit.local.cfg +++ /dev/null @@ -1,2 +0,0 @@ -if not 'WebAssembly' in config.root.targets: - config.unsupported = True diff --git a/test/CodeGen/WebAssembly/load-ext.ll b/test/CodeGen/WebAssembly/load-ext.ll deleted file mode 100644 index a624995ea625..000000000000 --- a/test/CodeGen/WebAssembly/load-ext.ll +++ /dev/null @@ -1,96 +0,0 @@ -; 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-wasm" - -; CHECK-LABEL: sext_i8_i32: -; CHECK: i32.load8_s $push0=, 0($0){{$}} -; CHECK-NEXT: return $pop0{{$}} -define i32 @sext_i8_i32(i8 *%p) { - %v = load i8, i8* %p - %e = sext i8 %v to i32 - ret i32 %e -} - -; CHECK-LABEL: zext_i8_i32: -; CHECK: i32.load8_u $push0=, 0($0){{$}} -; CHECK-NEXT: return $pop0{{$}} -define i32 @zext_i8_i32(i8 *%p) { - %v = load i8, i8* %p - %e = zext i8 %v to i32 - ret i32 %e -} - -; CHECK-LABEL: sext_i16_i32: -; CHECK: i32.load16_s $push0=, 0($0){{$}} -; CHECK-NEXT: return $pop0{{$}} -define i32 @sext_i16_i32(i16 *%p) { - %v = load i16, i16* %p - %e = sext i16 %v to i32 - ret i32 %e -} - -; CHECK-LABEL: zext_i16_i32: -; CHECK: i32.load16_u $push0=, 0($0){{$}} -; CHECK-NEXT: return $pop0{{$}} -define i32 @zext_i16_i32(i16 *%p) { - %v = load i16, i16* %p - %e = zext i16 %v to i32 - ret i32 %e -} - -; CHECK-LABEL: sext_i8_i64: -; CHECK: i64.load8_s $push0=, 0($0){{$}} -; CHECK-NEXT: return $pop0{{$}} -define i64 @sext_i8_i64(i8 *%p) { - %v = load i8, i8* %p - %e = sext i8 %v to i64 - ret i64 %e -} - -; CHECK-LABEL: zext_i8_i64: -; CHECK: i64.load8_u $push0=, 0($0){{$}} -; CHECK-NEXT: return $pop0{{$}} -define i64 @zext_i8_i64(i8 *%p) { - %v = load i8, i8* %p - %e = zext i8 %v to i64 - ret i64 %e -} - -; CHECK-LABEL: sext_i16_i64: -; CHECK: i64.load16_s $push0=, 0($0){{$}} -; CHECK-NEXT: return $pop0{{$}} -define i64 @sext_i16_i64(i16 *%p) { - %v = load i16, i16* %p - %e = sext i16 %v to i64 - ret i64 %e -} - -; CHECK-LABEL: zext_i16_i64: -; CHECK: i64.load16_u $push0=, 0($0){{$}} -; CHECK-NEXT: return $pop0{{$}} -define i64 @zext_i16_i64(i16 *%p) { - %v = load i16, i16* %p - %e = zext i16 %v to i64 - ret i64 %e -} - -; CHECK-LABEL: sext_i32_i64: -; CHECK: i64.load32_s $push0=, 0($0){{$}} -; CHECK-NEXT: return $pop0{{$}} -define i64 @sext_i32_i64(i32 *%p) { - %v = load i32, i32* %p - %e = sext i32 %v to i64 - ret i64 %e -} - -; CHECK-LABEL: zext_i32_i64: -; CHECK: i64.load32_u $push0=, 0($0){{$}} -; CHECK: return $pop0{{$}} -define i64 @zext_i32_i64(i32 *%p) { - %v = load i32, i32* %p - %e = zext i32 %v to i64 - ret i64 %e -} diff --git a/test/CodeGen/WebAssembly/load-store-i1.ll b/test/CodeGen/WebAssembly/load-store-i1.ll deleted file mode 100644 index 9882609d773b..000000000000 --- a/test/CodeGen/WebAssembly/load-store-i1.ll +++ /dev/null @@ -1,70 +0,0 @@ -; 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-wasm" - -; CHECK-LABEL: load_u_i1_i32: -; CHECK: i32.load8_u $push[[NUM0:[0-9]+]]=, 0($0){{$}} -; CHECK-NEXT: return $pop[[NUM0]]{{$}} -define i32 @load_u_i1_i32(i1* %p) { - %v = load i1, i1* %p - %e = zext i1 %v to i32 - ret i32 %e -} - -; CHECK-LABEL: load_s_i1_i32: -; CHECK: i32.const $push[[NUM3:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: i32.load8_u $push[[NUM0:[0-9]+]]=, 0($0){{$}} -; CHECK-NEXT: i32.const $push[[NUM1:[0-9]+]]=, 1{{$}} -; CHECK-NEXT: i32.and $push[[NUM2:[0-9]+]]=, $pop[[NUM0]], $pop[[NUM1]]{{$}} -; CHECK-NEXT: i32.sub $push[[NUM4:[0-9]+]]=, $pop[[NUM3]], $pop[[NUM2]]{{$}} -; CHECK-NEXT: return $pop[[NUM4]]{{$}} -define i32 @load_s_i1_i32(i1* %p) { - %v = load i1, i1* %p - %e = sext i1 %v to i32 - ret i32 %e -} - -; CHECK-LABEL: load_u_i1_i64: -; CHECK: i64.load8_u $push[[NUM0:[0-9]+]]=, 0($0){{$}} -; CHECK-NEXT: return $pop[[NUM0]]{{$}} -define i64 @load_u_i1_i64(i1* %p) { - %v = load i1, i1* %p - %e = zext i1 %v to i64 - ret i64 %e -} - -; CHECK-LABEL: load_s_i1_i64: -; CHECK: i64.const $push[[NUM3:[0-9]+]]=, 0{{$}} -; CHECK-NEXT: i64.load8_u $push[[NUM0:[0-9]+]]=, 0($0){{$}} -; CHECK-NEXT: i64.const $push[[NUM1:[0-9]+]]=, 1{{$}} -; CHECK-NEXT: i64.and $push[[NUM2:[0-9]+]]=, $pop[[NUM0]], $pop[[NUM1]]{{$}} -; CHECK-NEXT: i64.sub $push[[NUM4:[0-9]+]]=, $pop[[NUM3]], $pop[[NUM2]]{{$}} -; CHECK-NEXT: return $pop[[NUM4]]{{$}} -define i64 @load_s_i1_i64(i1* %p) { - %v = load i1, i1* %p - %e = sext i1 %v to i64 - ret i64 %e -} - -; CHECK-LABEL: store_i32_i1: -; CHECK: i32.const $push[[NUM0:[0-9]+]]=, 1{{$}} -; CHECK-NEXT: i32.and $push[[NUM1:[0-9]+]]=, $1, $pop[[NUM0]]{{$}} -; CHECK-NEXT: i32.store8 0($0), $pop[[NUM1]]{{$}} -define void @store_i32_i1(i1* %p, i32 %v) { - %t = trunc i32 %v to i1 - store i1 %t, i1* %p - ret void -} - -; CHECK-LABEL: store_i64_i1: -; CHECK: i64.const $push[[NUM0:[0-9]+]]=, 1{{$}} -; CHECK-NEXT: i64.and $push[[NUM1:[0-9]+]]=, $1, $pop[[NUM0]]{{$}} -; CHECK-NEXT: i64.store8 0($0), $pop[[NUM1]]{{$}} -define void @store_i64_i1(i1* %p, i64 %v) { - %t = trunc i64 %v to i1 - store i1 %t, i1* %p - ret void -} diff --git a/test/CodeGen/WebAssembly/load.ll b/test/CodeGen/WebAssembly/load.ll deleted file mode 100644 index 165d145fde1a..000000000000 --- a/test/CodeGen/WebAssembly/load.ll +++ /dev/null @@ -1,51 +0,0 @@ -; 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 - -; 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-wasm" - -; CHECK-LABEL: ldi32: -; CHECK-NEXT: .param i32{{$}} -; CHECK-NEXT: .result i32{{$}} -; 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 - ret i32 %v -} - -; CHECK-LABEL: ldi64: -; CHECK-NEXT: .param i32{{$}} -; CHECK-NEXT: .result i64{{$}} -; 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 - ret i64 %v -} - -; CHECK-LABEL: ldf32: -; CHECK-NEXT: .param i32{{$}} -; CHECK-NEXT: .result f32{{$}} -; 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 - ret float %v -} - -; CHECK-LABEL: ldf64: -; CHECK-NEXT: .param i32{{$}} -; CHECK-NEXT: .result f64{{$}} -; 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 - ret double %v -} diff --git a/test/CodeGen/WebAssembly/lower-em-ehsjlj-options.ll b/test/CodeGen/WebAssembly/lower-em-ehsjlj-options.ll deleted file mode 100644 index 91fde29ea59e..000000000000 --- a/test/CodeGen/WebAssembly/lower-em-ehsjlj-options.ll +++ /dev/null @@ -1,61 +0,0 @@ -; RUN: llc < %s -enable-emscripten-cxx-exceptions | FileCheck %s --check-prefix=EH -; RUN: llc < %s -enable-emscripten-sjlj | FileCheck %s --check-prefix=SJLJ -; 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-wasm" - -%struct.__jmp_buf_tag = type { [6 x i32], i32, [32 x i32] } - -define hidden void @exception() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) { -; EH-LABEL: type exception,@function -; NONE-LABEL: type exception,@function -entry: - invoke void @foo() - to label %try.cont unwind label %lpad -; EH: call __invoke_void@FUNCTION -; NONE: call foo@FUNCTION - -lpad: ; preds = %entry - %0 = landingpad { i8*, i32 } - catch i8* null - %1 = extractvalue { i8*, i32 } %0, 0 - %2 = extractvalue { i8*, i32 } %0, 1 - %3 = call i8* @__cxa_begin_catch(i8* %1) #2 - call void @__cxa_end_catch() - br label %try.cont - -try.cont: ; preds = %entry, %lpad - ret void -} - -define hidden void @setjmp_longjmp() { -; SJLJ-LABEL: type setjmp_longjmp,@function -; NONE-LABEL: type setjmp_longjmp,@function -entry: - %buf = alloca [1 x %struct.__jmp_buf_tag], align 16 - %arraydecay = getelementptr inbounds [1 x %struct.__jmp_buf_tag], [1 x %struct.__jmp_buf_tag]* %buf, i32 0, i32 0 - %call = call i32 @setjmp(%struct.__jmp_buf_tag* %arraydecay) #0 - %arraydecay1 = getelementptr inbounds [1 x %struct.__jmp_buf_tag], [1 x %struct.__jmp_buf_tag]* %buf, i32 0, i32 0 - call void @longjmp(%struct.__jmp_buf_tag* %arraydecay1, i32 1) #1 - unreachable -; SJLJ: i32.call ${{[a-zA-Z0-9]+}}=, saveSetjmp@FUNCTION -; SJLJ: i32.call ${{[a-zA-Z0-9]+}}=, testSetjmp@FUNCTION -; NONE: i32.call ${{[a-zA-Z0-9]+}}=, setjmp@FUNCTION -; NONE: call longjmp@FUNCTION -} - -declare void @foo() -declare i32 @__gxx_personality_v0(...) -declare i8* @__cxa_begin_catch(i8*) -declare void @__cxa_end_catch() -; Function Attrs: returns_twice -declare i32 @setjmp(%struct.__jmp_buf_tag*) #0 -; Function Attrs: noreturn -declare void @longjmp(%struct.__jmp_buf_tag*, i32) #1 -declare i8* @malloc(i32) -declare void @free(i8*) - -attributes #0 = { returns_twice } -attributes #1 = { noreturn } -attributes #2 = { nounwind } diff --git a/test/CodeGen/WebAssembly/lower-em-exceptions-whitelist.ll b/test/CodeGen/WebAssembly/lower-em-exceptions-whitelist.ll deleted file mode 100644 index 3864e445f639..000000000000 --- a/test/CodeGen/WebAssembly/lower-em-exceptions-whitelist.ll +++ /dev/null @@ -1,65 +0,0 @@ -; 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-wasm" - -define void @dont_catch() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) { -; CHECK-LABEL: @dont_catch( -entry: - invoke void @foo() - to label %invoke.cont unwind label %lpad -; CHECK: entry: -; CHECK-NEXT: call void @foo() -; CHECK-NEXT: br label %invoke.cont - -invoke.cont: ; preds = %entry - br label %try.cont - -lpad: ; preds = %entry - %0 = landingpad { i8*, i32 } - catch i8* null - %1 = extractvalue { i8*, i32 } %0, 0 - %2 = extractvalue { i8*, i32 } %0, 1 - br label %catch - -catch: ; preds = %lpad - %3 = call i8* @__cxa_begin_catch(i8* %1) - call void @__cxa_end_catch() - br label %try.cont - -try.cont: ; preds = %catch, %invoke.cont - ret void -} - -define void @do_catch() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) { -; CHECK-LABEL: @do_catch( -entry: - invoke void @foo() - to label %invoke.cont unwind label %lpad -; CHECK: entry: -; CHECK-NEXT: store i32 0, i32* -; CHECK-NEXT: call void @__invoke_void(void ()* @foo) - -invoke.cont: ; preds = %entry - br label %try.cont - -lpad: ; preds = %entry - %0 = landingpad { i8*, i32 } - catch i8* null - %1 = extractvalue { i8*, i32 } %0, 0 - %2 = extractvalue { i8*, i32 } %0, 1 - br label %catch - -catch: ; preds = %lpad - %3 = call i8* @__cxa_begin_catch(i8* %1) - call void @__cxa_end_catch() - br label %try.cont - -try.cont: ; preds = %catch, %invoke.cont - ret void -} - -declare void @foo() -declare i32 @__gxx_personality_v0(...) -declare i8* @__cxa_begin_catch(i8*) -declare void @__cxa_end_catch() diff --git a/test/CodeGen/WebAssembly/lower-em-exceptions.ll b/test/CodeGen/WebAssembly/lower-em-exceptions.ll deleted file mode 100644 index 060f481c3265..000000000000 --- a/test/CodeGen/WebAssembly/lower-em-exceptions.ll +++ /dev/null @@ -1,194 +0,0 @@ -; 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-wasm" - -@_ZTIi = external constant i8* -@_ZTIc = external constant i8* -; CHECK-DAG: @[[__THREW__:__THREW__.*]] = global i32 0 -; CHECK-DAG: @[[THREWVALUE:__threwValue.*]] = global i32 0 -; CHECK-DAG: @[[TEMPRET0:__tempRet0.*]] = global i32 0 - -; Test invoke instruction with clauses (try-catch block) -define void @clause() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) { -; CHECK-LABEL: @clause( -entry: - invoke void @foo(i32 3) - to label %invoke.cont unwind label %lpad -; CHECK: entry: -; CHECK-NEXT: store i32 0, i32* @[[__THREW__]] -; CHECK-NEXT: call void @__invoke_void_i32(void (i32)* @foo, i32 3) -; CHECK-NEXT: %[[__THREW__VAL:.*]] = load i32, i32* @[[__THREW__]] -; CHECK-NEXT: store i32 0, i32* @[[__THREW__]] -; CHECK-NEXT: %cmp = icmp eq i32 %[[__THREW__VAL]], 1 -; CHECK-NEXT: br i1 %cmp, label %lpad, label %invoke.cont - -invoke.cont: ; preds = %entry - br label %try.cont - -lpad: ; preds = %entry - %0 = landingpad { i8*, i32 } - catch i8* bitcast (i8** @_ZTIi to i8*) - catch i8* null - %1 = extractvalue { i8*, i32 } %0, 0 - %2 = extractvalue { i8*, i32 } %0, 1 - br label %catch.dispatch -; CHECK: lpad: -; CHECK-NEXT: %[[FMC:.*]] = call i8* @__cxa_find_matching_catch_4(i8* bitcast (i8** @_ZTIi to i8*), i8* null) -; CHECK-NEXT: %[[IVI1:.*]] = insertvalue { i8*, i32 } undef, i8* %[[FMC]], 0 -; CHECK-NEXT: %[[TEMPRET0_VAL:.*]] = load i32, i32* @[[TEMPRET0]] -; CHECK-NEXT: %[[IVI2:.*]] = insertvalue { i8*, i32 } %[[IVI1]], i32 %[[TEMPRET0_VAL]], 1 -; CHECK-NEXT: extractvalue { i8*, i32 } %[[IVI2]], 0 -; CHECK-NEXT: %[[CDR:.*]] = extractvalue { i8*, i32 } %[[IVI2]], 1 - -catch.dispatch: ; preds = %lpad - %3 = call i32 @llvm.eh.typeid.for(i8* bitcast (i8** @_ZTIi to i8*)) - %matches = icmp eq i32 %2, %3 - br i1 %matches, label %catch1, label %catch -; CHECK: catch.dispatch: -; CHECK-NEXT: %[[TYPEID:.*]] = call i32 @llvm_eh_typeid_for(i8* bitcast (i8** @_ZTIi to i8*)) -; CHECK-NEXT: %matches = icmp eq i32 %[[CDR]], %[[TYPEID]] - -catch1: ; preds = %catch.dispatch - %4 = call i8* @__cxa_begin_catch(i8* %1) - %5 = bitcast i8* %4 to i32* - %6 = load i32, i32* %5, align 4 - call void @__cxa_end_catch() - br label %try.cont - -try.cont: ; preds = %catch, %catch1, %invoke.cont - ret void - -catch: ; preds = %catch.dispatch - %7 = call i8* @__cxa_begin_catch(i8* %1) - call void @__cxa_end_catch() - br label %try.cont -} - -; Test invoke instruction with filters (functions with throw(...) declaration) -define void @filter() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) { -; CHECK-LABEL: @filter( -entry: - invoke void @foo(i32 3) - to label %invoke.cont unwind label %lpad -; CHECK: entry: -; CHECK-NEXT: store i32 0, i32* @[[__THREW__]] -; CHECK-NEXT: call void @__invoke_void_i32(void (i32)* @foo, i32 3) -; CHECK-NEXT: %[[__THREW__VAL:.*]] = load i32, i32* @[[__THREW__]] -; CHECK-NEXT: store i32 0, i32* @[[__THREW__]] -; CHECK-NEXT: %cmp = icmp eq i32 %[[__THREW__VAL]], 1 -; CHECK-NEXT: br i1 %cmp, label %lpad, label %invoke.cont - -invoke.cont: ; preds = %entry - ret void - -lpad: ; preds = %entry - %0 = landingpad { i8*, i32 } - filter [2 x i8*] [i8* bitcast (i8** @_ZTIi to i8*), i8* bitcast (i8** @_ZTIc to i8*)] - %1 = extractvalue { i8*, i32 } %0, 0 - %2 = extractvalue { i8*, i32 } %0, 1 - br label %filter.dispatch -; CHECK: lpad: -; CHECK-NEXT: %[[FMC:.*]] = call i8* @__cxa_find_matching_catch_4(i8* bitcast (i8** @_ZTIi to i8*), i8* bitcast (i8** @_ZTIc to i8*)) -; CHECK-NEXT: %[[IVI1:.*]] = insertvalue { i8*, i32 } undef, i8* %[[FMC]], 0 -; CHECK-NEXT: %[[TEMPRET0_VAL:.*]] = load i32, i32* @[[TEMPRET0]] -; CHECK-NEXT: %[[IVI2:.*]] = insertvalue { i8*, i32 } %[[IVI1]], i32 %[[TEMPRET0_VAL]], 1 -; CHECK-NEXT: extractvalue { i8*, i32 } %[[IVI2]], 0 -; CHECK-NEXT: extractvalue { i8*, i32 } %[[IVI2]], 1 - -filter.dispatch: ; preds = %lpad - %ehspec.fails = icmp slt i32 %2, 0 - br i1 %ehspec.fails, label %ehspec.unexpected, label %eh.resume - -ehspec.unexpected: ; preds = %filter.dispatch - call void @__cxa_call_unexpected(i8* %1) #4 - unreachable - -eh.resume: ; preds = %filter.dispatch - %lpad.val = insertvalue { i8*, i32 } undef, i8* %1, 0 - %lpad.val3 = insertvalue { i8*, i32 } %lpad.val, i32 %2, 1 - resume { i8*, i32 } %lpad.val3 -; CHECK: eh.resume: -; CHECK-NEXT: insertvalue -; CHECK-NEXT: %[[LPAD_VAL:.*]] = insertvalue -; CHECK-NEXT: %[[LOW:.*]] = extractvalue { i8*, i32 } %[[LPAD_VAL]], 0 -; CHECK-NEXT: call void @__resumeException(i8* %[[LOW]]) -; CHECK-NEXT: unreachable -} - -; Test if argument attributes indices in newly created call instructions are correct -define void @arg_attributes() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) { -; CHECK-LABEL: @arg_attributes( -entry: - %0 = invoke noalias i8* @bar(i8 signext 1, i8 zeroext 2) - to label %invoke.cont unwind label %lpad -; CHECK: entry: -; CHECK-NEXT: store i32 0, i32* @[[__THREW__]] -; CHECK-NEXT: %0 = call noalias i8* @"__invoke_i8*_i8_i8"(i8* (i8, i8)* @bar, i8 signext 1, i8 zeroext 2) - -invoke.cont: ; preds = %entry - br label %try.cont - -lpad: ; preds = %entry - %1 = landingpad { i8*, i32 } - catch i8* bitcast (i8** @_ZTIi to i8*) - catch i8* null - %2 = extractvalue { i8*, i32 } %1, 0 - %3 = extractvalue { i8*, i32 } %1, 1 - br label %catch.dispatch - -catch.dispatch: ; preds = %lpad - %4 = call i32 @llvm.eh.typeid.for(i8* bitcast (i8** @_ZTIi to i8*)) - %matches = icmp eq i32 %3, %4 - br i1 %matches, label %catch1, label %catch - -catch1: ; preds = %catch.dispatch - %5 = call i8* @__cxa_begin_catch(i8* %2) - %6 = bitcast i8* %5 to i32* - %7 = load i32, i32* %6, align 4 - call void @__cxa_end_catch() - br label %try.cont - -try.cont: ; preds = %catch, %catch1, %invoke.cont - ret void - -catch: ; preds = %catch.dispatch - %8 = call i8* @__cxa_begin_catch(i8* %2) - call void @__cxa_end_catch() - br label %try.cont -} - -declare void @foo(i32) -declare i8* @bar(i8, i8) - -declare i32 @__gxx_personality_v0(...) -declare i32 @llvm.eh.typeid.for(i8*) -declare i8* @__cxa_begin_catch(i8*) -declare void @__cxa_end_catch() -declare void @__cxa_call_unexpected(i8*) - -; JS glue functions and invoke wrappers declaration -; CHECK-DAG: declare void @__resumeException(i8*) -; CHECK-DAG: declare void @__invoke_void_i32(void (i32)*, i32) -; CHECK-DAG: declare i8* @__cxa_find_matching_catch_4(i8*, i8*) - -; setThrew function creation -; CHECK-LABEL: define void @setThrew(i32 %threw, i32 %value) { -; CHECK: entry: -; CHECK-NEXT: %[[__THREW__]].val = load i32, i32* @[[__THREW__]] -; CHECK-NEXT: %cmp = icmp eq i32 %[[__THREW__]].val, 0 -; CHECK-NEXT: br i1 %cmp, label %if.then, label %if.end -; CHECK: if.then: -; CHECK-NEXT: store i32 %threw, i32* @[[__THREW__]] -; CHECK-NEXT: store i32 %value, i32* @[[THREWVALUE]] -; CHECK-NEXT: br label %if.end -; CHECK: if.end: -; CHECK-NEXT: ret void -; CHECK: } - -; setTempRet0 function creation -; CHECK-LABEL: define void @setTempRet0(i32 %value) { -; CHECK: entry: -; CHECK-NEXT: store i32 %value, i32* @[[TEMPRET0]] -; CHECK-NEXT: ret void -; CHECK: } diff --git a/test/CodeGen/WebAssembly/lower-em-sjlj.ll b/test/CodeGen/WebAssembly/lower-em-sjlj.ll deleted file mode 100644 index cf42219c0114..000000000000 --- a/test/CodeGen/WebAssembly/lower-em-sjlj.ll +++ /dev/null @@ -1,213 +0,0 @@ -; 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-wasm" - -%struct.__jmp_buf_tag = type { [6 x i32], i32, [32 x i32] } - -@global_var = hidden global i32 0, align 4 -; CHECK-DAG: @[[__THREW__:__THREW__.*]] = global i32 0 -; CHECK-DAG: @[[THREWVALUE:__threwValue.*]] = global i32 0 -; CHECK-DAG: @[[TEMPRET0:__tempRet0.*]] = global i32 0 - -; Test a simple setjmp - longjmp sequence -define hidden void @setjmp_longjmp() { -; CHECK-LABEL: @setjmp_longjmp -entry: - %buf = alloca [1 x %struct.__jmp_buf_tag], align 16 - %arraydecay = getelementptr inbounds [1 x %struct.__jmp_buf_tag], [1 x %struct.__jmp_buf_tag]* %buf, i32 0, i32 0 - %call = call i32 @setjmp(%struct.__jmp_buf_tag* %arraydecay) #0 - %arraydecay1 = getelementptr inbounds [1 x %struct.__jmp_buf_tag], [1 x %struct.__jmp_buf_tag]* %buf, i32 0, i32 0 - call void @longjmp(%struct.__jmp_buf_tag* %arraydecay1, i32 1) #1 - unreachable -; CHECK: entry: -; CHECK-NEXT: %[[MALLOCCALL:.*]] = tail call i8* @malloc(i32 40) -; CHECK-NEXT: %[[SETJMP_TABLE:.*]] = bitcast i8* %[[MALLOCCALL]] to i32* -; CHECK-NEXT: store i32 0, i32* %[[SETJMP_TABLE]] -; CHECK-NEXT: %[[SETJMP_TABLE_SIZE:.*]] = add i32 4, 0 -; CHECK-NEXT: %[[BUF:.*]] = alloca [1 x %struct.__jmp_buf_tag] -; CHECK-NEXT: %[[ARRAYDECAY:.*]] = getelementptr inbounds [1 x %struct.__jmp_buf_tag], [1 x %struct.__jmp_buf_tag]* %[[BUF]], i32 0, i32 0 -; CHECK-NEXT: %[[SETJMP_TABLE1:.*]] = call i32* @saveSetjmp(%struct.__jmp_buf_tag* %[[ARRAYDECAY]], i32 1, i32* %[[SETJMP_TABLE]], i32 %[[SETJMP_TABLE_SIZE]]) -; CHECK-NEXT: %[[SETJMP_TABLE_SIZE1:.*]] = load i32, i32* @[[TEMPRET0]] -; CHECK-NEXT: br label %entry.split - -; CHECK: entry.split: -; CHECK-NEXT: phi i32 [ 0, %entry ], [ %[[LONGJMP_RESULT:.*]], %if.end ] -; CHECK-NEXT: %[[ARRAYDECAY1:.*]] = getelementptr inbounds [1 x %struct.__jmp_buf_tag], [1 x %struct.__jmp_buf_tag]* %[[BUF]], i32 0, i32 0 -; CHECK-NEXT: store i32 0, i32* @[[__THREW__]] -; CHECK-NEXT: call void @"__invoke_void_%struct.__jmp_buf_tag*_i32"(void (%struct.__jmp_buf_tag*, i32)* @emscripten_longjmp_jmpbuf, %struct.__jmp_buf_tag* %[[ARRAYDECAY1]], i32 1) -; CHECK-NEXT: %[[__THREW__VAL:.*]] = load i32, i32* @[[__THREW__]] -; CHECK-NEXT: store i32 0, i32* @[[__THREW__]] -; CHECK-NEXT: %[[CMP0:.*]] = icmp ne i32 %__THREW__.val, 0 -; CHECK-NEXT: %[[THREWVALUE_VAL:.*]] = load i32, i32* @[[THREWVALUE]] -; CHECK-NEXT: %[[CMP1:.*]] = icmp ne i32 %[[THREWVALUE_VAL]], 0 -; CHECK-NEXT: %[[CMP:.*]] = and i1 %[[CMP0]], %[[CMP1]] -; CHECK-NEXT: br i1 %[[CMP]], label %if.then1, label %if.else1 - -; CHECK: entry.split.split: -; CHECK-NEXT: unreachable - -; CHECK: if.then1: -; CHECK-NEXT: %[[__THREW__VAL_I32P:.*]] = inttoptr i32 %[[__THREW__VAL]] to i32* -; CHECK-NEXT: %[[__THREW__VAL_I32P_LOADED:.*]] = load i32, i32* %[[__THREW__VAL_I32P]] -; CHECK-NEXT: %[[LABEL:.*]] = call i32 @testSetjmp(i32 %[[__THREW__VAL_I32P_LOADED]], i32* %[[SETJMP_TABLE1]], i32 %[[SETJMP_TABLE_SIZE1]]) -; CHECK-NEXT: %[[CMP:.*]] = icmp eq i32 %[[LABEL]], 0 -; CHECK-NEXT: br i1 %[[CMP]], label %if.then2, label %if.end2 - -; CHECK: if.else1: -; CHECK-NEXT: br label %if.end - -; CHECK: if.end: -; CHECK-NEXT: %[[LABEL_PHI:.*]] = phi i32 [ %[[LABEL:.*]], %if.end2 ], [ -1, %if.else1 ] -; CHECK-NEXT: %[[LONGJMP_RESULT]] = load i32, i32* @[[TEMPRET0]] -; CHECK-NEXT: switch i32 %[[LABEL_PHI]], label %entry.split.split [ -; CHECK-NEXT: i32 1, label %entry.split -; CHECK-NEXT: ] - -; CHECK: if.then2: -; CHECK-NEXT: call void @emscripten_longjmp(i32 %[[__THREW__VAL]], i32 %[[THREWVALUE_VAL]]) -; CHECK-NEXT: unreachable - -; CHECK: if.end2: -; CHECK-NEXT: store i32 %[[THREWVALUE_VAL]], i32* @[[TEMPRET0]] -; CHECK-NEXT: br label %if.end -} - -; Test a case of a function call (which is not longjmp) after a setjmp -define hidden void @setjmp_other() { -; CHECK-LABEL: @setjmp_other -entry: - %buf = alloca [1 x %struct.__jmp_buf_tag], align 16 - %arraydecay = getelementptr inbounds [1 x %struct.__jmp_buf_tag], [1 x %struct.__jmp_buf_tag]* %buf, i32 0, i32 0 - %call = call i32 @setjmp(%struct.__jmp_buf_tag* %arraydecay) #0 - call void @foo() - ret void -; CHECK: entry: -; CHECK: %[[SETJMP_TABLE:.*]] = call i32* @saveSetjmp( - -; CHECK: entry.split: -; CHECK: call void @__invoke_void(void ()* @foo) - -; CHECK: entry.split.split: -; CHECK-NEXT: %[[BUF:.*]] = bitcast i32* %[[SETJMP_TABLE]] to i8* -; CHECK-NEXT: tail call void @free(i8* %[[BUF]]) -; CHECK-NEXT: ret void -} - -; Test a case when a function call is within try-catch, after a setjmp -define hidden void @exception_and_longjmp() #3 personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) { -; CHECK-LABEL: @exception_and_longjmp -entry: - %buf = alloca [1 x %struct.__jmp_buf_tag], align 16 - %arraydecay = getelementptr inbounds [1 x %struct.__jmp_buf_tag], [1 x %struct.__jmp_buf_tag]* %buf, i32 0, i32 0 - %call = call i32 @setjmp(%struct.__jmp_buf_tag* %arraydecay) #0 - invoke void @foo() - to label %try.cont unwind label %lpad - -; CHECK: entry.split: -; CHECK: store i32 0, i32* @[[__THREW__]] -; CHECK-NEXT: call void @__invoke_void(void ()* @foo) -; CHECK-NEXT: %[[__THREW__VAL:.*]] = load i32, i32* @[[__THREW__]] -; CHECK-NEXT: store i32 0, i32* @[[__THREW__]] -; CHECK-NEXT: %[[CMP0:.*]] = icmp ne i32 %[[__THREW__VAL]], 0 -; CHECK-NEXT: %[[THREWVALUE_VAL:.*]] = load i32, i32* @[[THREWVALUE]] -; CHECK-NEXT: %[[CMP1:.*]] = icmp ne i32 %[[THREWVALUE_VAL]], 0 -; CHECK-NEXT: %[[CMP:.*]] = and i1 %[[CMP0]], %[[CMP1]] -; CHECK-NEXT: br i1 %[[CMP]], label %if.then1, label %if.else1 - -; CHECK: entry.split.split: -; CHECK-NEXT: %[[CMP:.*]] = icmp eq i32 %[[__THREW__VAL]], 1 -; CHECK-NEXT: br i1 %[[CMP]], label %lpad, label %try.cont - -lpad: ; preds = %entry - %0 = landingpad { i8*, i32 } - catch i8* null - %1 = extractvalue { i8*, i32 } %0, 0 - %2 = extractvalue { i8*, i32 } %0, 1 - %3 = call i8* @__cxa_begin_catch(i8* %1) #2 - call void @__cxa_end_catch() - br label %try.cont - -try.cont: ; preds = %entry, %lpad - ret void -} - -; Test SSA validity -define hidden void @ssa(i32 %n) { -; CHECK-LABEL: @ssa -entry: - %buf = alloca [1 x %struct.__jmp_buf_tag], align 16 - %cmp = icmp sgt i32 %n, 5 - br i1 %cmp, label %if.then, label %if.end -; CHECK: entry: -; CHECK: %[[SETJMP_TABLE0:.*]] = bitcast i8* -; CHECK: %[[SETJMP_TABLE_SIZE0:.*]] = add i32 4, 0 - -if.then: ; preds = %entry - %0 = load i32, i32* @global_var, align 4 - %arraydecay = getelementptr inbounds [1 x %struct.__jmp_buf_tag], [1 x %struct.__jmp_buf_tag]* %buf, i32 0, i32 0 - %call = call i32 @setjmp(%struct.__jmp_buf_tag* %arraydecay) #0 - store i32 %0, i32* @global_var, align 4 - br label %if.end -; CHECK: if.then: -; CHECK: %[[VAR0:.*]] = load i32, i32* @global_var, align 4 -; CHECK: %[[SETJMP_TABLE1:.*]] = call i32* @saveSetjmp( -; CHECK-NEXT: %[[SETJMP_TABLE_SIZE1:.*]] = load i32, i32* @[[TEMPRET0]] - -; CHECK: if.then.split: -; CHECK: %[[VAR1:.*]] = phi i32 [ %[[VAR0]], %if.then ], [ %[[VAR2:.*]], %if.end3 ] -; CHECK: %[[SETJMP_TABLE_SIZE2:.*]] = phi i32 [ %[[SETJMP_TABLE_SIZE1]], %if.then ], [ %[[SETJMP_TABLE_SIZE3:.*]], %if.end3 ] -; CHECK: %[[SETJMP_TABLE2:.*]] = phi i32* [ %[[SETJMP_TABLE1]], %if.then ], [ %[[SETJMP_TABLE3:.*]], %if.end3 ] -; CHECK: store i32 %[[VAR1]], i32* @global_var, align 4 - -if.end: ; preds = %if.then, %entry - %arraydecay1 = getelementptr inbounds [1 x %struct.__jmp_buf_tag], [1 x %struct.__jmp_buf_tag]* %buf, i32 0, i32 0 - call void @longjmp(%struct.__jmp_buf_tag* %arraydecay1, i32 5) #1 - unreachable -; CHECK: if.end: -; CHECK: %[[VAR2]] = phi i32 [ %[[VAR1]], %if.then.split ], [ undef, %entry ] -; CHECK: %[[SETJMP_TABLE_SIZE3]] = phi i32 [ %[[SETJMP_TABLE_SIZE2]], %if.then.split ], [ %[[SETJMP_TABLE_SIZE0]], %entry ] -; CHECK: %[[SETJMP_TABLE3]] = phi i32* [ %[[SETJMP_TABLE2]], %if.then.split ], [ %[[SETJMP_TABLE0]], %entry ] -} - -; Test a case when a function only calls other functions that are neither setjmp nor longjmp -define hidden void @only_other_func() { -entry: - call void @foo() - ret void -; CHECK: call void @foo() -} - -; Test a case when a function only calls longjmp and not setjmp -define hidden void @only_longjmp() { -entry: - %buf = alloca [1 x %struct.__jmp_buf_tag], align 16 - %arraydecay = getelementptr inbounds [1 x %struct.__jmp_buf_tag], [1 x %struct.__jmp_buf_tag]* %buf, i32 0, i32 0 - call void @longjmp(%struct.__jmp_buf_tag* %arraydecay, i32 5) #1 - unreachable -; CHECK: %[[ARRAYDECAY:.*]] = getelementptr inbounds -; CHECK-NEXT: call void @emscripten_longjmp_jmpbuf(%struct.__jmp_buf_tag* %[[ARRAYDECAY]], i32 5) #1 -} - -declare void @foo() -; Function Attrs: returns_twice -declare i32 @setjmp(%struct.__jmp_buf_tag*) #0 -; Function Attrs: noreturn -declare void @longjmp(%struct.__jmp_buf_tag*, i32) #1 -declare i32 @__gxx_personality_v0(...) -declare i8* @__cxa_begin_catch(i8*) -declare void @__cxa_end_catch() -declare i8* @malloc(i32) -declare void @free(i8*) - -; JS glue functions and invoke wrappers declaration -; CHECK-DAG: declare i32* @saveSetjmp(%struct.__jmp_buf_tag*, i32, i32*, i32) -; CHECK-DAG: declare i32 @testSetjmp(i32, i32*, i32) -; CHECK-DAG: declare void @emscripten_longjmp_jmpbuf(%struct.__jmp_buf_tag*, i32) -; CHECK-DAG: declare void @emscripten_longjmp(i32, i32) -; CHECK-DAG: declare void @__invoke_void(void ()*) -; CHECK-DAG: declare void @"__invoke_void_%struct.__jmp_buf_tag*_i32"(void (%struct.__jmp_buf_tag*, i32)*, %struct.__jmp_buf_tag*, i32) - -attributes #0 = { returns_twice } -attributes #1 = { noreturn } -attributes #2 = { nounwind } diff --git a/test/CodeGen/WebAssembly/mem-intrinsics.ll b/test/CodeGen/WebAssembly/mem-intrinsics.ll deleted file mode 100644 index 32a7117a1ea6..000000000000 --- a/test/CodeGen/WebAssembly/mem-intrinsics.ll +++ /dev/null @@ -1,140 +0,0 @@ -; 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-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) -declare void @llvm.memset.p0i8.i32(i8* nocapture, i8, i32, i32, i1) - -; Test that return values are optimized. - -; CHECK-LABEL: copy_yes: -; CHECK: i32.call $push0=, memcpy@FUNCTION, $0, $1, $2{{$}} -; CHECK-NEXT: return $pop0{{$}} -define i8* @copy_yes(i8* %dst, i8* %src, i32 %len) { - call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dst, i8* %src, i32 %len, i32 1, i1 false) - ret i8* %dst -} - -; CHECK-LABEL: copy_no: -; CHECK: i32.call $drop=, memcpy@FUNCTION, $0, $1, $2{{$}} -; CHECK-NEXT: return{{$}} -define void @copy_no(i8* %dst, i8* %src, i32 %len) { - call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dst, i8* %src, i32 %len, i32 1, i1 false) - ret void -} - -; CHECK-LABEL: move_yes: -; CHECK: i32.call $push0=, memmove@FUNCTION, $0, $1, $2{{$}} -; CHECK-NEXT: return $pop0{{$}} -define i8* @move_yes(i8* %dst, i8* %src, i32 %len) { - call void @llvm.memmove.p0i8.p0i8.i32(i8* %dst, i8* %src, i32 %len, i32 1, i1 false) - ret i8* %dst -} - -; CHECK-LABEL: move_no: -; CHECK: i32.call $drop=, memmove@FUNCTION, $0, $1, $2{{$}} -; CHECK-NEXT: return{{$}} -define void @move_no(i8* %dst, i8* %src, i32 %len) { - call void @llvm.memmove.p0i8.p0i8.i32(i8* %dst, i8* %src, i32 %len, i32 1, i1 false) - ret void -} - -; CHECK-LABEL: set_yes: -; CHECK: i32.call $push0=, memset@FUNCTION, $0, $1, $2{{$}} -; CHECK-NEXT: return $pop0{{$}} -define i8* @set_yes(i8* %dst, i8 %src, i32 %len) { - call void @llvm.memset.p0i8.i32(i8* %dst, i8 %src, i32 %len, i32 1, i1 false) - ret i8* %dst -} - -; CHECK-LABEL: set_no: -; CHECK: i32.call $drop=, memset@FUNCTION, $0, $1, $2{{$}} -; CHECK-NEXT: return{{$}} -define void @set_no(i8* %dst, i8 %src, i32 %len) { - call void @llvm.memset.p0i8.i32(i8* %dst, i8 %src, i32 %len, i32 1, i1 false) - ret void -} - - -; CHECK-LABEL: frame_index: -; CHECK: i32.call $drop=, memset@FUNCTION, $pop{{[0-9]+}}, $pop{{[0-9]+}}, $pop{{[0-9]+}}{{$}} -; CHECK: i32.call $push{{[0-9]+}}=, memset@FUNCTION, ${{[0-9]+}}, $pop{{[0-9]+}}, $pop{{[0-9]+}}{{$}} -; CHECK: return{{$}} -define void @frame_index() { -entry: - %a = alloca [2048 x i8], align 16 - %b = alloca [2048 x i8], align 16 - %0 = getelementptr inbounds [2048 x i8], [2048 x i8]* %a, i32 0, i32 0 - %1 = getelementptr inbounds [2048 x i8], [2048 x i8]* %b, i32 0, i32 0 - call void @llvm.memset.p0i8.i32(i8* %0, i8 256, i32 1024, i32 16, i1 false) - call void @llvm.memset.p0i8.i32(i8* %1, i8 256, i32 1024, i32 16, i1 false) - ret void -} - -; If the result value of memset doesn't get stackified, it should be marked -; $drop. Note that we use a call to prevent tail dup so that we can test -; this specific functionality. - -; CHECK-LABEL: drop_result: -; CHECK: i32.call $drop=, memset@FUNCTION, $0, $1, $2 -declare i8* @def() -declare void @block_tail_dup() -define i8* @drop_result(i8* %arg, i8 %arg1, i32 %arg2, i32 %arg3, i32 %arg4) { -bb: - %tmp = icmp eq i32 %arg3, 0 - br i1 %tmp, label %bb5, label %bb9 - -bb5: - %tmp6 = icmp eq i32 %arg4, 0 - br i1 %tmp6, label %bb7, label %bb8 - -bb7: - call void @llvm.memset.p0i8.i32(i8* %arg, i8 %arg1, i32 %arg2, i32 1, i1 false) - br label %bb11 - -bb8: - br label %bb11 - -bb9: - %tmp10 = call i8* @def() - br label %bb11 - -bb11: - %tmp12 = phi i8* [ %arg, %bb7 ], [ %arg, %bb8 ], [ %tmp10, %bb9 ] - call void @block_tail_dup() - ret i8* %tmp12 -} - -; This is the same as drop_result, except we let tail dup happen, so the -; result of the memset *is* stackified. - -; CHECK-LABEL: tail_dup_to_reuse_result: -; CHECK: i32.call $push{{[0-9]+}}=, memset@FUNCTION, $0, $1, $2 -define i8* @tail_dup_to_reuse_result(i8* %arg, i8 %arg1, i32 %arg2, i32 %arg3, i32 %arg4) { -bb: - %tmp = icmp eq i32 %arg3, 0 - br i1 %tmp, label %bb5, label %bb9 - -bb5: - %tmp6 = icmp eq i32 %arg4, 0 - br i1 %tmp6, label %bb7, label %bb8 - -bb7: - call void @llvm.memset.p0i8.i32(i8* %arg, i8 %arg1, i32 %arg2, i32 1, i1 false) - br label %bb11 - -bb8: - br label %bb11 - -bb9: - %tmp10 = call i8* @def() - br label %bb11 - -bb11: - %tmp12 = phi i8* [ %arg, %bb7 ], [ %arg, %bb8 ], [ %tmp10, %bb9 ] - ret i8* %tmp12 -} diff --git a/test/CodeGen/WebAssembly/memory-addr32.ll b/test/CodeGen/WebAssembly/memory-addr32.ll deleted file mode 100644 index ad599b1b3f17..000000000000 --- a/test/CodeGen/WebAssembly/memory-addr32.ll +++ /dev/null @@ -1,28 +0,0 @@ -; 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-wasm" - -declare i32 @llvm.wasm.current.memory.i32() nounwind readonly -declare i32 @llvm.wasm.grow.memory.i32(i32) nounwind - -; CHECK-LABEL: current_memory: -; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: current_memory $push0={{$}} -; CHECK-NEXT: return $pop0{{$}} -define i32 @current_memory() { - %a = call i32 @llvm.wasm.current.memory.i32() - ret i32 %a -} - -; CHECK-LABEL: grow_memory: -; CHECK-NEXT: .param i32{{$}} -; 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/negative-base-reg.ll b/test/CodeGen/WebAssembly/negative-base-reg.ll deleted file mode 100644 index 377966ffa8d9..000000000000 --- a/test/CodeGen/WebAssembly/negative-base-reg.ll +++ /dev/null @@ -1,43 +0,0 @@ -; RUN: llc < %s -asm-verbose=false -verify-machineinstrs -disable-wasm-fallthrough-return-opt | FileCheck %s - -target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" -target triple = "wasm32" - -@args = hidden local_unnamed_addr global [32 x i32] zeroinitializer, align 16 - -; Function Attrs: norecurse nounwind -define hidden i32 @main() local_unnamed_addr #0 { - -; If LSR stops selecting a negative base reg value, then this test will no -; longer be useful as written. -; CHECK: i32.const $0=, -128 -entry: - br label %for.body - -for.body: ; preds = %for.body, %entry - %i.04 = phi i32 [ 0, %entry ], [ %inc, %for.body ] -; The offset should not be folded into the store. -; CHECK: i32.const $push{{[0-9]+}}=, args+128 -; CHECK: i32.add -; CHECK: i32.store 0( - %arrayidx = getelementptr inbounds [32 x i32], [32 x i32]* @args, i32 0, i32 %i.04 - store i32 1, i32* %arrayidx, align 4, !tbaa !1 - %inc = add nuw nsw i32 %i.04, 1 - %exitcond = icmp eq i32 %inc, 32 - br i1 %exitcond, label %for.end, label %for.body, !llvm.loop !5 - -for.end: ; preds = %for.body - ret i32 0 -} - -attributes #0 = { norecurse nounwind "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="generic" "unsafe-fp-math"="false" "use-soft-float"="false" } - -!llvm.ident = !{!0} - -!0 = !{!"clang version 4.0.0 (trunk 279056) (llvm/trunk 279074)"} -!1 = !{!2, !2, i64 0} -!2 = !{!"int", !3, i64 0} -!3 = !{!"omnipotent char", !4, i64 0} -!4 = !{!"Simple C/C++ TBAA"} -!5 = distinct !{!5, !6} -!6 = !{!"llvm.loop.unroll.disable"} diff --git a/test/CodeGen/WebAssembly/non-executable-stack.ll b/test/CodeGen/WebAssembly/non-executable-stack.ll deleted file mode 100644 index f1e1ba36a790..000000000000 --- a/test/CodeGen/WebAssembly/non-executable-stack.ll +++ /dev/null @@ -1,9 +0,0 @@ -; RUN: llc < %s -asm-verbose=false | FileCheck %s - -; Test that we don't emit anything declaring a non-executable stack, -; 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-wasm" - -; CHECK-NOT: .note.GNU-stack diff --git a/test/CodeGen/WebAssembly/offset-folding.ll b/test/CodeGen/WebAssembly/offset-folding.ll deleted file mode 100644 index e8e98ecc3307..000000000000 --- a/test/CodeGen/WebAssembly/offset-folding.ll +++ /dev/null @@ -1,63 +0,0 @@ -; RUN: llc < %s -asm-verbose=false | FileCheck %s - -; 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-wasm" - -@x = external global [0 x i32] -@y = global [50 x i32] zeroinitializer - -; Test basic constant offsets of both defined and external symbols. - -; CHECK-LABEL: test0: -; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: i32.const $push0=, x+188{{$}} -; CHECK=NEXT: return $pop0{{$}} -define i32* @test0() { - ret i32* getelementptr ([0 x i32], [0 x i32]* @x, i32 0, i32 47) -} - -; CHECK-LABEL: test1: -; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: i32.const $push0=, y+188{{$}} -; CHECK=NEXT: return $pop0{{$}} -define i32* @test1() { - ret i32* getelementptr ([50 x i32], [50 x i32]* @y, i32 0, i32 47) -} - -; Test zero offsets. - -; CHECK-LABEL: test2: -; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: i32.const $push0=, x{{$}} -; CHECK=NEXT: return $pop0{{$}} -define i32* @test2() { - ret i32* getelementptr ([0 x i32], [0 x i32]* @x, i32 0, i32 0) -} - -; CHECK-LABEL: test3: -; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: i32.const $push0=, y{{$}} -; CHECK=NEXT: return $pop0{{$}} -define i32* @test3() { - ret i32* getelementptr ([50 x i32], [50 x i32]* @y, i32 0, i32 0) -} - -; Test negative offsets. - -; CHECK-LABEL: test4: -; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: i32.const $push0=, x-188{{$}} -; CHECK=NEXT: return $pop0{{$}} -define i32* @test4() { - ret i32* getelementptr ([0 x i32], [0 x i32]* @x, i32 0, i32 -47) -} - -; CHECK-LABEL: test5: -; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: i32.const $push0=, y-188{{$}} -; CHECK=NEXT: return $pop0{{$}} -define i32* @test5() { - ret i32* getelementptr ([50 x i32], [50 x i32]* @y, i32 0, i32 -47) -} diff --git a/test/CodeGen/WebAssembly/offset.ll b/test/CodeGen/WebAssembly/offset.ll deleted file mode 100644 index 27c71873302a..000000000000 --- a/test/CodeGen/WebAssembly/offset.ll +++ /dev/null @@ -1,422 +0,0 @@ -; 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-wasm" - -; With an nuw add, we can fold an offset. - -; CHECK-LABEL: load_i32_with_folded_offset: -; CHECK: i32.load $push0=, 24($0){{$}} -define i32 @load_i32_with_folded_offset(i32* %p) { - %q = ptrtoint i32* %p to i32 - %r = add nuw i32 %q, 24 - %s = inttoptr i32 %r to i32* - %t = load i32, i32* %s - ret i32 %t -} - -; With an inbounds gep, we can fold an offset. - -; CHECK-LABEL: load_i32_with_folded_gep_offset: -; CHECK: i32.load $push0=, 24($0){{$}} -define i32 @load_i32_with_folded_gep_offset(i32* %p) { - %s = getelementptr inbounds i32, i32* %p, i32 6 - %t = load i32, i32* %s - ret i32 %t -} - -; We can't fold a negative offset though, even with an inbounds gep. - -; CHECK-LABEL: load_i32_with_unfolded_gep_negative_offset: -; CHECK: i32.const $push0=, -24{{$}} -; CHECK: i32.add $push1=, $0, $pop0{{$}} -; CHECK: i32.load $push2=, 0($pop1){{$}} -define i32 @load_i32_with_unfolded_gep_negative_offset(i32* %p) { - %s = getelementptr inbounds i32, i32* %p, i32 -6 - %t = load i32, i32* %s - ret i32 %t -} - -; Without nuw, and even with nsw, we can't fold an offset. - -; CHECK-LABEL: load_i32_with_unfolded_offset: -; CHECK: i32.const $push0=, 24{{$}} -; CHECK: i32.add $push1=, $0, $pop0{{$}} -; CHECK: i32.load $push2=, 0($pop1){{$}} -define i32 @load_i32_with_unfolded_offset(i32* %p) { - %q = ptrtoint i32* %p to i32 - %r = add nsw i32 %q, 24 - %s = inttoptr i32 %r to i32* - %t = load i32, i32* %s - ret i32 %t -} - -; Without inbounds, we can't fold a gep offset. - -; CHECK-LABEL: load_i32_with_unfolded_gep_offset: -; CHECK: i32.const $push0=, 24{{$}} -; CHECK: i32.add $push1=, $0, $pop0{{$}} -; CHECK: i32.load $push2=, 0($pop1){{$}} -define i32 @load_i32_with_unfolded_gep_offset(i32* %p) { - %s = getelementptr i32, i32* %p, i32 6 - %t = load i32, i32* %s - ret i32 %t -} - -; Same as above but with i64. - -; CHECK-LABEL: load_i64_with_folded_offset: -; CHECK: i64.load $push0=, 24($0){{$}} -define i64 @load_i64_with_folded_offset(i64* %p) { - %q = ptrtoint i64* %p to i32 - %r = add nuw i32 %q, 24 - %s = inttoptr i32 %r to i64* - %t = load i64, i64* %s - ret i64 %t -} - -; Same as above but with i64. - -; CHECK-LABEL: load_i64_with_folded_gep_offset: -; CHECK: i64.load $push0=, 24($0){{$}} -define i64 @load_i64_with_folded_gep_offset(i64* %p) { - %s = getelementptr inbounds i64, i64* %p, i32 3 - %t = load i64, i64* %s - ret i64 %t -} - -; Same as above but with i64. - -; CHECK-LABEL: load_i64_with_unfolded_gep_negative_offset: -; CHECK: i32.const $push0=, -24{{$}} -; CHECK: i32.add $push1=, $0, $pop0{{$}} -; CHECK: i64.load $push2=, 0($pop1){{$}} -define i64 @load_i64_with_unfolded_gep_negative_offset(i64* %p) { - %s = getelementptr inbounds i64, i64* %p, i32 -3 - %t = load i64, i64* %s - ret i64 %t -} - -; Same as above but with i64. - -; CHECK-LABEL: load_i64_with_unfolded_offset: -; CHECK: i32.const $push0=, 24{{$}} -; CHECK: i32.add $push1=, $0, $pop0{{$}} -; CHECK: i64.load $push2=, 0($pop1){{$}} -define i64 @load_i64_with_unfolded_offset(i64* %p) { - %q = ptrtoint i64* %p to i32 - %r = add nsw i32 %q, 24 - %s = inttoptr i32 %r to i64* - %t = load i64, i64* %s - ret i64 %t -} - -; Same as above but with i64. - -; CHECK-LABEL: load_i64_with_unfolded_gep_offset: -; CHECK: i32.const $push0=, 24{{$}} -; CHECK: i32.add $push1=, $0, $pop0{{$}} -; CHECK: i64.load $push2=, 0($pop1){{$}} -define i64 @load_i64_with_unfolded_gep_offset(i64* %p) { - %s = getelementptr i64, i64* %p, i32 3 - %t = load i64, i64* %s - ret i64 %t -} - -; CHECK-LABEL: load_i32_with_folded_or_offset: -; CHECK: i32.load8_s $push{{[0-9]+}}=, 2($pop{{[0-9]+}}){{$}} -define i32 @load_i32_with_folded_or_offset(i32 %x) { - %and = and i32 %x, -4 - %t0 = inttoptr i32 %and to i8* - %arrayidx = getelementptr inbounds i8, i8* %t0, i32 2 - %t1 = load i8, i8* %arrayidx, align 1 - %conv = sext i8 %t1 to i32 - ret i32 %conv -} - -; Same as above but with store. - -; CHECK-LABEL: store_i32_with_folded_offset: -; CHECK: i32.store 24($0), $pop0{{$}} -define void @store_i32_with_folded_offset(i32* %p) { - %q = ptrtoint i32* %p to i32 - %r = add nuw i32 %q, 24 - %s = inttoptr i32 %r to i32* - store i32 0, i32* %s - ret void -} - -; Same as above but with store. - -; CHECK-LABEL: store_i32_with_folded_gep_offset: -; CHECK: i32.store 24($0), $pop0{{$}} -define void @store_i32_with_folded_gep_offset(i32* %p) { - %s = getelementptr inbounds i32, i32* %p, i32 6 - store i32 0, i32* %s - ret void -} - -; Same as above but with store. - -; CHECK-LABEL: store_i32_with_unfolded_gep_negative_offset: -; CHECK: i32.const $push0=, -24{{$}} -; CHECK: i32.add $push1=, $0, $pop0{{$}} -; CHECK: i32.store 0($pop1), $pop2{{$}} -define void @store_i32_with_unfolded_gep_negative_offset(i32* %p) { - %s = getelementptr inbounds i32, i32* %p, i32 -6 - store i32 0, i32* %s - ret void -} - -; Same as above but with store. - -; CHECK-LABEL: store_i32_with_unfolded_offset: -; CHECK: i32.const $push0=, 24{{$}} -; CHECK: i32.add $push1=, $0, $pop0{{$}} -; CHECK: i32.store 0($pop1), $pop2{{$}} -define void @store_i32_with_unfolded_offset(i32* %p) { - %q = ptrtoint i32* %p to i32 - %r = add nsw i32 %q, 24 - %s = inttoptr i32 %r to i32* - store i32 0, i32* %s - ret void -} - -; Same as above but with store. - -; CHECK-LABEL: store_i32_with_unfolded_gep_offset: -; CHECK: i32.const $push0=, 24{{$}} -; CHECK: i32.add $push1=, $0, $pop0{{$}} -; CHECK: i32.store 0($pop1), $pop2{{$}} -define void @store_i32_with_unfolded_gep_offset(i32* %p) { - %s = getelementptr i32, i32* %p, i32 6 - store i32 0, i32* %s - ret void -} - -; Same as above but with store with i64. - -; CHECK-LABEL: store_i64_with_folded_offset: -; CHECK: i64.store 24($0), $pop0{{$}} -define void @store_i64_with_folded_offset(i64* %p) { - %q = ptrtoint i64* %p to i32 - %r = add nuw i32 %q, 24 - %s = inttoptr i32 %r to i64* - store i64 0, i64* %s - ret void -} - -; Same as above but with store with i64. - -; CHECK-LABEL: store_i64_with_folded_gep_offset: -; CHECK: i64.store 24($0), $pop0{{$}} -define void @store_i64_with_folded_gep_offset(i64* %p) { - %s = getelementptr inbounds i64, i64* %p, i32 3 - store i64 0, i64* %s - ret void -} - -; Same as above but with store with i64. - -; CHECK-LABEL: store_i64_with_unfolded_gep_negative_offset: -; CHECK: i32.const $push0=, -24{{$}} -; CHECK: i32.add $push1=, $0, $pop0{{$}} -; CHECK: i64.store 0($pop1), $pop2{{$}} -define void @store_i64_with_unfolded_gep_negative_offset(i64* %p) { - %s = getelementptr inbounds i64, i64* %p, i32 -3 - store i64 0, i64* %s - ret void -} - -; Same as above but with store with i64. - -; CHECK-LABEL: store_i64_with_unfolded_offset: -; CHECK: i32.const $push0=, 24{{$}} -; CHECK: i32.add $push1=, $0, $pop0{{$}} -; CHECK: i64.store 0($pop1), $pop2{{$}} -define void @store_i64_with_unfolded_offset(i64* %p) { - %q = ptrtoint i64* %p to i32 - %r = add nsw i32 %q, 24 - %s = inttoptr i32 %r to i64* - store i64 0, i64* %s - ret void -} - -; Same as above but with store with i64. - -; CHECK-LABEL: store_i64_with_unfolded_gep_offset: -; CHECK: i32.const $push0=, 24{{$}} -; CHECK: i32.add $push1=, $0, $pop0{{$}} -; CHECK: i64.store 0($pop1), $pop2{{$}} -define void @store_i64_with_unfolded_gep_offset(i64* %p) { - %s = getelementptr i64, i64* %p, i32 3 - store i64 0, i64* %s - ret void -} - -; CHECK-LABEL: store_i32_with_folded_or_offset: -; CHECK: i32.store8 2($pop{{[0-9]+}}), $pop{{[0-9]+}}{{$}} -define void @store_i32_with_folded_or_offset(i32 %x) { - %and = and i32 %x, -4 - %t0 = inttoptr i32 %and to i8* - %arrayidx = getelementptr inbounds i8, i8* %t0, i32 2 - store i8 0, i8* %arrayidx, align 1 - ret void -} - -; When loading from a fixed address, materialize a zero. - -; CHECK-LABEL: load_i32_from_numeric_address -; CHECK: i32.const $push0=, 0{{$}} -; CHECK: i32.load $push1=, 42($pop0){{$}} -define i32 @load_i32_from_numeric_address() { - %s = inttoptr i32 42 to i32* - %t = load i32, i32* %s - ret i32 %t -} - -; CHECK-LABEL: load_i32_from_global_address -; CHECK: i32.const $push0=, 0{{$}} -; CHECK: i32.load $push1=, gv($pop0){{$}} -@gv = global i32 0 -define i32 @load_i32_from_global_address() { - %t = load i32, i32* @gv - ret i32 %t -} - -; CHECK-LABEL: store_i32_to_numeric_address: -; CHECK-NEXT: i32.const $push0=, 0{{$}} -; CHECK-NEXT: i32.const $push1=, 0{{$}} -; CHECK-NEXT: i32.store 42($pop0), $pop1{{$}} -define void @store_i32_to_numeric_address() { - %s = inttoptr i32 42 to i32* - store i32 0, i32* %s - ret void -} - -; CHECK-LABEL: store_i32_to_global_address: -; CHECK: i32.const $push0=, 0{{$}} -; CHECK: i32.const $push1=, 0{{$}} -; CHECK: i32.store gv($pop0), $pop1{{$}} -define void @store_i32_to_global_address() { - store i32 0, i32* @gv - ret void -} - -; Fold an offset into a sign-extending load. - -; CHECK-LABEL: load_i8_s_with_folded_offset: -; CHECK: i32.load8_s $push0=, 24($0){{$}} -define i32 @load_i8_s_with_folded_offset(i8* %p) { - %q = ptrtoint i8* %p to i32 - %r = add nuw i32 %q, 24 - %s = inttoptr i32 %r to i8* - %t = load i8, i8* %s - %u = sext i8 %t to i32 - ret i32 %u -} - -; Fold a gep offset into a sign-extending load. - -; CHECK-LABEL: load_i8_s_with_folded_gep_offset: -; CHECK: i32.load8_s $push0=, 24($0){{$}} -define i32 @load_i8_s_with_folded_gep_offset(i8* %p) { - %s = getelementptr inbounds i8, i8* %p, i32 24 - %t = load i8, i8* %s - %u = sext i8 %t to i32 - ret i32 %u -} - -; Fold an offset into a zero-extending load. - -; CHECK-LABEL: load_i8_u_with_folded_offset: -; CHECK: i32.load8_u $push0=, 24($0){{$}} -define i32 @load_i8_u_with_folded_offset(i8* %p) { - %q = ptrtoint i8* %p to i32 - %r = add nuw i32 %q, 24 - %s = inttoptr i32 %r to i8* - %t = load i8, i8* %s - %u = zext i8 %t to i32 - ret i32 %u -} - -; Fold a gep offset into a zero-extending load. - -; CHECK-LABEL: load_i8_u_with_folded_gep_offset: -; CHECK: i32.load8_u $push0=, 24($0){{$}} -define i32 @load_i8_u_with_folded_gep_offset(i8* %p) { - %s = getelementptr inbounds i8, i8* %p, i32 24 - %t = load i8, i8* %s - %u = zext i8 %t to i32 - ret i32 %u -} - -; Fold an offset into a truncating store. - -; CHECK-LABEL: store_i8_with_folded_offset: -; CHECK: i32.store8 24($0), $pop0{{$}} -define void @store_i8_with_folded_offset(i8* %p) { - %q = ptrtoint i8* %p to i32 - %r = add nuw i32 %q, 24 - %s = inttoptr i32 %r to i8* - store i8 0, i8* %s - ret void -} - -; Fold a gep offset into a truncating store. - -; CHECK-LABEL: store_i8_with_folded_gep_offset: -; CHECK: i32.store8 24($0), $pop0{{$}} -define void @store_i8_with_folded_gep_offset(i8* %p) { - %s = getelementptr inbounds i8, i8* %p, i32 24 - store i8 0, i8* %s - ret void -} - -; Fold the offsets when lowering aggregate loads and stores. - -; CHECK-LABEL: aggregate_load_store: -; CHECK: i32.load $2=, 0($0){{$}} -; CHECK: i32.load $3=, 4($0){{$}} -; CHECK: i32.load $4=, 8($0){{$}} -; CHECK: i32.load $push0=, 12($0){{$}} -; CHECK: i32.store 12($1), $pop0{{$}} -; CHECK: i32.store 8($1), $4{{$}} -; CHECK: i32.store 4($1), $3{{$}} -; CHECK: i32.store 0($1), $2{{$}} -define void @aggregate_load_store({i32,i32,i32,i32}* %p, {i32,i32,i32,i32}* %q) { - ; volatile so that things stay in order for the tests above - %t = load volatile {i32,i32,i32,i32}, {i32, i32,i32,i32}* %p - store volatile {i32,i32,i32,i32} %t, {i32, i32,i32,i32}* %q - ret void -} - -; Fold the offsets when lowering aggregate return values. The stores get -; merged into i64 stores. - -; CHECK-LABEL: aggregate_return: -; CHECK: i64.const $push[[L0:[0-9]+]]=, 0{{$}} -; CHECK: i64.store 8($0):p2align=2, $pop[[L0]]{{$}} -; CHECK: i64.const $push[[L1:[0-9]+]]=, 0{{$}} -; CHECK: i64.store 0($0):p2align=2, $pop[[L1]]{{$}} -define {i32,i32,i32,i32} @aggregate_return() { - ret {i32,i32,i32,i32} zeroinitializer -} - -; Fold the offsets when lowering aggregate return values. The stores are not -; merged. - -; CHECK-LABEL: aggregate_return_without_merge: -; CHECK: i32.const $push[[L0:[0-9]+]]=, 0{{$}} -; CHECK: i32.store8 14($0), $pop[[L0]]{{$}} -; CHECK: i32.const $push[[L1:[0-9]+]]=, 0{{$}} -; CHECK: i32.store16 12($0), $pop[[L1]]{{$}} -; CHECK: i32.const $push[[L2:[0-9]+]]=, 0{{$}} -; CHECK: i32.store 8($0), $pop[[L2]]{{$}} -; CHECK: i64.const $push[[L3:[0-9]+]]=, 0{{$}} -; CHECK: i64.store 0($0), $pop[[L3]]{{$}} -define {i64,i32,i16,i8} @aggregate_return_without_merge() { - ret {i64,i32,i16,i8} zeroinitializer -} diff --git a/test/CodeGen/WebAssembly/phi.ll b/test/CodeGen/WebAssembly/phi.ll deleted file mode 100644 index 4aae92df54d9..000000000000 --- a/test/CodeGen/WebAssembly/phi.ll +++ /dev/null @@ -1,48 +0,0 @@ -; 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-wasm" - -; Basic phi triangle. - -; CHECK-LABEL: test0: -; 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 - br i1 %t, label %true, label %done -true: - %a = sdiv i32 %p, 3 - br label %done -done: - %s = phi i32 [ %a, %true ], [ %p, %entry ] - ret i32 %s -} - -; Swap phis. - -; CHECK-LABEL: test1: -; CHECK: .LBB1_1: -; CHECK: copy_local $[[NUM0:[0-9]+]]=, $[[NUM1:[0-9]+]]{{$}} -; CHECK: copy_local $[[NUM1]]=, $[[NUM2:[0-9]+]]{{$}} -; CHECK: copy_local $[[NUM2]]=, $[[NUM0]]{{$}} -define i32 @test1(i32 %n) { -entry: - br label %loop - -loop: - %a = phi i32 [ 0, %entry ], [ %b, %loop ] - %b = phi i32 [ 1, %entry ], [ %a, %loop ] - %i = phi i32 [ 0, %entry ], [ %i.next, %loop ] - - %i.next = add i32 %i, 1 - %t = icmp slt i32 %i.next, %n - br i1 %t, label %loop, label %exit - -exit: - ret i32 %a -} diff --git a/test/CodeGen/WebAssembly/reg-stackify.ll b/test/CodeGen/WebAssembly/reg-stackify.ll deleted file mode 100644 index d1423b5db395..000000000000 --- a/test/CodeGen/WebAssembly/reg-stackify.ll +++ /dev/null @@ -1,491 +0,0 @@ -; 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-wasm" - -; No because of pointer aliasing. - -; CHECK-LABEL: no0: -; CHECK: return $1{{$}} -define i32 @no0(i32* %p, i32* %q) { - %t = load i32, i32* %q - store i32 0, i32* %p - ret i32 %t -} - -; No because of side effects. - -; CHECK-LABEL: no1: -; CHECK: return $1{{$}} -define i32 @no1(i32* %p, i32* dereferenceable(4) %q) { - %t = load volatile i32, i32* %q, !invariant.load !0 - store volatile i32 0, i32* %p - ret i32 %t -} - -; Yes because of invariant load and no side effects. - -; CHECK-LABEL: yes0: -; CHECK: return $pop{{[0-9]+}}{{$}} -define i32 @yes0(i32* %p, i32* dereferenceable(4) %q) { - %t = load i32, i32* %q, !invariant.load !0 - store i32 0, i32* %p - ret i32 %t -} - -; Yes because of no intervening side effects. - -; CHECK-LABEL: yes1: -; CHECK: return $pop0{{$}} -define i32 @yes1(i32* %q) { - %t = load volatile i32, i32* %q - ret i32 %t -} - -; Yes because undefined behavior can be sunk past a store. - -; CHECK-LABEL: sink_trap: -; CHECK: return $pop{{[0-9]+}}{{$}} -define i32 @sink_trap(i32 %x, i32 %y, i32* %p) { - %t = sdiv i32 %x, %y - store volatile i32 0, i32* %p - ret i32 %t -} - -; Yes because the call is readnone. - -; CHECK-LABEL: sink_readnone_call: -; CHECK: return $pop0{{$}} -declare i32 @readnone_callee() readnone nounwind -define i32 @sink_readnone_call(i32 %x, i32 %y, i32* %p) { - %t = call i32 @readnone_callee() - store volatile i32 0, i32* %p - ret i32 %t -} - -; No because the call is readonly and there's an intervening store. - -; CHECK-LABEL: no_sink_readonly_call: -; CHECK: return ${{[0-9]+}}{{$}} -declare i32 @readonly_callee() readonly nounwind -define i32 @no_sink_readonly_call(i32 %x, i32 %y, i32* %p) { - %t = call i32 @readonly_callee() - store i32 0, i32* %p - ret i32 %t -} - -; Don't schedule stack uses into the stack. To reduce register pressure, the -; scheduler might be tempted to move the definition of $2 down. However, this -; would risk getting incorrect liveness if the instructions are later -; rearranged to make the stack contiguous. - -; CHECK-LABEL: stack_uses: -; CHECK: .param i32, i32, i32, i32{{$}} -; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: block {{$}} -; CHECK-NEXT: i32.const $push[[L13:[0-9]+]]=, 1{{$}} -; CHECK-NEXT: i32.lt_s $push[[L0:[0-9]+]]=, $0, $pop[[L13]]{{$}} -; CHECK-NEXT: i32.const $push[[L1:[0-9]+]]=, 2{{$}} -; CHECK-NEXT: i32.lt_s $push[[L2:[0-9]+]]=, $1, $pop[[L1]]{{$}} -; CHECK-NEXT: i32.xor $push[[L5:[0-9]+]]=, $pop[[L0]], $pop[[L2]]{{$}} -; CHECK-NEXT: i32.const $push[[L12:[0-9]+]]=, 1{{$}} -; CHECK-NEXT: i32.lt_s $push[[L3:[0-9]+]]=, $2, $pop[[L12]]{{$}} -; CHECK-NEXT: i32.const $push[[L11:[0-9]+]]=, 2{{$}} -; CHECK-NEXT: i32.lt_s $push[[L4:[0-9]+]]=, $3, $pop[[L11]]{{$}} -; CHECK-NEXT: i32.xor $push[[L6:[0-9]+]]=, $pop[[L3]], $pop[[L4]]{{$}} -; CHECK-NEXT: i32.xor $push[[L7:[0-9]+]]=, $pop[[L5]], $pop[[L6]]{{$}} -; CHECK-NEXT: i32.const $push10=, 1{{$}} -; CHECK-NEXT: i32.ne $push8=, $pop7, $pop10{{$}} -; CHECK-NEXT: br_if 0, $pop8{{$}} -; CHECK-NEXT: i32.const $push9=, 0{{$}} -; CHECK-NEXT: return $pop9{{$}} -; CHECK-NEXT: .LBB7_2: -; CHECK-NEXT: end_block{{$}} -; CHECK-NEXT: i32.const $push14=, 1{{$}} -; CHECK-NEXT: return $pop14{{$}} -define i32 @stack_uses(i32 %x, i32 %y, i32 %z, i32 %w) { -entry: - %c = icmp sle i32 %x, 0 - %d = icmp sle i32 %y, 1 - %e = icmp sle i32 %z, 0 - %f = icmp sle i32 %w, 1 - %g = xor i1 %c, %d - %h = xor i1 %e, %f - %i = xor i1 %g, %h - br i1 %i, label %true, label %false -true: - ret i32 0 -false: - ret i32 1 -} - -; Test an interesting case where the load has multiple uses and cannot -; be trivially stackified. However, it can be stackified with a tee_local. - -; CHECK-LABEL: multiple_uses: -; CHECK: .param i32, i32, 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]]{{$}} -; CHECK-NEXT: i32.ge_u $push[[NUM2:[0-9]+]]=, $pop[[NUM1]], $1{{$}} -; CHECK-NEXT: br_if 0, $pop[[NUM2]]{{$}} -; CHECK-NEXT: i32.lt_u $push[[NUM3:[0-9]+]]=, $3, $0{{$}} -; CHECK-NEXT: br_if 0, $pop[[NUM3]]{{$}} -; CHECK-NEXT: i32.store 0($2), $3{{$}} -; CHECK-NEXT: .LBB8_3: -; CHECK-NEXT: end_block{{$}} -; CHECK-NEXT: return{{$}} -define void @multiple_uses(i32* %arg0, i32* %arg1, i32* %arg2) nounwind { -bb: - br label %loop - -loop: - %tmp7 = load i32, i32* %arg2 - %tmp8 = inttoptr i32 %tmp7 to i32* - %tmp9 = icmp uge i32* %tmp8, %arg1 - %tmp10 = icmp ult i32* %tmp8, %arg0 - %tmp11 = or i1 %tmp9, %tmp10 - br i1 %tmp11, label %back, label %then - -then: - store i32 %tmp7, i32* %arg2 - br label %back - -back: - br i1 undef, label %return, label %loop - -return: - ret void -} - -; Don't stackify stores effects across other instructions with side effects. - -; CHECK: side_effects: -; CHECK: store -; CHECK-NEXT: call -; CHECK: store -; CHECK-NEXT: call -declare void @evoke_side_effects() -define hidden void @stackify_store_across_side_effects(double* nocapture %d) { -entry: - store double 2.0, double* %d - call void @evoke_side_effects() - store double 2.0, double* %d - call void @evoke_side_effects() - ret void -} - -; Div instructions have side effects and can't be reordered, but this entire -; function should still be able to be stackified because it's already in -; tree order. - -; CHECK-LABEL: div_tree: -; CHECK: .param i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32{{$}} -; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: i32.div_s $push[[L0:[0-9]+]]=, $0, $1{{$}} -; CHECK-NEXT: i32.div_s $push[[L1:[0-9]+]]=, $2, $3{{$}} -; CHECK-NEXT: i32.div_s $push[[L2:[0-9]+]]=, $pop[[L0]], $pop[[L1]]{{$}} -; CHECK-NEXT: i32.div_s $push[[L3:[0-9]+]]=, $4, $5{{$}} -; CHECK-NEXT: i32.div_s $push[[L4:[0-9]+]]=, $6, $7{{$}} -; CHECK-NEXT: i32.div_s $push[[L5:[0-9]+]]=, $pop[[L3]], $pop[[L4]]{{$}} -; CHECK-NEXT: i32.div_s $push[[L6:[0-9]+]]=, $pop[[L2]], $pop[[L5]]{{$}} -; CHECK-NEXT: i32.div_s $push[[L7:[0-9]+]]=, $8, $9{{$}} -; CHECK-NEXT: i32.div_s $push[[L8:[0-9]+]]=, $10, $11{{$}} -; CHECK-NEXT: i32.div_s $push[[L9:[0-9]+]]=, $pop[[L7]], $pop[[L8]]{{$}} -; CHECK-NEXT: i32.div_s $push[[L10:[0-9]+]]=, $12, $13{{$}} -; CHECK-NEXT: i32.div_s $push[[L11:[0-9]+]]=, $14, $15{{$}} -; CHECK-NEXT: i32.div_s $push[[L12:[0-9]+]]=, $pop[[L10]], $pop[[L11]]{{$}} -; CHECK-NEXT: i32.div_s $push[[L13:[0-9]+]]=, $pop[[L9]], $pop[[L12]]{{$}} -; CHECK-NEXT: i32.div_s $push[[L14:[0-9]+]]=, $pop[[L6]], $pop[[L13]]{{$}} -; CHECK-NEXT: return $pop[[L14]]{{$}} -define i32 @div_tree(i32 %a, i32 %b, i32 %c, i32 %d, i32 %e, i32 %f, i32 %g, i32 %h, i32 %i, i32 %j, i32 %k, i32 %l, i32 %m, i32 %n, i32 %o, i32 %p) { -entry: - %div = sdiv i32 %a, %b - %div1 = sdiv i32 %c, %d - %div2 = sdiv i32 %div, %div1 - %div3 = sdiv i32 %e, %f - %div4 = sdiv i32 %g, %h - %div5 = sdiv i32 %div3, %div4 - %div6 = sdiv i32 %div2, %div5 - %div7 = sdiv i32 %i, %j - %div8 = sdiv i32 %k, %l - %div9 = sdiv i32 %div7, %div8 - %div10 = sdiv i32 %m, %n - %div11 = sdiv i32 %o, %p - %div12 = sdiv i32 %div10, %div11 - %div13 = sdiv i32 %div9, %div12 - %div14 = sdiv i32 %div6, %div13 - ret i32 %div14 -} - -; A simple multiple-use case. - -; CHECK-LABEL: simple_multiple_use: -; CHECK: .param i32, i32{{$}} -; CHECK-NEXT: i32.mul $push[[NUM0:[0-9]+]]=, $1, $0{{$}} -; CHECK-NEXT: tee_local $push[[NUM1:[0-9]+]]=, $[[NUM2:[0-9]+]]=, $pop[[NUM0]]{{$}} -; CHECK-NEXT: call use_a@FUNCTION, $pop[[NUM1]]{{$}} -; CHECK-NEXT: call use_b@FUNCTION, $[[NUM2]]{{$}} -; CHECK-NEXT: return{{$}} -declare void @use_a(i32) -declare void @use_b(i32) -define void @simple_multiple_use(i32 %x, i32 %y) { - %mul = mul i32 %y, %x - call void @use_a(i32 %mul) - call void @use_b(i32 %mul) - ret void -} - -; Multiple uses of the same value in one instruction. - -; CHECK-LABEL: multiple_uses_in_same_insn: -; CHECK: .param i32, i32{{$}} -; CHECK-NEXT: i32.mul $push[[NUM0:[0-9]+]]=, $1, $0{{$}} -; CHECK-NEXT: tee_local $push[[NUM1:[0-9]+]]=, $[[NUM2:[0-9]+]]=, $pop[[NUM0]]{{$}} -; CHECK-NEXT: call use_2@FUNCTION, $pop[[NUM1]], $[[NUM2]]{{$}} -; CHECK-NEXT: return{{$}} -declare void @use_2(i32, i32) -define void @multiple_uses_in_same_insn(i32 %x, i32 %y) { - %mul = mul i32 %y, %x - call void @use_2(i32 %mul, i32 %mul) - ret void -} - -; Commute operands to achieve better stackifying. - -; CHECK-LABEL: commute: -; CHECK-NOT: param -; CHECK: .result i32{{$}} -; CHECK-NEXT: i32.call $push0=, red@FUNCTION{{$}} -; CHECK-NEXT: i32.call $push1=, green@FUNCTION{{$}} -; CHECK-NEXT: i32.add $push2=, $pop0, $pop1{{$}} -; CHECK-NEXT: i32.call $push3=, blue@FUNCTION{{$}} -; CHECK-NEXT: i32.add $push4=, $pop2, $pop3{{$}} -; CHECK-NEXT: return $pop4{{$}} -declare i32 @red() -declare i32 @green() -declare i32 @blue() -define i32 @commute() { - %call = call i32 @red() - %call1 = call i32 @green() - %add = add i32 %call1, %call - %call2 = call i32 @blue() - %add3 = add i32 %add, %call2 - ret i32 %add3 -} - -; Don't stackify a register when it would move a the def of the register past -; an implicit get_local for the register. - -; CHECK-LABEL: no_stackify_past_use: -; CHECK: i32.call $1=, callee@FUNCTION, $0 -; CHECK-NEXT: i32.const $push0=, 1 -; CHECK-NEXT: i32.add $push1=, $0, $pop0 -; CHECK-NEXT: i32.call $push2=, callee@FUNCTION, $pop1 -; CHECK-NEXT: i32.sub $push3=, $pop2, $1 -; CHECK-NEXT: i32.div_s $push4=, $pop3, $1 -; CHECK-NEXT: return $pop4 -declare i32 @callee(i32) -define i32 @no_stackify_past_use(i32 %arg) { - %tmp1 = call i32 @callee(i32 %arg) - %tmp2 = add i32 %arg, 1 - %tmp3 = call i32 @callee(i32 %tmp2) - %tmp5 = sub i32 %tmp3, %tmp1 - %tmp6 = sdiv i32 %tmp5, %tmp1 - ret i32 %tmp6 -} - -; This is the same as no_stackify_past_use, except using a commutative operator, -; so we can reorder the operands and stackify. - -; CHECK-LABEL: commute_to_fix_ordering: -; CHECK: i32.call $push[[L0:.+]]=, callee@FUNCTION, $0 -; CHECK: tee_local $push[[L1:.+]]=, $1=, $pop[[L0]] -; CHECK: i32.const $push0=, 1 -; CHECK: i32.add $push1=, $0, $pop0 -; CHECK: i32.call $push2=, callee@FUNCTION, $pop1 -; CHECK: i32.add $push3=, $1, $pop2 -; CHECK: i32.mul $push4=, $pop[[L1]], $pop3 -; CHECK: return $pop4 -define i32 @commute_to_fix_ordering(i32 %arg) { - %tmp1 = call i32 @callee(i32 %arg) - %tmp2 = add i32 %arg, 1 - %tmp3 = call i32 @callee(i32 %tmp2) - %tmp5 = add i32 %tmp3, %tmp1 - %tmp6 = mul i32 %tmp5, %tmp1 - ret i32 %tmp6 -} - -; Stackify individual defs of virtual registers with multiple defs. - -; CHECK-LABEL: multiple_defs: -; CHECK: f64.add $push[[NUM0:[0-9]+]]=, ${{[0-9]+}}, $pop{{[0-9]+}}{{$}} -; CHECK-NEXT: tee_local $push[[NUM1:[0-9]+]]=, $[[NUM2:[0-9]+]]=, $pop[[NUM0]]{{$}} -; CHECK-NEXT: f64.select $push{{[0-9]+}}=, $pop{{[0-9]+}}, $pop[[NUM1]], ${{[0-9]+}}{{$}} -; CHECK: $[[NUM2]]=, -define void @multiple_defs(i32 %arg, i32 %arg1, i1 %arg2, i1 %arg3, i1 %arg4) { -bb: - br label %bb5 - -bb5: ; preds = %bb21, %bb - %tmp = phi double [ 0.000000e+00, %bb ], [ %tmp22, %bb21 ] - %tmp6 = phi double [ 0.000000e+00, %bb ], [ %tmp23, %bb21 ] - %tmp7 = fcmp olt double %tmp6, 2.323450e+01 - br i1 %tmp7, label %bb8, label %bb21 - -bb8: ; preds = %bb17, %bb5 - %tmp9 = phi double [ %tmp19, %bb17 ], [ %tmp, %bb5 ] - %tmp10 = fadd double %tmp6, -1.000000e+00 - %tmp11 = select i1 %arg2, double -1.135357e+04, double %tmp10 - %tmp12 = fadd double %tmp11, %tmp9 - br i1 %arg3, label %bb17, label %bb13 - -bb13: ; preds = %bb8 - %tmp14 = or i32 %arg1, 2 - %tmp15 = icmp eq i32 %tmp14, 14 - %tmp16 = select i1 %tmp15, double -1.135357e+04, double 0xBFCE147AE147B000 - br label %bb17 - -bb17: ; preds = %bb13, %bb8 - %tmp18 = phi double [ %tmp16, %bb13 ], [ %tmp10, %bb8 ] - %tmp19 = fadd double %tmp18, %tmp12 - %tmp20 = fcmp olt double %tmp6, 2.323450e+01 - br i1 %tmp20, label %bb8, label %bb21 - -bb21: ; preds = %bb17, %bb5 - %tmp22 = phi double [ %tmp, %bb5 ], [ %tmp9, %bb17 ] - %tmp23 = fadd double %tmp6, 1.000000e+00 - br label %bb5 -} - -; Don't move calls past loads -; CHECK-LABEL: no_stackify_call_past_load: -; CHECK: i32.call $0=, red -; CHECK: i32.const $push0=, 0 -; CHECK: i32.load $1=, count($pop0) -@count = hidden global i32 0, align 4 -define i32 @no_stackify_call_past_load() { - %a = call i32 @red() - %b = load i32, i32* @count, align 4 - call i32 @callee(i32 %a) - ret i32 %b - ; use of a -} - -; Don't move stores past loads if there may be aliasing -; CHECK-LABEL: no_stackify_store_past_load -; CHECK: i32.store 0($1), $0 -; CHECK: i32.load {{.*}}, 0($2) -; CHECK: i32.call {{.*}}, callee@FUNCTION, $0{{$}} -define i32 @no_stackify_store_past_load(i32 %a, i32* %p1, i32* %p2) { - store i32 %a, i32* %p1 - %b = load i32, i32* %p2, align 4 - call i32 @callee(i32 %a) - ret i32 %b -} - -; Can still stackify past invariant loads. -; CHECK-LABEL: store_past_invar_load -; CHECK: i32.store 0($1), $0 -; CHECK: i32.call {{.*}}, callee@FUNCTION, $0 -; CHECK: i32.load $push{{.*}}, 0($2) -; CHECK: return $pop -define i32 @store_past_invar_load(i32 %a, i32* %p1, i32* dereferenceable(4) %p2) { - store i32 %a, i32* %p1 - %b = load i32, i32* %p2, !invariant.load !0 - call i32 @callee(i32 %a) - ret i32 %b -} - -; CHECK-LABEL: ignore_dbg_value: -; CHECK-NEXT: .Lfunc_begin -; CHECK-NEXT: unreachable -declare void @llvm.dbg.value(metadata, i64, metadata, metadata) -define void @ignore_dbg_value() { - call void @llvm.dbg.value(metadata i32 0, i64 0, metadata !7, metadata !9), !dbg !10 - unreachable -} - -; Don't stackify an expression that might use the stack into a return, since we -; might insert a prologue before the return. - -; CHECK-LABEL: no_stackify_past_epilogue: -; CHECK: return ${{[0-9]+}}{{$}} -declare i32 @use_memory(i32*) -define i32 @no_stackify_past_epilogue() { - %x = alloca i32 - %call = call i32 @use_memory(i32* %x) - ret i32 %call -} - -; Stackify a loop induction variable into a loop comparison. - -; CHECK-LABEL: stackify_indvar: -; CHECK: i32.const $push[[L5:.+]]=, 1{{$}} -; CHECK-NEXT: i32.add $push[[L4:.+]]=, $[[R0:.+]], $pop[[L5]]{{$}} -; CHECK-NEXT: tee_local $push[[L3:.+]]=, $[[R0]]=, $pop[[L4]]{{$}} -; CHECK-NEXT: i32.ne $push[[L2:.+]]=, $0, $pop[[L3]]{{$}} -define void @stackify_indvar(i32 %tmp, i32* %v) #0 { -bb: - br label %bb3 - -bb3: ; preds = %bb3, %bb2 - %tmp4 = phi i32 [ %tmp7, %bb3 ], [ 0, %bb ] - %tmp5 = load volatile i32, i32* %v, align 4 - %tmp6 = add nsw i32 %tmp5, %tmp4 - store volatile i32 %tmp6, i32* %v, align 4 - %tmp7 = add nuw nsw i32 %tmp4, 1 - %tmp8 = icmp eq i32 %tmp7, %tmp - br i1 %tmp8, label %bb10, label %bb3 - -bb10: ; preds = %bb9, %bb - ret void -} - -; Don't stackify a call past a __stack_pointer store. - -; CHECK-LABEL: stackpointer_dependency: -; CHECK: call {{.+}}, stackpointer_callee@FUNCTION, -; CHECK-NEXT: set_global 0, -declare i32 @stackpointer_callee(i8* readnone, i8* readnone) -declare i8* @llvm.frameaddress(i32) -define i32 @stackpointer_dependency(i8* readnone) { - %2 = tail call i8* @llvm.frameaddress(i32 0) - %3 = tail call i32 @stackpointer_callee(i8* %0, i8* %2) - ret i32 %3 -} - -; Stackify a call_indirect with respect to its ordering - -; CHECK-LABEL: call_indirect_stackify: -; CHECK: i32.load $push[[L4:.+]]=, 0($0) -; CHECK-NEXT: tee_local $push[[L3:.+]]=, $0=, $pop[[L4]] -; CHECK-NEXT: i32.load $push[[L0:.+]]=, 0($0) -; CHECK-NEXT: i32.load $push[[L1:.+]]=, 0($pop[[L0]]) -; CHECK-NEXT: i32.call_indirect $push{{.+}}=, $pop[[L3]], $1, $pop[[L1]] -%class.call_indirect = type { i32 (...)** } -define i32 @call_indirect_stackify(%class.call_indirect** %objptr, i32 %arg) { - %obj = load %class.call_indirect*, %class.call_indirect** %objptr - %addr = bitcast %class.call_indirect* %obj to i32(%class.call_indirect*, i32)*** - %vtable = load i32(%class.call_indirect*, i32)**, i32(%class.call_indirect*, i32)*** %addr - %vfn = getelementptr inbounds i32(%class.call_indirect*, i32)*, i32(%class.call_indirect*, i32)** %vtable, i32 0 - %f = load i32(%class.call_indirect*, i32)*, i32(%class.call_indirect*, i32)** %vfn - %ret = call i32 %f(%class.call_indirect* %obj, i32 %arg) - ret i32 %ret -} - -!llvm.module.flags = !{!0} -!llvm.dbg.cu = !{!1} - -!0 = !{i32 2, !"Debug Info Version", i32 3} -!1 = distinct !DICompileUnit(language: DW_LANG_C99, file: !2, producer: "clang version 3.9.0 (trunk 266005) (llvm/trunk 266105)", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !3) -!2 = !DIFile(filename: "test.c", directory: "/") -!3 = !{} -!5 = distinct !DISubprogram(name: "test", scope: !2, file: !2, line: 10, type: !6, isLocal: false, isDefinition: true, scopeLine: 11, flags: DIFlagPrototyped, isOptimized: true, unit: !1, variables: !3) -!6 = !DISubroutineType(types: !3) -!7 = !DILocalVariable(name: "nzcnt", scope: !5, file: !2, line: 15, type: !8) -!8 = !DIBasicType(name: "int", size: 32, align: 32, encoding: DW_ATE_signed) -!9 = !DIExpression() -!10 = !DILocation(line: 15, column: 6, scope: !5) diff --git a/test/CodeGen/WebAssembly/return-int32.ll b/test/CodeGen/WebAssembly/return-int32.ll deleted file mode 100644 index a6634b740cfc..000000000000 --- a/test/CodeGen/WebAssembly/return-int32.ll +++ /dev/null @@ -1,34 +0,0 @@ -; RUN: llc < %s -asm-verbose=false | FileCheck %s -; 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-wasm" - -; CHECK-LABEL: return_i32: -; CHECK-NEXT: .param i32{{$}} -; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: get_local $push0=, 0 -; CHECK-NEXT: end_function{{$}} -define i32 @return_i32(i32 %p) { - ret i32 %p -} - -; CHECK-LABEL: return_i32_twice: -; CHECK: store -; CHECK-NEXT: i32.const $push[[L0:[^,]+]]=, 1{{$}} -; CHECK-NEXT: return $pop[[L0]]{{$}} -; CHECK: store -; CHECK-NEXT: i32.const $push{{[^,]+}}=, 3{{$}} -; CHECK-NEXT: end_function{{$}} -define i32 @return_i32_twice(i32 %a) { - %b = icmp ne i32 %a, 0 - br i1 %b, label %true, label %false - -true: - store i32 0, i32* null - ret i32 1 - -false: - store i32 2, i32* null - ret i32 3 -} diff --git a/test/CodeGen/WebAssembly/return-void.ll b/test/CodeGen/WebAssembly/return-void.ll deleted file mode 100644 index 90cf37fd2c69..000000000000 --- a/test/CodeGen/WebAssembly/return-void.ll +++ /dev/null @@ -1,29 +0,0 @@ -; RUN: llc < %s -asm-verbose=false | FileCheck %s -; 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-wasm" - -; CHECK-LABEL: return_void: -; CHECK-NEXT: end_function{{$}} -define void @return_void() { - ret void -} - -; CHECK-LABEL: return_void_twice: -; CHECK: store -; CHECK-NEXT: return{{$}} -; CHECK: store -; CHECK-NEXT: end_function{{$}} -define void @return_void_twice(i32 %a) { - %b = icmp ne i32 %a, 0 - br i1 %b, label %true, label %false - -true: - store i32 0, i32* null - ret void - -false: - store i32 1, i32* null - ret void -} diff --git a/test/CodeGen/WebAssembly/returned.ll b/test/CodeGen/WebAssembly/returned.ll deleted file mode 100644 index dfd3fad794f1..000000000000 --- a/test/CodeGen/WebAssembly/returned.ll +++ /dev/null @@ -1,80 +0,0 @@ -; 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-wasm" - -; CHECK-LABEL: _Z3foov: -; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: i32.const $push0=, 1{{$}} -; CHECK-NEXT: {{^}} i32.call $push1=, _Znwm@FUNCTION, $pop0{{$}} -; CHECK-NEXT: {{^}} i32.call $push2=, _ZN5AppleC1Ev@FUNCTION, $pop1{{$}} -; CHECK-NEXT: return $pop2{{$}} -%class.Apple = type { i8 } -declare noalias i8* @_Znwm(i32) -declare %class.Apple* @_ZN5AppleC1Ev(%class.Apple* returned) -define %class.Apple* @_Z3foov() { -entry: - %call = tail call noalias i8* @_Znwm(i32 1) - %0 = bitcast i8* %call to %class.Apple* - %call1 = tail call %class.Apple* @_ZN5AppleC1Ev(%class.Apple* %0) - ret %class.Apple* %0 -} - -; CHECK-LABEL: _Z3barPvS_l: -; CHECK-NEXT: .param i32, i32, i32{{$}} -; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: {{^}} i32.call $push0=, memcpy@FUNCTION, $0, $1, $2{{$}} -; CHECK-NEXT: return $pop0{{$}} -declare i8* @memcpy(i8* returned, i8*, i32) -define i8* @_Z3barPvS_l(i8* %p, i8* %s, i32 %n) { -entry: - %call = tail call i8* @memcpy(i8* %p, i8* %s, i32 %n) - ret i8* %p -} - -; Test that the optimization isn't performed on constant arguments. - -; CHECK-LABEL: test_constant_arg: -; CHECK-NEXT: i32.const $push0=, global{{$}} -; CHECK-NEXT: {{^}} i32.call $drop=, returns_arg@FUNCTION, $pop0{{$}} -; CHECK-NEXT: return{{$}} -@global = external global i32 -@addr = global i32* @global -define void @test_constant_arg() { - %call = call i32* @returns_arg(i32* @global) - ret void -} -declare i32* @returns_arg(i32* returned) - -; Test that the optimization isn't performed on arguments without the -; "returned" attribute. - -; CHECK-LABEL: test_other_skipped: -; CHECK-NEXT: .param i32, i32, f64{{$}} -; CHECK-NEXT: {{^}} i32.call $drop=, do_something@FUNCTION, $0, $1, $2{{$}} -; CHECK-NEXT: {{^}} call do_something_with_i32@FUNCTION, $1{{$}} -; CHECK-NEXT: {{^}} call do_something_with_double@FUNCTION, $2{{$}} -declare i32 @do_something(i32 returned, i32, double) -declare void @do_something_with_i32(i32) -declare void @do_something_with_double(double) -define void @test_other_skipped(i32 %a, i32 %b, double %c) { - %call = call i32 @do_something(i32 %a, i32 %b, double %c) - call void @do_something_with_i32(i32 %b) - call void @do_something_with_double(double %c) - ret void -} - -; Test that the optimization is performed on arguments other than the first. - -; CHECK-LABEL: test_second_arg: -; CHECK-NEXT: .param i32, i32{{$}} -; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: {{^}} i32.call $push0=, do_something_else@FUNCTION, $0, $1{{$}} -; CHECK-NEXT: return $pop0{{$}} -declare i32 @do_something_else(i32, i32 returned) -define i32 @test_second_arg(i32 %a, i32 %b) { - %call = call i32 @do_something_else(i32 %a, i32 %b) - ret i32 %b -} diff --git a/test/CodeGen/WebAssembly/select.ll b/test/CodeGen/WebAssembly/select.ll deleted file mode 100644 index b25f16c499a8..000000000000 --- a/test/CodeGen/WebAssembly/select.ll +++ /dev/null @@ -1,135 +0,0 @@ -; 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-wasm" - -; CHECK-LABEL: select_i32_bool: -; CHECK-NEXT: .param i32, i32, i32{{$}} -; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: i32.select $push0=, $1, $2, $0{{$}} -; CHECK-NEXT: return $pop0{{$}} -define i32 @select_i32_bool(i1 zeroext %a, i32 %b, i32 %c) { - %cond = select i1 %a, i32 %b, i32 %c - ret i32 %cond -} - -; CHECK-LABEL: select_i32_eq: -; CHECK-NEXT: .param i32, i32, i32{{$}} -; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: i32.select $push0=, $2, $1, $0{{$}} -; CHECK-NEXT: return $pop0{{$}} -define i32 @select_i32_eq(i32 %a, i32 %b, i32 %c) { - %cmp = icmp eq i32 %a, 0 - %cond = select i1 %cmp, i32 %b, i32 %c - ret i32 %cond -} - -; CHECK-LABEL: select_i32_ne: -; CHECK-NEXT: .param i32, i32, i32{{$}} -; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: i32.select $push0=, $1, $2, $0{{$}} -; CHECK-NEXT: return $pop0{{$}} -define i32 @select_i32_ne(i32 %a, i32 %b, i32 %c) { - %cmp = icmp ne i32 %a, 0 - %cond = select i1 %cmp, i32 %b, i32 %c - ret i32 %cond -} - -; CHECK-LABEL: select_i64_bool: -; CHECK-NEXT: .param i32, i64, i64{{$}} -; CHECK-NEXT: .result i64{{$}} -; CHECK-NEXT: i64.select $push0=, $1, $2, $0{{$}} -; CHECK-NEXT: return $pop0{{$}} -define i64 @select_i64_bool(i1 zeroext %a, i64 %b, i64 %c) { - %cond = select i1 %a, i64 %b, i64 %c - ret i64 %cond -} - -; CHECK-LABEL: select_i64_eq: -; CHECK-NEXT: .param i32, i64, i64{{$}} -; CHECK-NEXT: .result i64{{$}} -; CHECK-NEXT: i64.select $push0=, $2, $1, $0{{$}} -; CHECK-NEXT: return $pop0{{$}} -define i64 @select_i64_eq(i32 %a, i64 %b, i64 %c) { - %cmp = icmp eq i32 %a, 0 - %cond = select i1 %cmp, i64 %b, i64 %c - ret i64 %cond -} - -; CHECK-LABEL: select_i64_ne: -; CHECK-NEXT: .param i32, i64, i64{{$}} -; CHECK-NEXT: .result i64{{$}} -; CHECK-NEXT: i64.select $push0=, $1, $2, $0{{$}} -; CHECK-NEXT: return $pop0{{$}} -define i64 @select_i64_ne(i32 %a, i64 %b, i64 %c) { - %cmp = icmp ne i32 %a, 0 - %cond = select i1 %cmp, i64 %b, i64 %c - ret i64 %cond -} - -; CHECK-LABEL: select_f32_bool: -; CHECK-NEXT: .param i32, f32, f32{{$}} -; CHECK-NEXT: .result f32{{$}} -; CHECK-NEXT: f32.select $push0=, $1, $2, $0{{$}} -; CHECK-NEXT: return $pop0{{$}} -define float @select_f32_bool(i1 zeroext %a, float %b, float %c) { - %cond = select i1 %a, float %b, float %c - ret float %cond -} - -; CHECK-LABEL: select_f32_eq: -; CHECK-NEXT: .param i32, f32, f32{{$}} -; CHECK-NEXT: .result f32{{$}} -; CHECK-NEXT: f32.select $push0=, $2, $1, $0{{$}} -; CHECK-NEXT: return $pop0{{$}} -define float @select_f32_eq(i32 %a, float %b, float %c) { - %cmp = icmp eq i32 %a, 0 - %cond = select i1 %cmp, float %b, float %c - ret float %cond -} - -; CHECK-LABEL: select_f32_ne: -; CHECK-NEXT: .param i32, f32, f32{{$}} -; CHECK-NEXT: .result f32{{$}} -; CHECK-NEXT: f32.select $push0=, $1, $2, $0{{$}} -; CHECK-NEXT: return $pop0{{$}} -define float @select_f32_ne(i32 %a, float %b, float %c) { - %cmp = icmp ne i32 %a, 0 - %cond = select i1 %cmp, float %b, float %c - ret float %cond -} - -; CHECK-LABEL: select_f64_bool: -; CHECK-NEXT: .param i32, f64, f64{{$}} -; CHECK-NEXT: .result f64{{$}} -; CHECK-NEXT: f64.select $push0=, $1, $2, $0{{$}} -; CHECK-NEXT: return $pop0{{$}} -define double @select_f64_bool(i1 zeroext %a, double %b, double %c) { - %cond = select i1 %a, double %b, double %c - ret double %cond -} - -; CHECK-LABEL: select_f64_eq: -; CHECK-NEXT: .param i32, f64, f64{{$}} -; CHECK-NEXT: .result f64{{$}} -; CHECK-NEXT: f64.select $push0=, $2, $1, $0{{$}} -; CHECK-NEXT: return $pop0{{$}} -define double @select_f64_eq(i32 %a, double %b, double %c) { - %cmp = icmp eq i32 %a, 0 - %cond = select i1 %cmp, double %b, double %c - ret double %cond -} - -; CHECK-LABEL: select_f64_ne: -; CHECK-NEXT: .param i32, f64, f64{{$}} -; CHECK-NEXT: .result f64{{$}} -; CHECK-NEXT: f64.select $push0=, $1, $2, $0{{$}} -; CHECK-NEXT: return $pop0{{$}} -define double @select_f64_ne(i32 %a, double %b, double %c) { - %cmp = icmp ne i32 %a, 0 - %cond = select i1 %cmp, double %b, double %c - ret double %cond -} diff --git a/test/CodeGen/WebAssembly/signext-zeroext.ll b/test/CodeGen/WebAssembly/signext-zeroext.ll deleted file mode 100644 index b07c7f669c37..000000000000 --- a/test/CodeGen/WebAssembly/signext-zeroext.ll +++ /dev/null @@ -1,62 +0,0 @@ -; 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-wasm" - -; CHECK-LABEL: z2s_func: -; CHECK-NEXT: .param i32{{$}} -; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: i32.const $push[[NUM0:[0-9]+]]=, 24{{$}} -; CHECK-NEXT: i32.shl $push[[NUM2:[0-9]+]]=, $0, $pop[[NUM0]]{{$}} -; CHECK-NEXT: i32.const $push[[NUM1:[0-9]+]]=, 24{{$}} -; CHECK-NEXT: i32.shr_s $push[[NUM3:[0-9]+]]=, $pop[[NUM2]], $pop[[NUM1]]{{$}} -; CHECK-NEXT: return $pop[[NUM3]]{{$}} -define signext i8 @z2s_func(i8 zeroext %t) { - ret i8 %t -} - -; CHECK-LABEL: s2z_func: -; CHECK-NEXT: .param i32{{$}} -; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: i32.const $push[[NUM0:[0-9]+]]=, 255{{$}} -; CHECK-NEXT: i32.and $push[[NUM1:[0-9]+]]=, $0, $pop[[NUM0]]{{$}} -; CHECK-NEXT: return $pop[[NUM1]]{{$}} -define zeroext i8 @s2z_func(i8 signext %t) { - ret i8 %t -} - -; CHECK-LABEL: z2s_call: -; CHECK-NEXT: .param i32{{$}} -; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: i32.const $push[[NUM0:[0-9]+]]=, 255{{$}} -; CHECK-NEXT: i32.and $push[[NUM1:[0-9]+]]=, $0, $pop[[NUM0]]{{$}} -; CHECK-NEXT: call $push[[NUM2:[0-9]+]]=, z2s_func@FUNCTION, $pop[[NUM1]]{{$}} -; CHECK-NEXT: return $pop[[NUM2]]{{$}} -define i32 @z2s_call(i32 %t) { - %s = trunc i32 %t to i8 - %u = call signext i8 @z2s_func(i8 zeroext %s) - %v = sext i8 %u to i32 - ret i32 %v -} - -; CHECK-LABEL: s2z_call: -; CHECK-NEXT: .param i32{{$}} -; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: i32.const $push[[NUM0:[0-9]+]]=, 24{{$}} -; CHECK-NEXT: i32.shl $push[[NUM1:[0-9]+]]=, $0, $pop[[NUM0]]{{$}} -; CHECK-NEXT: i32.const $push[[NUM6:[0-9]+]]=, 24{{$}} -; CHECK-NEXT: i32.shr_s $push[[NUM2:[0-9]+]]=, $pop[[NUM1]], $pop[[NUM6]]{{$}} -; CHECK-NEXT: call $push[[NUM3:[0-9]]]=, s2z_func@FUNCTION, $pop[[NUM2]]{{$}} -; CHECK-NEXT: i32.const $push[[NUM7:[0-9]+]]=, 24{{$}} -; CHECK-NEXT: i32.shl $push[[NUM4:[0-9]+]]=, $pop[[NUM3]], $pop[[NUM7]]{{$}} -; CHECK-NEXT: i32.const $push[[NUM8:[0-9]+]]=, 24{{$}} -; CHECK-NEXT: i32.shr_s $push[[NUM5:[0-9]+]]=, $pop[[NUM4]], $pop[[NUM8]]{{$}} -; CHECK-NEXT: return $pop[[NUM5]]{{$}} -define i32 @s2z_call(i32 %t) { - %s = trunc i32 %t to i8 - %u = call zeroext i8 @s2z_func(i8 signext %s) - %v = sext i8 %u to i32 - ret i32 %v -} diff --git a/test/CodeGen/WebAssembly/simd-arith.ll b/test/CodeGen/WebAssembly/simd-arith.ll deleted file mode 100644 index 62c659b7c01c..000000000000 --- a/test/CodeGen/WebAssembly/simd-arith.ll +++ /dev/null @@ -1,158 +0,0 @@ -; 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-wasm" - -declare i32 @llvm.ctlz.i32(i32, i1) -declare i32 @llvm.cttz.i32(i32, i1) -declare i32 @llvm.ctpop.i32(i32) - -; ============================================================================== -; 16 x i8 -; ============================================================================== -; CHECK-LABEL: add_v16i8 -; NO-SIMD128-NOT: i8x16 -; SIMD128: .param v128, v128{{$}} -; SIMD128: .result v128{{$}} -; SIMD128: i8x16.add $push0=, $0, $1{{$}} -; SIMD128: return $pop0{{$}} -define <16 x i8> @add_v16i8(<16 x i8> %x, <16 x i8> %y) { - %a = add <16 x i8> %x, %y - ret <16 x i8> %a -} - -; CHECK-LABEL: sub_v16i8 -; NO-SIMD128-NOT: i8x16 -; SIMD128: .param v128, v128{{$}} -; SIMD128: .result v128{{$}} -; SIMD128: i8x16.sub $push0=, $0, $1{{$}} -; SIMD128: return $pop0{{$}} -define <16 x i8> @sub_v16i8(<16 x i8> %x, <16 x i8> %y) { - %a = sub <16 x i8> %x, %y - ret <16 x i8> %a -} - -; CHECK-LABEL: mul_v16i8 -; NO-SIMD128-NOT: i8x16 -; SIMD128: .param v128, v128{{$}} -; SIMD128: .result v128{{$}} -; SIMD128: i8x16.mul $push0=, $0, $1{{$}} -; SIMD128: return $pop0{{$}} -define <16 x i8> @mul_v16i8(<16 x i8> %x, <16 x i8> %y) { - %a = mul <16 x i8> %x, %y - ret <16 x i8> %a -} - -; ============================================================================== -; 8 x i16 -; ============================================================================== -; CHECK-LABEL: add_v8i16 -; NO-SIMD128-NOT: i16x8 -; SIMD128: .param v128, v128{{$}} -; SIMD128: .result v128{{$}} -; SIMD128: i16x8.add $push0=, $0, $1{{$}} -; SIMD128: return $pop0{{$}} -define <8 x i16> @add_v8i16(<8 x i16> %x, <8 x i16> %y) { - %a = add <8 x i16> %x, %y - ret <8 x i16> %a -} - -; CHECK-LABEL: sub_v8i16 -; NO-SIMD128-NOT: i16x8 -; SIMD128: .param v128, v128{{$}} -; SIMD128: .result v128{{$}} -; SIMD128: i16x8.sub $push0=, $0, $1{{$}} -; SIMD128: return $pop0{{$}} -define <8 x i16> @sub_v8i16(<8 x i16> %x, <8 x i16> %y) { - %a = sub <8 x i16> %x, %y - ret <8 x i16> %a -} - -; CHECK-LABEL: mul_v8i16 -; NO-SIMD128-NOT: i16x8 -; SIMD128: .param v128, v128{{$}} -; SIMD128: .result v128{{$}} -; SIMD128: i16x8.mul $push0=, $0, $1{{$}} -; SIMD128: return $pop0{{$}} -define <8 x i16> @mul_v8i16(<8 x i16> %x, <8 x i16> %y) { - %a = mul <8 x i16> %x, %y - ret <8 x i16> %a -} - -; ============================================================================== -; 4 x i32 -; ============================================================================== -; CHECK-LABEL: add_v4i32 -; NO-SIMD128-NOT: i32x4 -; SIMD128: .param v128, v128{{$}} -; SIMD128: .result v128{{$}} -; SIMD128: i32x4.add $push0=, $0, $1{{$}} -; SIMD128: return $pop0{{$}} -define <4 x i32> @add_v4i32(<4 x i32> %x, <4 x i32> %y) { - %a = add <4 x i32> %x, %y - ret <4 x i32> %a -} - -; CHECK-LABEL: sub_v4i32 -; NO-SIMD128-NOT: i32x4 -; SIMD128: .param v128, v128{{$}} -; SIMD128: .result v128{{$}} -; SIMD128: i32x4.sub $push0=, $0, $1{{$}} -; SIMD128: return $pop0{{$}} -define <4 x i32> @sub_v4i32(<4 x i32> %x, <4 x i32> %y) { - %a = sub <4 x i32> %x, %y - ret <4 x i32> %a -} - -; CHECK-LABEL: mul_v4i32 -; NO-SIMD128-NOT: i32x4 -; SIMD128: .param v128, v128{{$}} -; SIMD128: .result v128{{$}} -; SIMD128: i32x4.mul $push0=, $0, $1{{$}} -; SIMD128: return $pop0{{$}} -define <4 x i32> @mul_v4i32(<4 x i32> %x, <4 x i32> %y) { - %a = mul <4 x i32> %x, %y - ret <4 x i32> %a -} - -; ============================================================================== -; 4 x float -; ============================================================================== -; CHECK-LABEL: add_v4f32 -; NO-SIMD128-NOT: f32x4 -; SIMD128: .param v128, v128{{$}} -; SIMD128: .result v128{{$}} -; SIMD128: f32x4.add $push0=, $0, $1{{$}} -; SIMD128: return $pop0{{$}} -define <4 x float> @add_v4f32(<4 x float> %x, <4 x float> %y) { - %a = fadd <4 x float> %x, %y - ret <4 x float> %a -} - -; CHECK-LABEL: sub_v4f32 -; NO-SIMD128-NOT: f32x4 -; SIMD128: .param v128, v128{{$}} -; SIMD128: .result v128{{$}} -; SIMD128: f32x4.sub $push0=, $0, $1{{$}} -; SIMD128: return $pop0{{$}} -define <4 x float> @sub_v4f32(<4 x float> %x, <4 x float> %y) { - %a = fsub <4 x float> %x, %y - ret <4 x float> %a -} - -; CHECK-LABEL: mul_v4f32 -; NO-SIMD128-NOT: f32x4 -; SIMD128: .param v128, v128{{$}} -; SIMD128: .result v128{{$}} -; SIMD128: f32x4.mul $push0=, $0, $1{{$}} -; SIMD128: return $pop0{{$}} -define <4 x float> @mul_v4f32(<4 x float> %x, <4 x float> %y) { - %a = fmul <4 x float> %x, %y - ret <4 x float> %a -} - diff --git a/test/CodeGen/WebAssembly/stack-alignment.ll b/test/CodeGen/WebAssembly/stack-alignment.ll deleted file mode 100644 index 95aa1f9dbf07..000000000000 --- a/test/CodeGen/WebAssembly/stack-alignment.ll +++ /dev/null @@ -1,149 +0,0 @@ -; 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-wasm" - -declare void @somefunc(i32*) - -; CHECK-LABEL: underalign: -; 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: get_local $push[[L3:.+]]=, [[SP]]{{$}} -; CHECK: i32.add $push[[underaligned:.+]]=, $pop[[L3]], $pop{{.+}} -; CHECK-NEXT: call somefunc@FUNCTION, $pop[[underaligned]] - -; 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 - call void @somefunc(i32* %underaligned) - ret void -} - -; CHECK-LABEL: overalign: -; 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: get_local $push[[M5:.+]]=, [[SP]]{{$}} -; CHECK: call somefunc@FUNCTION, $pop[[M5]]{{$}} - -; CHECK: get_local $push[[M6:.+]]=, [[BP]]{{$}} -; CHECK-NEXT: set_global 0, $pop[[M6]] -define void @overalign() { -entry: - %overaligned = alloca i32, align 32 - call void @somefunc(i32* %overaligned) - ret void -} - -; CHECK-LABEL: over_and_normal_align: -; 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: get_local $push[[M6:.+]]=, [[SP]]{{$}} -; CHECK: i32.add $push[[L6:.+]]=, $pop[[M6]], $pop{{.+}} -; CHECK-NEXT: call somefunc@FUNCTION, $pop[[L6]] -; CHECK: get_local $push[[M7:.+]]=, [[SP]]{{$}} -; CHECK: i32.add $push[[L8:.+]]=, $pop[[M7]], $pop{{.+}} -; CHECK-NEXT: call somefunc@FUNCTION, $pop[[L8]] - -; 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 - %normal = alloca i32 - call void @somefunc(i32* %over) - call void @somefunc(i32* %normal) - ret void -} - -; CHECK-LABEL: dynamic_overalign: -; 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: get_local $push[[M8:.+]]=, [[SP_2]]{{$}} -; CHECK: call somefunc@FUNCTION, $pop[[M8]] - -; 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 - call void @somefunc(i32* %dynamic) - ret void -} - -; CHECK-LABEL: overalign_and_dynamic: -; 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: get_local $push[[M10:.+]]=, [[FP]]{{$}} -; CHECK: i32.sub $push[[L16:.+]]=, $pop[[M10]], $pop{{.+}} -; CHECK-NEXT: tee_local $push{{.+}}=, [[SP:.+]], $pop[[L16]] - -; CHECK: get_local $push[[over:.+]]=, [[FP]] -; CHECK-NEXT: call somefunc@FUNCTION, $pop[[over]] -; CHECK: get_local $push[[another:.+]]=, [[SP]] -; CHECK-NEXT: call somefunc@FUNCTION, $pop[[another]] - -; 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 - %dynamic = alloca i32, i32 %num - call void @somefunc(i32* %over) - call void @somefunc(i32* %dynamic) - ret void -} - -; CHECK-LABEL: overalign_static_and_dynamic: -; 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: get_local $push[[M12:.+]]=, [[FP]]{{$}} -; CHECK: i32.sub $push[[L21:.+]]=, $pop[[M12]], $pop{{.+}} -; CHECK-NEXT: tee_local $push{{.+}}=, [[SP:.+]], $pop[[L21]] - -; 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: 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: 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 - %dynamic = alloca i32, i32 %num - %static = alloca i32 - call void @somefunc(i32* %over) - call void @somefunc(i32* %dynamic) - call void @somefunc(i32* %static) - ret void -} diff --git a/test/CodeGen/WebAssembly/store-trunc.ll b/test/CodeGen/WebAssembly/store-trunc.ll deleted file mode 100644 index ff358227d987..000000000000 --- a/test/CodeGen/WebAssembly/store-trunc.ll +++ /dev/null @@ -1,46 +0,0 @@ -; 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-wasm" - -; CHECK-LABEL: trunc_i8_i32: -; CHECK: i32.store8 0($0), $1{{$}} -define void @trunc_i8_i32(i8 *%p, i32 %v) { - %t = trunc i32 %v to i8 - store i8 %t, i8* %p - ret void -} - -; CHECK-LABEL: trunc_i16_i32: -; CHECK: i32.store16 0($0), $1{{$}} -define void @trunc_i16_i32(i16 *%p, i32 %v) { - %t = trunc i32 %v to i16 - store i16 %t, i16* %p - ret void -} - -; CHECK-LABEL: trunc_i8_i64: -; CHECK: i64.store8 0($0), $1{{$}} -define void @trunc_i8_i64(i8 *%p, i64 %v) { - %t = trunc i64 %v to i8 - store i8 %t, i8* %p - ret void -} - -; CHECK-LABEL: trunc_i16_i64: -; CHECK: i64.store16 0($0), $1{{$}} -define void @trunc_i16_i64(i16 *%p, i64 %v) { - %t = trunc i64 %v to i16 - store i16 %t, i16* %p - ret void -} - -; CHECK-LABEL: trunc_i32_i64: -; CHECK: i64.store32 0($0), $1{{$}} -define void @trunc_i32_i64(i32 *%p, i64 %v) { - %t = trunc i64 %v to i32 - store i32 %t, i32* %p - ret void -} diff --git a/test/CodeGen/WebAssembly/store.ll b/test/CodeGen/WebAssembly/store.ll deleted file mode 100644 index 153d7d9addf7..000000000000 --- a/test/CodeGen/WebAssembly/store.ll +++ /dev/null @@ -1,51 +0,0 @@ -; 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 - -; 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-wasm" - -; CHECK-LABEL: sti32: -; CHECK-NEXT: .param i32, i32{{$}} -; 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 - ret void -} - -; CHECK-LABEL: sti64: -; CHECK-NEXT: .param i32, i64{{$}} -; 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 - ret void -} - -; CHECK-LABEL: stf32: -; CHECK-NEXT: .param i32, f32{{$}} -; 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 - ret void -} - -; CHECK-LABEL: stf64: -; CHECK-NEXT: .param i32, f64{{$}} -; 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 - ret void -} diff --git a/test/CodeGen/WebAssembly/switch.ll b/test/CodeGen/WebAssembly/switch.ll deleted file mode 100644 index 18eac5534a45..000000000000 --- a/test/CodeGen/WebAssembly/switch.ll +++ /dev/null @@ -1,174 +0,0 @@ -; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -disable-block-placement -verify-machineinstrs | FileCheck %s - -; Test switch instructions. Block placement is disabled because it reorders -; 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-wasm" - -declare void @foo0() -declare void @foo1() -declare void @foo2() -declare void @foo3() -declare void @foo4() -declare void @foo5() - -; CHECK-LABEL: bar32: -; CHECK: block {{$}} -; CHECK: block {{$}} -; CHECK: block {{$}} -; CHECK: block {{$}} -; CHECK: block {{$}} -; CHECK: block {{$}} -; CHECK: block {{$}} -; CHECK: br_table {{[^,]+}}, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 4, 5, 0{{$}} -; CHECK: .LBB0_2: -; CHECK: call foo0@FUNCTION{{$}} -; CHECK: .LBB0_3: -; CHECK: call foo1@FUNCTION{{$}} -; CHECK: .LBB0_4: -; CHECK: call foo2@FUNCTION{{$}} -; CHECK: .LBB0_5: -; CHECK: call foo3@FUNCTION{{$}} -; CHECK: .LBB0_6: -; CHECK: call foo4@FUNCTION{{$}} -; CHECK: .LBB0_7: -; CHECK: call foo5@FUNCTION{{$}} -; CHECK: .LBB0_8: -; CHECK: return{{$}} -define void @bar32(i32 %n) { -entry: - switch i32 %n, label %sw.epilog [ - i32 0, label %sw.bb - i32 1, label %sw.bb - i32 2, label %sw.bb - i32 3, label %sw.bb - i32 4, label %sw.bb - i32 5, label %sw.bb - i32 6, label %sw.bb - i32 7, label %sw.bb.1 - i32 8, label %sw.bb.1 - i32 9, label %sw.bb.1 - i32 10, label %sw.bb.1 - i32 11, label %sw.bb.1 - i32 12, label %sw.bb.1 - i32 13, label %sw.bb.1 - i32 14, label %sw.bb.1 - i32 15, label %sw.bb.2 - i32 16, label %sw.bb.2 - i32 17, label %sw.bb.2 - i32 18, label %sw.bb.2 - i32 19, label %sw.bb.2 - i32 20, label %sw.bb.2 - i32 21, label %sw.bb.3 - i32 22, label %sw.bb.4 - i32 23, label %sw.bb.5 - ] - -sw.bb: ; preds = %entry, %entry, %entry, %entry, %entry, %entry, %entry - tail call void @foo0() - br label %sw.epilog - -sw.bb.1: ; preds = %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry - tail call void @foo1() - br label %sw.epilog - -sw.bb.2: ; preds = %entry, %entry, %entry, %entry, %entry, %entry - tail call void @foo2() - br label %sw.epilog - -sw.bb.3: ; preds = %entry - tail call void @foo3() - br label %sw.epilog - -sw.bb.4: ; preds = %entry - tail call void @foo4() - br label %sw.epilog - -sw.bb.5: ; preds = %entry - tail call void @foo5() - br label %sw.epilog - -sw.epilog: ; preds = %entry, %sw.bb.5, %sw.bb.4, %sw.bb.3, %sw.bb.2, %sw.bb.1, %sw.bb - ret void -} - -; CHECK-LABEL: bar64: -; CHECK: block {{$}} -; CHECK: block {{$}} -; CHECK: block {{$}} -; CHECK: block {{$}} -; CHECK: block {{$}} -; CHECK: block {{$}} -; CHECK: block {{$}} -; CHECK: br_table {{[^,]+}}, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 4, 5, 0{{$}} -; CHECK: .LBB1_2: -; CHECK: call foo0@FUNCTION{{$}} -; CHECK: .LBB1_3: -; CHECK: call foo1@FUNCTION{{$}} -; CHECK: .LBB1_4: -; CHECK: call foo2@FUNCTION{{$}} -; CHECK: .LBB1_5: -; CHECK: call foo3@FUNCTION{{$}} -; CHECK: .LBB1_6: -; CHECK: call foo4@FUNCTION{{$}} -; CHECK: .LBB1_7: -; CHECK: call foo5@FUNCTION{{$}} -; CHECK: .LBB1_8: -; CHECK: return{{$}} -define void @bar64(i64 %n) { -entry: - switch i64 %n, label %sw.epilog [ - i64 0, label %sw.bb - i64 1, label %sw.bb - i64 2, label %sw.bb - i64 3, label %sw.bb - i64 4, label %sw.bb - i64 5, label %sw.bb - i64 6, label %sw.bb - i64 7, label %sw.bb.1 - i64 8, label %sw.bb.1 - i64 9, label %sw.bb.1 - i64 10, label %sw.bb.1 - i64 11, label %sw.bb.1 - i64 12, label %sw.bb.1 - i64 13, label %sw.bb.1 - i64 14, label %sw.bb.1 - i64 15, label %sw.bb.2 - i64 16, label %sw.bb.2 - i64 17, label %sw.bb.2 - i64 18, label %sw.bb.2 - i64 19, label %sw.bb.2 - i64 20, label %sw.bb.2 - i64 21, label %sw.bb.3 - i64 22, label %sw.bb.4 - i64 23, label %sw.bb.5 - ] - -sw.bb: ; preds = %entry, %entry, %entry, %entry, %entry, %entry, %entry - tail call void @foo0() - br label %sw.epilog - -sw.bb.1: ; preds = %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry - tail call void @foo1() - br label %sw.epilog - -sw.bb.2: ; preds = %entry, %entry, %entry, %entry, %entry, %entry - tail call void @foo2() - br label %sw.epilog - -sw.bb.3: ; preds = %entry - tail call void @foo3() - br label %sw.epilog - -sw.bb.4: ; preds = %entry - tail call void @foo4() - br label %sw.epilog - -sw.bb.5: ; preds = %entry - tail call void @foo5() - br label %sw.epilog - -sw.epilog: ; preds = %entry, %sw.bb.5, %sw.bb.4, %sw.bb.3, %sw.bb.2, %sw.bb.1, %sw.bb - ret void -} diff --git a/test/CodeGen/WebAssembly/unreachable.ll b/test/CodeGen/WebAssembly/unreachable.ll deleted file mode 100644 index de96b0927563..000000000000 --- a/test/CodeGen/WebAssembly/unreachable.ll +++ /dev/null @@ -1,34 +0,0 @@ -; RUN: llc < %s -asm-verbose=false -verify-machineinstrs | FileCheck %s -; RUN: llc < %s -asm-verbose=false -fast-isel -fast-isel-abort=1 -verify-machineinstrs | FileCheck %s - -; Test that LLVM unreachable instruction and trap intrinsic are lowered to -; wasm unreachable - -target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" -target triple = "wasm32-unknown-unknown-wasm" - -declare void @llvm.trap() -declare void @llvm.debugtrap() -declare void @abort() - -; CHECK-LABEL: f1: -; CHECK: call abort@FUNCTION{{$}} -; CHECK: unreachable -define i32 @f1() { - call void @abort() - unreachable -} - -; CHECK-LABEL: f2: -; CHECK: unreachable -define void @f2() { - call void @llvm.trap() - ret void -} - -; CHECK-LABEL: f3: -; CHECK: unreachable -define void @f3() { - call void @llvm.debugtrap() - ret void -} diff --git a/test/CodeGen/WebAssembly/unsupported-function-bitcasts.ll b/test/CodeGen/WebAssembly/unsupported-function-bitcasts.ll deleted file mode 100644 index c3d420a6ece6..000000000000 --- a/test/CodeGen/WebAssembly/unsupported-function-bitcasts.ll +++ /dev/null @@ -1,27 +0,0 @@ -; RUN: llc < %s -asm-verbose=false | FileCheck %s - -; Test that function pointer casts that require conversions are not converted -; to wrappers. In theory some conversions could be supported, but currently no -; conversions are implemented. - -target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" -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 $push{{[0-9]+}}=, has_i64_ret@FUNCTION{{$}} -; CHECK-NEXT: drop -; CHECK-NEXT: end_function - -; CHECK-NOT: .Lbitcast - -declare void @has_i64_arg(i64) -declare i64 @has_i64_ret() - -define void @test() { -entry: - call void bitcast (void (i64)* @has_i64_arg to void (i32)*)(i32 0) - %t = call i32 bitcast (i64 ()* @has_i64_ret to i32 ()*)() - ret void -} diff --git a/test/CodeGen/WebAssembly/unused-argument.ll b/test/CodeGen/WebAssembly/unused-argument.ll deleted file mode 100644 index a70fc4bd2a46..000000000000 --- a/test/CodeGen/WebAssembly/unused-argument.ll +++ /dev/null @@ -1,31 +0,0 @@ -; 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-wasm" - -; CHECK-LABEL: unused_first: -; CHECK-NEXT: .param i32, i32{{$}} -; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: return $1{{$}} -define i32 @unused_first(i32 %x, i32 %y) { - ret i32 %y -} - -; CHECK-LABEL: unused_second: -; CHECK-NEXT: .param i32, i32{{$}} -; CHECK-NEXT: .result i32{{$}} -; CHECK-NEXT: return $0{{$}} -define i32 @unused_second(i32 %x, i32 %y) { - ret i32 %x -} - -; CHECK-LABEL: call_something: -; CHECK-NEXT: {{^}} i32.call $drop=, return_something@FUNCTION{{$}} -; CHECK-NEXT: return{{$}} -declare i32 @return_something() -define void @call_something() { - call i32 @return_something() - ret void -} diff --git a/test/CodeGen/WebAssembly/userstack.ll b/test/CodeGen/WebAssembly/userstack.ll deleted file mode 100644 index 57ca75705e5e..000000000000 --- a/test/CodeGen/WebAssembly/userstack.ll +++ /dev/null @@ -1,333 +0,0 @@ -; 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-wasm" - -declare void @ext_func(i64* %ptr) -declare void @ext_func_i32(i32* %ptr) - -; CHECK-LABEL: alloca32: -; Check that there is an extra local for the stack pointer. -; CHECK: .local i32{{$}} -define void @alloca32() noredzone { - ; 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: set_global 0, $pop[[L8]]{{$}} - %retval = alloca i32 - ; CHECK: get_local $push[[L4:.+]]=, [[SP]]{{$}} - ; CHECK: i32.const $push[[L0:.+]]=, 0 - ; CHECK: i32.store 12($pop[[L4]]), $pop[[L0]] - store i32 0, i32* %retval - ; CHECK: get_local $push[[L6:.+]]=, [[SP]]{{$}} - ; CHECK-NEXT: i32.const $push[[L5:.+]]=, 16 - ; 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: 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]] - %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($pop[[L2]]), $pop[[L1]] - store double 0.0, double* %r2 - ; CHECK-NEXT: return - ret void -} - -; CHECK-LABEL: allocarray: -; CHECK: .local i32{{$}} -define void @allocarray() { - ; 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: set_global 0, $pop[[L11]] - %r = alloca [33 x i32] - - ; CHECK: i32.const $push{{.+}}=, 24 - ; 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[[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-NEXT: get_local $push[[L2:.+]]=, [[SP]]{{$}} - ; CHECK-NEXT: i32.const $push[[L7:.+]]=, 144 - ; CHECK-NEXT: i32.add $push[[L8:.+]]=, $pop[[L2]], $pop[[L7]] - ; CHECK-NEXT: set_global 0, $pop[[L8]] - ret void -} - -; CHECK-LABEL: non_mem_use -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: 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:.+]]=, $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: 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:.+]]=, $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 -} - -; CHECK-LABEL: allocarray_inbounds: -; CHECK: .local i32{{$}} -define void @allocarray_inbounds() { - ; 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: set_global 0, $pop[[L10]]{{$}} - %r = alloca [5 x i32] - ; CHECK: i32.const $push[[L3:.+]]=, 1 - ; CHECK-DAG: i32.store 24(${{.+}}), $pop[[L3]] - %p = getelementptr inbounds [5 x i32], [5 x i32]* %r, i32 0, i32 0 - store i32 1, i32* %p - ; This store should have both the GEP and the FI folded into it. - ; CHECK-DAG: i32.store 12(${{.+}}), $pop - %p2 = getelementptr inbounds [5 x i32], [5 x i32]* %r, i32 0, i32 3 - store i32 1, i32* %p2 - call void @ext_func(i64* null); - ; CHECK: call ext_func - ; CHECK: i32.const $push[[L5:.+]]=, 32{{$}} - ; CHECK-NEXT: i32.add $push[[L7:.+]]=, ${{.+}}, $pop[[L5]] - ; CHECK-NEXT: set_global 0, $pop[[L7]] - ret void -} - -; CHECK-LABEL: dynamic_alloca: -define void @dynamic_alloca(i32 %alloc) { - ; 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: 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: set_global 0, $pop{{.+}} - ret void -} - -; CHECK-LABEL: dynamic_alloca_redzone: -define void @dynamic_alloca_redzone(i32 %alloc) { - ; 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 - %r = alloca i32, i32 %alloc - ; 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($pop[[L7]]), $pop[[L6]]{{$}} - store i32 0, i32* %r - ; CHECK-NEXT: return - ret void -} - -; 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: 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: set_global 0, $pop[[L22]] - - ; Alloc and write to a static alloca - ; 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 - store volatile i32 101, i32* %static - - ; Decrement SP in the body by the dynamic amount. - ; CHECK: i32.sub - ; 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]]($pop[[L17]]), $pop[[L7]] - ; CHECK-NEXT: get_local $push[[L9:.+]]=, [[dynamic_local]]{{$}} - ; CHECK-NEXT: i32.const $push[[L8:.+]]=, 103 - ; 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{{.+}} - %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]]($pop[[L22]]), $pop[[L9]] - ; CHECK-NEXT: get_local $push[[L23:.+]]=, [[dynamic_local]] - ; CHECK-NEXT: i32.const $push[[L10:.+]]=, 105 - ; 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($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: 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 -} - -declare i8* @llvm.stacksave() -declare void @llvm.stackrestore(i8*) - -; CHECK-LABEL: llvm_stack_builtins: -define void @llvm_stack_builtins(i32 %alloc) noredzone { - ; 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: set_local [[STACK]], - %dynamic = alloca i32, i32 %alloc - - ; CHECK: get_local $push[[L12:.+]]=, [[STACK]] - ; CHECK-NEXT: set_global 0, $pop[[L12]] - call void @llvm.stackrestore(i8* %stack) - - ret void -} - -; Not actually using the alloca'd variables exposed an issue with register -; stackification, where copying the stack pointer into the frame pointer was -; 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: 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: set_local [[FP]], - - ; CHECK: get_local $push[[L12:.+]]=, [[FP]] - ; CHECK-NEXT: set_global 0, $pop[[L12]] - ret void -} - -; The use of the alloca in a phi causes a CopyToReg DAG node to be generated, -; which has to have special handling because CopyToReg can't have a FI operand -; CHECK-LABEL: copytoreg_fi: -define void @copytoreg_fi(i1 %cond, i32* %b) { -entry: - ; CHECK: i32.const $push[[L1:.+]]=, 16 - ; CHECK-NEXT: i32.sub $push[[L3:.+]]=, {{.+}}, $pop[[L1]] - %addr = alloca i32 - ; CHECK: i32.const $push[[OFF:.+]]=, 12 - ; CHECK-NEXT: i32.add $push[[ADDR:.+]]=, $pop[[L3]], $pop[[OFF]] - ; CHECK-NEXT: set_local [[COPY:.+]], $pop[[ADDR]] - br label %body -body: - %a = phi i32* [%addr, %entry], [%b, %body] - store i32 1, i32* %a - ; CHECK: get_local $push[[L12:.+]]=, [[COPY]] - ; CHECK: i32.store 0($pop[[L12]]), - br i1 %cond, label %body, label %exit -exit: - ret void -} - -declare void @use_i8_star(i8*) -declare i8* @llvm.frameaddress(i32) - -; Test __builtin_frame_address(0). -; CHECK-LABEL: frameaddress_0: -; 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: 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) - ret void -} - -; Test __builtin_frame_address(1). - -; CHECK-LABEL: frameaddress_1: -; CHECK-NEXT: i32.const $push0=, 0{{$}} -; CHECK-NEXT: call use_i8_star@FUNCTION, $pop0{{$}} -; CHECK-NEXT: return{{$}} -define void @frameaddress_1() { - %t = call i8* @llvm.frameaddress(i32 1) - call void @use_i8_star(i8* %t) - ret void -} - -; Test a stack address passed to an inline asm. -; CHECK-LABEL: inline_asm: -; CHECK: get_global {{.+}}, 0{{$}} -; CHECK: #APP -; CHECK-NEXT: # %{{[0-9]+}}{{$}} -; CHECK-NEXT: #NO_APP -define void @inline_asm() { - %tmp = alloca i8 - call void asm sideeffect "# %0", "r"(i8* %tmp) - ret void -} - -; TODO: test over-aligned alloca diff --git a/test/CodeGen/WebAssembly/varargs.ll b/test/CodeGen/WebAssembly/varargs.ll deleted file mode 100644 index 3f04700131cc..000000000000 --- a/test/CodeGen/WebAssembly/varargs.ll +++ /dev/null @@ -1,149 +0,0 @@ -; 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-wasm" - -; Test va_start. - -; TODO: Test va_start. -; CHECK-LABEL: start: -; CHECK-NEXT: .param i32, i32 -; CHECK-NOT: __stack_pointer -define void @start(i8** %ap, ...) { -entry: - %0 = bitcast i8** %ap to i8* -; Store the second argument (the hidden vararg buffer pointer) into ap -; CHECK: i32.store 0($0), $1 - call void @llvm.va_start(i8* %0) - ret void -} - -; Test va_end. - -; CHECK-LABEL: end: -; CHECK-NEXT: .param i32{{$}} -; CHECK-NEXT: return{{$}} -define void @end(i8** %ap) { -entry: - %0 = bitcast i8** %ap to i8* - call void @llvm.va_end(i8* %0) - ret void -} - -; Test va_copy. - -; CHECK-LABEL: copy: -; CHECK-NEXT: .param i32, i32{{$}} -; CHECK-NEXT: i32.load $push0=, 0($1){{$}} -; CHECK-NEXT: i32.store 0($0), $pop0{{$}} -; CHECK-NEXT: return{{$}} -define void @copy(i8** %ap, i8** %bp) { -entry: - %0 = bitcast i8** %ap to i8* - %1 = bitcast i8** %bp to i8* - call void @llvm.va_copy(i8* %0, i8* %1) - ret void -} - -; Test va_arg with an i8 argument. - -; CHECK-LABEL: arg_i8: -; CHECK-NEXT: .param i32{{$}} -; CHECK-NEXT: .result 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{{$}} -; CHECK-NEXT: i32.add $push[[NUM3:[0-9]+]]=, $pop[[NUM1]], $pop[[NUM2]]{{$}} -; CHECK-NEXT: i32.store 0($0), $pop[[NUM3]]{{$}} -; CHECK-NEXT: i32.load $push[[NUM4:[0-9]+]]=, 0($1){{$}} -; CHECK-NEXT: return $pop[[NUM4]]{{$}} -define i8 @arg_i8(i8** %ap) { -entry: - %t = va_arg i8** %ap, i8 - ret i8 %t -} - -; Test va_arg with an i32 argument. - -; CHECK-LABEL: arg_i32: -; CHECK-NEXT: .param i32{{$}} -; CHECK-NEXT: .result 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]]{{$}} -; CHECK-NEXT: i32.const $push[[NUM3:[0-9]+]]=, -4{{$}} -; CHECK-NEXT: i32.and $push[[NUM4:[0-9]+]]=, $pop[[NUM2]], $pop[[NUM3]]{{$}} -; CHECK-NEXT: tee_local $push[[NUM5:[0-9]+]]=, $1=, $pop[[NUM4]]{{$}} -; CHECK-NEXT: i32.const $push[[NUM6:[0-9]+]]=, 4{{$}} -; CHECK-NEXT: i32.add $push[[NUM7:[0-9]+]]=, $pop[[NUM5]], $pop[[NUM6]]{{$}} -; CHECK-NEXT: i32.store 0($0), $pop[[NUM7]]{{$}} -; CHECK-NEXT: i32.load $push[[NUM8:[0-9]+]]=, 0($1){{$}} -; CHECK-NEXT: return $pop[[NUM8]]{{$}} -define i32 @arg_i32(i8** %ap) { -entry: - %t = va_arg i8** %ap, i32 - ret i32 %t -} - -; Test va_arg with an i128 argument. - -; CHECK-LABEL: arg_i128: -; CHECK-NEXT: .param i32, i32{{$}} -; CHECK: i32.and -; CHECK: i64.load -; CHECK: i64.load -; CHECK: return{{$}} -define i128 @arg_i128(i8** %ap) { -entry: - %t = va_arg i8** %ap, i128 - ret i128 %t -} - -; Test a varargs call with no actual arguments. - -declare void @callee(...) - -; CHECK-LABEL: caller_none: -; CHECK-NEXT: i32.const $push0=, 0 -; CHECK-NEXT: call callee@FUNCTION, $pop0 -; CHECK-NEXT: return{{$}} -define void @caller_none() { - call void (...) @callee() - ret void -} - -; Test a varargs call with some actual arguments. -; Note that the store of 2.0 is converted to an i64 store; this optimization -; is not needed on WebAssembly, but there isn't currently a convenient hook for -; disabling it. - -; CHECK-LABEL: caller_some -; CHECK-DAG: i32.store -; CHECK-DAG: i64.store -define void @caller_some() { - call void (...) @callee(i32 0, double 2.0) - ret void -} - -; Test a va_start call in a non-entry block -; CHECK-LABEL: startbb: -; CHECK: .param i32, i32, i32 -define void @startbb(i1 %cond, i8** %ap, ...) { -entry: - br i1 %cond, label %bb0, label %bb1 -bb0: - ret void -bb1: - %0 = bitcast i8** %ap to i8* -; Store the second argument (the hidden vararg buffer pointer) into ap -; CHECK: i32.store 0($1), $2 - call void @llvm.va_start(i8* %0) - ret void -} - - -declare void @llvm.va_start(i8*) -declare void @llvm.va_end(i8*) -declare void @llvm.va_copy(i8*, i8*) diff --git a/test/CodeGen/WebAssembly/vtable.ll b/test/CodeGen/WebAssembly/vtable.ll deleted file mode 100644 index b39e7bc0f7f2..000000000000 --- a/test/CodeGen/WebAssembly/vtable.ll +++ /dev/null @@ -1,174 +0,0 @@ -; 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. -; -; The class hierarchy is: -; struct A; -; struct B : public A; -; struct C : public A; -; struct D : public B; -; 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-wasm" - -%struct.A = type { i32 (...)** } -%struct.B = type { %struct.A } -%struct.C = type { %struct.A } -%struct.D = type { %struct.B } - -@_ZTVN10__cxxabiv117__class_type_infoE = external global i8* -@_ZTVN10__cxxabiv120__si_class_type_infoE = external global i8* - -; TYPEINFONAME-LABEL: _ZTS1A: -; TYPEINFONAME-NEXT: .asciz "1A" -@_ZTS1A = constant [3 x i8] c"1A\00" -; TYPEINFONAME-LABEL: _ZTS1B: -; TYPEINFONAME-NEXT: .asciz "1B" -@_ZTS1B = constant [3 x i8] c"1B\00" -; TYPEINFONAME-LABEL: _ZTS1C: -; TYPEINFONAME-NEXT: .asciz "1C" -@_ZTS1C = constant [3 x i8] c"1C\00" -; TYPEINFONAME-LABEL: _ZTS1D: -; TYPEINFONAME-NEXT: .asciz "1D" -@_ZTS1D = constant [3 x i8] c"1D\00" - -; VTABLE: .type _ZTV1A,@object -; VTABLE-NEXT: .section .data.rel.ro._ZTV1A, -; VTABLE-NEXT: .globl _ZTV1A -; VTABLE-LABEL: _ZTV1A: -; VTABLE-NEXT: .int32 0 -; VTABLE-NEXT: .int32 _ZTI1A -; VTABLE-NEXT: .int32 _ZN1AD2Ev -; VTABLE-NEXT: .int32 _ZN1AD0Ev -; VTABLE-NEXT: .int32 _ZN1A3fooEv -; 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 -; VTABLE-NEXT: .int32 _ZTI1B -; VTABLE-NEXT: .int32 _ZN1AD2Ev -; VTABLE-NEXT: .int32 _ZN1BD0Ev -; VTABLE-NEXT: .int32 _ZN1B3fooEv -; 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 -; VTABLE-NEXT: .int32 _ZTI1C -; VTABLE-NEXT: .int32 _ZN1AD2Ev -; VTABLE-NEXT: .int32 _ZN1CD0Ev -; VTABLE-NEXT: .int32 _ZN1C3fooEv -; 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 -; VTABLE-NEXT: .int32 _ZTI1D -; VTABLE-NEXT: .int32 _ZN1AD2Ev -; VTABLE-NEXT: .int32 _ZN1DD0Ev -; VTABLE-NEXT: .int32 _ZN1D3fooEv -; VTABLE-NEXT: .size _ZTV1D, 20 -@_ZTV1D = constant [5 x i8*] [i8* null, i8* bitcast ({ i8*, i8*, i8* }* @_ZTI1D to i8*), i8* bitcast (%struct.A* (%struct.A*)* @_ZN1AD2Ev to i8*), i8* bitcast (void (%struct.D*)* @_ZN1DD0Ev to i8*), i8* bitcast (void (%struct.D*)* @_ZN1D3fooEv to i8*)], align 4 - -; TYPEINFO: .type _ZTI1A,@object -; TYPEINFO: .globl _ZTI1A -; TYPEINFO-LABEL: _ZTI1A: -; TYPEINFO-NEXT: .int32 _ZTVN10__cxxabiv117__class_type_infoE+8 -; TYPEINFO-NEXT: .int32 _ZTS1A -; TYPEINFO-NEXT: .size _ZTI1A, 8 -@_ZTI1A = constant { i8*, i8* } { i8* bitcast (i8** getelementptr inbounds (i8*, i8** @_ZTVN10__cxxabiv117__class_type_infoE, i32 2) to i8*), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @_ZTS1A, i32 0, i32 0) } -; TYPEINFO: .type _ZTI1B,@object -; TYPEINFO: .globl _ZTI1B -; TYPEINFO-LABEL: _ZTI1B: -; TYPEINFO-NEXT: .int32 _ZTVN10__cxxabiv120__si_class_type_infoE+8 -; TYPEINFO-NEXT: .int32 _ZTS1B -; TYPEINFO-NEXT: .int32 _ZTI1A -; TYPEINFO-NEXT: .size _ZTI1B, 12 -@_ZTI1B = constant { i8*, i8*, i8* } { i8* bitcast (i8** getelementptr inbounds (i8*, i8** @_ZTVN10__cxxabiv120__si_class_type_infoE, i32 2) to i8*), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @_ZTS1B, i32 0, i32 0), i8* bitcast ({ i8*, i8* }* @_ZTI1A to i8*) } -; TYPEINFO: .type _ZTI1C,@object -; TYPEINFO: .globl _ZTI1C -; TYPEINFO-LABEL: _ZTI1C: -; TYPEINFO-NEXT: .int32 _ZTVN10__cxxabiv120__si_class_type_infoE+8 -; TYPEINFO-NEXT: .int32 _ZTS1C -; TYPEINFO-NEXT: .int32 _ZTI1A -; TYPEINFO-NEXT: .size _ZTI1C, 12 -@_ZTI1C = constant { i8*, i8*, i8* } { i8* bitcast (i8** getelementptr inbounds (i8*, i8** @_ZTVN10__cxxabiv120__si_class_type_infoE, i32 2) to i8*), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @_ZTS1C, i32 0, i32 0), i8* bitcast ({ i8*, i8* }* @_ZTI1A to i8*) } -; TYPEINFO: .type _ZTI1D,@object -; TYPEINFO: .globl _ZTI1D -; TYPEINFO-LABEL: _ZTI1D: -; TYPEINFO-NEXT: .int32 _ZTVN10__cxxabiv120__si_class_type_infoE+8 -; TYPEINFO-NEXT: .int32 _ZTS1D -; TYPEINFO-NEXT: .int32 _ZTI1B -; TYPEINFO-NEXT: .size _ZTI1D, 12 -@_ZTI1D = constant { i8*, i8*, i8* } { i8* bitcast (i8** getelementptr inbounds (i8*, i8** @_ZTVN10__cxxabiv120__si_class_type_infoE, i32 2) to i8*), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @_ZTS1D, i32 0, i32 0), i8* bitcast ({ i8*, i8*, i8* }* @_ZTI1B to i8*) } - -@g = global i32 0, align 4 - -define void @_ZN1A3fooEv(%struct.A* %this) { -entry: - store i32 2, i32* @g, align 4 - ret void -} - -define void @_ZN1B3fooEv(%struct.B* %this) { -entry: - store i32 4, i32* @g, align 4 - ret void -} - -define void @_ZN1C3fooEv(%struct.C* %this) { -entry: - store i32 6, i32* @g, align 4 - ret void -} - -define void @_ZN1D3fooEv(%struct.D* %this) { -entry: - store i32 8, i32* @g, align 4 - ret void -} - -define linkonce_odr void @_ZN1AD0Ev(%struct.A* %this) { -entry: - %0 = bitcast %struct.A* %this to i8* - tail call void @_ZdlPv(i8* %0) - ret void -} - -define linkonce_odr void @_ZN1BD0Ev(%struct.B* %this) { -entry: - %0 = bitcast %struct.B* %this to i8* - tail call void @_ZdlPv(i8* %0) - ret void -} - -define linkonce_odr void @_ZN1CD0Ev(%struct.C* %this) { -entry: - %0 = bitcast %struct.C* %this to i8* - tail call void @_ZdlPv(i8* %0) - ret void -} - -define linkonce_odr %struct.A* @_ZN1AD2Ev(%struct.A* returned %this) { -entry: - ret %struct.A* %this -} - -define linkonce_odr void @_ZN1DD0Ev(%struct.D* %this) { -entry: - %0 = bitcast %struct.D* %this to i8* - tail call void @_ZdlPv(i8* %0) - ret void -} - -declare void @_ZdlPv(i8*) |