summaryrefslogtreecommitdiffstats
path: root/llvm/test
diff options
context:
space:
mode:
Diffstat (limited to 'llvm/test')
-rw-r--r--llvm/test/CodeGen/WebAssembly/i32-load-store-alignment.ll33
-rw-r--r--llvm/test/CodeGen/WebAssembly/i64-load-store-alignment.ll27
-rw-r--r--llvm/test/CodeGen/WebAssembly/offset-atomics.ll542
-rw-r--r--llvm/test/CodeGen/WebAssembly/offset.ll405
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:
OpenPOWER on IntegriCloud