diff options
Diffstat (limited to 'llvm/test/CodeGen/WebAssembly')
| -rw-r--r-- | llvm/test/CodeGen/WebAssembly/i32-load-store-alignment.ll | 33 | ||||
| -rw-r--r-- | llvm/test/CodeGen/WebAssembly/i64-load-store-alignment.ll | 27 | ||||
| -rw-r--r-- | llvm/test/CodeGen/WebAssembly/offset-atomics.ll | 542 | ||||
| -rw-r--r-- | llvm/test/CodeGen/WebAssembly/offset.ll | 405 |
4 files changed, 659 insertions, 348 deletions
diff --git a/llvm/test/CodeGen/WebAssembly/i32-load-store-alignment.ll b/llvm/test/CodeGen/WebAssembly/i32-load-store-alignment.ll index a4ce351dc26..a7b67387e17 100644 --- a/llvm/test/CodeGen/WebAssembly/i32-load-store-alignment.ll +++ b/llvm/test/CodeGen/WebAssembly/i32-load-store-alignment.ll @@ -5,7 +5,9 @@ target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target triple = "wasm32-unknown-unknown" -; Loads. +;===---------------------------------------------------------------------------- +; Loads +;===---------------------------------------------------------------------------- ; CHECK-LABEL: ldi32_a1: ; CHECK-NEXT: .param i32{{$}} @@ -63,7 +65,9 @@ define i32 @ldi32_a8(i32 *%p) { ret i32 %v } -; Extending loads. +;===---------------------------------------------------------------------------- +; Extending loads +;===---------------------------------------------------------------------------- ; CHECK-LABEL: ldi8_a1: ; CHECK-NEXT: .param i32{{$}} @@ -115,7 +119,9 @@ define i16 @ldi16_a4(i16 *%p) { ret i16 %v } -; Stores. +;===---------------------------------------------------------------------------- +; Stores +;===---------------------------------------------------------------------------- ; CHECK-LABEL: sti32_a1: ; CHECK-NEXT: .param i32, i32{{$}} @@ -166,7 +172,9 @@ define void @sti32_a8(i32 *%p, i32 %v) { ret void } -; Truncating stores. +;===---------------------------------------------------------------------------- +; Truncating stores +;===---------------------------------------------------------------------------- ; CHECK-LABEL: sti8_a1: ; CHECK-NEXT: .param i32, i32{{$}} @@ -213,9 +221,12 @@ define void @sti16_a4(i16 *%p, i16 %v) { ret void } -; Atomics. -; Wasm atomics have the alignment field, but it must always have the -; type's natural alignment. +;===---------------------------------------------------------------------------- +; Atomic loads +;===---------------------------------------------------------------------------- + +; Wasm atomics have the alignment field, but it must always have the type's +; natural alignment. ; CHECK-LABEL: ldi32_atomic_a4: ; CHECK-NEXT: .param i32{{$}} @@ -227,7 +238,7 @@ define i32 @ldi32_atomic_a4(i32 *%p) { ret i32 %v } -; 8 is greater than the default alignment so it is rounded down to 4 +; 8 is greater than the default alignment so it is ignored. ; CHECK-LABEL: ldi32_atomic_a8: ; CHECK-NEXT: .param i32{{$}} @@ -239,6 +250,10 @@ define i32 @ldi32_atomic_a8(i32 *%p) { ret i32 %v } +;===---------------------------------------------------------------------------- +; Atomic stores +;===---------------------------------------------------------------------------- + ; CHECK-LABEL: sti32_atomic_a4: ; CHECK-NEXT: .param i32, i32{{$}} ; CHECK-NEXT: i32.atomic.store 0($0), $1{{$}} @@ -248,6 +263,8 @@ define void @sti32_atomic_a4(i32 *%p, i32 %v) { ret void } +; 8 is greater than the default alignment so it is ignored. + ; CHECK-LABEL: sti32_atomic_a8: ; CHECK-NEXT: .param i32, i32{{$}} ; CHECK-NEXT: i32.atomic.store 0($0), $1{{$}} diff --git a/llvm/test/CodeGen/WebAssembly/i64-load-store-alignment.ll b/llvm/test/CodeGen/WebAssembly/i64-load-store-alignment.ll index f3b8e15b602..eb303c150ef 100644 --- a/llvm/test/CodeGen/WebAssembly/i64-load-store-alignment.ll +++ b/llvm/test/CodeGen/WebAssembly/i64-load-store-alignment.ll @@ -5,7 +5,9 @@ target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target triple = "wasm32-unknown-unknown" -; Loads. +;===---------------------------------------------------------------------------- +; Loads +;===---------------------------------------------------------------------------- ; CHECK-LABEL: ldi64_a1: ; CHECK-NEXT: .param i32{{$}} @@ -73,7 +75,9 @@ define i64 @ldi64_a16(i64 *%p) { ret i64 %v } -; Extending loads. +;===---------------------------------------------------------------------------- +; Extending loads +;===---------------------------------------------------------------------------- ; CHECK-LABEL: ldi8_a1: ; CHECK-NEXT: .param i32{{$}} @@ -174,7 +178,9 @@ define i64 @ldi32_a8(i32 *%p) { ret i64 %w } -; Stores. +;===---------------------------------------------------------------------------- +; Stores +;===---------------------------------------------------------------------------- ; CHECK-LABEL: sti64_a1: ; CHECK-NEXT: .param i32, i64{{$}} @@ -234,7 +240,9 @@ define void @sti64_a16(i64 *%p, i64 %v) { ret void } -; Truncating stores. +;===---------------------------------------------------------------------------- +; Truncating stores +;===---------------------------------------------------------------------------- ; CHECK-LABEL: sti8_a1: ; CHECK-NEXT: .param i32, i64{{$}} @@ -326,7 +334,10 @@ define void @sti32_a8(i32 *%p, i64 %w) { ret void } -; Atomics. +;===---------------------------------------------------------------------------- +; Atomic loads +;===---------------------------------------------------------------------------- + ; Wasm atomics have the alignment field, but it must always have the type's ; natural alignment. @@ -341,6 +352,7 @@ define i64 @ldi64_atomic_a8(i64 *%p) { } ; 16 is greater than the default alignment so it is ignored. + ; CHECK-LABEL: ldi64_atomic_a16: ; CHECK-NEXT: .param i32{{$}} ; CHECK-NEXT: .result i64{{$}} @@ -351,6 +363,10 @@ define i64 @ldi64_atomic_a16(i64 *%p) { ret i64 %v } +;===---------------------------------------------------------------------------- +; Atomic stores +;===---------------------------------------------------------------------------- + ; CHECK-LABEL: sti64_atomic_a4: ; CHECK-NEXT: .param i32, i64{{$}} ; CHECK-NEXT: i64.atomic.store 0($0), $1{{$}} @@ -361,6 +377,7 @@ define void @sti64_atomic_a4(i64 *%p, i64 %v) { } ; 16 is greater than the default alignment so it is ignored. + ; CHECK-LABEL: sti64_atomic_a8: ; CHECK-NEXT: .param i32, i64{{$}} ; CHECK-NEXT: i64.atomic.store 0($0), $1{{$}} diff --git a/llvm/test/CodeGen/WebAssembly/offset-atomics.ll b/llvm/test/CodeGen/WebAssembly/offset-atomics.ll index 98c53b23432..75074dc994b 100644 --- a/llvm/test/CodeGen/WebAssembly/offset-atomics.ll +++ b/llvm/test/CodeGen/WebAssembly/offset-atomics.ll @@ -6,11 +6,15 @@ target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target triple = "wasm32-unknown-unknown" +;===---------------------------------------------------------------------------- +; Atomic loads: 32-bit +;===---------------------------------------------------------------------------- + ; Basic load. ; CHECK-LABEL: load_i32_no_offset: -; CHECK: i32.atomic.load $push[[NUM:[0-9]+]]=, 0($0){{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} +; CHECK: i32.atomic.load $push0=, 0($0){{$}} +; CHECK-NEXT: return $pop0{{$}} define i32 @load_i32_no_offset(i32 *%p) { %v = load atomic i32, i32* %p seq_cst, align 4 ret i32 %v @@ -19,7 +23,7 @@ define i32 @load_i32_no_offset(i32 *%p) { ; With an nuw add, we can fold an offset. ; CHECK-LABEL: load_i32_with_folded_offset: -; CHECK: i32.atomic.load $push0=, 24($0){{$}} +; CHECK: i32.atomic.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 @@ -31,7 +35,7 @@ define i32 @load_i32_with_folded_offset(i32* %p) { ; With an inbounds gep, we can fold an offset. ; CHECK-LABEL: load_i32_with_folded_gep_offset: -; CHECK: i32.atomic.load $push0=, 24($0){{$}} +; CHECK: i32.atomic.load $push0=, 24($0){{$}} define i32 @load_i32_with_folded_gep_offset(i32* %p) { %s = getelementptr inbounds i32, i32* %p, i32 6 %t = load atomic i32, i32* %s seq_cst, align 4 @@ -42,8 +46,8 @@ define i32 @load_i32_with_folded_gep_offset(i32* %p) { ; CHECK-LABEL: load_i32_with_unfolded_gep_negative_offset: ; CHECK: i32.const $push0=, -24{{$}} -; CHECK: i32.add $push1=, $0, $pop0{{$}} -; CHECK: i32.atomic.load $push2=, 0($pop1){{$}} +; CHECK: i32.add $push1=, $0, $pop0{{$}} +; CHECK: i32.atomic.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 atomic i32, i32* %s seq_cst, align 4 @@ -54,8 +58,8 @@ define i32 @load_i32_with_unfolded_gep_negative_offset(i32* %p) { ; CHECK-LABEL: load_i32_with_unfolded_offset: ; CHECK: i32.const $push0=, 24{{$}} -; CHECK: i32.add $push1=, $0, $pop0{{$}} -; CHECK: i32.atomic.load $push2=, 0($pop1){{$}} +; CHECK: i32.add $push1=, $0, $pop0{{$}} +; CHECK: i32.atomic.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 @@ -68,26 +72,52 @@ define i32 @load_i32_with_unfolded_offset(i32* %p) { ; CHECK-LABEL: load_i32_with_unfolded_gep_offset: ; CHECK: i32.const $push0=, 24{{$}} -; CHECK: i32.add $push1=, $0, $pop0{{$}} -; CHECK: i32.atomic.load $push2=, 0($pop1){{$}} +; CHECK: i32.add $push1=, $0, $pop0{{$}} +; CHECK: i32.atomic.load $push2=, 0($pop1){{$}} define i32 @load_i32_with_unfolded_gep_offset(i32* %p) { %s = getelementptr i32, i32* %p, i32 6 %t = load atomic i32, i32* %s seq_cst, align 4 ret i32 %t } +; When loading from a fixed address, materialize a zero. + +; CHECK-LABEL: load_i32_from_numeric_address +; CHECK: i32.const $push0=, 0{{$}} +; CHECK: i32.atomic.load $push1=, 42($pop0){{$}} +define i32 @load_i32_from_numeric_address() { + %s = inttoptr i32 42 to i32* + %t = load atomic i32, i32* %s seq_cst, align 4 + ret i32 %t +} + +; CHECK-LABEL: load_i32_from_global_address +; CHECK: i32.const $push0=, 0{{$}} +; CHECK: i32.atomic.load $push1=, gv($pop0){{$}} +@gv = global i32 0 +define i32 @load_i32_from_global_address() { + %t = load atomic i32, i32* @gv seq_cst, align 4 + ret i32 %t +} + +;===---------------------------------------------------------------------------- +; Atomic loads: 64-bit +;===---------------------------------------------------------------------------- + +; Basic load. + ; CHECK-LABEL: load_i64_no_offset: -; CHECK: i64.atomic.load $push[[NUM:[0-9]+]]=, 0($0){{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} +; CHECK: i64.atomic.load $push0=, 0($0){{$}} +; CHECK-NEXT: return $pop0{{$}} define i64 @load_i64_no_offset(i64 *%p) { %v = load atomic i64, i64* %p seq_cst, align 8 ret i64 %v } -; Same as above but with i64. +; With an nuw add, we can fold an offset. ; CHECK-LABEL: load_i64_with_folded_offset: -; CHECK: i64.atomic.load $push0=, 24($0){{$}} +; CHECK: i64.atomic.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 @@ -96,34 +126,34 @@ define i64 @load_i64_with_folded_offset(i64* %p) { ret i64 %t } -; Same as above but with i64. +; With an inbounds gep, we can fold an offset. ; CHECK-LABEL: load_i64_with_folded_gep_offset: -; CHECK: i64.atomic.load $push0=, 24($0){{$}} +; CHECK: i64.atomic.load $push0=, 24($0){{$}} define i64 @load_i64_with_folded_gep_offset(i64* %p) { %s = getelementptr inbounds i64, i64* %p, i32 3 %t = load atomic i64, i64* %s seq_cst, align 8 ret i64 %t } -; Same as above but with i64. +; We can't fold a negative offset though, even with an inbounds gep. ; CHECK-LABEL: load_i64_with_unfolded_gep_negative_offset: ; CHECK: i32.const $push0=, -24{{$}} -; CHECK: i32.add $push1=, $0, $pop0{{$}} -; CHECK: i64.atomic.load $push2=, 0($pop1){{$}} +; CHECK: i32.add $push1=, $0, $pop0{{$}} +; CHECK: i64.atomic.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 atomic i64, i64* %s seq_cst, align 8 ret i64 %t } -; Same as above but with i64. +; Without nuw, and even with nsw, we can't fold an offset. ; CHECK-LABEL: load_i64_with_unfolded_offset: ; CHECK: i32.const $push0=, 24{{$}} -; CHECK: i32.add $push1=, $0, $pop0{{$}} -; CHECK: i64.atomic.load $push2=, 0($pop1){{$}} +; CHECK: i32.add $push1=, $0, $pop0{{$}} +; CHECK: i64.atomic.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 @@ -132,31 +162,23 @@ define i64 @load_i64_with_unfolded_offset(i64* %p) { ret i64 %t } -; Same as above but with i64. +; Without inbounds, we can't fold a gep offset. ; CHECK-LABEL: load_i64_with_unfolded_gep_offset: ; CHECK: i32.const $push0=, 24{{$}} -; CHECK: i32.add $push1=, $0, $pop0{{$}} -; CHECK: i64.atomic.load $push2=, 0($pop1){{$}} +; CHECK: i32.add $push1=, $0, $pop0{{$}} +; CHECK: i64.atomic.load $push2=, 0($pop1){{$}} define i64 @load_i64_with_unfolded_gep_offset(i64* %p) { %s = getelementptr i64, i64* %p, i32 3 %t = load atomic i64, i64* %s seq_cst, align 8 ret i64 %t } -; CHECK-LABEL: load_i32_with_folded_or_offset: -; CHECK: i32.atomic.load8_u $push[[R1:[0-9]+]]=, 2($pop{{[0-9]+}}){{$}} -; CHECK-NEXT: i32.extend8_s $push{{[0-9]+}}=, $pop[[R1]]{{$}} -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 atomic i8, i8* %arrayidx seq_cst, align 8 - %conv = sext i8 %t1 to i32 - ret i32 %conv -} +;===---------------------------------------------------------------------------- +; Atomic stores: 32-bit +;===---------------------------------------------------------------------------- -; Same as above but with store. +; Basic store. ; CHECK-LABEL: store_i32_no_offset: ; CHECK-NEXT: .param i32, i32{{$}} @@ -167,7 +189,7 @@ define void @store_i32_no_offset(i32 *%p, i32 %v) { ret void } -; Same as above but with store. +; With an nuw add, we can fold an offset. ; CHECK-LABEL: store_i32_with_folded_offset: ; CHECK: i32.atomic.store 24($0), $pop0{{$}} @@ -179,7 +201,7 @@ define void @store_i32_with_folded_offset(i32* %p) { ret void } -; Same as above but with store. +; With an inbounds gep, we can fold an offset. ; CHECK-LABEL: store_i32_with_folded_gep_offset: ; CHECK: i32.atomic.store 24($0), $pop0{{$}} @@ -189,11 +211,11 @@ define void @store_i32_with_folded_gep_offset(i32* %p) { ret void } -; Same as above but with store. +; We can't fold a negative offset though, even with an inbounds gep. ; CHECK-LABEL: store_i32_with_unfolded_gep_negative_offset: -; CHECK: i32.const $push0=, -24{{$}} -; CHECK: i32.add $push1=, $0, $pop0{{$}} +; CHECK: i32.const $push0=, -24{{$}} +; CHECK: i32.add $push1=, $0, $pop0{{$}} ; CHECK: i32.atomic.store 0($pop1), $pop2{{$}} define void @store_i32_with_unfolded_gep_negative_offset(i32* %p) { %s = getelementptr inbounds i32, i32* %p, i32 -6 @@ -201,11 +223,11 @@ define void @store_i32_with_unfolded_gep_negative_offset(i32* %p) { ret void } -; Same as above but with store. +; Without nuw, and even with nsw, we can't fold an offset. ; CHECK-LABEL: store_i32_with_unfolded_offset: -; CHECK: i32.const $push0=, 24{{$}} -; CHECK: i32.add $push1=, $0, $pop0{{$}} +; CHECK: i32.const $push0=, 24{{$}} +; CHECK: i32.add $push1=, $0, $pop0{{$}} ; CHECK: i32.atomic.store 0($pop1), $pop2{{$}} define void @store_i32_with_unfolded_offset(i32* %p) { %q = ptrtoint i32* %p to i32 @@ -215,11 +237,11 @@ define void @store_i32_with_unfolded_offset(i32* %p) { ret void } -; Same as above but with store. +; Without inbounds, we can't fold a gep offset. ; CHECK-LABEL: store_i32_with_unfolded_gep_offset: -; CHECK: i32.const $push0=, 24{{$}} -; CHECK: i32.add $push1=, $0, $pop0{{$}} +; CHECK: i32.const $push0=, 24{{$}} +; CHECK: i32.add $push1=, $0, $pop0{{$}} ; CHECK: i32.atomic.store 0($pop1), $pop2{{$}} define void @store_i32_with_unfolded_gep_offset(i32* %p) { %s = getelementptr i32, i32* %p, i32 6 @@ -227,7 +249,32 @@ define void @store_i32_with_unfolded_gep_offset(i32* %p) { ret void } -; Same as above but with store with i64. +; When storing from a fixed address, materialize a zero. + +; CHECK-LABEL: store_i32_to_numeric_address: +; CHECK-NEXT: i32.const $push0=, 0{{$}} +; CHECK-NEXT: i32.const $push1=, 0{{$}} +; CHECK-NEXT: i32.atomic.store 42($pop0), $pop1{{$}} +define void @store_i32_to_numeric_address() { + %s = inttoptr i32 42 to i32* + store atomic i32 0, i32* %s seq_cst, align 4 + ret void +} + +; CHECK-LABEL: store_i32_to_global_address: +; CHECK: i32.const $push0=, 0{{$}} +; CHECK: i32.const $push1=, 0{{$}} +; CHECK: i32.atomic.store gv($pop0), $pop1{{$}} +define void @store_i32_to_global_address() { + store atomic i32 0, i32* @gv seq_cst, align 4 + ret void +} + +;===---------------------------------------------------------------------------- +; Atomic stores: 64-bit +;===---------------------------------------------------------------------------- + +; Basic store. ; CHECK-LABEL: store_i64_no_offset: ; CHECK-NEXT: .param i32, i64{{$}} @@ -238,7 +285,7 @@ define void @store_i64_no_offset(i64 *%p, i64 %v) { ret void } -; Same as above but with store with i64. +; With an nuw add, we can fold an offset. ; CHECK-LABEL: store_i64_with_folded_offset: ; CHECK: i64.atomic.store 24($0), $pop0{{$}} @@ -250,7 +297,7 @@ define void @store_i64_with_folded_offset(i64* %p) { ret void } -; Same as above but with store with i64. +; With an inbounds gep, we can fold an offset. ; CHECK-LABEL: store_i64_with_folded_gep_offset: ; CHECK: i64.atomic.store 24($0), $pop0{{$}} @@ -260,11 +307,11 @@ define void @store_i64_with_folded_gep_offset(i64* %p) { ret void } -; Same as above but with store with i64. +; We can't fold a negative offset though, even with an inbounds gep. ; CHECK-LABEL: store_i64_with_unfolded_gep_negative_offset: -; CHECK: i32.const $push0=, -24{{$}} -; CHECK: i32.add $push1=, $0, $pop0{{$}} +; CHECK: i32.const $push0=, -24{{$}} +; CHECK: i32.add $push1=, $0, $pop0{{$}} ; CHECK: i64.atomic.store 0($pop1), $pop2{{$}} define void @store_i64_with_unfolded_gep_negative_offset(i64* %p) { %s = getelementptr inbounds i64, i64* %p, i32 -3 @@ -272,11 +319,11 @@ define void @store_i64_with_unfolded_gep_negative_offset(i64* %p) { ret void } -; Same as above but with store with i64. +; Without nuw, and even with nsw, we can't fold an offset. ; CHECK-LABEL: store_i64_with_unfolded_offset: -; CHECK: i32.const $push0=, 24{{$}} -; CHECK: i32.add $push1=, $0, $pop0{{$}} +; CHECK: i32.const $push0=, 24{{$}} +; CHECK: i32.add $push1=, $0, $pop0{{$}} ; CHECK: i64.atomic.store 0($pop1), $pop2{{$}} define void @store_i64_with_unfolded_offset(i64* %p) { %q = ptrtoint i64* %p to i32 @@ -286,11 +333,11 @@ define void @store_i64_with_unfolded_offset(i64* %p) { ret void } -; Same as above but with store with i64. +; Without inbounds, we can't fold a gep offset. ; CHECK-LABEL: store_i64_with_unfolded_gep_offset: -; CHECK: i32.const $push0=, 24{{$}} -; CHECK: i32.add $push1=, $0, $pop0{{$}} +; CHECK: i32.const $push0=, 24{{$}} +; CHECK: i32.add $push1=, $0, $pop0{{$}} ; CHECK: i64.atomic.store 0($pop1), $pop2{{$}} define void @store_i64_with_unfolded_gep_offset(i64* %p) { %s = getelementptr i64, i64* %p, i32 3 @@ -298,52 +345,16 @@ define void @store_i64_with_unfolded_gep_offset(i64* %p) { 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.atomic.load $push1=, 42($pop0){{$}} -define i32 @load_i32_from_numeric_address() { - %s = inttoptr i32 42 to i32* - %t = load atomic i32, i32* %s seq_cst, align 4 - ret i32 %t -} - - -; CHECK-LABEL: load_i32_from_global_address -; CHECK: i32.const $push0=, 0{{$}} -; CHECK: i32.atomic.load $push1=, gv($pop0){{$}} -@gv = global i32 0 -define i32 @load_i32_from_global_address() { - %t = load atomic i32, i32* @gv seq_cst, align 4 - 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.atomic.store 42($pop0), $pop1{{$}} -define void @store_i32_to_numeric_address() { - %s = inttoptr i32 42 to i32* - store atomic i32 0, i32* %s seq_cst, align 4 - ret void -} - -; CHECK-LABEL: store_i32_to_global_address: -; CHECK: i32.const $push0=, 0{{$}} -; CHECK: i32.const $push1=, 0{{$}} -; CHECK: i32.atomic.store gv($pop0), $pop1{{$}} -define void @store_i32_to_global_address() { - store atomic i32 0, i32* @gv seq_cst, align 4 - ret void -} +;===---------------------------------------------------------------------------- +; Atomic sign-extending loads +;===---------------------------------------------------------------------------- ; Fold an offset into a sign-extending load. -; CHECK-LABEL: load_i8_s_with_folded_offset: +; CHECK-LABEL: load_i8_i32_s_with_folded_offset: ; CHECK: i32.atomic.load8_u $push0=, 24($0){{$}} ; CHECK-NEXT: i32.extend8_s $push1=, $pop0 -define i32 @load_i8_s_with_folded_offset(i8* %p) { +define i32 @load_i8_i32_s_with_folded_offset(i8* %p) { %q = ptrtoint i8* %p to i32 %r = add nuw i32 %q, 24 %s = inttoptr i32 %r to i8* @@ -352,167 +363,232 @@ define i32 @load_i8_s_with_folded_offset(i8* %p) { ret i32 %u } +; 32->64 sext load gets selected as i32.atomic.load, i64_extend_s/i32 +; CHECK-LABEL: load_i32_i64_s_with_folded_offset: +; CHECK: i32.atomic.load $push0=, 24($0){{$}} +; CHECK-NEXT: i64.extend_s/i32 $push1=, $pop0{{$}} +define i64 @load_i32_i64_s_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 atomic i32, i32* %s seq_cst, align 4 + %u = sext i32 %t to i64 + ret i64 %u +} + ; Fold a gep offset into a sign-extending load. -; CHECK-LABEL: load_i8_s_with_folded_gep_offset: +; CHECK-LABEL: load_i8_i32_s_with_folded_gep_offset: ; CHECK: i32.atomic.load8_u $push0=, 24($0){{$}} ; CHECK-NEXT: i32.extend8_s $push1=, $pop0 -define i32 @load_i8_s_with_folded_gep_offset(i8* %p) { +define i32 @load_i8_i32_s_with_folded_gep_offset(i8* %p) { %s = getelementptr inbounds i8, i8* %p, i32 24 %t = load atomic i8, i8* %s seq_cst, align 1 %u = sext i8 %t to i32 ret i32 %u } -; CHECK-LABEL: load_i16_s_i64_with_folded_gep_offset: -; CHECK: i64.atomic.load16_u $push0=, 6($0){{$}} -define i64 @load_i16_s_i64_with_folded_gep_offset(i16* %p) { - %s = getelementptr inbounds i16, i16* %p, i32 3 +; CHECK-LABEL: load_i16_i32_s_with_folded_gep_offset: +; CHECK: i32.atomic.load16_u $push0=, 48($0){{$}} +; CHECK-NEXT: i32.extend16_s $push1=, $pop0 +define i32 @load_i16_i32_s_with_folded_gep_offset(i16* %p) { + %s = getelementptr inbounds i16, i16* %p, i32 24 %t = load atomic i16, i16* %s seq_cst, align 2 - %u = zext i16 %t to i64 + %u = sext i16 %t to i32 + ret i32 %u +} + +; CHECK-LABEL: load_i16_i64_s_with_folded_gep_offset: +; CHECK: i64.atomic.load16_u $push0=, 48($0){{$}} +; CHECK-NEXT: i64.extend16_s $push1=, $pop0 +define i64 @load_i16_i64_s_with_folded_gep_offset(i16* %p) { + %s = getelementptr inbounds i16, i16* %p, i32 24 + %t = load atomic i16, i16* %s seq_cst, align 2 + %u = sext i16 %t to i64 ret i64 %u } -; CHECK-LABEL: load_i64_with_folded_or_offset: +; 'add' in this code becomes 'or' after DAG optimization. Treat an 'or' node as +; an 'add' if the or'ed bits are known to be zero. + +; CHECK-LABEL: load_i8_i32_s_with_folded_or_offset: +; CHECK: i32.atomic.load8_u $push[[R1:[0-9]+]]=, 2($pop{{[0-9]+}}){{$}} +; CHECK-NEXT: i32.extend8_s $push{{[0-9]+}}=, $pop[[R1]]{{$}} +define i32 @load_i8_i32_s_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 atomic i8, i8* %arrayidx seq_cst, align 1 + %conv = sext i8 %t1 to i32 + ret i32 %conv +} + +; CHECK-LABEL: load_i8_i64_s_with_folded_or_offset: ; CHECK: i64.atomic.load8_u $push[[R1:[0-9]+]]=, 2($pop{{[0-9]+}}){{$}} ; CHECK-NEXT: i64.extend8_s $push{{[0-9]+}}=, $pop[[R1]]{{$}} -define i64 @load_i64_with_folded_or_offset(i32 %x) { +define i64 @load_i8_i64_s_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 atomic i8, i8* %arrayidx seq_cst, align 8 + %t1 = load atomic i8, i8* %arrayidx seq_cst, align 1 %conv = sext i8 %t1 to i64 ret i64 %conv } +; When loading from a fixed address, materialize a zero. + +; CHECK-LABEL: load_i16_i32_s_from_numeric_address +; CHECK: i32.const $push0=, 0{{$}} +; CHECK: i32.atomic.load16_u $push1=, 42($pop0){{$}} +; CHECK-NEXT: i32.extend16_s $push2=, $pop1 +define i32 @load_i16_i32_s_from_numeric_address() { + %s = inttoptr i32 42 to i16* + %t = load atomic i16, i16* %s seq_cst, align 2 + %u = sext i16 %t to i32 + ret i32 %u +} + +; CHECK-LABEL: load_i8_i32_s_from_global_address +; CHECK: i32.const $push0=, 0{{$}} +; CHECK: i32.atomic.load8_u $push1=, gv8($pop0){{$}} +; CHECK-NEXT: i32.extend8_s $push2=, $pop1{{$}} +@gv8 = global i8 0 +define i32 @load_i8_i32_s_from_global_address() { + %t = load atomic i8, i8* @gv8 seq_cst, align 1 + %u = sext i8 %t to i32 + ret i32 %u +} + +;===---------------------------------------------------------------------------- +; Atomic zero-extending loads +;===---------------------------------------------------------------------------- ; Fold an offset into a zero-extending load. -; CHECK-LABEL: load_i16_u_with_folded_offset: -; CHECK: i32.atomic.load16_u $push0=, 24($0){{$}} -define i32 @load_i16_u_with_folded_offset(i8* %p) { +; CHECK-LABEL: load_i8_i32_z_with_folded_offset: +; CHECK: i32.atomic.load8_u $push0=, 24($0){{$}} +define i32 @load_i8_i32_z_with_folded_offset(i8* %p) { %q = ptrtoint i8* %p to i32 %r = add nuw i32 %q, 24 - %s = inttoptr i32 %r to i16* - %t = load atomic i16, i16* %s seq_cst, align 2 - %u = zext i16 %t to i32 + %s = inttoptr i32 %r to i8* + %t = load atomic i8, i8* %s seq_cst, align 1 + %u = zext i8 %t to i32 ret i32 %u } +; CHECK-LABEL: load_i32_i64_z_with_folded_offset: +; CHECK: i64.atomic.load32_u $push0=, 24($0){{$}} +define i64 @load_i32_i64_z_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 atomic i32, i32* %s seq_cst, align 4 + %u = zext i32 %t to i64 + ret i64 %u +} + ; Fold a gep offset into a zero-extending load. -; CHECK-LABEL: load_i8_u_with_folded_gep_offset: +; CHECK-LABEL: load_i8_i32_z_with_folded_gep_offset: ; CHECK: i32.atomic.load8_u $push0=, 24($0){{$}} -define i32 @load_i8_u_with_folded_gep_offset(i8* %p) { +define i32 @load_i8_i32_z_with_folded_gep_offset(i8* %p) { %s = getelementptr inbounds i8, i8* %p, i32 24 %t = load atomic i8, i8* %s seq_cst, align 1 %u = zext i8 %t to i32 ret i32 %u } +; CHECK-LABEL: load_i16_i32_z_with_folded_gep_offset: +; CHECK: i32.atomic.load16_u $push0=, 48($0){{$}} +define i32 @load_i16_i32_z_with_folded_gep_offset(i16* %p) { + %s = getelementptr inbounds i16, i16* %p, i32 24 + %t = load atomic i16, i16* %s seq_cst, align 2 + %u = zext i16 %t to i32 + ret i32 %u +} + +; CHECK-LABEL: load_i16_i64_z_with_folded_gep_offset: +; CHECK: i64.atomic.load16_u $push0=, 48($0){{$}} +define i64 @load_i16_i64_z_with_folded_gep_offset(i16* %p) { + %s = getelementptr inbounds i16, i16* %p, i64 24 + %t = load atomic i16, i16* %s seq_cst, align 2 + %u = zext i16 %t to i64 + ret i64 %u +} + +; 'add' in this code becomes 'or' after DAG optimization. Treat an 'or' node as +; an 'add' if the or'ed bits are known to be zero. + +; CHECK-LABEL: load_i8_i32_z_with_folded_or_offset: +; CHECK: i32.atomic.load8_u $push[[R1:[0-9]+]]=, 2($pop{{[0-9]+}}){{$}} +define i32 @load_i8_i32_z_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 atomic i8, i8* %arrayidx seq_cst, align 1 + %conv = zext i8 %t1 to i32 + ret i32 %conv +} + +; CHECK-LABEL: load_i8_i64_z_with_folded_or_offset: +; CHECK: i64.atomic.load8_u $push[[R1:[0-9]+]]=, 2($pop{{[0-9]+}}){{$}} +define i64 @load_i8_i64_z_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 atomic i8, i8* %arrayidx seq_cst, align 1 + %conv = zext i8 %t1 to i64 + ret i64 %conv +} ; When loading from a fixed address, materialize a zero. -; As above but with extending load. -; CHECK-LABEL: load_zext_i32_from_numeric_address +; CHECK-LABEL: load_i16_i32_z_from_numeric_address ; CHECK: i32.const $push0=, 0{{$}} -; CHECK: i32.atomic.load16_u $push1=, 42($pop0){{$}} -define i32 @load_zext_i32_from_numeric_address() { +; CHECK: i32.atomic.load16_u $push1=, 42($pop0){{$}} +define i32 @load_i16_i32_z_from_numeric_address() { %s = inttoptr i32 42 to i16* %t = load atomic i16, i16* %s seq_cst, align 2 %u = zext i16 %t to i32 ret i32 %u } -; CHECK-LABEL: load_sext_i32_from_global_address +; CHECK-LABEL: load_i8_i32_z_from_global_address ; CHECK: i32.const $push0=, 0{{$}} -; CHECK: i32.atomic.load8_u $push1=, gv8($pop0){{$}} -; CHECK-NEXT: i32.extend8_s $push2=, $pop1{{$}} -@gv8 = global i8 0 -define i32 @load_sext_i32_from_global_address() { +; CHECK: i32.atomic.load8_u $push1=, gv8($pop0){{$}} +define i32 @load_i8_i32_z_from_global_address() { %t = load atomic i8, i8* @gv8 seq_cst, align 1 - %u = sext i8 %t to i32 + %u = zext i8 %t to i32 ret i32 %u } -; Fold an offset into a sign-extending load. -; As above but 32 extended to 64 bit. -; CHECK-LABEL: load_i32_i64_s_with_folded_offset: -; CHECK: i32.atomic.load $push0=, 24($0){{$}} -; CHECK-NEXT: i64.extend_s/i32 $push1=, $pop0{{$}} -define i64 @load_i32_i64_s_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 atomic i32, i32* %s seq_cst, align 4 - %u = sext i32 %t to i64 - ret i64 %u -} - -; Fold a gep offset into a zero-extending load. -; As above but 32 extended to 64 bit. -; CHECK-LABEL: load_i32_i64_u_with_folded_gep_offset: -; CHECK: i64.atomic.load32_u $push0=, 96($0){{$}} -define i64 @load_i32_i64_u_with_folded_gep_offset(i32* %p) { - %s = getelementptr inbounds i32, i32* %p, i32 24 - %t = load atomic i32, i32* %s seq_cst, align 4 - %u = zext i32 %t to i64 - ret i64 %u -} - ; i8 return value should test anyext loads -; CHECK-LABEL: ldi8_a1: -; CHECK: i32.atomic.load8_u $push[[NUM:[0-9]+]]=, 0($0){{$}} -; CHECK-NEXT: return $pop[[NUM]]{{$}} -define i8 @ldi8_a1(i8 *%p) { + +; CHECK-LABEL: load_i8_i32_retvalue: +; CHECK: i32.atomic.load8_u $push0=, 0($0){{$}} +; CHECK-NEXT: return $pop0{{$}} +define i8 @load_i8_i32_retvalue(i8 *%p) { %v = load atomic i8, i8* %p seq_cst, align 1 ret i8 %v } -; Fold an offset into a truncating store. - -; CHECK-LABEL: store_i8_with_folded_offset: -; CHECK: i32.atomic.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 atomic i8 0, i8* %s seq_cst, align 1 - ret void -} +;===---------------------------------------------------------------------------- +; Atomic truncating stores +;===---------------------------------------------------------------------------- -; CHECK-LABEL: store_i16_with_folded_offset: -; CHECK: i32.atomic.store16 24($0), $pop0{{$}} -define void @store_i16_with_folded_offset(i16* %p) { - %q = ptrtoint i16* %p to i32 - %r = add nuw i32 %q, 24 - %s = inttoptr i32 %r to i16* - store atomic i16 0, i16* %s seq_cst, align 2 - ret void -} +; Fold an offset into a truncating store. -; CHECK-LABEL: store_i8_i64_with_folded_offset: -; CHECK: i64.atomic.store8 24($0), $1{{$}} -define void @store_i8_i64_with_folded_offset(i8* %p, i64 %v) { +; CHECK-LABEL: store_i8_i32_with_folded_offset: +; CHECK: i32.atomic.store8 24($0), $1{{$}} +define void @store_i8_i32_with_folded_offset(i8* %p, i32 %v) { %q = ptrtoint i8* %p to i32 %r = add nuw i32 %q, 24 %s = inttoptr i32 %r to i8* - %t = trunc i64 %v to i8 + %t = trunc i32 %v to i8 store atomic i8 %t, i8* %s seq_cst, align 1 ret void } -; CHECK-LABEL: store_i16_i64_with_folded_offset: -; CHECK: i64.atomic.store16 24($0), $1{{$}} -define void @store_i16_i64_with_folded_offset(i16* %p, i64 %v) { - %q = ptrtoint i16* %p to i32 - %r = add nuw i32 %q, 24 - %s = inttoptr i32 %r to i16* - %t = trunc i64 %v to i16 - store atomic i16 %t, i16* %s seq_cst, align 2 - ret void -} - ; CHECK-LABEL: store_i32_i64_with_folded_offset: ; CHECK: i64.atomic.store32 24($0), $1{{$}} define void @store_i32_i64_with_folded_offset(i32* %p, i64 %v) { @@ -526,28 +602,21 @@ define void @store_i32_i64_with_folded_offset(i32* %p, i64 %v) { ; Fold a gep offset into a truncating store. -; CHECK-LABEL: store_i8_with_folded_gep_offset: -; CHECK: i32.atomic.store8 24($0), $pop0{{$}} -define void @store_i8_with_folded_gep_offset(i8* %p) { +; CHECK-LABEL: store_i8_i32_with_folded_gep_offset: +; CHECK: i32.atomic.store8 24($0), $1{{$}} +define void @store_i8_i32_with_folded_gep_offset(i8* %p, i32 %v) { %s = getelementptr inbounds i8, i8* %p, i32 24 - store atomic i8 0, i8* %s seq_cst, align 1 + %t = trunc i32 %v to i8 + store atomic i8 %t, i8* %s seq_cst, align 1 ret void } -; CHECK-LABEL: store_i16_with_folded_gep_offset: -; CHECK: i32.atomic.store16 48($0), $pop0{{$}} -define void @store_i16_with_folded_gep_offset(i16* %p) { +; CHECK-LABEL: store_i16_i32_with_folded_gep_offset: +; CHECK: i32.atomic.store16 48($0), $1{{$}} +define void @store_i16_i32_with_folded_gep_offset(i16* %p, i32 %v) { %s = getelementptr inbounds i16, i16* %p, i32 24 - store atomic i16 0, i16* %s seq_cst, align 2 - ret void -} - -; CHECK-LABEL: store_i8_i64_with_folded_gep_offset: -; CHECK: i64.atomic.store8 24($0), $1{{$}} -define void @store_i8_i64_with_folded_gep_offset(i8* %p, i64 %v) { - %s = getelementptr inbounds i8, i8* %p, i32 24 - %t = trunc i64 %v to i8 - store atomic i8 %t, i8* %s seq_cst, align 2 + %t = trunc i32 %v to i16 + store atomic i16 %t, i16* %s seq_cst, align 2 ret void } @@ -560,34 +629,17 @@ define void @store_i16_i64_with_folded_gep_offset(i16* %p, i64 %v) { ret void } -; CHECK-LABEL: store_i32_i64_with_folded_gep_offset: -; CHECK: i64.atomic.store32 96($0), $1{{$}} -define void @store_i32_i64_with_folded_gep_offset(i32* %p, i64 %v) { - %s = getelementptr inbounds i32, i32* %p, i32 24 - %t = trunc i64 %v to i32 - store atomic i32 %t, i32* %s seq_cst, align 4 - ret void -} - -; Fold an or_is_add pattern based offset into a truncating store. +; 'add' in this code becomes 'or' after DAG optimization. Treat an 'or' node as +; an 'add' if the or'ed bits are known to be zero. -; CHECK-LABEL: store_i8_with_folded_or_offset: -; CHECK: i32.atomic.store8 2($pop{{[0-9]+}}), $pop{{[0-9]+}}{{$}} -define void @store_i8_with_folded_or_offset(i32 %x) { +; CHECK-LABEL: store_i8_i32_with_folded_or_offset: +; CHECK: i32.atomic.store8 2($pop{{[0-9]+}}), $1{{$}} +define void @store_i8_i32_with_folded_or_offset(i32 %x, i32 %v) { %and = and i32 %x, -4 %p = inttoptr i32 %and to i8* %arrayidx = getelementptr inbounds i8, i8* %p, i32 2 - store atomic i8 0, i8* %arrayidx seq_cst, align 1 - ret void -} - -; CHECK-LABEL: store_i16_with_folded_or_offset: -; CHECK: i32.atomic.store16 4($pop{{[0-9]+}}), $pop{{[0-9]+}}{{$}} -define void @store_i16_with_folded_or_offset(i32 %x) { - %and = and i32 %x, -4 - %p = inttoptr i32 %and to i16* - %arrayidx = getelementptr inbounds i16, i16* %p, i32 2 - store atomic i16 0, i16* %arrayidx seq_cst, align 2 + %t = trunc i32 %v to i8 + store atomic i8 %t, i8* %arrayidx seq_cst, align 1 ret void } @@ -601,25 +653,3 @@ define void @store_i8_i64_with_folded_or_offset(i32 %x, i64 %v) { store atomic i8 %t, i8* %arrayidx seq_cst, align 1 ret void } - -; CHECK-LABEL: store_i16_i64_with_folded_or_offset: -; CHECK: i64.atomic.store16 4($pop{{[0-9]+}}), $1{{$}} -define void @store_i16_i64_with_folded_or_offset(i32 %x, i64 %v) { - %and = and i32 %x, -4 - %p = inttoptr i32 %and to i16* - %arrayidx = getelementptr inbounds i16, i16* %p, i32 2 - %t = trunc i64 %v to i16 - store atomic i16 %t, i16* %arrayidx seq_cst, align 2 - ret void -} - -; CHECK-LABEL: store_i32_i64_with_folded_or_offset: -; CHECK: i64.atomic.store32 8($pop{{[0-9]+}}), $1{{$}} -define void @store_i32_i64_with_folded_or_offset(i32 %x, i64 %v) { - %and = and i32 %x, -4 - %p = inttoptr i32 %and to i32* - %arrayidx = getelementptr inbounds i32, i32* %p, i32 2 - %t = trunc i64 %v to i32 - store atomic i32 %t, i32* %arrayidx seq_cst, align 4 - ret void -} diff --git a/llvm/test/CodeGen/WebAssembly/offset.ll b/llvm/test/CodeGen/WebAssembly/offset.ll index 125fdd7d80f..d2e5ca2ddd5 100644 --- a/llvm/test/CodeGen/WebAssembly/offset.ll +++ b/llvm/test/CodeGen/WebAssembly/offset.ll @@ -1,10 +1,24 @@ -; RUN: llc < %s -asm-verbose=false -disable-wasm-explicit-locals | FileCheck %s +; RUN: llc < %s -asm-verbose=false -disable-wasm-explicit-locals -disable-wasm-fallthrough-return-opt | 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" +;===---------------------------------------------------------------------------- +; Loads: 32-bit +;===---------------------------------------------------------------------------- + +; Basic load. + +; CHECK-LABEL: load_i32_no_offset: +; CHECK: i32.load $push0=, 0($0){{$}} +; CHECK-NEXT: return $pop0{{$}} +define i32 @load_i32_no_offset(i32 *%p) { + %v = load i32, i32* %p + ret i32 %v +} + ; With an nuw add, we can fold an offset. ; CHECK-LABEL: load_i32_with_folded_offset: @@ -65,7 +79,41 @@ define i32 @load_i32_with_unfolded_gep_offset(i32* %p) { ret i32 %t } -; Same as above but with i64. +; 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 +} + +;===---------------------------------------------------------------------------- +; Loads: 64-bit +;===---------------------------------------------------------------------------- + +; Basic load. + +; CHECK-LABEL: load_i64_no_offset: +; CHECK: i64.load $push0=, 0($0){{$}} +; CHECK-NEXT: return $pop0{{$}} +define i64 @load_i64_no_offset(i64 *%p) { + %v = load i64, i64* %p + ret i64 %v +} + +; With an nuw add, we can fold an offset. ; CHECK-LABEL: load_i64_with_folded_offset: ; CHECK: i64.load $push0=, 24($0){{$}} @@ -77,7 +125,7 @@ define i64 @load_i64_with_folded_offset(i64* %p) { ret i64 %t } -; Same as above but with i64. +; With an inbounds gep, we can fold an offset. ; CHECK-LABEL: load_i64_with_folded_gep_offset: ; CHECK: i64.load $push0=, 24($0){{$}} @@ -87,7 +135,7 @@ define i64 @load_i64_with_folded_gep_offset(i64* %p) { ret i64 %t } -; Same as above but with i64. +; We can't fold a negative offset though, even with an inbounds gep. ; CHECK-LABEL: load_i64_with_unfolded_gep_negative_offset: ; CHECK: i32.const $push0=, -24{{$}} @@ -99,7 +147,7 @@ define i64 @load_i64_with_unfolded_gep_negative_offset(i64* %p) { ret i64 %t } -; Same as above but with i64. +; Without nuw, and even with nsw, we can't fold an offset. ; CHECK-LABEL: load_i64_with_unfolded_offset: ; CHECK: i32.const $push0=, 24{{$}} @@ -113,7 +161,7 @@ define i64 @load_i64_with_unfolded_offset(i64* %p) { ret i64 %t } -; Same as above but with i64. +; Without inbounds, we can't fold a gep offset. ; CHECK-LABEL: load_i64_with_unfolded_gep_offset: ; CHECK: i32.const $push0=, 24{{$}} @@ -125,18 +173,22 @@ define i64 @load_i64_with_unfolded_gep_offset(i64* %p) { 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 +;===---------------------------------------------------------------------------- +; Stores: 32-bit +;===---------------------------------------------------------------------------- + +; Basic store. + +; CHECK-LABEL: store_i32_no_offset: +; CHECK-NEXT: .param i32, i32{{$}} +; CHECK-NEXT: i32.store 0($0), $1{{$}} +; CHECK-NEXT: return{{$}} +define void @store_i32_no_offset(i32 *%p, i32 %v) { + store i32 %v, i32* %p + ret void } -; Same as above but with store. +; With an nuw add, we can fold an offset. ; CHECK-LABEL: store_i32_with_folded_offset: ; CHECK: i32.store 24($0), $pop0{{$}} @@ -148,7 +200,7 @@ define void @store_i32_with_folded_offset(i32* %p) { ret void } -; Same as above but with store. +; With an inbounds gep, we can fold an offset. ; CHECK-LABEL: store_i32_with_folded_gep_offset: ; CHECK: i32.store 24($0), $pop0{{$}} @@ -158,7 +210,7 @@ define void @store_i32_with_folded_gep_offset(i32* %p) { ret void } -; Same as above but with store. +; We can't fold a negative offset though, even with an inbounds gep. ; CHECK-LABEL: store_i32_with_unfolded_gep_negative_offset: ; CHECK: i32.const $push0=, -24{{$}} @@ -170,7 +222,7 @@ define void @store_i32_with_unfolded_gep_negative_offset(i32* %p) { ret void } -; Same as above but with store. +; Without nuw, and even with nsw, we can't fold an offset. ; CHECK-LABEL: store_i32_with_unfolded_offset: ; CHECK: i32.const $push0=, 24{{$}} @@ -184,7 +236,7 @@ define void @store_i32_with_unfolded_offset(i32* %p) { ret void } -; Same as above but with store. +; Without inbounds, we can't fold a gep offset. ; CHECK-LABEL: store_i32_with_unfolded_gep_offset: ; CHECK: i32.const $push0=, 24{{$}} @@ -196,7 +248,32 @@ define void @store_i32_with_unfolded_gep_offset(i32* %p) { ret void } -; Same as above but with store with i64. +; When storing from a fixed address, materialize a zero. + +; 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 +} + +;===---------------------------------------------------------------------------- +; Stores: 64-bit +;===---------------------------------------------------------------------------- + +; Basic store. ; CHECK-LABEL: store_i64_with_folded_offset: ; CHECK: i64.store 24($0), $pop0{{$}} @@ -208,7 +285,7 @@ define void @store_i64_with_folded_offset(i64* %p) { ret void } -; Same as above but with store with i64. +; With an nuw add, we can fold an offset. ; CHECK-LABEL: store_i64_with_folded_gep_offset: ; CHECK: i64.store 24($0), $pop0{{$}} @@ -218,7 +295,7 @@ define void @store_i64_with_folded_gep_offset(i64* %p) { ret void } -; Same as above but with store with i64. +; With an inbounds gep, we can fold an offset. ; CHECK-LABEL: store_i64_with_unfolded_gep_negative_offset: ; CHECK: i32.const $push0=, -24{{$}} @@ -230,7 +307,7 @@ define void @store_i64_with_unfolded_gep_negative_offset(i64* %p) { ret void } -; Same as above but with store with i64. +; We can't fold a negative offset though, even with an inbounds gep. ; CHECK-LABEL: store_i64_with_unfolded_offset: ; CHECK: i32.const $push0=, 24{{$}} @@ -244,7 +321,7 @@ define void @store_i64_with_unfolded_offset(i64* %p) { ret void } -; Same as above but with store with i64. +; Without nuw, and even with nsw, we can't fold an offset. ; CHECK-LABEL: store_i64_with_unfolded_gep_offset: ; CHECK: i32.const $push0=, 24{{$}} @@ -256,6 +333,8 @@ define void @store_i64_with_unfolded_gep_offset(i64* %p) { ret void } +; Without inbounds, we can't fold a gep offset. + ; 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) { @@ -266,50 +345,15 @@ define void @store_i32_with_folded_or_offset(i32 %x) { 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 -} +;===---------------------------------------------------------------------------- +; Sign-extending loads +;===---------------------------------------------------------------------------- ; Fold an offset into a sign-extending load. -; CHECK-LABEL: load_i8_s_with_folded_offset: +; CHECK-LABEL: load_i8_i32_s_with_folded_offset: ; CHECK: i32.load8_s $push0=, 24($0){{$}} -define i32 @load_i8_s_with_folded_offset(i8* %p) { +define i32 @load_i8_i32_s_with_folded_offset(i8* %p) { %q = ptrtoint i8* %p to i32 %r = add nuw i32 %q, 24 %s = inttoptr i32 %r to i8* @@ -318,22 +362,102 @@ define i32 @load_i8_s_with_folded_offset(i8* %p) { ret i32 %u } +; CHECK-LABEL: load_i32_i64_s_with_folded_offset: +; CHECK: i64.load32_s $push0=, 24($0){{$}} +define i64 @load_i32_i64_s_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 + %u = sext i32 %t to i64 + ret i64 %u +} + ; Fold a gep offset into a sign-extending load. -; CHECK-LABEL: load_i8_s_with_folded_gep_offset: +; CHECK-LABEL: load_i8_i32_s_with_folded_gep_offset: ; CHECK: i32.load8_s $push0=, 24($0){{$}} -define i32 @load_i8_s_with_folded_gep_offset(i8* %p) { +define i32 @load_i8_i32_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 } +; CHECK-LABEL: load_i16_i32_s_with_folded_gep_offset: +; CHECK: i32.load16_s $push0=, 48($0){{$}} +define i32 @load_i16_i32_s_with_folded_gep_offset(i16* %p) { + %s = getelementptr inbounds i16, i16* %p, i32 24 + %t = load i16, i16* %s + %u = sext i16 %t to i32 + ret i32 %u +} + +; CHECK-LABEL: load_i16_i64_s_with_folded_gep_offset: +; CHECK: i64.load16_s $push0=, 48($0){{$}} +define i64 @load_i16_i64_s_with_folded_gep_offset(i16* %p) { + %s = getelementptr inbounds i16, i16* %p, i32 24 + %t = load i16, i16* %s + %u = sext i16 %t to i64 + ret i64 %u +} + +; 'add' in this code becomes 'or' after DAG optimization. Treat an 'or' node as +; an 'add' if the or'ed bits are known to be zero. + +; CHECK-LABEL: load_i8_i32_s_with_folded_or_offset: +; CHECK: i32.load8_s $push{{[0-9]+}}=, 2($pop{{[0-9]+}}){{$}} +define i32 @load_i8_i32_s_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 + %conv = sext i8 %t1 to i32 + ret i32 %conv +} + +; CHECK-LABEL: load_i8_i64_s_with_folded_or_offset: +; CHECK: i64.load8_s $push{{[0-9]+}}=, 2($pop{{[0-9]+}}){{$}} +define i64 @load_i8_i64_s_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 + %conv = sext i8 %t1 to i64 + ret i64 %conv +} + +; When loading from a fixed address, materialize a zero. + +; CHECK-LABEL: load_i16_i32_s_from_numeric_address +; CHECK: i32.const $push0=, 0{{$}} +; CHECK: i32.load16_s $push1=, 42($pop0){{$}} +define i32 @load_i16_i32_s_from_numeric_address() { + %s = inttoptr i32 42 to i16* + %t = load i16, i16* %s + %u = sext i16 %t to i32 + ret i32 %u +} + +; CHECK-LABEL: load_i8_i32_s_from_global_address +; CHECK: i32.const $push0=, 0{{$}} +; CHECK: i32.load8_s $push1=, gv8($pop0){{$}} +@gv8 = global i8 0 +define i32 @load_i8_i32_s_from_global_address() { + %t = load i8, i8* @gv8 + %u = sext i8 %t to i32 + ret i32 %u +} + +;===---------------------------------------------------------------------------- +; Zero-extending loads +;===---------------------------------------------------------------------------- + ; Fold an offset into a zero-extending load. -; CHECK-LABEL: load_i8_u_with_folded_offset: +; CHECK-LABEL: load_i8_i32_z_with_folded_offset: ; CHECK: i32.load8_u $push0=, 24($0){{$}} -define i32 @load_i8_u_with_folded_offset(i8* %p) { +define i32 @load_i8_i32_z_with_folded_offset(i8* %p) { %q = ptrtoint i8* %p to i32 %r = add nuw i32 %q, 24 %s = inttoptr i32 %r to i8* @@ -342,39 +466,162 @@ define i32 @load_i8_u_with_folded_offset(i8* %p) { ret i32 %u } +; CHECK-LABEL: load_i32_i64_z_with_folded_offset: +; CHECK: i64.load32_u $push0=, 24($0){{$}} +define i64 @load_i32_i64_z_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 + %u = zext i32 %t to i64 + ret i64 %u +} + ; Fold a gep offset into a zero-extending load. -; CHECK-LABEL: load_i8_u_with_folded_gep_offset: +; CHECK-LABEL: load_i8_i32_z_with_folded_gep_offset: ; CHECK: i32.load8_u $push0=, 24($0){{$}} -define i32 @load_i8_u_with_folded_gep_offset(i8* %p) { +define i32 @load_i8_i32_z_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 } +; CHECK-LABEL: load_i16_i32_z_with_folded_gep_offset: +; CHECK: i32.load16_u $push0=, 48($0){{$}} +define i32 @load_i16_i32_z_with_folded_gep_offset(i16* %p) { + %s = getelementptr inbounds i16, i16* %p, i32 24 + %t = load i16, i16* %s + %u = zext i16 %t to i32 + ret i32 %u +} + +; CHECK-LABEL: load_i16_i64_z_with_folded_gep_offset: +; CHECK: i64.load16_u $push0=, 48($0){{$}} +define i64 @load_i16_i64_z_with_folded_gep_offset(i16* %p) { + %s = getelementptr inbounds i16, i16* %p, i64 24 + %t = load i16, i16* %s + %u = zext i16 %t to i64 + ret i64 %u +} + +; When loading from a fixed address, materialize a zero. + +; CHECK-LABEL: load_i16_i32_z_from_numeric_address +; CHECK: i32.const $push0=, 0{{$}} +; CHECK: i32.load16_u $push1=, 42($pop0){{$}} +define i32 @load_i16_i32_z_from_numeric_address() { + %s = inttoptr i32 42 to i16* + %t = load i16, i16* %s + %u = zext i16 %t to i32 + ret i32 %u +} + +; CHECK-LABEL: load_i8_i32_z_from_global_address +; CHECK: i32.const $push0=, 0{{$}} +; CHECK: i32.load8_u $push1=, gv8($pop0){{$}} +define i32 @load_i8_i32_z_from_global_address() { + %t = load i8, i8* @gv8 + %u = zext i8 %t to i32 + ret i32 %u +} + +; i8 return value should test anyext loads +; CHECK-LABEL: load_i8_i32_retvalue: +; CHECK: i32.load8_u $push[[NUM:[0-9]+]]=, 0($0){{$}} +; CHECK-NEXT: return $pop[[NUM]]{{$}} +define i8 @load_i8_i32_retvalue(i8 *%p) { + %v = load i8, i8* %p + ret i8 %v +} + +;===---------------------------------------------------------------------------- +; Truncating stores +;===---------------------------------------------------------------------------- + ; 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) { +; CHECK-LABEL: store_i8_i32_with_folded_offset: +; CHECK: i32.store8 24($0), $1{{$}} +define void @store_i8_i32_with_folded_offset(i8* %p, i32 %v) { %q = ptrtoint i8* %p to i32 %r = add nuw i32 %q, 24 %s = inttoptr i32 %r to i8* - store i8 0, i8* %s + %t = trunc i32 %v to i8 + store i8 %t, i8* %s + ret void +} + +; CHECK-LABEL: store_i32_i64_with_folded_offset: +; CHECK: i64.store32 24($0), $1{{$}} +define void @store_i32_i64_with_folded_offset(i32* %p, i64 %v) { + %q = ptrtoint i32* %p to i32 + %r = add nuw i32 %q, 24 + %s = inttoptr i32 %r to i32* + %t = trunc i64 %v to i32 + store i32 %t, i32* %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) { +; CHECK-LABEL: store_i8_i32_with_folded_gep_offset: +; CHECK: i32.store8 24($0), $1{{$}} +define void @store_i8_i32_with_folded_gep_offset(i8* %p, i32 %v) { %s = getelementptr inbounds i8, i8* %p, i32 24 - store i8 0, i8* %s + %t = trunc i32 %v to i8 + store i8 %t, i8* %s + ret void +} + +; CHECK-LABEL: store_i16_i32_with_folded_gep_offset: +; CHECK: i32.store16 48($0), $1{{$}} +define void @store_i16_i32_with_folded_gep_offset(i16* %p, i32 %v) { + %s = getelementptr inbounds i16, i16* %p, i32 24 + %t = trunc i32 %v to i16 + store i16 %t, i16* %s + ret void +} + +; CHECK-LABEL: store_i16_i64_with_folded_gep_offset: +; CHECK: i64.store16 48($0), $1{{$}} +define void @store_i16_i64_with_folded_gep_offset(i16* %p, i64 %v) { + %s = getelementptr inbounds i16, i16* %p, i64 24 + %t = trunc i64 %v to i16 + store i16 %t, i16* %s + ret void +} + +; 'add' in this code becomes 'or' after DAG optimization. Treat an 'or' node as +; an 'add' if the or'ed bits are known to be zero. + +; CHECK-LABEL: store_i8_i32_with_folded_or_offset: +; CHECK: i32.store8 2($pop{{[0-9]+}}), $1{{$}} +define void @store_i8_i32_with_folded_or_offset(i32 %x, i32 %v) { + %and = and i32 %x, -4 + %p = inttoptr i32 %and to i8* + %arrayidx = getelementptr inbounds i8, i8* %p, i32 2 + %t = trunc i32 %v to i8 + store i8 %t, i8* %arrayidx + ret void +} + +; CHECK-LABEL: store_i8_i64_with_folded_or_offset: +; CHECK: i64.store8 2($pop{{[0-9]+}}), $1{{$}} +define void @store_i8_i64_with_folded_or_offset(i32 %x, i64 %v) { + %and = and i32 %x, -4 + %p = inttoptr i32 %and to i8* + %arrayidx = getelementptr inbounds i8, i8* %p, i32 2 + %t = trunc i64 %v to i8 + store i8 %t, i8* %arrayidx ret void } +;===---------------------------------------------------------------------------- +; Aggregate values +;===---------------------------------------------------------------------------- + ; Fold the offsets when lowering aggregate loads and stores. ; CHECK-LABEL: aggregate_load_store: |
