| ; RUN: not --crash llc > /dev/null < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt |
| ; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -wasm-disable-explicit-locals -wasm-keep-registers -mattr=+atomics,+sign-ext | FileCheck %s |
| |
| ; Test that atomic loads are assembled properly. |
| |
| target triple = "wasm32-unknown-unknown" |
| |
| ;===---------------------------------------------------------------------------- |
| ; Atomic loads: 32-bit |
| ;===---------------------------------------------------------------------------- |
| |
| ; Basic load. |
| |
| ; CHECK-LABEL: load_i32_no_offset: |
| ; CHECK: i32.atomic.load $push0=, 0($0){{$}} |
| ; CHECK-NEXT: return $pop0{{$}} |
| define i32 @load_i32_no_offset(ptr %p) { |
| %v = load atomic i32, ptr %p seq_cst, align 4 |
| ret i32 %v |
| } |
| |
| ; With an nuw add, we can fold an offset. |
| |
| ; CHECK-LABEL: load_i32_with_folded_offset: |
| ; CHECK: i32.atomic.load $push0=, 24($0){{$}} |
| define i32 @load_i32_with_folded_offset(ptr %p) { |
| %q = ptrtoint ptr %p to i32 |
| %r = add nuw i32 %q, 24 |
| %s = inttoptr i32 %r to ptr |
| %t = load atomic i32, ptr %s seq_cst, align 4 |
| ret i32 %t |
| } |
| |
| ; With an inbounds gep, we can fold an offset. |
| |
| ; CHECK-LABEL: load_i32_with_folded_gep_offset: |
| ; CHECK: i32.atomic.load $push0=, 24($0){{$}} |
| define i32 @load_i32_with_folded_gep_offset(ptr %p) { |
| %s = getelementptr inbounds i32, ptr %p, i32 6 |
| %t = load atomic i32, ptr %s seq_cst, align 4 |
| ret i32 %t |
| } |
| |
| ; We can't fold a negative offset though, even with an inbounds gep. |
| |
| ; CHECK-LABEL: load_i32_with_unfolded_gep_negative_offset: |
| ; CHECK: i32.const $push0=, -24{{$}} |
| ; CHECK: i32.add $push1=, $0, $pop0{{$}} |
| ; CHECK: i32.atomic.load $push2=, 0($pop1){{$}} |
| define i32 @load_i32_with_unfolded_gep_negative_offset(ptr %p) { |
| %s = getelementptr inbounds i32, ptr %p, i32 -6 |
| %t = load atomic i32, ptr %s seq_cst, align 4 |
| ret i32 %t |
| } |
| |
| ; Without nuw, and even with nsw, we can't fold an offset. |
| |
| ; CHECK-LABEL: load_i32_with_unfolded_offset: |
| ; CHECK: i32.const $push0=, 24{{$}} |
| ; CHECK: i32.add $push1=, $0, $pop0{{$}} |
| ; CHECK: i32.atomic.load $push2=, 0($pop1){{$}} |
| define i32 @load_i32_with_unfolded_offset(ptr %p) { |
| %q = ptrtoint ptr %p to i32 |
| %r = add nsw i32 %q, 24 |
| %s = inttoptr i32 %r to ptr |
| %t = load atomic i32, ptr %s seq_cst, align 4 |
| ret i32 %t |
| } |
| |
| ; Without inbounds, we can't fold a gep offset. |
| |
| ; CHECK-LABEL: load_i32_with_unfolded_gep_offset: |
| ; CHECK: i32.const $push0=, 24{{$}} |
| ; CHECK: i32.add $push1=, $0, $pop0{{$}} |
| ; CHECK: i32.atomic.load $push2=, 0($pop1){{$}} |
| define i32 @load_i32_with_unfolded_gep_offset(ptr %p) { |
| %s = getelementptr i32, ptr %p, i32 6 |
| %t = load atomic i32, ptr %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 ptr |
| %t = load atomic i32, ptr %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, ptr @gv seq_cst, align 4 |
| ret i32 %t |
| } |
| |
| ;===---------------------------------------------------------------------------- |
| ; Atomic loads: 64-bit |
| ;===---------------------------------------------------------------------------- |
| |
| ; Basic load. |
| |
| ; CHECK-LABEL: load_i64_no_offset: |
| ; CHECK: i64.atomic.load $push0=, 0($0){{$}} |
| ; CHECK-NEXT: return $pop0{{$}} |
| define i64 @load_i64_no_offset(ptr %p) { |
| %v = load atomic i64, ptr %p seq_cst, align 8 |
| ret i64 %v |
| } |
| |
| ; With an nuw add, we can fold an offset. |
| |
| ; CHECK-LABEL: load_i64_with_folded_offset: |
| ; CHECK: i64.atomic.load $push0=, 24($0){{$}} |
| define i64 @load_i64_with_folded_offset(ptr %p) { |
| %q = ptrtoint ptr %p to i32 |
| %r = add nuw i32 %q, 24 |
| %s = inttoptr i32 %r to ptr |
| %t = load atomic i64, ptr %s seq_cst, align 8 |
| ret i64 %t |
| } |
| |
| ; With an inbounds gep, we can fold an offset. |
| |
| ; CHECK-LABEL: load_i64_with_folded_gep_offset: |
| ; CHECK: i64.atomic.load $push0=, 24($0){{$}} |
| define i64 @load_i64_with_folded_gep_offset(ptr %p) { |
| %s = getelementptr inbounds i64, ptr %p, i32 3 |
| %t = load atomic i64, ptr %s seq_cst, align 8 |
| ret i64 %t |
| } |
| |
| ; 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){{$}} |
| define i64 @load_i64_with_unfolded_gep_negative_offset(ptr %p) { |
| %s = getelementptr inbounds i64, ptr %p, i32 -3 |
| %t = load atomic i64, ptr %s seq_cst, align 8 |
| ret i64 %t |
| } |
| |
| ; 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){{$}} |
| define i64 @load_i64_with_unfolded_offset(ptr %p) { |
| %q = ptrtoint ptr %p to i32 |
| %r = add nsw i32 %q, 24 |
| %s = inttoptr i32 %r to ptr |
| %t = load atomic i64, ptr %s seq_cst, align 8 |
| ret i64 %t |
| } |
| |
| ; 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){{$}} |
| define i64 @load_i64_with_unfolded_gep_offset(ptr %p) { |
| %s = getelementptr i64, ptr %p, i32 3 |
| %t = load atomic i64, ptr %s seq_cst, align 8 |
| ret i64 %t |
| } |
| |
| ;===---------------------------------------------------------------------------- |
| ; Atomic stores: 32-bit |
| ;===---------------------------------------------------------------------------- |
| |
| ; Basic store. |
| |
| ; CHECK-LABEL: store_i32_no_offset: |
| ; CHECK-NEXT: .functype store_i32_no_offset (i32, i32) -> (){{$}} |
| ; CHECK-NEXT: i32.atomic.store 0($0), $1{{$}} |
| ; CHECK-NEXT: return{{$}} |
| define void @store_i32_no_offset(ptr %p, i32 %v) { |
| store atomic i32 %v, ptr %p seq_cst, align 4 |
| ret void |
| } |
| |
| ; With an nuw add, we can fold an offset. |
| |
| ; CHECK-LABEL: store_i32_with_folded_offset: |
| ; CHECK: i32.atomic.store 24($0), $pop0{{$}} |
| define void @store_i32_with_folded_offset(ptr %p) { |
| %q = ptrtoint ptr %p to i32 |
| %r = add nuw i32 %q, 24 |
| %s = inttoptr i32 %r to ptr |
| store atomic i32 0, ptr %s seq_cst, align 4 |
| ret void |
| } |
| |
| ; With an inbounds gep, we can fold an offset. |
| |
| ; CHECK-LABEL: store_i32_with_folded_gep_offset: |
| ; CHECK: i32.atomic.store 24($0), $pop0{{$}} |
| define void @store_i32_with_folded_gep_offset(ptr %p) { |
| %s = getelementptr inbounds i32, ptr %p, i32 6 |
| store atomic i32 0, ptr %s seq_cst, align 4 |
| ret void |
| } |
| |
| ; 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.atomic.store 0($pop1), $pop2{{$}} |
| define void @store_i32_with_unfolded_gep_negative_offset(ptr %p) { |
| %s = getelementptr inbounds i32, ptr %p, i32 -6 |
| store atomic i32 0, ptr %s seq_cst, align 4 |
| ret void |
| } |
| |
| ; 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.atomic.store 0($pop1), $pop2{{$}} |
| define void @store_i32_with_unfolded_offset(ptr %p) { |
| %q = ptrtoint ptr %p to i32 |
| %r = add nsw i32 %q, 24 |
| %s = inttoptr i32 %r to ptr |
| store atomic i32 0, ptr %s seq_cst, align 4 |
| ret void |
| } |
| |
| ; 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.atomic.store 0($pop1), $pop2{{$}} |
| define void @store_i32_with_unfolded_gep_offset(ptr %p) { |
| %s = getelementptr i32, ptr %p, i32 6 |
| store atomic i32 0, ptr %s seq_cst, align 4 |
| ret void |
| } |
| |
| ; When storing from a fixed address, materialize a zero. |
| |
| ; CHECK-LABEL: store_i32_to_numeric_address: |
| ; CHECK: 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 ptr |
| store atomic i32 0, ptr %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, ptr @gv seq_cst, align 4 |
| ret void |
| } |
| |
| ;===---------------------------------------------------------------------------- |
| ; Atomic stores: 64-bit |
| ;===---------------------------------------------------------------------------- |
| |
| ; Basic store. |
| |
| ; CHECK-LABEL: store_i64_no_offset: |
| ; CHECK-NEXT: .functype store_i64_no_offset (i32, i64) -> (){{$}} |
| ; CHECK-NEXT: i64.atomic.store 0($0), $1{{$}} |
| ; CHECK-NEXT: return{{$}} |
| define void @store_i64_no_offset(ptr %p, i64 %v) { |
| store atomic i64 %v, ptr %p seq_cst, align 8 |
| ret void |
| } |
| |
| ; With an nuw add, we can fold an offset. |
| |
| ; CHECK-LABEL: store_i64_with_folded_offset: |
| ; CHECK: i64.atomic.store 24($0), $pop0{{$}} |
| define void @store_i64_with_folded_offset(ptr %p) { |
| %q = ptrtoint ptr %p to i32 |
| %r = add nuw i32 %q, 24 |
| %s = inttoptr i32 %r to ptr |
| store atomic i64 0, ptr %s seq_cst, align 8 |
| ret void |
| } |
| |
| ; With an inbounds gep, we can fold an offset. |
| |
| ; CHECK-LABEL: store_i64_with_folded_gep_offset: |
| ; CHECK: i64.atomic.store 24($0), $pop0{{$}} |
| define void @store_i64_with_folded_gep_offset(ptr %p) { |
| %s = getelementptr inbounds i64, ptr %p, i32 3 |
| store atomic i64 0, ptr %s seq_cst, align 8 |
| ret void |
| } |
| |
| ; 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: i64.atomic.store 0($pop1), $pop2{{$}} |
| define void @store_i64_with_unfolded_gep_negative_offset(ptr %p) { |
| %s = getelementptr inbounds i64, ptr %p, i32 -3 |
| store atomic i64 0, ptr %s seq_cst, align 8 |
| ret void |
| } |
| |
| ; 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: i64.atomic.store 0($pop1), $pop2{{$}} |
| define void @store_i64_with_unfolded_offset(ptr %p) { |
| %q = ptrtoint ptr %p to i32 |
| %r = add nsw i32 %q, 24 |
| %s = inttoptr i32 %r to ptr |
| store atomic i64 0, ptr %s seq_cst, align 8 |
| ret void |
| } |
| |
| ; 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: i64.atomic.store 0($pop1), $pop2{{$}} |
| define void @store_i64_with_unfolded_gep_offset(ptr %p) { |
| %s = getelementptr i64, ptr %p, i32 3 |
| store atomic i64 0, ptr %s seq_cst, align 8 |
| ret void |
| } |
| |
| ;===---------------------------------------------------------------------------- |
| ; Atomic sign-extending loads |
| ;===---------------------------------------------------------------------------- |
| |
| ; Fold an offset into a sign-extending load. |
| |
| ; 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_i32_s_with_folded_offset(ptr %p) { |
| %q = ptrtoint ptr %p to i32 |
| %r = add nuw i32 %q, 24 |
| %s = inttoptr i32 %r to ptr |
| %t = load atomic i8, ptr %s seq_cst, align 1 |
| %u = sext i8 %t to i32 |
| ret i32 %u |
| } |
| |
| ; 32->64 sext load gets selected as i32.atomic.load, i64.extend_i32_s |
| ; CHECK-LABEL: load_i32_i64_s_with_folded_offset: |
| ; CHECK: i32.atomic.load $push0=, 24($0){{$}} |
| ; CHECK-NEXT: i64.extend_i32_s $push1=, $pop0{{$}} |
| define i64 @load_i32_i64_s_with_folded_offset(ptr %p) { |
| %q = ptrtoint ptr %p to i32 |
| %r = add nuw i32 %q, 24 |
| %s = inttoptr i32 %r to ptr |
| %t = load atomic i32, ptr %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_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_i32_s_with_folded_gep_offset(ptr %p) { |
| %s = getelementptr inbounds i8, ptr %p, i32 24 |
| %t = load atomic i8, ptr %s seq_cst, align 1 |
| %u = sext i8 %t to i32 |
| ret i32 %u |
| } |
| |
| ; 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(ptr %p) { |
| %s = getelementptr inbounds i16, ptr %p, i32 24 |
| %t = load atomic i16, ptr %s seq_cst, align 2 |
| %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(ptr %p) { |
| %s = getelementptr inbounds i16, ptr %p, i32 24 |
| %t = load atomic i16, ptr %s seq_cst, align 2 |
| %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.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 ptr |
| %arrayidx = getelementptr inbounds i8, ptr %t0, i32 2 |
| %t1 = load atomic i8, ptr %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_i8_i64_s_with_folded_or_offset(i32 %x) { |
| %and = and i32 %x, -4 |
| %t0 = inttoptr i32 %and to ptr |
| %arrayidx = getelementptr inbounds i8, ptr %t0, i32 2 |
| %t1 = load atomic i8, ptr %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 ptr |
| %t = load atomic i16, ptr %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, ptr @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_i8_i32_z_with_folded_offset: |
| ; CHECK: i32.atomic.load8_u $push0=, 24($0){{$}} |
| define i32 @load_i8_i32_z_with_folded_offset(ptr %p) { |
| %q = ptrtoint ptr %p to i32 |
| %r = add nuw i32 %q, 24 |
| %s = inttoptr i32 %r to ptr |
| %t = load atomic i8, ptr %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(ptr %p) { |
| %q = ptrtoint ptr %p to i32 |
| %r = add nuw i32 %q, 24 |
| %s = inttoptr i32 %r to ptr |
| %t = load atomic i32, ptr %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_i32_z_with_folded_gep_offset: |
| ; CHECK: i32.atomic.load8_u $push0=, 24($0){{$}} |
| define i32 @load_i8_i32_z_with_folded_gep_offset(ptr %p) { |
| %s = getelementptr inbounds i8, ptr %p, i32 24 |
| %t = load atomic i8, ptr %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(ptr %p) { |
| %s = getelementptr inbounds i16, ptr %p, i32 24 |
| %t = load atomic i16, ptr %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(ptr %p) { |
| %s = getelementptr inbounds i16, ptr %p, i64 24 |
| %t = load atomic i16, ptr %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 ptr |
| %arrayidx = getelementptr inbounds i8, ptr %t0, i32 2 |
| %t1 = load atomic i8, ptr %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 ptr |
| %arrayidx = getelementptr inbounds i8, ptr %t0, i32 2 |
| %t1 = load atomic i8, ptr %arrayidx seq_cst, align 1 |
| %conv = zext i8 %t1 to i64 |
| ret i64 %conv |
| } |
| |
| ; 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.atomic.load16_u $push1=, 42($pop0){{$}} |
| define i32 @load_i16_i32_z_from_numeric_address() { |
| %s = inttoptr i32 42 to ptr |
| %t = load atomic i16, ptr %s seq_cst, align 2 |
| %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.atomic.load8_u $push1=, gv8($pop0){{$}} |
| define i32 @load_i8_i32_z_from_global_address() { |
| %t = load atomic i8, ptr @gv8 seq_cst, align 1 |
| %u = zext i8 %t to i32 |
| ret i32 %u |
| } |
| |
| ; i8 return value should test anyext loads |
| |
| ; CHECK-LABEL: load_i8_i32_retvalue: |
| ; CHECK: i32.atomic.load8_u $push0=, 0($0){{$}} |
| ; CHECK-NEXT: return $pop0{{$}} |
| define i8 @load_i8_i32_retvalue(ptr %p) { |
| %v = load atomic i8, ptr %p seq_cst, align 1 |
| ret i8 %v |
| } |
| |
| ;===---------------------------------------------------------------------------- |
| ; Atomic truncating stores |
| ;===---------------------------------------------------------------------------- |
| |
| ; Fold an offset into a truncating store. |
| |
| ; CHECK-LABEL: store_i8_i32_with_folded_offset: |
| ; CHECK: i32.atomic.store8 24($0), $1{{$}} |
| define void @store_i8_i32_with_folded_offset(ptr %p, i32 %v) { |
| %q = ptrtoint ptr %p to i32 |
| %r = add nuw i32 %q, 24 |
| %s = inttoptr i32 %r to ptr |
| %t = trunc i32 %v to i8 |
| store atomic i8 %t, ptr %s seq_cst, align 1 |
| 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(ptr %p, i64 %v) { |
| %q = ptrtoint ptr %p to i32 |
| %r = add nuw i32 %q, 24 |
| %s = inttoptr i32 %r to ptr |
| %t = trunc i64 %v to i32 |
| store atomic i32 %t, ptr %s seq_cst, align 4 |
| ret void |
| } |
| |
| ; Fold a gep offset into a truncating store. |
| |
| ; 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(ptr %p, i32 %v) { |
| %s = getelementptr inbounds i8, ptr %p, i32 24 |
| %t = trunc i32 %v to i8 |
| store atomic i8 %t, ptr %s seq_cst, align 1 |
| ret void |
| } |
| |
| ; 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(ptr %p, i32 %v) { |
| %s = getelementptr inbounds i16, ptr %p, i32 24 |
| %t = trunc i32 %v to i16 |
| store atomic i16 %t, ptr %s seq_cst, align 2 |
| ret void |
| } |
| |
| ; CHECK-LABEL: store_i16_i64_with_folded_gep_offset: |
| ; CHECK: i64.atomic.store16 48($0), $1{{$}} |
| define void @store_i16_i64_with_folded_gep_offset(ptr %p, i64 %v) { |
| %s = getelementptr inbounds i16, ptr %p, i32 24 |
| %t = trunc i64 %v to i16 |
| store atomic i16 %t, ptr %s seq_cst, align 2 |
| 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.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 ptr |
| %arrayidx = getelementptr inbounds i8, ptr %p, i32 2 |
| %t = trunc i32 %v to i8 |
| store atomic i8 %t, ptr %arrayidx seq_cst, align 1 |
| ret void |
| } |
| |
| ; CHECK-LABEL: store_i8_i64_with_folded_or_offset: |
| ; CHECK: i64.atomic.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 ptr |
| %arrayidx = getelementptr inbounds i8, ptr %p, i32 2 |
| %t = trunc i64 %v to i8 |
| store atomic i8 %t, ptr %arrayidx seq_cst, align 1 |
| ret void |
| } |
| |
| ;===---------------------------------------------------------------------------- |
| ; Atomic binary read-modify-writes: 32-bit |
| ;===---------------------------------------------------------------------------- |
| |
| ; There are several RMW instructions, but here we only test 'add' as an example. |
| |
| ; Basic RMW. |
| |
| ; CHECK-LABEL: rmw_add_i32_no_offset: |
| ; CHECK-NEXT: .functype rmw_add_i32_no_offset (i32, i32) -> (i32){{$}} |
| ; CHECK: i32.atomic.rmw.add $push0=, 0($0), $1{{$}} |
| ; CHECK-NEXT: return $pop0{{$}} |
| define i32 @rmw_add_i32_no_offset(ptr %p, i32 %v) { |
| %old = atomicrmw add ptr %p, i32 %v seq_cst |
| ret i32 %old |
| } |
| |
| ; With an nuw add, we can fold an offset. |
| |
| ; CHECK-LABEL: rmw_add_i32_with_folded_offset: |
| ; CHECK: i32.atomic.rmw.add $push0=, 24($0), $1{{$}} |
| define i32 @rmw_add_i32_with_folded_offset(ptr %p, i32 %v) { |
| %q = ptrtoint ptr %p to i32 |
| %r = add nuw i32 %q, 24 |
| %s = inttoptr i32 %r to ptr |
| %old = atomicrmw add ptr %s, i32 %v seq_cst |
| ret i32 %old |
| } |
| |
| ; With an inbounds gep, we can fold an offset. |
| |
| ; CHECK-LABEL: rmw_add_i32_with_folded_gep_offset: |
| ; CHECK: i32.atomic.rmw.add $push0=, 24($0), $1{{$}} |
| define i32 @rmw_add_i32_with_folded_gep_offset(ptr %p, i32 %v) { |
| %s = getelementptr inbounds i32, ptr %p, i32 6 |
| %old = atomicrmw add ptr %s, i32 %v seq_cst |
| ret i32 %old |
| } |
| |
| ; We can't fold a negative offset though, even with an inbounds gep. |
| |
| ; CHECK-LABEL: rmw_add_i32_with_unfolded_gep_negative_offset: |
| ; CHECK: i32.const $push0=, -24{{$}} |
| ; CHECK: i32.add $push1=, $0, $pop0{{$}} |
| ; CHECK: i32.atomic.rmw.add $push2=, 0($pop1), $1{{$}} |
| define i32 @rmw_add_i32_with_unfolded_gep_negative_offset(ptr %p, i32 %v) { |
| %s = getelementptr inbounds i32, ptr %p, i32 -6 |
| %old = atomicrmw add ptr %s, i32 %v seq_cst |
| ret i32 %old |
| } |
| |
| ; Without nuw, and even with nsw, we can't fold an offset. |
| |
| ; CHECK-LABEL: rmw_add_i32_with_unfolded_offset: |
| ; CHECK: i32.const $push0=, 24{{$}} |
| ; CHECK: i32.add $push1=, $0, $pop0{{$}} |
| ; CHECK: i32.atomic.rmw.add $push2=, 0($pop1), $1{{$}} |
| define i32 @rmw_add_i32_with_unfolded_offset(ptr %p, i32 %v) { |
| %q = ptrtoint ptr %p to i32 |
| %r = add nsw i32 %q, 24 |
| %s = inttoptr i32 %r to ptr |
| %old = atomicrmw add ptr %s, i32 %v seq_cst |
| ret i32 %old |
| } |
| |
| ; Without inbounds, we can't fold a gep offset. |
| |
| ; CHECK-LABEL: rmw_add_i32_with_unfolded_gep_offset: |
| ; CHECK: i32.const $push0=, 24{{$}} |
| ; CHECK: i32.add $push1=, $0, $pop0{{$}} |
| ; CHECK: i32.atomic.rmw.add $push2=, 0($pop1), $1{{$}} |
| define i32 @rmw_add_i32_with_unfolded_gep_offset(ptr %p, i32 %v) { |
| %s = getelementptr i32, ptr %p, i32 6 |
| %old = atomicrmw add ptr %s, i32 %v seq_cst |
| ret i32 %old |
| } |
| |
| ; When loading from a fixed address, materialize a zero. |
| |
| ; CHECK-LABEL: rmw_add_i32_from_numeric_address |
| ; CHECK: i32.const $push0=, 0{{$}} |
| ; CHECK: i32.atomic.rmw.add $push1=, 42($pop0), $0{{$}} |
| define i32 @rmw_add_i32_from_numeric_address(i32 %v) { |
| %s = inttoptr i32 42 to ptr |
| %old = atomicrmw add ptr %s, i32 %v seq_cst |
| ret i32 %old |
| } |
| |
| ; CHECK-LABEL: rmw_add_i32_from_global_address |
| ; CHECK: i32.const $push0=, 0{{$}} |
| ; CHECK: i32.atomic.rmw.add $push1=, gv($pop0), $0{{$}} |
| define i32 @rmw_add_i32_from_global_address(i32 %v) { |
| %old = atomicrmw add ptr @gv, i32 %v seq_cst |
| ret i32 %old |
| } |
| |
| ;===---------------------------------------------------------------------------- |
| ; Atomic binary read-modify-writes: 64-bit |
| ;===---------------------------------------------------------------------------- |
| |
| ; Basic RMW. |
| |
| ; CHECK-LABEL: rmw_add_i64_no_offset: |
| ; CHECK-NEXT: .functype rmw_add_i64_no_offset (i32, i64) -> (i64){{$}} |
| ; CHECK: i64.atomic.rmw.add $push0=, 0($0), $1{{$}} |
| ; CHECK-NEXT: return $pop0{{$}} |
| define i64 @rmw_add_i64_no_offset(ptr %p, i64 %v) { |
| %old = atomicrmw add ptr %p, i64 %v seq_cst |
| ret i64 %old |
| } |
| |
| ; With an nuw add, we can fold an offset. |
| |
| ; CHECK-LABEL: rmw_add_i64_with_folded_offset: |
| ; CHECK: i64.atomic.rmw.add $push0=, 24($0), $1{{$}} |
| define i64 @rmw_add_i64_with_folded_offset(ptr %p, i64 %v) { |
| %q = ptrtoint ptr %p to i32 |
| %r = add nuw i32 %q, 24 |
| %s = inttoptr i32 %r to ptr |
| %old = atomicrmw add ptr %s, i64 %v seq_cst |
| ret i64 %old |
| } |
| |
| ; With an inbounds gep, we can fold an offset. |
| |
| ; CHECK-LABEL: rmw_add_i64_with_folded_gep_offset: |
| ; CHECK: i64.atomic.rmw.add $push0=, 24($0), $1{{$}} |
| define i64 @rmw_add_i64_with_folded_gep_offset(ptr %p, i64 %v) { |
| %s = getelementptr inbounds i64, ptr %p, i32 3 |
| %old = atomicrmw add ptr %s, i64 %v seq_cst |
| ret i64 %old |
| } |
| |
| ; We can't fold a negative offset though, even with an inbounds gep. |
| |
| ; CHECK-LABEL: rmw_add_i64_with_unfolded_gep_negative_offset: |
| ; CHECK: i32.const $push0=, -24{{$}} |
| ; CHECK: i32.add $push1=, $0, $pop0{{$}} |
| ; CHECK: i64.atomic.rmw.add $push2=, 0($pop1), $1{{$}} |
| define i64 @rmw_add_i64_with_unfolded_gep_negative_offset(ptr %p, i64 %v) { |
| %s = getelementptr inbounds i64, ptr %p, i32 -3 |
| %old = atomicrmw add ptr %s, i64 %v seq_cst |
| ret i64 %old |
| } |
| |
| ; Without nuw, and even with nsw, we can't fold an offset. |
| |
| ; CHECK-LABEL: rmw_add_i64_with_unfolded_offset: |
| ; CHECK: i32.const $push0=, 24{{$}} |
| ; CHECK: i32.add $push1=, $0, $pop0{{$}} |
| ; CHECK: i64.atomic.rmw.add $push2=, 0($pop1), $1{{$}} |
| define i64 @rmw_add_i64_with_unfolded_offset(ptr %p, i64 %v) { |
| %q = ptrtoint ptr %p to i32 |
| %r = add nsw i32 %q, 24 |
| %s = inttoptr i32 %r to ptr |
| %old = atomicrmw add ptr %s, i64 %v seq_cst |
| ret i64 %old |
| } |
| |
| ; Without inbounds, we can't fold a gep offset. |
| |
| ; CHECK-LABEL: rmw_add_i64_with_unfolded_gep_offset: |
| ; CHECK: i32.const $push0=, 24{{$}} |
| ; CHECK: i32.add $push1=, $0, $pop0{{$}} |
| ; CHECK: i64.atomic.rmw.add $push2=, 0($pop1), $1{{$}} |
| define i64 @rmw_add_i64_with_unfolded_gep_offset(ptr %p, i64 %v) { |
| %s = getelementptr i64, ptr %p, i32 3 |
| %old = atomicrmw add ptr %s, i64 %v seq_cst |
| ret i64 %old |
| } |
| |
| ;===---------------------------------------------------------------------------- |
| ; Atomic truncating & sign-extending binary RMWs |
| ;===---------------------------------------------------------------------------- |
| |
| ; Fold an offset into a sign-extending rmw. |
| |
| ; CHECK-LABEL: rmw_add_i8_i32_s_with_folded_offset: |
| ; CHECK: i32.atomic.rmw8.add_u $push0=, 24($0), $1{{$}} |
| ; CHECK-NEXT: i32.extend8_s $push1=, $pop0 |
| define i32 @rmw_add_i8_i32_s_with_folded_offset(ptr %p, i32 %v) { |
| %q = ptrtoint ptr %p to i32 |
| %r = add nuw i32 %q, 24 |
| %s = inttoptr i32 %r to ptr |
| %t = trunc i32 %v to i8 |
| %old = atomicrmw add ptr %s, i8 %t seq_cst |
| %u = sext i8 %old to i32 |
| ret i32 %u |
| } |
| |
| ; 32->64 sext rmw gets selected as i32.atomic.rmw.add, i64.extend_i32_s |
| ; CHECK-LABEL: rmw_add_i32_i64_s_with_folded_offset: |
| ; CHECK: i32.wrap_i64 $push0=, $1 |
| ; CHECK-NEXT: i32.atomic.rmw.add $push1=, 24($0), $pop0{{$}} |
| ; CHECK-NEXT: i64.extend_i32_s $push2=, $pop1{{$}} |
| define i64 @rmw_add_i32_i64_s_with_folded_offset(ptr %p, i64 %v) { |
| %q = ptrtoint ptr %p to i32 |
| %r = add nuw i32 %q, 24 |
| %s = inttoptr i32 %r to ptr |
| %t = trunc i64 %v to i32 |
| %old = atomicrmw add ptr %s, i32 %t seq_cst |
| %u = sext i32 %old to i64 |
| ret i64 %u |
| } |
| |
| ; Fold a gep offset into a sign-extending rmw. |
| |
| ; CHECK-LABEL: rmw_add_i8_i32_s_with_folded_gep_offset: |
| ; CHECK: i32.atomic.rmw8.add_u $push0=, 24($0), $1{{$}} |
| ; CHECK-NEXT: i32.extend8_s $push1=, $pop0 |
| define i32 @rmw_add_i8_i32_s_with_folded_gep_offset(ptr %p, i32 %v) { |
| %s = getelementptr inbounds i8, ptr %p, i32 24 |
| %t = trunc i32 %v to i8 |
| %old = atomicrmw add ptr %s, i8 %t seq_cst |
| %u = sext i8 %old to i32 |
| ret i32 %u |
| } |
| |
| ; CHECK-LABEL: rmw_add_i16_i32_s_with_folded_gep_offset: |
| ; CHECK: i32.atomic.rmw16.add_u $push0=, 48($0), $1{{$}} |
| ; CHECK-NEXT: i32.extend16_s $push1=, $pop0 |
| define i32 @rmw_add_i16_i32_s_with_folded_gep_offset(ptr %p, i32 %v) { |
| %s = getelementptr inbounds i16, ptr %p, i32 24 |
| %t = trunc i32 %v to i16 |
| %old = atomicrmw add ptr %s, i16 %t seq_cst |
| %u = sext i16 %old to i32 |
| ret i32 %u |
| } |
| |
| ; CHECK-LABEL: rmw_add_i16_i64_s_with_folded_gep_offset: |
| ; CHECK: i64.atomic.rmw16.add_u $push0=, 48($0), $1{{$}} |
| ; CHECK-NEXT: i64.extend16_s $push1=, $pop0 |
| define i64 @rmw_add_i16_i64_s_with_folded_gep_offset(ptr %p, i64 %v) { |
| %s = getelementptr inbounds i16, ptr %p, i32 24 |
| %t = trunc i64 %v to i16 |
| %old = atomicrmw add ptr %s, i16 %t seq_cst |
| %u = sext i16 %old 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: rmw_add_i8_i32_s_with_folded_or_offset: |
| ; CHECK: i32.atomic.rmw8.add_u $push[[R1:[0-9]+]]=, 2($pop{{[0-9]+}}), $1{{$}} |
| ; CHECK-NEXT: i32.extend8_s $push{{[0-9]+}}=, $pop[[R1]]{{$}} |
| define i32 @rmw_add_i8_i32_s_with_folded_or_offset(i32 %x, i32 %v) { |
| %and = and i32 %x, -4 |
| %t0 = inttoptr i32 %and to ptr |
| %arrayidx = getelementptr inbounds i8, ptr %t0, i32 2 |
| %t = trunc i32 %v to i8 |
| %old = atomicrmw add ptr %arrayidx, i8 %t seq_cst |
| %conv = sext i8 %old to i32 |
| ret i32 %conv |
| } |
| |
| ; CHECK-LABEL: rmw_add_i8_i64_s_with_folded_or_offset: |
| ; CHECK: i64.atomic.rmw8.add_u $push[[R1:[0-9]+]]=, 2($pop{{[0-9]+}}), $1{{$}} |
| ; CHECK-NEXT: i64.extend8_s $push{{[0-9]+}}=, $pop[[R1]]{{$}} |
| define i64 @rmw_add_i8_i64_s_with_folded_or_offset(i32 %x, i64 %v) { |
| %and = and i32 %x, -4 |
| %t0 = inttoptr i32 %and to ptr |
| %arrayidx = getelementptr inbounds i8, ptr %t0, i32 2 |
| %t = trunc i64 %v to i8 |
| %old = atomicrmw add ptr %arrayidx, i8 %t seq_cst |
| %conv = sext i8 %old to i64 |
| ret i64 %conv |
| } |
| |
| ; When loading from a fixed address, materialize a zero. |
| |
| ; CHECK-LABEL: rmw_add_i16_i32_s_from_numeric_address |
| ; CHECK: i32.const $push0=, 0{{$}} |
| ; CHECK: i32.atomic.rmw16.add_u $push1=, 42($pop0), $0{{$}} |
| ; CHECK-NEXT: i32.extend16_s $push2=, $pop1 |
| define i32 @rmw_add_i16_i32_s_from_numeric_address(i32 %v) { |
| %s = inttoptr i32 42 to ptr |
| %t = trunc i32 %v to i16 |
| %old = atomicrmw add ptr %s, i16 %t seq_cst |
| %u = sext i16 %old to i32 |
| ret i32 %u |
| } |
| |
| ; CHECK-LABEL: rmw_add_i8_i32_s_from_global_address |
| ; CHECK: i32.const $push0=, 0{{$}} |
| ; CHECK: i32.atomic.rmw8.add_u $push1=, gv8($pop0), $0{{$}} |
| ; CHECK-NEXT: i32.extend8_s $push2=, $pop1{{$}} |
| define i32 @rmw_add_i8_i32_s_from_global_address(i32 %v) { |
| %t = trunc i32 %v to i8 |
| %old = atomicrmw add ptr @gv8, i8 %t seq_cst |
| %u = sext i8 %old to i32 |
| ret i32 %u |
| } |
| |
| ;===---------------------------------------------------------------------------- |
| ; Atomic truncating & zero-extending binary RMWs |
| ;===---------------------------------------------------------------------------- |
| |
| ; Fold an offset into a zero-extending rmw. |
| |
| ; CHECK-LABEL: rmw_add_i8_i32_z_with_folded_offset: |
| ; CHECK: i32.atomic.rmw8.add_u $push0=, 24($0), $1{{$}} |
| define i32 @rmw_add_i8_i32_z_with_folded_offset(ptr %p, i32 %v) { |
| %q = ptrtoint ptr %p to i32 |
| %r = add nuw i32 %q, 24 |
| %s = inttoptr i32 %r to ptr |
| %t = trunc i32 %v to i8 |
| %old = atomicrmw add ptr %s, i8 %t seq_cst |
| %u = zext i8 %old to i32 |
| ret i32 %u |
| } |
| |
| ; CHECK-LABEL: rmw_add_i32_i64_z_with_folded_offset: |
| ; CHECK: i64.atomic.rmw32.add_u $push0=, 24($0), $1{{$}} |
| define i64 @rmw_add_i32_i64_z_with_folded_offset(ptr %p, i64 %v) { |
| %q = ptrtoint ptr %p to i32 |
| %r = add nuw i32 %q, 24 |
| %s = inttoptr i32 %r to ptr |
| %t = trunc i64 %v to i32 |
| %old = atomicrmw add ptr %s, i32 %t seq_cst |
| %u = zext i32 %old to i64 |
| ret i64 %u |
| } |
| |
| ; Fold a gep offset into a zero-extending rmw. |
| |
| ; CHECK-LABEL: rmw_add_i8_i32_z_with_folded_gep_offset: |
| ; CHECK: i32.atomic.rmw8.add_u $push0=, 24($0), $1{{$}} |
| define i32 @rmw_add_i8_i32_z_with_folded_gep_offset(ptr %p, i32 %v) { |
| %s = getelementptr inbounds i8, ptr %p, i32 24 |
| %t = trunc i32 %v to i8 |
| %old = atomicrmw add ptr %s, i8 %t seq_cst |
| %u = zext i8 %old to i32 |
| ret i32 %u |
| } |
| |
| ; CHECK-LABEL: rmw_add_i16_i32_z_with_folded_gep_offset: |
| ; CHECK: i32.atomic.rmw16.add_u $push0=, 48($0), $1{{$}} |
| define i32 @rmw_add_i16_i32_z_with_folded_gep_offset(ptr %p, i32 %v) { |
| %s = getelementptr inbounds i16, ptr %p, i32 24 |
| %t = trunc i32 %v to i16 |
| %old = atomicrmw add ptr %s, i16 %t seq_cst |
| %u = zext i16 %old to i32 |
| ret i32 %u |
| } |
| |
| ; CHECK-LABEL: rmw_add_i16_i64_z_with_folded_gep_offset: |
| ; CHECK: i64.atomic.rmw16.add_u $push0=, 48($0), $1{{$}} |
| define i64 @rmw_add_i16_i64_z_with_folded_gep_offset(ptr %p, i64 %v) { |
| %s = getelementptr inbounds i16, ptr %p, i32 24 |
| %t = trunc i64 %v to i16 |
| %old = atomicrmw add ptr %s, i16 %t seq_cst |
| %u = zext i16 %old 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: rmw_add_i8_i32_z_with_folded_or_offset: |
| ; CHECK: i32.atomic.rmw8.add_u $push[[R1:[0-9]+]]=, 2($pop{{[0-9]+}}), $1{{$}} |
| define i32 @rmw_add_i8_i32_z_with_folded_or_offset(i32 %x, i32 %v) { |
| %and = and i32 %x, -4 |
| %t0 = inttoptr i32 %and to ptr |
| %arrayidx = getelementptr inbounds i8, ptr %t0, i32 2 |
| %t = trunc i32 %v to i8 |
| %old = atomicrmw add ptr %arrayidx, i8 %t seq_cst |
| %conv = zext i8 %old to i32 |
| ret i32 %conv |
| } |
| |
| ; CHECK-LABEL: rmw_add_i8_i64_z_with_folded_or_offset: |
| ; CHECK: i64.atomic.rmw8.add_u $push[[R1:[0-9]+]]=, 2($pop{{[0-9]+}}), $1{{$}} |
| define i64 @rmw_add_i8_i64_z_with_folded_or_offset(i32 %x, i64 %v) { |
| %and = and i32 %x, -4 |
| %t0 = inttoptr i32 %and to ptr |
| %arrayidx = getelementptr inbounds i8, ptr %t0, i32 2 |
| %t = trunc i64 %v to i8 |
| %old = atomicrmw add ptr %arrayidx, i8 %t seq_cst |
| %conv = zext i8 %old to i64 |
| ret i64 %conv |
| } |
| |
| ; When loading from a fixed address, materialize a zero. |
| |
| ; CHECK-LABEL: rmw_add_i16_i32_z_from_numeric_address |
| ; CHECK: i32.const $push0=, 0{{$}} |
| ; CHECK: i32.atomic.rmw16.add_u $push1=, 42($pop0), $0{{$}} |
| define i32 @rmw_add_i16_i32_z_from_numeric_address(i32 %v) { |
| %s = inttoptr i32 42 to ptr |
| %t = trunc i32 %v to i16 |
| %old = atomicrmw add ptr %s, i16 %t seq_cst |
| %u = zext i16 %old to i32 |
| ret i32 %u |
| } |
| |
| ; CHECK-LABEL: rmw_add_i8_i32_z_from_global_address |
| ; CHECK: i32.const $push0=, 0{{$}} |
| ; CHECK: i32.atomic.rmw8.add_u $push1=, gv8($pop0), $0{{$}} |
| define i32 @rmw_add_i8_i32_z_from_global_address(i32 %v) { |
| %t = trunc i32 %v to i8 |
| %old = atomicrmw add ptr @gv8, i8 %t seq_cst |
| %u = zext i8 %old to i32 |
| ret i32 %u |
| } |
| |
| ; i8 return value should test anyext RMWs |
| |
| ; CHECK-LABEL: rmw_add_i8_i32_retvalue: |
| ; CHECK: i32.atomic.rmw8.add_u $push0=, 0($0), $1{{$}} |
| ; CHECK-NEXT: return $pop0{{$}} |
| define i8 @rmw_add_i8_i32_retvalue(ptr %p, i32 %v) { |
| %t = trunc i32 %v to i8 |
| %old = atomicrmw add ptr %p, i8 %t seq_cst |
| ret i8 %old |
| } |
| |
| ;===---------------------------------------------------------------------------- |
| ; Atomic ternary read-modify-writes: 32-bit |
| ;===---------------------------------------------------------------------------- |
| |
| ; Basic RMW. |
| |
| ; CHECK-LABEL: cmpxchg_i32_no_offset: |
| ; CHECK-NEXT: .functype cmpxchg_i32_no_offset (i32, i32, i32) -> (i32){{$}} |
| ; CHECK: i32.atomic.rmw.cmpxchg $push0=, 0($0), $1, $2{{$}} |
| ; CHECK-NEXT: return $pop0{{$}} |
| define i32 @cmpxchg_i32_no_offset(ptr %p, i32 %exp, i32 %new) { |
| %pair = cmpxchg ptr %p, i32 %exp, i32 %new seq_cst seq_cst |
| %old = extractvalue { i32, i1 } %pair, 0 |
| ret i32 %old |
| } |
| |
| ; With an nuw add, we can fold an offset. |
| |
| ; CHECK-LABEL: cmpxchg_i32_with_folded_offset: |
| ; CHECK: i32.atomic.rmw.cmpxchg $push0=, 24($0), $1, $2{{$}} |
| define i32 @cmpxchg_i32_with_folded_offset(ptr %p, i32 %exp, i32 %new) { |
| %q = ptrtoint ptr %p to i32 |
| %r = add nuw i32 %q, 24 |
| %s = inttoptr i32 %r to ptr |
| %pair = cmpxchg ptr %s, i32 %exp, i32 %new seq_cst seq_cst |
| %old = extractvalue { i32, i1 } %pair, 0 |
| ret i32 %old |
| } |
| |
| ; With an inbounds gep, we can fold an offset. |
| |
| ; CHECK-LABEL: cmpxchg_i32_with_folded_gep_offset: |
| ; CHECK: i32.atomic.rmw.cmpxchg $push0=, 24($0), $1, $2{{$}} |
| define i32 @cmpxchg_i32_with_folded_gep_offset(ptr %p, i32 %exp, i32 %new) { |
| %s = getelementptr inbounds i32, ptr %p, i32 6 |
| %pair = cmpxchg ptr %s, i32 %exp, i32 %new seq_cst seq_cst |
| %old = extractvalue { i32, i1 } %pair, 0 |
| ret i32 %old |
| } |
| |
| ; We can't fold a negative offset though, even with an inbounds gep. |
| |
| ; CHECK-LABEL: cmpxchg_i32_with_unfolded_gep_negative_offset: |
| ; CHECK: i32.const $push0=, -24{{$}} |
| ; CHECK: i32.add $push1=, $0, $pop0{{$}} |
| ; CHECK: i32.atomic.rmw.cmpxchg $push2=, 0($pop1), $1, $2{{$}} |
| define i32 @cmpxchg_i32_with_unfolded_gep_negative_offset(ptr %p, i32 %exp, i32 %new) { |
| %s = getelementptr inbounds i32, ptr %p, i32 -6 |
| %pair = cmpxchg ptr %s, i32 %exp, i32 %new seq_cst seq_cst |
| %old = extractvalue { i32, i1 } %pair, 0 |
| ret i32 %old |
| } |
| |
| ; Without nuw, and even with nsw, we can't fold an offset. |
| |
| ; CHECK-LABEL: cmpxchg_i32_with_unfolded_offset: |
| ; CHECK: i32.const $push0=, 24{{$}} |
| ; CHECK: i32.add $push1=, $0, $pop0{{$}} |
| ; CHECK: i32.atomic.rmw.cmpxchg $push2=, 0($pop1), $1, $2{{$}} |
| define i32 @cmpxchg_i32_with_unfolded_offset(ptr %p, i32 %exp, i32 %new) { |
| %q = ptrtoint ptr %p to i32 |
| %r = add nsw i32 %q, 24 |
| %s = inttoptr i32 %r to ptr |
| %pair = cmpxchg ptr %s, i32 %exp, i32 %new seq_cst seq_cst |
| %old = extractvalue { i32, i1 } %pair, 0 |
| ret i32 %old |
| } |
| |
| ; Without inbounds, we can't fold a gep offset. |
| |
| ; CHECK-LABEL: cmpxchg_i32_with_unfolded_gep_offset: |
| ; CHECK: i32.const $push0=, 24{{$}} |
| ; CHECK: i32.add $push1=, $0, $pop0{{$}} |
| ; CHECK: i32.atomic.rmw.cmpxchg $push2=, 0($pop1), $1, $2{{$}} |
| define i32 @cmpxchg_i32_with_unfolded_gep_offset(ptr %p, i32 %exp, i32 %new) { |
| %s = getelementptr i32, ptr %p, i32 6 |
| %pair = cmpxchg ptr %s, i32 %exp, i32 %new seq_cst seq_cst |
| %old = extractvalue { i32, i1 } %pair, 0 |
| ret i32 %old |
| } |
| |
| ; When loading from a fixed address, materialize a zero. |
| |
| ; CHECK-LABEL: cmpxchg_i32_from_numeric_address |
| ; CHECK: i32.const $push0=, 0{{$}} |
| ; CHECK: i32.atomic.rmw.cmpxchg $push1=, 42($pop0), $0, $1{{$}} |
| define i32 @cmpxchg_i32_from_numeric_address(i32 %exp, i32 %new) { |
| %s = inttoptr i32 42 to ptr |
| %pair = cmpxchg ptr %s, i32 %exp, i32 %new seq_cst seq_cst |
| %old = extractvalue { i32, i1 } %pair, 0 |
| ret i32 %old |
| } |
| |
| ; CHECK-LABEL: cmpxchg_i32_from_global_address |
| ; CHECK: i32.const $push0=, 0{{$}} |
| ; CHECK: i32.atomic.rmw.cmpxchg $push1=, gv($pop0), $0, $1{{$}} |
| define i32 @cmpxchg_i32_from_global_address(i32 %exp, i32 %new) { |
| %pair = cmpxchg ptr @gv, i32 %exp, i32 %new seq_cst seq_cst |
| %old = extractvalue { i32, i1 } %pair, 0 |
| ret i32 %old |
| } |
| |
| ;===---------------------------------------------------------------------------- |
| ; Atomic ternary read-modify-writes: 64-bit |
| ;===---------------------------------------------------------------------------- |
| |
| ; Basic RMW. |
| |
| ; CHECK-LABEL: cmpxchg_i64_no_offset: |
| ; CHECK-NEXT: .functype cmpxchg_i64_no_offset (i32, i64, i64) -> (i64){{$}} |
| ; CHECK: i64.atomic.rmw.cmpxchg $push0=, 0($0), $1, $2{{$}} |
| ; CHECK-NEXT: return $pop0{{$}} |
| define i64 @cmpxchg_i64_no_offset(ptr %p, i64 %exp, i64 %new) { |
| %pair = cmpxchg ptr %p, i64 %exp, i64 %new seq_cst seq_cst |
| %old = extractvalue { i64, i1 } %pair, 0 |
| ret i64 %old |
| } |
| |
| ; With an nuw add, we can fold an offset. |
| |
| ; CHECK-LABEL: cmpxchg_i64_with_folded_offset: |
| ; CHECK: i64.atomic.rmw.cmpxchg $push0=, 24($0), $1, $2{{$}} |
| define i64 @cmpxchg_i64_with_folded_offset(ptr %p, i64 %exp, i64 %new) { |
| %q = ptrtoint ptr %p to i32 |
| %r = add nuw i32 %q, 24 |
| %s = inttoptr i32 %r to ptr |
| %pair = cmpxchg ptr %s, i64 %exp, i64 %new seq_cst seq_cst |
| %old = extractvalue { i64, i1 } %pair, 0 |
| ret i64 %old |
| } |
| |
| ; With an inbounds gep, we can fold an offset. |
| |
| ; CHECK-LABEL: cmpxchg_i64_with_folded_gep_offset: |
| ; CHECK: i64.atomic.rmw.cmpxchg $push0=, 24($0), $1, $2{{$}} |
| define i64 @cmpxchg_i64_with_folded_gep_offset(ptr %p, i64 %exp, i64 %new) { |
| %s = getelementptr inbounds i64, ptr %p, i32 3 |
| %pair = cmpxchg ptr %s, i64 %exp, i64 %new seq_cst seq_cst |
| %old = extractvalue { i64, i1 } %pair, 0 |
| ret i64 %old |
| } |
| |
| ; We can't fold a negative offset though, even with an inbounds gep. |
| |
| ; CHECK-LABEL: cmpxchg_i64_with_unfolded_gep_negative_offset: |
| ; CHECK: i32.const $push0=, -24{{$}} |
| ; CHECK: i32.add $push1=, $0, $pop0{{$}} |
| ; CHECK: i64.atomic.rmw.cmpxchg $push2=, 0($pop1), $1, $2{{$}} |
| define i64 @cmpxchg_i64_with_unfolded_gep_negative_offset(ptr %p, i64 %exp, i64 %new) { |
| %s = getelementptr inbounds i64, ptr %p, i32 -3 |
| %pair = cmpxchg ptr %s, i64 %exp, i64 %new seq_cst seq_cst |
| %old = extractvalue { i64, i1 } %pair, 0 |
| ret i64 %old |
| } |
| |
| ; Without nuw, and even with nsw, we can't fold an offset. |
| |
| ; CHECK-LABEL: cmpxchg_i64_with_unfolded_offset: |
| ; CHECK: i32.const $push0=, 24{{$}} |
| ; CHECK: i32.add $push1=, $0, $pop0{{$}} |
| ; CHECK: i64.atomic.rmw.cmpxchg $push2=, 0($pop1), $1, $2{{$}} |
| define i64 @cmpxchg_i64_with_unfolded_offset(ptr %p, i64 %exp, i64 %new) { |
| %q = ptrtoint ptr %p to i32 |
| %r = add nsw i32 %q, 24 |
| %s = inttoptr i32 %r to ptr |
| %pair = cmpxchg ptr %s, i64 %exp, i64 %new seq_cst seq_cst |
| %old = extractvalue { i64, i1 } %pair, 0 |
| ret i64 %old |
| } |
| |
| ; Without inbounds, we can't fold a gep offset. |
| |
| ; CHECK-LABEL: cmpxchg_i64_with_unfolded_gep_offset: |
| ; CHECK: i32.const $push0=, 24{{$}} |
| ; CHECK: i32.add $push1=, $0, $pop0{{$}} |
| ; CHECK: i64.atomic.rmw.cmpxchg $push2=, 0($pop1), $1, $2{{$}} |
| define i64 @cmpxchg_i64_with_unfolded_gep_offset(ptr %p, i64 %exp, i64 %new) { |
| %s = getelementptr i64, ptr %p, i32 3 |
| %pair = cmpxchg ptr %s, i64 %exp, i64 %new seq_cst seq_cst |
| %old = extractvalue { i64, i1 } %pair, 0 |
| ret i64 %old |
| } |
| |
| ;===---------------------------------------------------------------------------- |
| ; Atomic truncating & sign-extending ternary RMWs |
| ;===---------------------------------------------------------------------------- |
| |
| ; Fold an offset into a sign-extending rmw. |
| |
| ; CHECK-LABEL: cmpxchg_i8_i32_s_with_folded_offset: |
| ; CHECK: i32.atomic.rmw8.cmpxchg_u $push0=, 24($0), $1, $2{{$}} |
| ; CHECK-NEXT: i32.extend8_s $push1=, $pop0 |
| define i32 @cmpxchg_i8_i32_s_with_folded_offset(ptr %p, i32 %exp, i32 %new) { |
| %q = ptrtoint ptr %p to i32 |
| %r = add nuw i32 %q, 24 |
| %s = inttoptr i32 %r to ptr |
| %exp_t = trunc i32 %exp to i8 |
| %new_t = trunc i32 %new to i8 |
| %pair = cmpxchg ptr %s, i8 %exp_t, i8 %new_t seq_cst seq_cst |
| %old = extractvalue { i8, i1 } %pair, 0 |
| %u = sext i8 %old to i32 |
| ret i32 %u |
| } |
| |
| ; 32->64 sext rmw gets selected as i32.atomic.rmw.cmpxchg, i64.extend_i32_s |
| ; CHECK-LABEL: cmpxchg_i32_i64_s_with_folded_offset: |
| ; CHECK: i32.wrap_i64 $push1=, $1 |
| ; CHECK-NEXT: i32.wrap_i64 $push0=, $2 |
| ; CHECK-NEXT: i32.atomic.rmw.cmpxchg $push2=, 24($0), $pop1, $pop0{{$}} |
| ; CHECK-NEXT: i64.extend_i32_s $push3=, $pop2{{$}} |
| define i64 @cmpxchg_i32_i64_s_with_folded_offset(ptr %p, i64 %exp, i64 %new) { |
| %q = ptrtoint ptr %p to i32 |
| %r = add nuw i32 %q, 24 |
| %s = inttoptr i32 %r to ptr |
| %exp_t = trunc i64 %exp to i32 |
| %new_t = trunc i64 %new to i32 |
| %pair = cmpxchg ptr %s, i32 %exp_t, i32 %new_t seq_cst seq_cst |
| %old = extractvalue { i32, i1 } %pair, 0 |
| %u = sext i32 %old to i64 |
| ret i64 %u |
| } |
| |
| ; Fold a gep offset into a sign-extending rmw. |
| |
| ; CHECK-LABEL: cmpxchg_i8_i32_s_with_folded_gep_offset: |
| ; CHECK: i32.atomic.rmw8.cmpxchg_u $push0=, 24($0), $1, $2{{$}} |
| ; CHECK-NEXT: i32.extend8_s $push1=, $pop0 |
| define i32 @cmpxchg_i8_i32_s_with_folded_gep_offset(ptr %p, i32 %exp, i32 %new) { |
| %s = getelementptr inbounds i8, ptr %p, i32 24 |
| %exp_t = trunc i32 %exp to i8 |
| %new_t = trunc i32 %new to i8 |
| %pair = cmpxchg ptr %s, i8 %exp_t, i8 %new_t seq_cst seq_cst |
| %old = extractvalue { i8, i1 } %pair, 0 |
| %u = sext i8 %old to i32 |
| ret i32 %u |
| } |
| |
| ; CHECK-LABEL: cmpxchg_i16_i32_s_with_folded_gep_offset: |
| ; CHECK: i32.atomic.rmw16.cmpxchg_u $push0=, 48($0), $1, $2{{$}} |
| ; CHECK-NEXT: i32.extend16_s $push1=, $pop0 |
| define i32 @cmpxchg_i16_i32_s_with_folded_gep_offset(ptr %p, i32 %exp, i32 %new) { |
| %s = getelementptr inbounds i16, ptr %p, i32 24 |
| %exp_t = trunc i32 %exp to i16 |
| %new_t = trunc i32 %new to i16 |
| %pair = cmpxchg ptr %s, i16 %exp_t, i16 %new_t seq_cst seq_cst |
| %old = extractvalue { i16, i1 } %pair, 0 |
| %u = sext i16 %old to i32 |
| ret i32 %u |
| } |
| |
| ; CHECK-LABEL: cmpxchg_i16_i64_s_with_folded_gep_offset: |
| ; CHECK: i64.atomic.rmw16.cmpxchg_u $push0=, 48($0), $1, $2{{$}} |
| ; CHECK-NEXT: i64.extend16_s $push1=, $pop0 |
| define i64 @cmpxchg_i16_i64_s_with_folded_gep_offset(ptr %p, i64 %exp, i64 %new) { |
| %s = getelementptr inbounds i16, ptr %p, i32 24 |
| %exp_t = trunc i64 %exp to i16 |
| %new_t = trunc i64 %new to i16 |
| %pair = cmpxchg ptr %s, i16 %exp_t, i16 %new_t seq_cst seq_cst |
| %old = extractvalue { i16, i1 } %pair, 0 |
| %u = sext i16 %old 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: cmpxchg_i8_i32_s_with_folded_or_offset: |
| ; CHECK: i32.atomic.rmw8.cmpxchg_u $push[[R1:[0-9]+]]=, 2($pop{{[0-9]+}}), $1, $2{{$}} |
| ; CHECK-NEXT: i32.extend8_s $push{{[0-9]+}}=, $pop[[R1]]{{$}} |
| define i32 @cmpxchg_i8_i32_s_with_folded_or_offset(i32 %x, i32 %exp, i32 %new) { |
| %and = and i32 %x, -4 |
| %t0 = inttoptr i32 %and to ptr |
| %arrayidx = getelementptr inbounds i8, ptr %t0, i32 2 |
| %exp_t = trunc i32 %exp to i8 |
| %new_t = trunc i32 %new to i8 |
| %pair = cmpxchg ptr %arrayidx, i8 %exp_t, i8 %new_t seq_cst seq_cst |
| %old = extractvalue { i8, i1 } %pair, 0 |
| %conv = sext i8 %old to i32 |
| ret i32 %conv |
| } |
| |
| ; CHECK-LABEL: cmpxchg_i8_i64_s_with_folded_or_offset: |
| ; CHECK: i64.atomic.rmw8.cmpxchg_u $push[[R1:[0-9]+]]=, 2($pop{{[0-9]+}}), $1, $2{{$}} |
| ; CHECK-NEXT: i64.extend8_s $push{{[0-9]+}}=, $pop[[R1]]{{$}} |
| define i64 @cmpxchg_i8_i64_s_with_folded_or_offset(i32 %x, i64 %exp, i64 %new) { |
| %and = and i32 %x, -4 |
| %t0 = inttoptr i32 %and to ptr |
| %arrayidx = getelementptr inbounds i8, ptr %t0, i32 2 |
| %exp_t = trunc i64 %exp to i8 |
| %new_t = trunc i64 %new to i8 |
| %pair = cmpxchg ptr %arrayidx, i8 %exp_t, i8 %new_t seq_cst seq_cst |
| %old = extractvalue { i8, i1 } %pair, 0 |
| %conv = sext i8 %old to i64 |
| ret i64 %conv |
| } |
| |
| ; When loading from a fixed address, materialize a zero. |
| |
| ; CHECK-LABEL: cmpxchg_i16_i32_s_from_numeric_address |
| ; CHECK: i32.const $push0=, 0{{$}} |
| ; CHECK: i32.atomic.rmw16.cmpxchg_u $push1=, 42($pop0), $0, $1{{$}} |
| ; CHECK-NEXT: i32.extend16_s $push2=, $pop1 |
| define i32 @cmpxchg_i16_i32_s_from_numeric_address(i32 %exp, i32 %new) { |
| %s = inttoptr i32 42 to ptr |
| %exp_t = trunc i32 %exp to i16 |
| %new_t = trunc i32 %new to i16 |
| %pair = cmpxchg ptr %s, i16 %exp_t, i16 %new_t seq_cst seq_cst |
| %old = extractvalue { i16, i1 } %pair, 0 |
| %u = sext i16 %old to i32 |
| ret i32 %u |
| } |
| |
| ; CHECK-LABEL: cmpxchg_i8_i32_s_from_global_address |
| ; CHECK: i32.const $push0=, 0{{$}} |
| ; CHECK: i32.atomic.rmw8.cmpxchg_u $push1=, gv8($pop0), $0, $1{{$}} |
| ; CHECK-NEXT: i32.extend8_s $push2=, $pop1{{$}} |
| define i32 @cmpxchg_i8_i32_s_from_global_address(i32 %exp, i32 %new) { |
| %exp_t = trunc i32 %exp to i8 |
| %new_t = trunc i32 %new to i8 |
| %pair = cmpxchg ptr @gv8, i8 %exp_t, i8 %new_t seq_cst seq_cst |
| %old = extractvalue { i8, i1 } %pair, 0 |
| %u = sext i8 %old to i32 |
| ret i32 %u |
| } |
| |
| ;===---------------------------------------------------------------------------- |
| ; Atomic truncating & zero-extending ternary RMWs |
| ;===---------------------------------------------------------------------------- |
| |
| ; Fold an offset into a sign-extending rmw. |
| |
| ; CHECK-LABEL: cmpxchg_i8_i32_z_with_folded_offset: |
| ; CHECK: i32.atomic.rmw8.cmpxchg_u $push0=, 24($0), $1, $2{{$}} |
| define i32 @cmpxchg_i8_i32_z_with_folded_offset(ptr %p, i32 %exp, i32 %new) { |
| %q = ptrtoint ptr %p to i32 |
| %r = add nuw i32 %q, 24 |
| %s = inttoptr i32 %r to ptr |
| %exp_t = trunc i32 %exp to i8 |
| %new_t = trunc i32 %new to i8 |
| %pair = cmpxchg ptr %s, i8 %exp_t, i8 %new_t seq_cst seq_cst |
| %old = extractvalue { i8, i1 } %pair, 0 |
| %u = zext i8 %old to i32 |
| ret i32 %u |
| } |
| |
| ; CHECK-LABEL: cmpxchg_i32_i64_z_with_folded_offset: |
| ; CHECK: i64.atomic.rmw32.cmpxchg_u $push0=, 24($0), $1, $2{{$}} |
| define i64 @cmpxchg_i32_i64_z_with_folded_offset(ptr %p, i64 %exp, i64 %new) { |
| %q = ptrtoint ptr %p to i32 |
| %r = add nuw i32 %q, 24 |
| %s = inttoptr i32 %r to ptr |
| %exp_t = trunc i64 %exp to i32 |
| %new_t = trunc i64 %new to i32 |
| %pair = cmpxchg ptr %s, i32 %exp_t, i32 %new_t seq_cst seq_cst |
| %old = extractvalue { i32, i1 } %pair, 0 |
| %u = zext i32 %old to i64 |
| ret i64 %u |
| } |
| |
| ; Fold a gep offset into a sign-extending rmw. |
| |
| ; CHECK-LABEL: cmpxchg_i8_i32_z_with_folded_gep_offset: |
| ; CHECK: i32.atomic.rmw8.cmpxchg_u $push0=, 24($0), $1, $2{{$}} |
| define i32 @cmpxchg_i8_i32_z_with_folded_gep_offset(ptr %p, i32 %exp, i32 %new) { |
| %s = getelementptr inbounds i8, ptr %p, i32 24 |
| %exp_t = trunc i32 %exp to i8 |
| %new_t = trunc i32 %new to i8 |
| %pair = cmpxchg ptr %s, i8 %exp_t, i8 %new_t seq_cst seq_cst |
| %old = extractvalue { i8, i1 } %pair, 0 |
| %u = zext i8 %old to i32 |
| ret i32 %u |
| } |
| |
| ; CHECK-LABEL: cmpxchg_i16_i32_z_with_folded_gep_offset: |
| ; CHECK: i32.atomic.rmw16.cmpxchg_u $push0=, 48($0), $1, $2{{$}} |
| define i32 @cmpxchg_i16_i32_z_with_folded_gep_offset(ptr %p, i32 %exp, i32 %new) { |
| %s = getelementptr inbounds i16, ptr %p, i32 24 |
| %exp_t = trunc i32 %exp to i16 |
| %new_t = trunc i32 %new to i16 |
| %pair = cmpxchg ptr %s, i16 %exp_t, i16 %new_t seq_cst seq_cst |
| %old = extractvalue { i16, i1 } %pair, 0 |
| %u = zext i16 %old to i32 |
| ret i32 %u |
| } |
| |
| ; CHECK-LABEL: cmpxchg_i16_i64_z_with_folded_gep_offset: |
| ; CHECK: i64.atomic.rmw16.cmpxchg_u $push0=, 48($0), $1, $2{{$}} |
| define i64 @cmpxchg_i16_i64_z_with_folded_gep_offset(ptr %p, i64 %exp, i64 %new) { |
| %s = getelementptr inbounds i16, ptr %p, i32 24 |
| %exp_t = trunc i64 %exp to i16 |
| %new_t = trunc i64 %new to i16 |
| %pair = cmpxchg ptr %s, i16 %exp_t, i16 %new_t seq_cst seq_cst |
| %old = extractvalue { i16, i1 } %pair, 0 |
| %u = zext i16 %old 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: cmpxchg_i8_i32_z_with_folded_or_offset: |
| ; CHECK: i32.atomic.rmw8.cmpxchg_u $push[[R1:[0-9]+]]=, 2($pop{{[0-9]+}}), $1, $2{{$}} |
| define i32 @cmpxchg_i8_i32_z_with_folded_or_offset(i32 %x, i32 %exp, i32 %new) { |
| %and = and i32 %x, -4 |
| %t0 = inttoptr i32 %and to ptr |
| %arrayidx = getelementptr inbounds i8, ptr %t0, i32 2 |
| %exp_t = trunc i32 %exp to i8 |
| %new_t = trunc i32 %new to i8 |
| %pair = cmpxchg ptr %arrayidx, i8 %exp_t, i8 %new_t seq_cst seq_cst |
| %old = extractvalue { i8, i1 } %pair, 0 |
| %conv = zext i8 %old to i32 |
| ret i32 %conv |
| } |
| |
| ; CHECK-LABEL: cmpxchg_i8_i64_z_with_folded_or_offset: |
| ; CHECK: i64.atomic.rmw8.cmpxchg_u $push[[R1:[0-9]+]]=, 2($pop{{[0-9]+}}), $1, $2{{$}} |
| define i64 @cmpxchg_i8_i64_z_with_folded_or_offset(i32 %x, i64 %exp, i64 %new) { |
| %and = and i32 %x, -4 |
| %t0 = inttoptr i32 %and to ptr |
| %arrayidx = getelementptr inbounds i8, ptr %t0, i32 2 |
| %exp_t = trunc i64 %exp to i8 |
| %new_t = trunc i64 %new to i8 |
| %pair = cmpxchg ptr %arrayidx, i8 %exp_t, i8 %new_t seq_cst seq_cst |
| %old = extractvalue { i8, i1 } %pair, 0 |
| %conv = zext i8 %old to i64 |
| ret i64 %conv |
| } |
| |
| ; When loading from a fixed address, materialize a zero. |
| |
| ; CHECK-LABEL: cmpxchg_i16_i32_z_from_numeric_address |
| ; CHECK: i32.const $push0=, 0{{$}} |
| ; CHECK: i32.atomic.rmw16.cmpxchg_u $push1=, 42($pop0), $0, $1{{$}} |
| define i32 @cmpxchg_i16_i32_z_from_numeric_address(i32 %exp, i32 %new) { |
| %s = inttoptr i32 42 to ptr |
| %exp_t = trunc i32 %exp to i16 |
| %new_t = trunc i32 %new to i16 |
| %pair = cmpxchg ptr %s, i16 %exp_t, i16 %new_t seq_cst seq_cst |
| %old = extractvalue { i16, i1 } %pair, 0 |
| %u = zext i16 %old to i32 |
| ret i32 %u |
| } |
| |
| ; CHECK-LABEL: cmpxchg_i8_i32_z_from_global_address |
| ; CHECK: i32.const $push0=, 0{{$}} |
| ; CHECK: i32.atomic.rmw8.cmpxchg_u $push1=, gv8($pop0), $0, $1{{$}} |
| define i32 @cmpxchg_i8_i32_z_from_global_address(i32 %exp, i32 %new) { |
| %exp_t = trunc i32 %exp to i8 |
| %new_t = trunc i32 %new to i8 |
| %pair = cmpxchg ptr @gv8, i8 %exp_t, i8 %new_t seq_cst seq_cst |
| %old = extractvalue { i8, i1 } %pair, 0 |
| %u = zext i8 %old to i32 |
| ret i32 %u |
| } |
| |
| ;===---------------------------------------------------------------------------- |
| ; Waits: 32-bit |
| ;===---------------------------------------------------------------------------- |
| |
| declare i32 @llvm.wasm.memory.atomic.wait32(ptr, i32, i64) |
| |
| ; Basic wait. |
| |
| ; CHECK-LABEL: wait32_no_offset: |
| ; CHECK: memory.atomic.wait32 $push0=, 0($0), $1, $2{{$}} |
| ; CHECK-NEXT: return $pop0{{$}} |
| define i32 @wait32_no_offset(ptr %p, i32 %exp, i64 %timeout) { |
| %v = call i32 @llvm.wasm.memory.atomic.wait32(ptr %p, i32 %exp, i64 %timeout) |
| ret i32 %v |
| } |
| |
| ; With an nuw add, we can fold an offset. |
| |
| ; CHECK-LABEL: wait32_with_folded_offset: |
| ; CHECK: memory.atomic.wait32 $push0=, 24($0), $1, $2{{$}} |
| define i32 @wait32_with_folded_offset(ptr %p, i32 %exp, i64 %timeout) { |
| %q = ptrtoint ptr %p to i32 |
| %r = add nuw i32 %q, 24 |
| %s = inttoptr i32 %r to ptr |
| %t = call i32 @llvm.wasm.memory.atomic.wait32(ptr %s, i32 %exp, i64 %timeout) |
| ret i32 %t |
| } |
| |
| ; With an inbounds gep, we can fold an offset. |
| |
| ; CHECK-LABEL: wait32_with_folded_gep_offset: |
| ; CHECK: memory.atomic.wait32 $push0=, 24($0), $1, $2{{$}} |
| define i32 @wait32_with_folded_gep_offset(ptr %p, i32 %exp, i64 %timeout) { |
| %s = getelementptr inbounds i32, ptr %p, i32 6 |
| %t = call i32 @llvm.wasm.memory.atomic.wait32(ptr %s, i32 %exp, i64 %timeout) |
| ret i32 %t |
| } |
| |
| ; We can't fold a negative offset though, even with an inbounds gep. |
| |
| ; CHECK-LABEL: wait32_with_unfolded_gep_negative_offset: |
| ; CHECK: i32.const $push0=, -24{{$}} |
| ; CHECK: i32.add $push1=, $0, $pop0{{$}} |
| ; CHECK: memory.atomic.wait32 $push2=, 0($pop1), $1, $2{{$}} |
| define i32 @wait32_with_unfolded_gep_negative_offset(ptr %p, i32 %exp, i64 %timeout) { |
| %s = getelementptr inbounds i32, ptr %p, i32 -6 |
| %t = call i32 @llvm.wasm.memory.atomic.wait32(ptr %s, i32 %exp, i64 %timeout) |
| ret i32 %t |
| } |
| |
| ; Without nuw, and even with nsw, we can't fold an offset. |
| |
| ; CHECK-LABEL: wait32_with_unfolded_offset: |
| ; CHECK: i32.const $push0=, 24{{$}} |
| ; CHECK: i32.add $push1=, $0, $pop0{{$}} |
| ; CHECK: memory.atomic.wait32 $push2=, 0($pop1), $1, $2{{$}} |
| define i32 @wait32_with_unfolded_offset(ptr %p, i32 %exp, i64 %timeout) { |
| %q = ptrtoint ptr %p to i32 |
| %r = add nsw i32 %q, 24 |
| %s = inttoptr i32 %r to ptr |
| %t = call i32 @llvm.wasm.memory.atomic.wait32(ptr %s, i32 %exp, i64 %timeout) |
| ret i32 %t |
| } |
| |
| ; Without inbounds, we can't fold a gep offset. |
| |
| ; CHECK-LABEL: wait32_with_unfolded_gep_offset: |
| ; CHECK: i32.const $push0=, 24{{$}} |
| ; CHECK: i32.add $push1=, $0, $pop0{{$}} |
| ; CHECK: memory.atomic.wait32 $push2=, 0($pop1), $1, $2{{$}} |
| define i32 @wait32_with_unfolded_gep_offset(ptr %p, i32 %exp, i64 %timeout) { |
| %s = getelementptr i32, ptr %p, i32 6 |
| %t = call i32 @llvm.wasm.memory.atomic.wait32(ptr %s, i32 %exp, i64 %timeout) |
| ret i32 %t |
| } |
| |
| ; When waiting from a fixed address, materialize a zero. |
| |
| ; CHECK-LABEL: wait32_from_numeric_address |
| ; CHECK: i32.const $push0=, 0{{$}} |
| ; CHECK: memory.atomic.wait32 $push1=, 42($pop0), $0, $1{{$}} |
| define i32 @wait32_from_numeric_address(i32 %exp, i64 %timeout) { |
| %s = inttoptr i32 42 to ptr |
| %t = call i32 @llvm.wasm.memory.atomic.wait32(ptr %s, i32 %exp, i64 %timeout) |
| ret i32 %t |
| } |
| |
| ; CHECK-LABEL: wait32_from_global_address |
| ; CHECK: i32.const $push0=, 0{{$}} |
| ; CHECK: memory.atomic.wait32 $push1=, gv($pop0), $0, $1{{$}} |
| define i32 @wait32_from_global_address(i32 %exp, i64 %timeout) { |
| %t = call i32 @llvm.wasm.memory.atomic.wait32(ptr @gv, i32 %exp, i64 %timeout) |
| ret i32 %t |
| } |
| |
| ;===---------------------------------------------------------------------------- |
| ; Waits: 64-bit |
| ;===---------------------------------------------------------------------------- |
| |
| declare i32 @llvm.wasm.memory.atomic.wait64(ptr, i64, i64) |
| |
| ; Basic wait. |
| |
| ; CHECK-LABEL: wait64_no_offset: |
| ; CHECK: memory.atomic.wait64 $push0=, 0($0), $1, $2{{$}} |
| ; CHECK-NEXT: return $pop0{{$}} |
| define i32 @wait64_no_offset(ptr %p, i64 %exp, i64 %timeout) { |
| %v = call i32 @llvm.wasm.memory.atomic.wait64(ptr %p, i64 %exp, i64 %timeout) |
| ret i32 %v |
| } |
| |
| ; With an nuw add, we can fold an offset. |
| |
| ; CHECK-LABEL: wait64_with_folded_offset: |
| ; CHECK: memory.atomic.wait64 $push0=, 24($0), $1, $2{{$}} |
| define i32 @wait64_with_folded_offset(ptr %p, i64 %exp, i64 %timeout) { |
| %q = ptrtoint ptr %p to i32 |
| %r = add nuw i32 %q, 24 |
| %s = inttoptr i32 %r to ptr |
| %t = call i32 @llvm.wasm.memory.atomic.wait64(ptr %s, i64 %exp, i64 %timeout) |
| ret i32 %t |
| } |
| |
| ; With an inbounds gep, we can fold an offset. |
| |
| ; CHECK-LABEL: wait64_with_folded_gep_offset: |
| ; CHECK: memory.atomic.wait64 $push0=, 24($0), $1, $2{{$}} |
| define i32 @wait64_with_folded_gep_offset(ptr %p, i64 %exp, i64 %timeout) { |
| %s = getelementptr inbounds i64, ptr %p, i32 3 |
| %t = call i32 @llvm.wasm.memory.atomic.wait64(ptr %s, i64 %exp, i64 %timeout) |
| ret i32 %t |
| } |
| |
| ; We can't fold a negative offset though, even with an inbounds gep. |
| |
| ; CHECK-LABEL: wait64_with_unfolded_gep_negative_offset: |
| ; CHECK: i32.const $push0=, -24{{$}} |
| ; CHECK: i32.add $push1=, $0, $pop0{{$}} |
| ; CHECK: memory.atomic.wait64 $push2=, 0($pop1), $1, $2{{$}} |
| define i32 @wait64_with_unfolded_gep_negative_offset(ptr %p, i64 %exp, i64 %timeout) { |
| %s = getelementptr inbounds i64, ptr %p, i32 -3 |
| %t = call i32 @llvm.wasm.memory.atomic.wait64(ptr %s, i64 %exp, i64 %timeout) |
| ret i32 %t |
| } |
| |
| ; Without nuw, and even with nsw, we can't fold an offset. |
| |
| ; CHECK-LABEL: wait64_with_unfolded_offset: |
| ; CHECK: i32.const $push0=, 24{{$}} |
| ; CHECK: i32.add $push1=, $0, $pop0{{$}} |
| ; CHECK: memory.atomic.wait64 $push2=, 0($pop1), $1, $2{{$}} |
| define i32 @wait64_with_unfolded_offset(ptr %p, i64 %exp, i64 %timeout) { |
| %q = ptrtoint ptr %p to i32 |
| %r = add nsw i32 %q, 24 |
| %s = inttoptr i32 %r to ptr |
| %t = call i32 @llvm.wasm.memory.atomic.wait64(ptr %s, i64 %exp, i64 %timeout) |
| ret i32 %t |
| } |
| |
| ; Without inbounds, we can't fold a gep offset. |
| |
| ; CHECK-LABEL: wait64_with_unfolded_gep_offset: |
| ; CHECK: i32.const $push0=, 24{{$}} |
| ; CHECK: i32.add $push1=, $0, $pop0{{$}} |
| ; CHECK: memory.atomic.wait64 $push2=, 0($pop1), $1, $2{{$}} |
| define i32 @wait64_with_unfolded_gep_offset(ptr %p, i64 %exp, i64 %timeout) { |
| %s = getelementptr i64, ptr %p, i32 3 |
| %t = call i32 @llvm.wasm.memory.atomic.wait64(ptr %s, i64 %exp, i64 %timeout) |
| ret i32 %t |
| } |
| |
| ;===---------------------------------------------------------------------------- |
| ; Notifies |
| ;===---------------------------------------------------------------------------- |
| |
| declare i32 @llvm.wasm.memory.atomic.notify(ptr, i32) |
| |
| ; Basic notify. |
| |
| ; CHECK-LABEL: notify_no_offset: |
| ; CHECK: memory.atomic.notify $push0=, 0($0), $1{{$}} |
| ; CHECK-NEXT: return $pop0{{$}} |
| define i32 @notify_no_offset(ptr %p, i32 %notify_count) { |
| %v = call i32 @llvm.wasm.memory.atomic.notify(ptr %p, i32 %notify_count) |
| ret i32 %v |
| } |
| |
| ; With an nuw add, we can fold an offset. |
| |
| ; CHECK-LABEL: notify_with_folded_offset: |
| ; CHECK: memory.atomic.notify $push0=, 24($0), $1{{$}} |
| define i32 @notify_with_folded_offset(ptr %p, i32 %notify_count) { |
| %q = ptrtoint ptr %p to i32 |
| %r = add nuw i32 %q, 24 |
| %s = inttoptr i32 %r to ptr |
| %t = call i32 @llvm.wasm.memory.atomic.notify(ptr %s, i32 %notify_count) |
| ret i32 %t |
| } |
| |
| ; With an inbounds gep, we can fold an offset. |
| |
| ; CHECK-LABEL: notify_with_folded_gep_offset: |
| ; CHECK: memory.atomic.notify $push0=, 24($0), $1{{$}} |
| define i32 @notify_with_folded_gep_offset(ptr %p, i32 %notify_count) { |
| %s = getelementptr inbounds i32, ptr %p, i32 6 |
| %t = call i32 @llvm.wasm.memory.atomic.notify(ptr %s, i32 %notify_count) |
| ret i32 %t |
| } |
| |
| ; We can't fold a negative offset though, even with an inbounds gep. |
| |
| ; CHECK-LABEL: notify_with_unfolded_gep_negative_offset: |
| ; CHECK: i32.const $push0=, -24{{$}} |
| ; CHECK: i32.add $push1=, $0, $pop0{{$}} |
| ; CHECK: memory.atomic.notify $push2=, 0($pop1), $1{{$}} |
| define i32 @notify_with_unfolded_gep_negative_offset(ptr %p, i32 %notify_count) { |
| %s = getelementptr inbounds i32, ptr %p, i32 -6 |
| %t = call i32 @llvm.wasm.memory.atomic.notify(ptr %s, i32 %notify_count) |
| ret i32 %t |
| } |
| |
| ; Without nuw, and even with nsw, we can't fold an offset. |
| |
| ; CHECK-LABEL: notify_with_unfolded_offset: |
| ; CHECK: i32.const $push0=, 24{{$}} |
| ; CHECK: i32.add $push1=, $0, $pop0{{$}} |
| ; CHECK: memory.atomic.notify $push2=, 0($pop1), $1{{$}} |
| define i32 @notify_with_unfolded_offset(ptr %p, i32 %notify_count) { |
| %q = ptrtoint ptr %p to i32 |
| %r = add nsw i32 %q, 24 |
| %s = inttoptr i32 %r to ptr |
| %t = call i32 @llvm.wasm.memory.atomic.notify(ptr %s, i32 %notify_count) |
| ret i32 %t |
| } |
| |
| ; Without inbounds, we can't fold a gep offset. |
| |
| ; CHECK-LABEL: notify_with_unfolded_gep_offset: |
| ; CHECK: i32.const $push0=, 24{{$}} |
| ; CHECK: i32.add $push1=, $0, $pop0{{$}} |
| ; CHECK: memory.atomic.notify $push2=, 0($pop1), $1{{$}} |
| define i32 @notify_with_unfolded_gep_offset(ptr %p, i32 %notify_count) { |
| %s = getelementptr i32, ptr %p, i32 6 |
| %t = call i32 @llvm.wasm.memory.atomic.notify(ptr %s, i32 %notify_count) |
| ret i32 %t |
| } |
| |
| ; When notifying from a fixed address, materialize a zero. |
| |
| ; CHECK-LABEL: notify_from_numeric_address |
| ; CHECK: i32.const $push0=, 0{{$}} |
| ; CHECK: memory.atomic.notify $push1=, 42($pop0), $0{{$}} |
| define i32 @notify_from_numeric_address(i32 %notify_count) { |
| %s = inttoptr i32 42 to ptr |
| %t = call i32 @llvm.wasm.memory.atomic.notify(ptr %s, i32 %notify_count) |
| ret i32 %t |
| } |
| |
| ; CHECK-LABEL: notify_from_global_address |
| ; CHECK: i32.const $push0=, 0{{$}} |
| ; CHECK: memory.atomic.notify $push1=, gv($pop0), $0{{$}} |
| define i32 @notify_from_global_address(i32 %notify_count) { |
| %t = call i32 @llvm.wasm.memory.atomic.notify(ptr @gv, i32 %notify_count) |
| ret i32 %t |
| } |