This is an archive of the discontinued LLVM Phabricator instance.

Differential D149780

[WebAssembly] Remove incorrect result from wasm64 store_lane instructions
ClosedPublic

Authored by tlively on May 3 2023, 12:38 PM.

Details

Reviewers
sbc100
Commits
rGabdb5e041ce2: [WebAssembly] Remove incorrect result from wasm64 store_lane instructions
Summary

The wasm64 versions of the v128.storeX_lane instructions was incorrectly defined
as returning a v128 value, which resulted in spurious drop instructions being
emitted and causing validation to fail. This was not caught earlier because
wasm64 has been experimental and not well tested. Update the relevant test file
to test both wasm32 and wasm64.

Fixes #62443.

Diff Detail

Event Timeline

tlively created this revision.May 3 2023, 12:38 PM
Herald added a project: Restricted Project. · View Herald TranscriptMay 3 2023, 12:38 PM
Herald added subscribers: pmatos, asb, wingo and 5 others. · View Herald Transcript
tlively requested review of this revision.May 3 2023, 12:38 PM
Herald added a project: Restricted Project. · View Herald TranscriptMay 3 2023, 12:38 PM
Herald added subscribers: llvm-commits, aheejin. · View Herald Transcript
tlively updated this revision to Diff 519225.May 3 2023, 1:09 PM
  • Update additional test
sbc100 added a comment.May 3 2023, 2:06 PM

Nice! God knows how long it would have taken me to find that one!

sbc100 accepted this revision.May 3 2023, 2:07 PM
This revision is now accepted and ready to land.May 3 2023, 2:07 PM
Harbormaster completed remote builds in B229796: Diff 519225.May 3 2023, 2:34 PM
Closed by commit rGabdb5e041ce2: [WebAssembly] Remove incorrect result from wasm64 store_lane instructions (authored by tlively). · Explain WhyMay 3 2023, 4:00 PM
This revision was automatically updated to reflect the committed changes.
tlively added a commit: rGabdb5e041ce2: [WebAssembly] Remove incorrect result from wasm64 store_lane instructions.

Revision Contents

PathSize
llvm/
lib/
Target/
WebAssembly/
2 lines
test/
CodeGen/
WebAssembly/
1 line
621 lines

Diff 519291

llvm/lib/Target/WebAssembly/WebAssemblyInstrSIMD.td

Show First 20 Lines • Show All 370 Lines • ▼ Show 20 Linesmulticlass SIMDStoreLane<Vec vec, bits<32> simdop> {
defm STORE_LANE_#vec#_A32 : defm STORE_LANE_#vec#_A32 :
SIMD_I<(outs), SIMD_I<(outs),
(ins P2Align:$p2align, offset32_op:$off, vec_i8imm_op:$idx, (ins P2Align:$p2align, offset32_op:$off, vec_i8imm_op:$idx,
I32:$addr, V128:$vec), I32:$addr, V128:$vec),
(outs), (ins P2Align:$p2align, offset32_op:$off, vec_i8imm_op:$idx), (outs), (ins P2Align:$p2align, offset32_op:$off, vec_i8imm_op:$idx),
[], name#"\t${off}(${addr})$p2align, $vec, $idx", [], name#"\t${off}(${addr})$p2align, $vec, $idx",
name#"\t$off$p2align, $idx", simdop>; name#"\t$off$p2align, $idx", simdop>;
defm STORE_LANE_#vec#_A64 : defm STORE_LANE_#vec#_A64 :
SIMD_I<(outs V128:$dst), SIMD_I<(outs),
(ins P2Align:$p2align, offset64_op:$off, vec_i8imm_op:$idx, (ins P2Align:$p2align, offset64_op:$off, vec_i8imm_op:$idx,
I64:$addr, V128:$vec), I64:$addr, V128:$vec),
(outs), (ins P2Align:$p2align, offset64_op:$off, vec_i8imm_op:$idx), (outs), (ins P2Align:$p2align, offset64_op:$off, vec_i8imm_op:$idx),
[], name#"\t${off}(${addr})$p2align, $vec, $idx", [], name#"\t${off}(${addr})$p2align, $vec, $idx",
name#"\t$off$p2align, $idx", simdop>; name#"\t$off$p2align, $idx", simdop>;
} // mayStore = 1, UseNamedOperandTable = 1 } // mayStore = 1, UseNamedOperandTable = 1
} }
▲ Show 20 Lines • Show All 1,094 Lines • Show Last 20 Lines

llvm/test/CodeGen/WebAssembly/pr59626.ll

Show All 28 Lines
; CHECK-64-NEXT: i32.store8 2 ; CHECK-64-NEXT: i32.store8 2
; CHECK-64-NEXT: local.get 0 ; CHECK-64-NEXT: local.get 0
; CHECK-64-NEXT: i32.const 0 ; CHECK-64-NEXT: i32.const 0
; CHECK-64-NEXT: i32.store16 0 ; CHECK-64-NEXT: i32.store16 0
; CHECK-64-NEXT: local.get 1 ; CHECK-64-NEXT: local.get 1
; CHECK-64-NEXT: local.get 2 ; CHECK-64-NEXT: local.get 2
; CHECK-64-NEXT: i8x16.splat ; CHECK-64-NEXT: i8x16.splat
; CHECK-64-NEXT: v128.store16_lane 0, 0 ; CHECK-64-NEXT: v128.store16_lane 0, 0
; CHECK-64-NEXT: drop
; CHECK-64-NEXT: v128.const 0, 0 ; CHECK-64-NEXT: v128.const 0, 0
; CHECK-64-NEXT: i32x4.extract_lane 0 ; CHECK-64-NEXT: i32x4.extract_lane 0
; CHECK-64-NEXT: # fallthrough-return ; CHECK-64-NEXT: # fallthrough-return
BB: BB:
store <3 x i8> zeroinitializer, ptr %0 store <3 x i8> zeroinitializer, ptr %0
%S = shufflevector <3 x i128> zeroinitializer, <3 x i128> <i128 0, i128 1, i128 2>, <3 x i32> undef %S = shufflevector <3 x i128> zeroinitializer, <3 x i128> <i128 0, i128 1, i128 2>, <3 x i32> undef
%C = icmp ule <3 x i128> %S, zeroinitializer %C = icmp ule <3 x i128> %S, zeroinitializer
%C1 = zext <3 x i1> %C to <3 x i8> %C1 = zext <3 x i1> %C to <3 x i8>
%E = extractelement <3 x i8> %C1, i32 0 %E = extractelement <3 x i8> %C1, i32 0
%B = sdiv <3 x i8> <i8 1, i8 3, i8 5>, %C1 %B = sdiv <3 x i8> <i8 1, i8 3, i8 5>, %C1
store <3 x i8> %B, ptr %1 store <3 x i8> %B, ptr %1
ret i8 %E ret i8 %E
} }

llvm/test/CodeGen/WebAssembly/simd-load-lane-offset.ll

; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
; RUN: llc < %s -verify-machineinstrs -mattr=+simd128 | FileCheck %s ; RUN: llc < %s -verify-machineinstrs -mattr=+simd128 -mtriple=wasm32-unknown-unknown | FileCheck %s
; RUN: llc < %s -verify-machineinstrs -mattr=+simd128 -mtriple=wasm64-unknown-unknown | FileCheck %s --check-prefix MEM64
; Test SIMD v128.load{8,16,32,64}_lane instructions. ; Test SIMD v128.load{8,16,32,64}_lane instructions.
; TODO: Use the offset field by supporting more patterns. Right now only the ; TODO: Use the offset field by supporting more patterns. Right now only the
; equivalents of LoadPatNoOffset/StorePatNoOffset are supported. ; equivalents of LoadPatNoOffset/StorePatNoOffset are supported.
target triple = "wasm32-unknown-unknown"
;===---------------------------------------------------------------------------- ;===----------------------------------------------------------------------------
; v128.load8_lane / v128.store8_lane ; v128.load8_lane / v128.store8_lane
;===---------------------------------------------------------------------------- ;===----------------------------------------------------------------------------
define <16 x i8> @load_lane_i8_no_offset(ptr %p, <16 x i8> %v) { define <16 x i8> @load_lane_i8_no_offset(ptr %p, <16 x i8> %v) {
; CHECK-LABEL: load_lane_i8_no_offset: ; CHECK-LABEL: load_lane_i8_no_offset:
; CHECK: .functype load_lane_i8_no_offset (i32, v128) -> (v128) ; CHECK: .functype load_lane_i8_no_offset (i32, v128) -> (v128)
; CHECK-NEXT: # %bb.0: ; CHECK-NEXT: # %bb.0:
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: local.get 1 ; CHECK-NEXT: local.get 1
; CHECK-NEXT: v128.load8_lane 0, 0 ; CHECK-NEXT: v128.load8_lane 0, 0
; CHECK-NEXT: # fallthrough-return ; CHECK-NEXT: # fallthrough-return
;
; MEM64-LABEL: load_lane_i8_no_offset:
; MEM64: .functype load_lane_i8_no_offset (i64, v128) -> (v128)
; MEM64-NEXT: # %bb.0:
; MEM64-NEXT: local.get 0
; MEM64-NEXT: local.get 1
; MEM64-NEXT: v128.load8_lane 0, 0
; MEM64-NEXT: # fallthrough-return
%x = load i8, ptr %p %x = load i8, ptr %p
%t = insertelement <16 x i8> %v, i8 %x, i32 0 %t = insertelement <16 x i8> %v, i8 %x, i32 0
ret <16 x i8> %t ret <16 x i8> %t
} }
define <16 x i8> @load_lane_i8_with_folded_offset(ptr %p, <16 x i8> %v) { define <16 x i8> @load_lane_i8_with_folded_offset(ptr %p, <16 x i8> %v) {
; CHECK-LABEL: load_lane_i8_with_folded_offset: ; CHECK-LABEL: load_lane_i8_with_folded_offset:
; CHECK: .functype load_lane_i8_with_folded_offset (i32, v128) -> (v128) ; CHECK: .functype load_lane_i8_with_folded_offset (i32, v128) -> (v128)
; CHECK-NEXT: # %bb.0: ; CHECK-NEXT: # %bb.0:
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: i32.const 24 ; CHECK-NEXT: i32.const 24
; CHECK-NEXT: i32.add ; CHECK-NEXT: i32.add
; CHECK-NEXT: local.get 1 ; CHECK-NEXT: local.get 1
; CHECK-NEXT: v128.load8_lane 0, 0 ; CHECK-NEXT: v128.load8_lane 0, 0
; CHECK-NEXT: # fallthrough-return ; CHECK-NEXT: # fallthrough-return
;
; MEM64-LABEL: load_lane_i8_with_folded_offset:
; MEM64: .functype load_lane_i8_with_folded_offset (i64, v128) -> (v128)
; MEM64-NEXT: # %bb.0:
; MEM64-NEXT: local.get 0
; MEM64-NEXT: i32.wrap_i64
; MEM64-NEXT: i32.const 24
; MEM64-NEXT: i32.add
; MEM64-NEXT: i64.extend_i32_u
; MEM64-NEXT: local.get 1
; MEM64-NEXT: v128.load8_lane 0, 0
; MEM64-NEXT: # fallthrough-return
%q = ptrtoint ptr %p to i32 %q = ptrtoint ptr %p to i32
%r = add nuw i32 %q, 24 %r = add nuw i32 %q, 24
%s = inttoptr i32 %r to ptr %s = inttoptr i32 %r to ptr
%x = load i8, ptr %s %x = load i8, ptr %s
%t = insertelement <16 x i8> %v, i8 %x, i32 0 %t = insertelement <16 x i8> %v, i8 %x, i32 0
ret <16 x i8> %t ret <16 x i8> %t
} }
define <16 x i8> @load_lane_i8_with_folded_gep_offset(ptr %p, <16 x i8> %v) { define <16 x i8> @load_lane_i8_with_folded_gep_offset(ptr %p, <16 x i8> %v) {
; CHECK-LABEL: load_lane_i8_with_folded_gep_offset: ; CHECK-LABEL: load_lane_i8_with_folded_gep_offset:
; CHECK: .functype load_lane_i8_with_folded_gep_offset (i32, v128) -> (v128) ; CHECK: .functype load_lane_i8_with_folded_gep_offset (i32, v128) -> (v128)
; CHECK-NEXT: # %bb.0: ; CHECK-NEXT: # %bb.0:
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: i32.const 6 ; CHECK-NEXT: i32.const 6
; CHECK-NEXT: i32.add ; CHECK-NEXT: i32.add
; CHECK-NEXT: local.get 1 ; CHECK-NEXT: local.get 1
; CHECK-NEXT: v128.load8_lane 0, 0 ; CHECK-NEXT: v128.load8_lane 0, 0
; CHECK-NEXT: # fallthrough-return ; CHECK-NEXT: # fallthrough-return
;
; MEM64-LABEL: load_lane_i8_with_folded_gep_offset:
; MEM64: .functype load_lane_i8_with_folded_gep_offset (i64, v128) -> (v128)
; MEM64-NEXT: # %bb.0:
; MEM64-NEXT: local.get 0
; MEM64-NEXT: i64.const 6
; MEM64-NEXT: i64.add
; MEM64-NEXT: local.get 1
; MEM64-NEXT: v128.load8_lane 0, 0
; MEM64-NEXT: # fallthrough-return
%s = getelementptr inbounds i8, ptr %p, i32 6 %s = getelementptr inbounds i8, ptr %p, i32 6
%x = load i8, ptr %s %x = load i8, ptr %s
%t = insertelement <16 x i8> %v, i8 %x, i32 0 %t = insertelement <16 x i8> %v, i8 %x, i32 0
ret <16 x i8> %t ret <16 x i8> %t
} }
define <16 x i8> @load_lane_i8_with_unfolded_gep_negative_offset(ptr %p, <16 x i8> %v) { define <16 x i8> @load_lane_i8_with_unfolded_gep_negative_offset(ptr %p, <16 x i8> %v) {
; CHECK-LABEL: load_lane_i8_with_unfolded_gep_negative_offset: ; CHECK-LABEL: load_lane_i8_with_unfolded_gep_negative_offset:
; CHECK: .functype load_lane_i8_with_unfolded_gep_negative_offset (i32, v128) -> (v128) ; CHECK: .functype load_lane_i8_with_unfolded_gep_negative_offset (i32, v128) -> (v128)
; CHECK-NEXT: # %bb.0: ; CHECK-NEXT: # %bb.0:
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: i32.const -6 ; CHECK-NEXT: i32.const -6
; CHECK-NEXT: i32.add ; CHECK-NEXT: i32.add
; CHECK-NEXT: local.get 1 ; CHECK-NEXT: local.get 1
; CHECK-NEXT: v128.load8_lane 0, 0 ; CHECK-NEXT: v128.load8_lane 0, 0
; CHECK-NEXT: # fallthrough-return ; CHECK-NEXT: # fallthrough-return
;
; MEM64-LABEL: load_lane_i8_with_unfolded_gep_negative_offset:
; MEM64: .functype load_lane_i8_with_unfolded_gep_negative_offset (i64, v128) -> (v128)
; MEM64-NEXT: # %bb.0:
; MEM64-NEXT: local.get 0
; MEM64-NEXT: i64.const -6
; MEM64-NEXT: i64.add
; MEM64-NEXT: local.get 1
; MEM64-NEXT: v128.load8_lane 0, 0
; MEM64-NEXT: # fallthrough-return
%s = getelementptr inbounds i8, ptr %p, i32 -6 %s = getelementptr inbounds i8, ptr %p, i32 -6
%x = load i8, ptr %s %x = load i8, ptr %s
%t = insertelement <16 x i8> %v, i8 %x, i32 0 %t = insertelement <16 x i8> %v, i8 %x, i32 0
ret <16 x i8> %t ret <16 x i8> %t
} }
define <16 x i8> @load_lane_i8_with_unfolded_offset(ptr %p, <16 x i8> %v) { define <16 x i8> @load_lane_i8_with_unfolded_offset(ptr %p, <16 x i8> %v) {
; CHECK-LABEL: load_lane_i8_with_unfolded_offset: ; CHECK-LABEL: load_lane_i8_with_unfolded_offset:
; CHECK: .functype load_lane_i8_with_unfolded_offset (i32, v128) -> (v128) ; CHECK: .functype load_lane_i8_with_unfolded_offset (i32, v128) -> (v128)
; CHECK-NEXT: # %bb.0: ; CHECK-NEXT: # %bb.0:
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: i32.const 24 ; CHECK-NEXT: i32.const 24
; CHECK-NEXT: i32.add ; CHECK-NEXT: i32.add
; CHECK-NEXT: local.get 1 ; CHECK-NEXT: local.get 1
; CHECK-NEXT: v128.load8_lane 0, 0 ; CHECK-NEXT: v128.load8_lane 0, 0
; CHECK-NEXT: # fallthrough-return ; CHECK-NEXT: # fallthrough-return
;
; MEM64-LABEL: load_lane_i8_with_unfolded_offset:
; MEM64: .functype load_lane_i8_with_unfolded_offset (i64, v128) -> (v128)
; MEM64-NEXT: # %bb.0:
; MEM64-NEXT: local.get 0
; MEM64-NEXT: i32.wrap_i64
; MEM64-NEXT: i32.const 24
; MEM64-NEXT: i32.add
; MEM64-NEXT: i64.extend_i32_u
; MEM64-NEXT: local.get 1
; MEM64-NEXT: v128.load8_lane 0, 0
; MEM64-NEXT: # fallthrough-return
%q = ptrtoint ptr %p to i32 %q = ptrtoint ptr %p to i32
%r = add nsw i32 %q, 24 %r = add nsw i32 %q, 24
%s = inttoptr i32 %r to ptr %s = inttoptr i32 %r to ptr
%x = load i8, ptr %s %x = load i8, ptr %s
%t = insertelement <16 x i8> %v, i8 %x, i32 0 %t = insertelement <16 x i8> %v, i8 %x, i32 0
ret <16 x i8> %t ret <16 x i8> %t
} }
define <16 x i8> @load_lane_i8_with_unfolded_gep_offset(ptr %p, <16 x i8> %v) { define <16 x i8> @load_lane_i8_with_unfolded_gep_offset(ptr %p, <16 x i8> %v) {
; CHECK-LABEL: load_lane_i8_with_unfolded_gep_offset: ; CHECK-LABEL: load_lane_i8_with_unfolded_gep_offset:
; CHECK: .functype load_lane_i8_with_unfolded_gep_offset (i32, v128) -> (v128) ; CHECK: .functype load_lane_i8_with_unfolded_gep_offset (i32, v128) -> (v128)
; CHECK-NEXT: # %bb.0: ; CHECK-NEXT: # %bb.0:
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: i32.const 6 ; CHECK-NEXT: i32.const 6
; CHECK-NEXT: i32.add ; CHECK-NEXT: i32.add
; CHECK-NEXT: local.get 1 ; CHECK-NEXT: local.get 1
; CHECK-NEXT: v128.load8_lane 0, 0 ; CHECK-NEXT: v128.load8_lane 0, 0
; CHECK-NEXT: # fallthrough-return ; CHECK-NEXT: # fallthrough-return
;
; MEM64-LABEL: load_lane_i8_with_unfolded_gep_offset:
; MEM64: .functype load_lane_i8_with_unfolded_gep_offset (i64, v128) -> (v128)
; MEM64-NEXT: # %bb.0:
; MEM64-NEXT: local.get 0
; MEM64-NEXT: i64.const 6
; MEM64-NEXT: i64.add
; MEM64-NEXT: local.get 1
; MEM64-NEXT: v128.load8_lane 0, 0
; MEM64-NEXT: # fallthrough-return
%s = getelementptr i8, ptr %p, i32 6 %s = getelementptr i8, ptr %p, i32 6
%x = load i8, ptr %s %x = load i8, ptr %s
%t = insertelement <16 x i8> %v, i8 %x, i32 0 %t = insertelement <16 x i8> %v, i8 %x, i32 0
ret <16 x i8> %t ret <16 x i8> %t
} }
define <16 x i8> @load_lane_i8_from_numeric_address(<16 x i8> %v) { define <16 x i8> @load_lane_i8_from_numeric_address(<16 x i8> %v) {
; CHECK-LABEL: load_lane_i8_from_numeric_address: ; CHECK-LABEL: load_lane_i8_from_numeric_address:
; CHECK: .functype load_lane_i8_from_numeric_address (v128) -> (v128) ; CHECK: .functype load_lane_i8_from_numeric_address (v128) -> (v128)
; CHECK-NEXT: # %bb.0: ; CHECK-NEXT: # %bb.0:
; CHECK-NEXT: i32.const 42 ; CHECK-NEXT: i32.const 42
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: v128.load8_lane 0, 0 ; CHECK-NEXT: v128.load8_lane 0, 0
; CHECK-NEXT: # fallthrough-return ; CHECK-NEXT: # fallthrough-return
;
; MEM64-LABEL: load_lane_i8_from_numeric_address:
; MEM64: .functype load_lane_i8_from_numeric_address (v128) -> (v128)
; MEM64-NEXT: # %bb.0:
; MEM64-NEXT: i64.const 42
; MEM64-NEXT: local.get 0
; MEM64-NEXT: v128.load8_lane 0, 0
; MEM64-NEXT: # fallthrough-return
%s = inttoptr i32 42 to ptr %s = inttoptr i32 42 to ptr
%x = load i8, ptr %s %x = load i8, ptr %s
%t = insertelement <16 x i8> %v, i8 %x, i32 0 %t = insertelement <16 x i8> %v, i8 %x, i32 0
ret <16 x i8> %t ret <16 x i8> %t
} }
@gv_i8 = global i8 0 @gv_i8 = global i8 0
define <16 x i8> @load_lane_i8_from_global_address(<16 x i8> %v) { define <16 x i8> @load_lane_i8_from_global_address(<16 x i8> %v) {
; CHECK-LABEL: load_lane_i8_from_global_address: ; CHECK-LABEL: load_lane_i8_from_global_address:
; CHECK: .functype load_lane_i8_from_global_address (v128) -> (v128) ; CHECK: .functype load_lane_i8_from_global_address (v128) -> (v128)
; CHECK-NEXT: # %bb.0: ; CHECK-NEXT: # %bb.0:
; CHECK-NEXT: i32.const gv_i8 ; CHECK-NEXT: i32.const gv_i8
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: v128.load8_lane 0, 0 ; CHECK-NEXT: v128.load8_lane 0, 0
; CHECK-NEXT: # fallthrough-return ; CHECK-NEXT: # fallthrough-return
;
; MEM64-LABEL: load_lane_i8_from_global_address:
; MEM64: .functype load_lane_i8_from_global_address (v128) -> (v128)
; MEM64-NEXT: # %bb.0:
; MEM64-NEXT: i64.const gv_i8
; MEM64-NEXT: local.get 0
; MEM64-NEXT: v128.load8_lane 0, 0
; MEM64-NEXT: # fallthrough-return
%x = load i8, ptr @gv_i8 %x = load i8, ptr @gv_i8
%t = insertelement <16 x i8> %v, i8 %x, i32 0 %t = insertelement <16 x i8> %v, i8 %x, i32 0
ret <16 x i8> %t ret <16 x i8> %t
} }
define void @store_lane_i8_no_offset(<16 x i8> %v, ptr %p) { define void @store_lane_i8_no_offset(<16 x i8> %v, ptr %p) {
; CHECK-LABEL: store_lane_i8_no_offset: ; CHECK-LABEL: store_lane_i8_no_offset:
; CHECK: .functype store_lane_i8_no_offset (v128, i32) -> () ; CHECK: .functype store_lane_i8_no_offset (v128, i32) -> ()
; CHECK-NEXT: # %bb.0: ; CHECK-NEXT: # %bb.0:
; CHECK-NEXT: local.get 1 ; CHECK-NEXT: local.get 1
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: v128.store8_lane 0, 0 ; CHECK-NEXT: v128.store8_lane 0, 0
; CHECK-NEXT: # fallthrough-return ; CHECK-NEXT: # fallthrough-return
;
; MEM64-LABEL: store_lane_i8_no_offset:
; MEM64: .functype store_lane_i8_no_offset (v128, i64) -> ()
; MEM64-NEXT: # %bb.0:
; MEM64-NEXT: local.get 1
; MEM64-NEXT: local.get 0
; MEM64-NEXT: v128.store8_lane 0, 0
; MEM64-NEXT: # fallthrough-return
%x = extractelement <16 x i8> %v, i32 0 %x = extractelement <16 x i8> %v, i32 0
store i8 %x, ptr %p store i8 %x, ptr %p
ret void ret void
} }
define void @store_lane_i8_with_folded_offset(<16 x i8> %v, ptr %p) { define void @store_lane_i8_with_folded_offset(<16 x i8> %v, ptr %p) {
; CHECK-LABEL: store_lane_i8_with_folded_offset: ; CHECK-LABEL: store_lane_i8_with_folded_offset:
; CHECK: .functype store_lane_i8_with_folded_offset (v128, i32) -> () ; CHECK: .functype store_lane_i8_with_folded_offset (v128, i32) -> ()
; CHECK-NEXT: # %bb.0: ; CHECK-NEXT: # %bb.0:
; CHECK-NEXT: local.get 1 ; CHECK-NEXT: local.get 1
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: v128.store8_lane 24, 0 ; CHECK-NEXT: v128.store8_lane 24, 0
; CHECK-NEXT: # fallthrough-return ; CHECK-NEXT: # fallthrough-return
;
; MEM64-LABEL: store_lane_i8_with_folded_offset:
; MEM64: .functype store_lane_i8_with_folded_offset (v128, i64) -> ()
; MEM64-NEXT: # %bb.0:
; MEM64-NEXT: local.get 1
; MEM64-NEXT: i32.wrap_i64
; MEM64-NEXT: i32.const 24
; MEM64-NEXT: i32.add
; MEM64-NEXT: i64.extend_i32_u
; MEM64-NEXT: local.get 0
; MEM64-NEXT: v128.store8_lane 0, 0
; MEM64-NEXT: # fallthrough-return
%q = ptrtoint ptr %p to i32 %q = ptrtoint ptr %p to i32
%r = add nuw i32 %q, 24 %r = add nuw i32 %q, 24
%s = inttoptr i32 %r to ptr %s = inttoptr i32 %r to ptr
%x = extractelement <16 x i8> %v, i32 0 %x = extractelement <16 x i8> %v, i32 0
store i8 %x, ptr %s store i8 %x, ptr %s
ret void ret void
} }
define void @store_lane_i8_with_folded_gep_offset(<16 x i8> %v, ptr %p) { define void @store_lane_i8_with_folded_gep_offset(<16 x i8> %v, ptr %p) {
; CHECK-LABEL: store_lane_i8_with_folded_gep_offset: ; CHECK-LABEL: store_lane_i8_with_folded_gep_offset:
; CHECK: .functype store_lane_i8_with_folded_gep_offset (v128, i32) -> () ; CHECK: .functype store_lane_i8_with_folded_gep_offset (v128, i32) -> ()
; CHECK-NEXT: # %bb.0: ; CHECK-NEXT: # %bb.0:
; CHECK-NEXT: local.get 1 ; CHECK-NEXT: local.get 1
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: v128.store8_lane 6, 0 ; CHECK-NEXT: v128.store8_lane 6, 0
; CHECK-NEXT: # fallthrough-return ; CHECK-NEXT: # fallthrough-return
;
; MEM64-LABEL: store_lane_i8_with_folded_gep_offset:
; MEM64: .functype store_lane_i8_with_folded_gep_offset (v128, i64) -> ()
; MEM64-NEXT: # %bb.0:
; MEM64-NEXT: local.get 1
; MEM64-NEXT: local.get 0
; MEM64-NEXT: v128.store8_lane 6, 0
; MEM64-NEXT: # fallthrough-return
%s = getelementptr inbounds i8, ptr %p, i32 6 %s = getelementptr inbounds i8, ptr %p, i32 6
%x = extractelement <16 x i8> %v, i32 0 %x = extractelement <16 x i8> %v, i32 0
store i8 %x, ptr %s store i8 %x, ptr %s
ret void ret void
} }
define void @store_lane_i8_with_unfolded_gep_negative_offset(<16 x i8> %v, ptr %p) { define void @store_lane_i8_with_unfolded_gep_negative_offset(<16 x i8> %v, ptr %p) {
; CHECK-LABEL: store_lane_i8_with_unfolded_gep_negative_offset: ; CHECK-LABEL: store_lane_i8_with_unfolded_gep_negative_offset:
; CHECK: .functype store_lane_i8_with_unfolded_gep_negative_offset (v128, i32) -> () ; CHECK: .functype store_lane_i8_with_unfolded_gep_negative_offset (v128, i32) -> ()
; CHECK-NEXT: # %bb.0: ; CHECK-NEXT: # %bb.0:
; CHECK-NEXT: local.get 1 ; CHECK-NEXT: local.get 1
; CHECK-NEXT: i32.const -6 ; CHECK-NEXT: i32.const -6
; CHECK-NEXT: i32.add ; CHECK-NEXT: i32.add
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: v128.store8_lane 0, 0 ; CHECK-NEXT: v128.store8_lane 0, 0
; CHECK-NEXT: # fallthrough-return ; CHECK-NEXT: # fallthrough-return
;
; MEM64-LABEL: store_lane_i8_with_unfolded_gep_negative_offset:
; MEM64: .functype store_lane_i8_with_unfolded_gep_negative_offset (v128, i64) -> ()
; MEM64-NEXT: # %bb.0:
; MEM64-NEXT: local.get 1
; MEM64-NEXT: i64.const -6
; MEM64-NEXT: i64.add
; MEM64-NEXT: local.get 0
; MEM64-NEXT: v128.store8_lane 0, 0
; MEM64-NEXT: # fallthrough-return
%s = getelementptr inbounds i8, ptr %p, i32 -6 %s = getelementptr inbounds i8, ptr %p, i32 -6
%x = extractelement <16 x i8> %v, i32 0 %x = extractelement <16 x i8> %v, i32 0
store i8 %x, ptr %s store i8 %x, ptr %s
ret void ret void
} }
define void @store_lane_i8_with_unfolded_offset(<16 x i8> %v, ptr %p) { define void @store_lane_i8_with_unfolded_offset(<16 x i8> %v, ptr %p) {
; CHECK-LABEL: store_lane_i8_with_unfolded_offset: ; CHECK-LABEL: store_lane_i8_with_unfolded_offset:
; CHECK: .functype store_lane_i8_with_unfolded_offset (v128, i32) -> () ; CHECK: .functype store_lane_i8_with_unfolded_offset (v128, i32) -> ()
; CHECK-NEXT: # %bb.0: ; CHECK-NEXT: # %bb.0:
; CHECK-NEXT: local.get 1 ; CHECK-NEXT: local.get 1
; CHECK-NEXT: i32.const 24 ; CHECK-NEXT: i32.const 24
; CHECK-NEXT: i32.add ; CHECK-NEXT: i32.add
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: v128.store8_lane 0, 0 ; CHECK-NEXT: v128.store8_lane 0, 0
; CHECK-NEXT: # fallthrough-return ; CHECK-NEXT: # fallthrough-return
;
; MEM64-LABEL: store_lane_i8_with_unfolded_offset:
; MEM64: .functype store_lane_i8_with_unfolded_offset (v128, i64) -> ()
; MEM64-NEXT: # %bb.0:
; MEM64-NEXT: local.get 1
; MEM64-NEXT: i32.wrap_i64
; MEM64-NEXT: i32.const 24
; MEM64-NEXT: i32.add
; MEM64-NEXT: i64.extend_i32_u
; MEM64-NEXT: local.get 0
; MEM64-NEXT: v128.store8_lane 0, 0
; MEM64-NEXT: # fallthrough-return
%q = ptrtoint ptr %p to i32 %q = ptrtoint ptr %p to i32
%r = add nsw i32 %q, 24 %r = add nsw i32 %q, 24
%s = inttoptr i32 %r to ptr %s = inttoptr i32 %r to ptr
%x = extractelement <16 x i8> %v, i32 0 %x = extractelement <16 x i8> %v, i32 0
store i8 %x, ptr %s store i8 %x, ptr %s
ret void ret void
} }
define void @store_lane_i8_with_unfolded_gep_offset(<16 x i8> %v, ptr %p) { define void @store_lane_i8_with_unfolded_gep_offset(<16 x i8> %v, ptr %p) {
; CHECK-LABEL: store_lane_i8_with_unfolded_gep_offset: ; CHECK-LABEL: store_lane_i8_with_unfolded_gep_offset:
; CHECK: .functype store_lane_i8_with_unfolded_gep_offset (v128, i32) -> () ; CHECK: .functype store_lane_i8_with_unfolded_gep_offset (v128, i32) -> ()
; CHECK-NEXT: # %bb.0: ; CHECK-NEXT: # %bb.0:
; CHECK-NEXT: local.get 1 ; CHECK-NEXT: local.get 1
; CHECK-NEXT: i32.const 6 ; CHECK-NEXT: i32.const 6
; CHECK-NEXT: i32.add ; CHECK-NEXT: i32.add
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: v128.store8_lane 0, 0 ; CHECK-NEXT: v128.store8_lane 0, 0
; CHECK-NEXT: # fallthrough-return ; CHECK-NEXT: # fallthrough-return
;
; MEM64-LABEL: store_lane_i8_with_unfolded_gep_offset:
; MEM64: .functype store_lane_i8_with_unfolded_gep_offset (v128, i64) -> ()
; MEM64-NEXT: # %bb.0:
; MEM64-NEXT: local.get 1
; MEM64-NEXT: i64.const 6
; MEM64-NEXT: i64.add
; MEM64-NEXT: local.get 0
; MEM64-NEXT: v128.store8_lane 0, 0
; MEM64-NEXT: # fallthrough-return
%s = getelementptr i8, ptr %p, i32 6 %s = getelementptr i8, ptr %p, i32 6
%x = extractelement <16 x i8> %v, i32 0 %x = extractelement <16 x i8> %v, i32 0
store i8 %x, ptr %s store i8 %x, ptr %s
ret void ret void
} }
define void @store_lane_i8_to_numeric_address(<16 x i8> %v) { define void @store_lane_i8_to_numeric_address(<16 x i8> %v) {
; CHECK-LABEL: store_lane_i8_to_numeric_address: ; CHECK-LABEL: store_lane_i8_to_numeric_address:
; CHECK: .functype store_lane_i8_to_numeric_address (v128) -> () ; CHECK: .functype store_lane_i8_to_numeric_address (v128) -> ()
; CHECK-NEXT: # %bb.0: ; CHECK-NEXT: # %bb.0:
; CHECK-NEXT: i32.const 0 ; CHECK-NEXT: i32.const 0
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: v128.store8_lane 42, 0 ; CHECK-NEXT: v128.store8_lane 42, 0
; CHECK-NEXT: # fallthrough-return ; CHECK-NEXT: # fallthrough-return
;
; MEM64-LABEL: store_lane_i8_to_numeric_address:
; MEM64: .functype store_lane_i8_to_numeric_address (v128) -> ()
; MEM64-NEXT: # %bb.0:
; MEM64-NEXT: i64.const 0
; MEM64-NEXT: local.get 0
; MEM64-NEXT: v128.store8_lane 42, 0
; MEM64-NEXT: # fallthrough-return
%s = inttoptr i32 42 to ptr %s = inttoptr i32 42 to ptr
%x = extractelement <16 x i8> %v, i32 0 %x = extractelement <16 x i8> %v, i32 0
store i8 %x, ptr %s store i8 %x, ptr %s
ret void ret void
} }
define void @store_lane_i8_from_global_address(<16 x i8> %v) { define void @store_lane_i8_from_global_address(<16 x i8> %v) {
; CHECK-LABEL: store_lane_i8_from_global_address: ; CHECK-LABEL: store_lane_i8_from_global_address:
; CHECK: .functype store_lane_i8_from_global_address (v128) -> () ; CHECK: .functype store_lane_i8_from_global_address (v128) -> ()
; CHECK-NEXT: # %bb.0: ; CHECK-NEXT: # %bb.0:
; CHECK-NEXT: i32.const 0 ; CHECK-NEXT: i32.const 0
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: v128.store8_lane gv_i8, 0 ; CHECK-NEXT: v128.store8_lane gv_i8, 0
; CHECK-NEXT: # fallthrough-return ; CHECK-NEXT: # fallthrough-return
;
; MEM64-LABEL: store_lane_i8_from_global_address:
; MEM64: .functype store_lane_i8_from_global_address (v128) -> ()
; MEM64-NEXT: # %bb.0:
; MEM64-NEXT: i64.const 0
; MEM64-NEXT: local.get 0
; MEM64-NEXT: v128.store8_lane gv_i8, 0
; MEM64-NEXT: # fallthrough-return
%x = extractelement <16 x i8> %v, i32 0 %x = extractelement <16 x i8> %v, i32 0
store i8 %x, ptr @gv_i8 store i8 %x, ptr @gv_i8
ret void ret void
} }
;===---------------------------------------------------------------------------- ;===----------------------------------------------------------------------------
; v128.load16_lane / v128.store16_lane ; v128.load16_lane / v128.store16_lane
;===---------------------------------------------------------------------------- ;===----------------------------------------------------------------------------
define <8 x i16> @load_lane_i16_no_offset(ptr %p, <8 x i16> %v) { define <8 x i16> @load_lane_i16_no_offset(ptr %p, <8 x i16> %v) {
; CHECK-LABEL: load_lane_i16_no_offset: ; CHECK-LABEL: load_lane_i16_no_offset:
; CHECK: .functype load_lane_i16_no_offset (i32, v128) -> (v128) ; CHECK: .functype load_lane_i16_no_offset (i32, v128) -> (v128)
; CHECK-NEXT: # %bb.0: ; CHECK-NEXT: # %bb.0:
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: local.get 1 ; CHECK-NEXT: local.get 1
; CHECK-NEXT: v128.load16_lane 0, 0 ; CHECK-NEXT: v128.load16_lane 0, 0
; CHECK-NEXT: # fallthrough-return ; CHECK-NEXT: # fallthrough-return
;
; MEM64-LABEL: load_lane_i16_no_offset:
; MEM64: .functype load_lane_i16_no_offset (i64, v128) -> (v128)
; MEM64-NEXT: # %bb.0:
; MEM64-NEXT: local.get 0
; MEM64-NEXT: local.get 1
; MEM64-NEXT: v128.load16_lane 0, 0
; MEM64-NEXT: # fallthrough-return
%x = load i16, ptr %p %x = load i16, ptr %p
%t = insertelement <8 x i16> %v, i16 %x, i32 0 %t = insertelement <8 x i16> %v, i16 %x, i32 0
ret <8 x i16> %t ret <8 x i16> %t
} }
define <8 x i16> @load_lane_i16_with_folded_offset(ptr %p, <8 x i16> %v) { define <8 x i16> @load_lane_i16_with_folded_offset(ptr %p, <8 x i16> %v) {
; CHECK-LABEL: load_lane_i16_with_folded_offset: ; CHECK-LABEL: load_lane_i16_with_folded_offset:
; CHECK: .functype load_lane_i16_with_folded_offset (i32, v128) -> (v128) ; CHECK: .functype load_lane_i16_with_folded_offset (i32, v128) -> (v128)
; CHECK-NEXT: # %bb.0: ; CHECK-NEXT: # %bb.0:
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: i32.const 24 ; CHECK-NEXT: i32.const 24
; CHECK-NEXT: i32.add ; CHECK-NEXT: i32.add
; CHECK-NEXT: local.get 1 ; CHECK-NEXT: local.get 1
; CHECK-NEXT: v128.load16_lane 0, 0 ; CHECK-NEXT: v128.load16_lane 0, 0
; CHECK-NEXT: # fallthrough-return ; CHECK-NEXT: # fallthrough-return
;
; MEM64-LABEL: load_lane_i16_with_folded_offset:
; MEM64: .functype load_lane_i16_with_folded_offset (i64, v128) -> (v128)
; MEM64-NEXT: # %bb.0:
; MEM64-NEXT: local.get 0
; MEM64-NEXT: i32.wrap_i64
; MEM64-NEXT: i32.const 24
; MEM64-NEXT: i32.add
; MEM64-NEXT: i64.extend_i32_u
; MEM64-NEXT: local.get 1
; MEM64-NEXT: v128.load16_lane 0, 0
; MEM64-NEXT: # fallthrough-return
%q = ptrtoint ptr %p to i32 %q = ptrtoint ptr %p to i32
%r = add nuw i32 %q, 24 %r = add nuw i32 %q, 24
%s = inttoptr i32 %r to ptr %s = inttoptr i32 %r to ptr
%x = load i16, ptr %s %x = load i16, ptr %s
%t = insertelement <8 x i16> %v, i16 %x, i32 0 %t = insertelement <8 x i16> %v, i16 %x, i32 0
ret <8 x i16> %t ret <8 x i16> %t
} }
define <8 x i16> @load_lane_i16_with_folded_gep_offset(ptr %p, <8 x i16> %v) { define <8 x i16> @load_lane_i16_with_folded_gep_offset(ptr %p, <8 x i16> %v) {
; CHECK-LABEL: load_lane_i16_with_folded_gep_offset: ; CHECK-LABEL: load_lane_i16_with_folded_gep_offset:
; CHECK: .functype load_lane_i16_with_folded_gep_offset (i32, v128) -> (v128) ; CHECK: .functype load_lane_i16_with_folded_gep_offset (i32, v128) -> (v128)
; CHECK-NEXT: # %bb.0: ; CHECK-NEXT: # %bb.0:
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: i32.const 12 ; CHECK-NEXT: i32.const 12
; CHECK-NEXT: i32.add ; CHECK-NEXT: i32.add
; CHECK-NEXT: local.get 1 ; CHECK-NEXT: local.get 1
; CHECK-NEXT: v128.load16_lane 0, 0 ; CHECK-NEXT: v128.load16_lane 0, 0
; CHECK-NEXT: # fallthrough-return ; CHECK-NEXT: # fallthrough-return
;
; MEM64-LABEL: load_lane_i16_with_folded_gep_offset:
; MEM64: .functype load_lane_i16_with_folded_gep_offset (i64, v128) -> (v128)
; MEM64-NEXT: # %bb.0:
; MEM64-NEXT: local.get 0
; MEM64-NEXT: i64.const 12
; MEM64-NEXT: i64.add
; MEM64-NEXT: local.get 1
; MEM64-NEXT: v128.load16_lane 0, 0
; MEM64-NEXT: # fallthrough-return
%s = getelementptr inbounds i16, ptr %p, i32 6 %s = getelementptr inbounds i16, ptr %p, i32 6
%x = load i16, ptr %s %x = load i16, ptr %s
%t = insertelement <8 x i16> %v, i16 %x, i32 0 %t = insertelement <8 x i16> %v, i16 %x, i32 0
ret <8 x i16> %t ret <8 x i16> %t
} }
define <8 x i16> @load_lane_i16_with_unfolded_gep_negative_offset(ptr %p, <8 x i16> %v) { define <8 x i16> @load_lane_i16_with_unfolded_gep_negative_offset(ptr %p, <8 x i16> %v) {
; CHECK-LABEL: load_lane_i16_with_unfolded_gep_negative_offset: ; CHECK-LABEL: load_lane_i16_with_unfolded_gep_negative_offset:
; CHECK: .functype load_lane_i16_with_unfolded_gep_negative_offset (i32, v128) -> (v128) ; CHECK: .functype load_lane_i16_with_unfolded_gep_negative_offset (i32, v128) -> (v128)
; CHECK-NEXT: # %bb.0: ; CHECK-NEXT: # %bb.0:
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: i32.const -12 ; CHECK-NEXT: i32.const -12
; CHECK-NEXT: i32.add ; CHECK-NEXT: i32.add
; CHECK-NEXT: local.get 1 ; CHECK-NEXT: local.get 1
; CHECK-NEXT: v128.load16_lane 0, 0 ; CHECK-NEXT: v128.load16_lane 0, 0
; CHECK-NEXT: # fallthrough-return ; CHECK-NEXT: # fallthrough-return
;
; MEM64-LABEL: load_lane_i16_with_unfolded_gep_negative_offset:
; MEM64: .functype load_lane_i16_with_unfolded_gep_negative_offset (i64, v128) -> (v128)
; MEM64-NEXT: # %bb.0:
; MEM64-NEXT: local.get 0
; MEM64-NEXT: i64.const -12
; MEM64-NEXT: i64.add
; MEM64-NEXT: local.get 1
; MEM64-NEXT: v128.load16_lane 0, 0
; MEM64-NEXT: # fallthrough-return
%s = getelementptr inbounds i16, ptr %p, i32 -6 %s = getelementptr inbounds i16, ptr %p, i32 -6
%x = load i16, ptr %s %x = load i16, ptr %s
%t = insertelement <8 x i16> %v, i16 %x, i32 0 %t = insertelement <8 x i16> %v, i16 %x, i32 0
ret <8 x i16> %t ret <8 x i16> %t
} }
define <8 x i16> @load_lane_i16_with_unfolded_offset(ptr %p, <8 x i16> %v) { define <8 x i16> @load_lane_i16_with_unfolded_offset(ptr %p, <8 x i16> %v) {
; CHECK-LABEL: load_lane_i16_with_unfolded_offset: ; CHECK-LABEL: load_lane_i16_with_unfolded_offset:
; CHECK: .functype load_lane_i16_with_unfolded_offset (i32, v128) -> (v128) ; CHECK: .functype load_lane_i16_with_unfolded_offset (i32, v128) -> (v128)
; CHECK-NEXT: # %bb.0: ; CHECK-NEXT: # %bb.0:
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: i32.const 24 ; CHECK-NEXT: i32.const 24
; CHECK-NEXT: i32.add ; CHECK-NEXT: i32.add
; CHECK-NEXT: local.get 1 ; CHECK-NEXT: local.get 1
; CHECK-NEXT: v128.load16_lane 0, 0 ; CHECK-NEXT: v128.load16_lane 0, 0
; CHECK-NEXT: # fallthrough-return ; CHECK-NEXT: # fallthrough-return
;
; MEM64-LABEL: load_lane_i16_with_unfolded_offset:
; MEM64: .functype load_lane_i16_with_unfolded_offset (i64, v128) -> (v128)
; MEM64-NEXT: # %bb.0:
; MEM64-NEXT: local.get 0
; MEM64-NEXT: i32.wrap_i64
; MEM64-NEXT: i32.const 24
; MEM64-NEXT: i32.add
; MEM64-NEXT: i64.extend_i32_u
; MEM64-NEXT: local.get 1
; MEM64-NEXT: v128.load16_lane 0, 0
; MEM64-NEXT: # fallthrough-return
%q = ptrtoint ptr %p to i32 %q = ptrtoint ptr %p to i32
%r = add nsw i32 %q, 24 %r = add nsw i32 %q, 24
%s = inttoptr i32 %r to ptr %s = inttoptr i32 %r to ptr
%x = load i16, ptr %s %x = load i16, ptr %s
%t = insertelement <8 x i16> %v, i16 %x, i32 0 %t = insertelement <8 x i16> %v, i16 %x, i32 0
ret <8 x i16> %t ret <8 x i16> %t
} }
define <8 x i16> @load_lane_i16_with_unfolded_gep_offset(ptr %p, <8 x i16> %v) { define <8 x i16> @load_lane_i16_with_unfolded_gep_offset(ptr %p, <8 x i16> %v) {
; CHECK-LABEL: load_lane_i16_with_unfolded_gep_offset: ; CHECK-LABEL: load_lane_i16_with_unfolded_gep_offset:
; CHECK: .functype load_lane_i16_with_unfolded_gep_offset (i32, v128) -> (v128) ; CHECK: .functype load_lane_i16_with_unfolded_gep_offset (i32, v128) -> (v128)
; CHECK-NEXT: # %bb.0: ; CHECK-NEXT: # %bb.0:
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: i32.const 12 ; CHECK-NEXT: i32.const 12
; CHECK-NEXT: i32.add ; CHECK-NEXT: i32.add
; CHECK-NEXT: local.get 1 ; CHECK-NEXT: local.get 1
; CHECK-NEXT: v128.load16_lane 0, 0 ; CHECK-NEXT: v128.load16_lane 0, 0
; CHECK-NEXT: # fallthrough-return ; CHECK-NEXT: # fallthrough-return
;
; MEM64-LABEL: load_lane_i16_with_unfolded_gep_offset:
; MEM64: .functype load_lane_i16_with_unfolded_gep_offset (i64, v128) -> (v128)
; MEM64-NEXT: # %bb.0:
; MEM64-NEXT: local.get 0
; MEM64-NEXT: i64.const 12
; MEM64-NEXT: i64.add
; MEM64-NEXT: local.get 1
; MEM64-NEXT: v128.load16_lane 0, 0
; MEM64-NEXT: # fallthrough-return
%s = getelementptr i16, ptr %p, i32 6 %s = getelementptr i16, ptr %p, i32 6
%x = load i16, ptr %s %x = load i16, ptr %s
%t = insertelement <8 x i16> %v, i16 %x, i32 0 %t = insertelement <8 x i16> %v, i16 %x, i32 0
ret <8 x i16> %t ret <8 x i16> %t
} }
define <8 x i16> @load_lane_i16_from_numeric_address(<8 x i16> %v) { define <8 x i16> @load_lane_i16_from_numeric_address(<8 x i16> %v) {
; CHECK-LABEL: load_lane_i16_from_numeric_address: ; CHECK-LABEL: load_lane_i16_from_numeric_address:
; CHECK: .functype load_lane_i16_from_numeric_address (v128) -> (v128) ; CHECK: .functype load_lane_i16_from_numeric_address (v128) -> (v128)
; CHECK-NEXT: # %bb.0: ; CHECK-NEXT: # %bb.0:
; CHECK-NEXT: i32.const 42 ; CHECK-NEXT: i32.const 42
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: v128.load16_lane 0, 0 ; CHECK-NEXT: v128.load16_lane 0, 0
; CHECK-NEXT: # fallthrough-return ; CHECK-NEXT: # fallthrough-return
;
; MEM64-LABEL: load_lane_i16_from_numeric_address:
; MEM64: .functype load_lane_i16_from_numeric_address (v128) -> (v128)
; MEM64-NEXT: # %bb.0:
; MEM64-NEXT: i64.const 42
; MEM64-NEXT: local.get 0
; MEM64-NEXT: v128.load16_lane 0, 0
; MEM64-NEXT: # fallthrough-return
%s = inttoptr i32 42 to ptr %s = inttoptr i32 42 to ptr
%x = load i16, ptr %s %x = load i16, ptr %s
%t = insertelement <8 x i16> %v, i16 %x, i32 0 %t = insertelement <8 x i16> %v, i16 %x, i32 0
ret <8 x i16> %t ret <8 x i16> %t
} }
@gv_i16 = global i16 0 @gv_i16 = global i16 0
define <8 x i16> @load_lane_i16_from_global_address(<8 x i16> %v) { define <8 x i16> @load_lane_i16_from_global_address(<8 x i16> %v) {
; CHECK-LABEL: load_lane_i16_from_global_address: ; CHECK-LABEL: load_lane_i16_from_global_address:
; CHECK: .functype load_lane_i16_from_global_address (v128) -> (v128) ; CHECK: .functype load_lane_i16_from_global_address (v128) -> (v128)
; CHECK-NEXT: # %bb.0: ; CHECK-NEXT: # %bb.0:
; CHECK-NEXT: i32.const gv_i16 ; CHECK-NEXT: i32.const gv_i16
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: v128.load16_lane 0, 0 ; CHECK-NEXT: v128.load16_lane 0, 0
; CHECK-NEXT: # fallthrough-return ; CHECK-NEXT: # fallthrough-return
;
; MEM64-LABEL: load_lane_i16_from_global_address:
; MEM64: .functype load_lane_i16_from_global_address (v128) -> (v128)
; MEM64-NEXT: # %bb.0:
; MEM64-NEXT: i64.const gv_i16
; MEM64-NEXT: local.get 0
; MEM64-NEXT: v128.load16_lane 0, 0
; MEM64-NEXT: # fallthrough-return
%x = load i16, ptr @gv_i16 %x = load i16, ptr @gv_i16
%t = insertelement <8 x i16> %v, i16 %x, i32 0 %t = insertelement <8 x i16> %v, i16 %x, i32 0
ret <8 x i16> %t ret <8 x i16> %t
} }
define void @store_lane_i16_no_offset(<8 x i16> %v, ptr %p) { define void @store_lane_i16_no_offset(<8 x i16> %v, ptr %p) {
; CHECK-LABEL: store_lane_i16_no_offset: ; CHECK-LABEL: store_lane_i16_no_offset:
; CHECK: .functype store_lane_i16_no_offset (v128, i32) -> () ; CHECK: .functype store_lane_i16_no_offset (v128, i32) -> ()
; CHECK-NEXT: # %bb.0: ; CHECK-NEXT: # %bb.0:
; CHECK-NEXT: local.get 1 ; CHECK-NEXT: local.get 1
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: v128.store16_lane 0, 0 ; CHECK-NEXT: v128.store16_lane 0, 0
; CHECK-NEXT: # fallthrough-return ; CHECK-NEXT: # fallthrough-return
;
; MEM64-LABEL: store_lane_i16_no_offset:
; MEM64: .functype store_lane_i16_no_offset (v128, i64) -> ()
; MEM64-NEXT: # %bb.0:
; MEM64-NEXT: local.get 1
; MEM64-NEXT: local.get 0
; MEM64-NEXT: v128.store16_lane 0, 0
; MEM64-NEXT: # fallthrough-return
%x = extractelement <8 x i16> %v, i32 0 %x = extractelement <8 x i16> %v, i32 0
store i16 %x, ptr %p store i16 %x, ptr %p
ret void ret void
} }
define void @store_lane_i16_with_folded_offset(<8 x i16> %v, ptr %p) { define void @store_lane_i16_with_folded_offset(<8 x i16> %v, ptr %p) {
; CHECK-LABEL: store_lane_i16_with_folded_offset: ; CHECK-LABEL: store_lane_i16_with_folded_offset:
; CHECK: .functype store_lane_i16_with_folded_offset (v128, i32) -> () ; CHECK: .functype store_lane_i16_with_folded_offset (v128, i32) -> ()
; CHECK-NEXT: # %bb.0: ; CHECK-NEXT: # %bb.0:
; CHECK-NEXT: local.get 1 ; CHECK-NEXT: local.get 1
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: v128.store16_lane 24, 0 ; CHECK-NEXT: v128.store16_lane 24, 0
; CHECK-NEXT: # fallthrough-return ; CHECK-NEXT: # fallthrough-return
;
; MEM64-LABEL: store_lane_i16_with_folded_offset:
; MEM64: .functype store_lane_i16_with_folded_offset (v128, i64) -> ()
; MEM64-NEXT: # %bb.0:
; MEM64-NEXT: local.get 1
; MEM64-NEXT: i32.wrap_i64
; MEM64-NEXT: i32.const 24
; MEM64-NEXT: i32.add
; MEM64-NEXT: i64.extend_i32_u
; MEM64-NEXT: local.get 0
; MEM64-NEXT: v128.store16_lane 0, 0
; MEM64-NEXT: # fallthrough-return
%q = ptrtoint ptr %p to i32 %q = ptrtoint ptr %p to i32
%r = add nuw i32 %q, 24 %r = add nuw i32 %q, 24
%s = inttoptr i32 %r to ptr %s = inttoptr i32 %r to ptr
%x = extractelement <8 x i16> %v, i32 0 %x = extractelement <8 x i16> %v, i32 0
store i16 %x, ptr %s store i16 %x, ptr %s
ret void ret void
} }
define void @store_lane_i16_with_folded_gep_offset(<8 x i16> %v, ptr %p) { define void @store_lane_i16_with_folded_gep_offset(<8 x i16> %v, ptr %p) {
; CHECK-LABEL: store_lane_i16_with_folded_gep_offset: ; CHECK-LABEL: store_lane_i16_with_folded_gep_offset:
; CHECK: .functype store_lane_i16_with_folded_gep_offset (v128, i32) -> () ; CHECK: .functype store_lane_i16_with_folded_gep_offset (v128, i32) -> ()
; CHECK-NEXT: # %bb.0: ; CHECK-NEXT: # %bb.0:
; CHECK-NEXT: local.get 1 ; CHECK-NEXT: local.get 1
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: v128.store16_lane 12, 0 ; CHECK-NEXT: v128.store16_lane 12, 0
; CHECK-NEXT: # fallthrough-return ; CHECK-NEXT: # fallthrough-return
;
; MEM64-LABEL: store_lane_i16_with_folded_gep_offset:
; MEM64: .functype store_lane_i16_with_folded_gep_offset (v128, i64) -> ()
; MEM64-NEXT: # %bb.0:
; MEM64-NEXT: local.get 1
; MEM64-NEXT: local.get 0
; MEM64-NEXT: v128.store16_lane 12, 0
; MEM64-NEXT: # fallthrough-return
%s = getelementptr inbounds i16, ptr %p, i32 6 %s = getelementptr inbounds i16, ptr %p, i32 6
%x = extractelement <8 x i16> %v, i32 0 %x = extractelement <8 x i16> %v, i32 0
store i16 %x, ptr %s store i16 %x, ptr %s
ret void ret void
} }
define void @store_lane_i16_with_unfolded_gep_negative_offset(<8 x i16> %v, ptr %p) { define void @store_lane_i16_with_unfolded_gep_negative_offset(<8 x i16> %v, ptr %p) {
; CHECK-LABEL: store_lane_i16_with_unfolded_gep_negative_offset: ; CHECK-LABEL: store_lane_i16_with_unfolded_gep_negative_offset:
; CHECK: .functype store_lane_i16_with_unfolded_gep_negative_offset (v128, i32) -> () ; CHECK: .functype store_lane_i16_with_unfolded_gep_negative_offset (v128, i32) -> ()
; CHECK-NEXT: # %bb.0: ; CHECK-NEXT: # %bb.0:
; CHECK-NEXT: local.get 1 ; CHECK-NEXT: local.get 1
; CHECK-NEXT: i32.const -12 ; CHECK-NEXT: i32.const -12
; CHECK-NEXT: i32.add ; CHECK-NEXT: i32.add
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: v128.store16_lane 0, 0 ; CHECK-NEXT: v128.store16_lane 0, 0
; CHECK-NEXT: # fallthrough-return ; CHECK-NEXT: # fallthrough-return
;
; MEM64-LABEL: store_lane_i16_with_unfolded_gep_negative_offset:
; MEM64: .functype store_lane_i16_with_unfolded_gep_negative_offset (v128, i64) -> ()
; MEM64-NEXT: # %bb.0:
; MEM64-NEXT: local.get 1
; MEM64-NEXT: i64.const -12
; MEM64-NEXT: i64.add
; MEM64-NEXT: local.get 0
; MEM64-NEXT: v128.store16_lane 0, 0
; MEM64-NEXT: # fallthrough-return
%s = getelementptr inbounds i16, ptr %p, i32 -6 %s = getelementptr inbounds i16, ptr %p, i32 -6
%x = extractelement <8 x i16> %v, i32 0 %x = extractelement <8 x i16> %v, i32 0
store i16 %x, ptr %s store i16 %x, ptr %s
ret void ret void
} }
define void @store_lane_i16_with_unfolded_offset(<8 x i16> %v, ptr %p) { define void @store_lane_i16_with_unfolded_offset(<8 x i16> %v, ptr %p) {
; CHECK-LABEL: store_lane_i16_with_unfolded_offset: ; CHECK-LABEL: store_lane_i16_with_unfolded_offset:
; CHECK: .functype store_lane_i16_with_unfolded_offset (v128, i32) -> () ; CHECK: .functype store_lane_i16_with_unfolded_offset (v128, i32) -> ()
; CHECK-NEXT: # %bb.0: ; CHECK-NEXT: # %bb.0:
; CHECK-NEXT: local.get 1 ; CHECK-NEXT: local.get 1
; CHECK-NEXT: i32.const 24 ; CHECK-NEXT: i32.const 24
; CHECK-NEXT: i32.add ; CHECK-NEXT: i32.add
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: v128.store16_lane 0, 0 ; CHECK-NEXT: v128.store16_lane 0, 0
; CHECK-NEXT: # fallthrough-return ; CHECK-NEXT: # fallthrough-return
;
; MEM64-LABEL: store_lane_i16_with_unfolded_offset:
; MEM64: .functype store_lane_i16_with_unfolded_offset (v128, i64) -> ()
; MEM64-NEXT: # %bb.0:
; MEM64-NEXT: local.get 1
; MEM64-NEXT: i32.wrap_i64
; MEM64-NEXT: i32.const 24
; MEM64-NEXT: i32.add
; MEM64-NEXT: i64.extend_i32_u
; MEM64-NEXT: local.get 0
; MEM64-NEXT: v128.store16_lane 0, 0
; MEM64-NEXT: # fallthrough-return
%q = ptrtoint ptr %p to i32 %q = ptrtoint ptr %p to i32
%r = add nsw i32 %q, 24 %r = add nsw i32 %q, 24
%s = inttoptr i32 %r to ptr %s = inttoptr i32 %r to ptr
%x = extractelement <8 x i16> %v, i32 0 %x = extractelement <8 x i16> %v, i32 0
store i16 %x, ptr %s store i16 %x, ptr %s
ret void ret void
} }
define void @store_lane_i16_with_unfolded_gep_offset(<8 x i16> %v, ptr %p) { define void @store_lane_i16_with_unfolded_gep_offset(<8 x i16> %v, ptr %p) {
; CHECK-LABEL: store_lane_i16_with_unfolded_gep_offset: ; CHECK-LABEL: store_lane_i16_with_unfolded_gep_offset:
; CHECK: .functype store_lane_i16_with_unfolded_gep_offset (v128, i32) -> () ; CHECK: .functype store_lane_i16_with_unfolded_gep_offset (v128, i32) -> ()
; CHECK-NEXT: # %bb.0: ; CHECK-NEXT: # %bb.0:
; CHECK-NEXT: local.get 1 ; CHECK-NEXT: local.get 1
; CHECK-NEXT: i32.const 12 ; CHECK-NEXT: i32.const 12
; CHECK-NEXT: i32.add ; CHECK-NEXT: i32.add
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: v128.store16_lane 0, 0 ; CHECK-NEXT: v128.store16_lane 0, 0
; CHECK-NEXT: # fallthrough-return ; CHECK-NEXT: # fallthrough-return
;
; MEM64-LABEL: store_lane_i16_with_unfolded_gep_offset:
; MEM64: .functype store_lane_i16_with_unfolded_gep_offset (v128, i64) -> ()
; MEM64-NEXT: # %bb.0:
; MEM64-NEXT: local.get 1
; MEM64-NEXT: i64.const 12
; MEM64-NEXT: i64.add
; MEM64-NEXT: local.get 0
; MEM64-NEXT: v128.store16_lane 0, 0
; MEM64-NEXT: # fallthrough-return
%s = getelementptr i16, ptr %p, i32 6 %s = getelementptr i16, ptr %p, i32 6
%x = extractelement <8 x i16> %v, i32 0 %x = extractelement <8 x i16> %v, i32 0
store i16 %x, ptr %s store i16 %x, ptr %s
ret void ret void
} }
define void @store_lane_i16_to_numeric_address(<8 x i16> %v) { define void @store_lane_i16_to_numeric_address(<8 x i16> %v) {
; CHECK-LABEL: store_lane_i16_to_numeric_address: ; CHECK-LABEL: store_lane_i16_to_numeric_address:
; CHECK: .functype store_lane_i16_to_numeric_address (v128) -> () ; CHECK: .functype store_lane_i16_to_numeric_address (v128) -> ()
; CHECK-NEXT: # %bb.0: ; CHECK-NEXT: # %bb.0:
; CHECK-NEXT: i32.const 0 ; CHECK-NEXT: i32.const 0
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: v128.store16_lane 42, 0 ; CHECK-NEXT: v128.store16_lane 42, 0
; CHECK-NEXT: # fallthrough-return ; CHECK-NEXT: # fallthrough-return
;
; MEM64-LABEL: store_lane_i16_to_numeric_address:
; MEM64: .functype store_lane_i16_to_numeric_address (v128) -> ()
; MEM64-NEXT: # %bb.0:
; MEM64-NEXT: i64.const 0
; MEM64-NEXT: local.get 0
; MEM64-NEXT: v128.store16_lane 42, 0
; MEM64-NEXT: # fallthrough-return
%s = inttoptr i32 42 to ptr %s = inttoptr i32 42 to ptr
%x = extractelement <8 x i16> %v, i32 0 %x = extractelement <8 x i16> %v, i32 0
store i16 %x, ptr %s store i16 %x, ptr %s
ret void ret void
} }
define void @store_lane_i16_from_global_address(<8 x i16> %v) { define void @store_lane_i16_from_global_address(<8 x i16> %v) {
; CHECK-LABEL: store_lane_i16_from_global_address: ; CHECK-LABEL: store_lane_i16_from_global_address:
; CHECK: .functype store_lane_i16_from_global_address (v128) -> () ; CHECK: .functype store_lane_i16_from_global_address (v128) -> ()
; CHECK-NEXT: # %bb.0: ; CHECK-NEXT: # %bb.0:
; CHECK-NEXT: i32.const 0 ; CHECK-NEXT: i32.const 0
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: v128.store16_lane gv_i16, 0 ; CHECK-NEXT: v128.store16_lane gv_i16, 0
; CHECK-NEXT: # fallthrough-return ; CHECK-NEXT: # fallthrough-return
;
; MEM64-LABEL: store_lane_i16_from_global_address:
; MEM64: .functype store_lane_i16_from_global_address (v128) -> ()
; MEM64-NEXT: # %bb.0:
; MEM64-NEXT: i64.const 0
; MEM64-NEXT: local.get 0
; MEM64-NEXT: v128.store16_lane gv_i16, 0
; MEM64-NEXT: # fallthrough-return
%x = extractelement <8 x i16> %v, i32 0 %x = extractelement <8 x i16> %v, i32 0
store i16 %x, ptr @gv_i16 store i16 %x, ptr @gv_i16
ret void ret void
} }
;===---------------------------------------------------------------------------- ;===----------------------------------------------------------------------------
; v128.load32_lane / v128.store32_lane ; v128.load32_lane / v128.store32_lane
;===---------------------------------------------------------------------------- ;===----------------------------------------------------------------------------
define <4 x i32> @load_lane_i32_no_offset(ptr %p, <4 x i32> %v) { define <4 x i32> @load_lane_i32_no_offset(ptr %p, <4 x i32> %v) {
; CHECK-LABEL: load_lane_i32_no_offset: ; CHECK-LABEL: load_lane_i32_no_offset:
; CHECK: .functype load_lane_i32_no_offset (i32, v128) -> (v128) ; CHECK: .functype load_lane_i32_no_offset (i32, v128) -> (v128)
; CHECK-NEXT: # %bb.0: ; CHECK-NEXT: # %bb.0:
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: local.get 1 ; CHECK-NEXT: local.get 1
; CHECK-NEXT: v128.load32_lane 0, 0 ; CHECK-NEXT: v128.load32_lane 0, 0
; CHECK-NEXT: # fallthrough-return ; CHECK-NEXT: # fallthrough-return
;
; MEM64-LABEL: load_lane_i32_no_offset:
; MEM64: .functype load_lane_i32_no_offset (i64, v128) -> (v128)
; MEM64-NEXT: # %bb.0:
; MEM64-NEXT: local.get 0
; MEM64-NEXT: local.get 1
; MEM64-NEXT: v128.load32_lane 0, 0
; MEM64-NEXT: # fallthrough-return
%x = load i32, ptr %p %x = load i32, ptr %p
%t = insertelement <4 x i32> %v, i32 %x, i32 0 %t = insertelement <4 x i32> %v, i32 %x, i32 0
ret <4 x i32> %t ret <4 x i32> %t
} }
define <4 x i32> @load_lane_i32_with_folded_offset(ptr %p, <4 x i32> %v) { define <4 x i32> @load_lane_i32_with_folded_offset(ptr %p, <4 x i32> %v) {
; CHECK-LABEL: load_lane_i32_with_folded_offset: ; CHECK-LABEL: load_lane_i32_with_folded_offset:
; CHECK: .functype load_lane_i32_with_folded_offset (i32, v128) -> (v128) ; CHECK: .functype load_lane_i32_with_folded_offset (i32, v128) -> (v128)
; CHECK-NEXT: # %bb.0: ; CHECK-NEXT: # %bb.0:
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: i32.const 24 ; CHECK-NEXT: i32.const 24
; CHECK-NEXT: i32.add ; CHECK-NEXT: i32.add
; CHECK-NEXT: local.get 1 ; CHECK-NEXT: local.get 1
; CHECK-NEXT: v128.load32_lane 0, 0 ; CHECK-NEXT: v128.load32_lane 0, 0
; CHECK-NEXT: # fallthrough-return ; CHECK-NEXT: # fallthrough-return
;
; MEM64-LABEL: load_lane_i32_with_folded_offset:
; MEM64: .functype load_lane_i32_with_folded_offset (i64, v128) -> (v128)
; MEM64-NEXT: # %bb.0:
; MEM64-NEXT: local.get 0
; MEM64-NEXT: i32.wrap_i64
; MEM64-NEXT: i32.const 24
; MEM64-NEXT: i32.add
; MEM64-NEXT: i64.extend_i32_u
; MEM64-NEXT: local.get 1
; MEM64-NEXT: v128.load32_lane 0, 0
; MEM64-NEXT: # fallthrough-return
%q = ptrtoint ptr %p to i32 %q = ptrtoint ptr %p to i32
%r = add nuw i32 %q, 24 %r = add nuw i32 %q, 24
%s = inttoptr i32 %r to ptr %s = inttoptr i32 %r to ptr
%x = load i32, ptr %s %x = load i32, ptr %s
%t = insertelement <4 x i32> %v, i32 %x, i32 0 %t = insertelement <4 x i32> %v, i32 %x, i32 0
ret <4 x i32> %t ret <4 x i32> %t
} }
define <4 x i32> @load_lane_i32_with_folded_gep_offset(ptr %p, <4 x i32> %v) { define <4 x i32> @load_lane_i32_with_folded_gep_offset(ptr %p, <4 x i32> %v) {
; CHECK-LABEL: load_lane_i32_with_folded_gep_offset: ; CHECK-LABEL: load_lane_i32_with_folded_gep_offset:
; CHECK: .functype load_lane_i32_with_folded_gep_offset (i32, v128) -> (v128) ; CHECK: .functype load_lane_i32_with_folded_gep_offset (i32, v128) -> (v128)
; CHECK-NEXT: # %bb.0: ; CHECK-NEXT: # %bb.0:
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: i32.const 24 ; CHECK-NEXT: i32.const 24
; CHECK-NEXT: i32.add ; CHECK-NEXT: i32.add
; CHECK-NEXT: local.get 1 ; CHECK-NEXT: local.get 1
; CHECK-NEXT: v128.load32_lane 0, 0 ; CHECK-NEXT: v128.load32_lane 0, 0
; CHECK-NEXT: # fallthrough-return ; CHECK-NEXT: # fallthrough-return
;
; MEM64-LABEL: load_lane_i32_with_folded_gep_offset:
; MEM64: .functype load_lane_i32_with_folded_gep_offset (i64, v128) -> (v128)
; MEM64-NEXT: # %bb.0:
; MEM64-NEXT: local.get 0
; MEM64-NEXT: i64.const 24
; MEM64-NEXT: i64.add
; MEM64-NEXT: local.get 1
; MEM64-NEXT: v128.load32_lane 0, 0
; MEM64-NEXT: # fallthrough-return
%s = getelementptr inbounds i32, ptr %p, i32 6 %s = getelementptr inbounds i32, ptr %p, i32 6
%x = load i32, ptr %s %x = load i32, ptr %s
%t = insertelement <4 x i32> %v, i32 %x, i32 0 %t = insertelement <4 x i32> %v, i32 %x, i32 0
ret <4 x i32> %t ret <4 x i32> %t
} }
define <4 x i32> @load_lane_i32_with_unfolded_gep_negative_offset(ptr %p, <4 x i32> %v) { define <4 x i32> @load_lane_i32_with_unfolded_gep_negative_offset(ptr %p, <4 x i32> %v) {
; CHECK-LABEL: load_lane_i32_with_unfolded_gep_negative_offset: ; CHECK-LABEL: load_lane_i32_with_unfolded_gep_negative_offset:
; CHECK: .functype load_lane_i32_with_unfolded_gep_negative_offset (i32, v128) -> (v128) ; CHECK: .functype load_lane_i32_with_unfolded_gep_negative_offset (i32, v128) -> (v128)
; CHECK-NEXT: # %bb.0: ; CHECK-NEXT: # %bb.0:
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: i32.const -24 ; CHECK-NEXT: i32.const -24
; CHECK-NEXT: i32.add ; CHECK-NEXT: i32.add
; CHECK-NEXT: local.get 1 ; CHECK-NEXT: local.get 1
; CHECK-NEXT: v128.load32_lane 0, 0 ; CHECK-NEXT: v128.load32_lane 0, 0
; CHECK-NEXT: # fallthrough-return ; CHECK-NEXT: # fallthrough-return
;
; MEM64-LABEL: load_lane_i32_with_unfolded_gep_negative_offset:
; MEM64: .functype load_lane_i32_with_unfolded_gep_negative_offset (i64, v128) -> (v128)
; MEM64-NEXT: # %bb.0:
; MEM64-NEXT: local.get 0
; MEM64-NEXT: i64.const -24
; MEM64-NEXT: i64.add
; MEM64-NEXT: local.get 1
; MEM64-NEXT: v128.load32_lane 0, 0
; MEM64-NEXT: # fallthrough-return
%s = getelementptr inbounds i32, ptr %p, i32 -6 %s = getelementptr inbounds i32, ptr %p, i32 -6
%x = load i32, ptr %s %x = load i32, ptr %s
%t = insertelement <4 x i32> %v, i32 %x, i32 0 %t = insertelement <4 x i32> %v, i32 %x, i32 0
ret <4 x i32> %t ret <4 x i32> %t
} }
define <4 x i32> @load_lane_i32_with_unfolded_offset(ptr %p, <4 x i32> %v) { define <4 x i32> @load_lane_i32_with_unfolded_offset(ptr %p, <4 x i32> %v) {
; CHECK-LABEL: load_lane_i32_with_unfolded_offset: ; CHECK-LABEL: load_lane_i32_with_unfolded_offset:
; CHECK: .functype load_lane_i32_with_unfolded_offset (i32, v128) -> (v128) ; CHECK: .functype load_lane_i32_with_unfolded_offset (i32, v128) -> (v128)
; CHECK-NEXT: # %bb.0: ; CHECK-NEXT: # %bb.0:
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: i32.const 24 ; CHECK-NEXT: i32.const 24
; CHECK-NEXT: i32.add ; CHECK-NEXT: i32.add
; CHECK-NEXT: local.get 1 ; CHECK-NEXT: local.get 1
; CHECK-NEXT: v128.load32_lane 0, 0 ; CHECK-NEXT: v128.load32_lane 0, 0
; CHECK-NEXT: # fallthrough-return ; CHECK-NEXT: # fallthrough-return
;
; MEM64-LABEL: load_lane_i32_with_unfolded_offset:
; MEM64: .functype load_lane_i32_with_unfolded_offset (i64, v128) -> (v128)
; MEM64-NEXT: # %bb.0:
; MEM64-NEXT: local.get 0
; MEM64-NEXT: i32.wrap_i64
; MEM64-NEXT: i32.const 24
; MEM64-NEXT: i32.add
; MEM64-NEXT: i64.extend_i32_u
; MEM64-NEXT: local.get 1
; MEM64-NEXT: v128.load32_lane 0, 0
; MEM64-NEXT: # fallthrough-return
%q = ptrtoint ptr %p to i32 %q = ptrtoint ptr %p to i32
%r = add nsw i32 %q, 24 %r = add nsw i32 %q, 24
%s = inttoptr i32 %r to ptr %s = inttoptr i32 %r to ptr
%x = load i32, ptr %s %x = load i32, ptr %s
%t = insertelement <4 x i32> %v, i32 %x, i32 0 %t = insertelement <4 x i32> %v, i32 %x, i32 0
ret <4 x i32> %t ret <4 x i32> %t
} }
define <4 x i32> @load_lane_i32_with_unfolded_gep_offset(ptr %p, <4 x i32> %v) { define <4 x i32> @load_lane_i32_with_unfolded_gep_offset(ptr %p, <4 x i32> %v) {
; CHECK-LABEL: load_lane_i32_with_unfolded_gep_offset: ; CHECK-LABEL: load_lane_i32_with_unfolded_gep_offset:
; CHECK: .functype load_lane_i32_with_unfolded_gep_offset (i32, v128) -> (v128) ; CHECK: .functype load_lane_i32_with_unfolded_gep_offset (i32, v128) -> (v128)
; CHECK-NEXT: # %bb.0: ; CHECK-NEXT: # %bb.0:
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: i32.const 24 ; CHECK-NEXT: i32.const 24
; CHECK-NEXT: i32.add ; CHECK-NEXT: i32.add
; CHECK-NEXT: local.get 1 ; CHECK-NEXT: local.get 1
; CHECK-NEXT: v128.load32_lane 0, 0 ; CHECK-NEXT: v128.load32_lane 0, 0
; CHECK-NEXT: # fallthrough-return ; CHECK-NEXT: # fallthrough-return
;
; MEM64-LABEL: load_lane_i32_with_unfolded_gep_offset:
; MEM64: .functype load_lane_i32_with_unfolded_gep_offset (i64, v128) -> (v128)
; MEM64-NEXT: # %bb.0:
; MEM64-NEXT: local.get 0
; MEM64-NEXT: i64.const 24
; MEM64-NEXT: i64.add
; MEM64-NEXT: local.get 1
; MEM64-NEXT: v128.load32_lane 0, 0
; MEM64-NEXT: # fallthrough-return
%s = getelementptr i32, ptr %p, i32 6 %s = getelementptr i32, ptr %p, i32 6
%x = load i32, ptr %s %x = load i32, ptr %s
%t = insertelement <4 x i32> %v, i32 %x, i32 0 %t = insertelement <4 x i32> %v, i32 %x, i32 0
ret <4 x i32> %t ret <4 x i32> %t
} }
define <4 x i32> @load_lane_i32_from_numeric_address(<4 x i32> %v) { define <4 x i32> @load_lane_i32_from_numeric_address(<4 x i32> %v) {
; CHECK-LABEL: load_lane_i32_from_numeric_address: ; CHECK-LABEL: load_lane_i32_from_numeric_address:
; CHECK: .functype load_lane_i32_from_numeric_address (v128) -> (v128) ; CHECK: .functype load_lane_i32_from_numeric_address (v128) -> (v128)
; CHECK-NEXT: # %bb.0: ; CHECK-NEXT: # %bb.0:
; CHECK-NEXT: i32.const 42 ; CHECK-NEXT: i32.const 42
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: v128.load32_lane 0, 0 ; CHECK-NEXT: v128.load32_lane 0, 0
; CHECK-NEXT: # fallthrough-return ; CHECK-NEXT: # fallthrough-return
;
; MEM64-LABEL: load_lane_i32_from_numeric_address:
; MEM64: .functype load_lane_i32_from_numeric_address (v128) -> (v128)
; MEM64-NEXT: # %bb.0:
; MEM64-NEXT: i64.const 42
; MEM64-NEXT: local.get 0
; MEM64-NEXT: v128.load32_lane 0, 0
; MEM64-NEXT: # fallthrough-return
%s = inttoptr i32 42 to ptr %s = inttoptr i32 42 to ptr
%x = load i32, ptr %s %x = load i32, ptr %s
%t = insertelement <4 x i32> %v, i32 %x, i32 0 %t = insertelement <4 x i32> %v, i32 %x, i32 0
ret <4 x i32> %t ret <4 x i32> %t
} }
@gv_i32 = global i32 0 @gv_i32 = global i32 0
define <4 x i32> @load_lane_i32_from_global_address(<4 x i32> %v) { define <4 x i32> @load_lane_i32_from_global_address(<4 x i32> %v) {
; CHECK-LABEL: load_lane_i32_from_global_address: ; CHECK-LABEL: load_lane_i32_from_global_address:
; CHECK: .functype load_lane_i32_from_global_address (v128) -> (v128) ; CHECK: .functype load_lane_i32_from_global_address (v128) -> (v128)
; CHECK-NEXT: # %bb.0: ; CHECK-NEXT: # %bb.0:
; CHECK-NEXT: i32.const gv_i32 ; CHECK-NEXT: i32.const gv_i32
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: v128.load32_lane 0, 0 ; CHECK-NEXT: v128.load32_lane 0, 0
; CHECK-NEXT: # fallthrough-return ; CHECK-NEXT: # fallthrough-return
;
; MEM64-LABEL: load_lane_i32_from_global_address:
; MEM64: .functype load_lane_i32_from_global_address (v128) -> (v128)
; MEM64-NEXT: # %bb.0:
; MEM64-NEXT: i64.const gv_i32
; MEM64-NEXT: local.get 0
; MEM64-NEXT: v128.load32_lane 0, 0
; MEM64-NEXT: # fallthrough-return
%x = load i32, ptr @gv_i32 %x = load i32, ptr @gv_i32
%t = insertelement <4 x i32> %v, i32 %x, i32 0 %t = insertelement <4 x i32> %v, i32 %x, i32 0
ret <4 x i32> %t ret <4 x i32> %t
} }
define void @store_lane_i32_no_offset(<4 x i32> %v, ptr %p) { define void @store_lane_i32_no_offset(<4 x i32> %v, ptr %p) {
; CHECK-LABEL: store_lane_i32_no_offset: ; CHECK-LABEL: store_lane_i32_no_offset:
; CHECK: .functype store_lane_i32_no_offset (v128, i32) -> () ; CHECK: .functype store_lane_i32_no_offset (v128, i32) -> ()
; CHECK-NEXT: # %bb.0: ; CHECK-NEXT: # %bb.0:
; CHECK-NEXT: local.get 1 ; CHECK-NEXT: local.get 1
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: v128.store32_lane 0, 0 ; CHECK-NEXT: v128.store32_lane 0, 0
; CHECK-NEXT: # fallthrough-return ; CHECK-NEXT: # fallthrough-return
;
; MEM64-LABEL: store_lane_i32_no_offset:
; MEM64: .functype store_lane_i32_no_offset (v128, i64) -> ()
; MEM64-NEXT: # %bb.0:
; MEM64-NEXT: local.get 1
; MEM64-NEXT: local.get 0
; MEM64-NEXT: v128.store32_lane 0, 0
; MEM64-NEXT: # fallthrough-return
%x = extractelement <4 x i32> %v, i32 0 %x = extractelement <4 x i32> %v, i32 0
store i32 %x, ptr %p store i32 %x, ptr %p
ret void ret void
} }
define void @store_lane_i32_with_folded_offset(<4 x i32> %v, ptr %p) { define void @store_lane_i32_with_folded_offset(<4 x i32> %v, ptr %p) {
; CHECK-LABEL: store_lane_i32_with_folded_offset: ; CHECK-LABEL: store_lane_i32_with_folded_offset:
; CHECK: .functype store_lane_i32_with_folded_offset (v128, i32) -> () ; CHECK: .functype store_lane_i32_with_folded_offset (v128, i32) -> ()
; CHECK-NEXT: # %bb.0: ; CHECK-NEXT: # %bb.0:
; CHECK-NEXT: local.get 1 ; CHECK-NEXT: local.get 1
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: v128.store32_lane 24, 0 ; CHECK-NEXT: v128.store32_lane 24, 0
; CHECK-NEXT: # fallthrough-return ; CHECK-NEXT: # fallthrough-return
;
; MEM64-LABEL: store_lane_i32_with_folded_offset:
; MEM64: .functype store_lane_i32_with_folded_offset (v128, i64) -> ()
; MEM64-NEXT: # %bb.0:
; MEM64-NEXT: local.get 1
; MEM64-NEXT: i32.wrap_i64
; MEM64-NEXT: i32.const 24
; MEM64-NEXT: i32.add
; MEM64-NEXT: i64.extend_i32_u
; MEM64-NEXT: local.get 0
; MEM64-NEXT: v128.store32_lane 0, 0
; MEM64-NEXT: # fallthrough-return
%q = ptrtoint ptr %p to i32 %q = ptrtoint ptr %p to i32
%r = add nuw i32 %q, 24 %r = add nuw i32 %q, 24
%s = inttoptr i32 %r to ptr %s = inttoptr i32 %r to ptr
%x = extractelement <4 x i32> %v, i32 0 %x = extractelement <4 x i32> %v, i32 0
store i32 %x, ptr %s store i32 %x, ptr %s
ret void ret void
} }
define void @store_lane_i32_with_folded_gep_offset(<4 x i32> %v, ptr %p) { define void @store_lane_i32_with_folded_gep_offset(<4 x i32> %v, ptr %p) {
; CHECK-LABEL: store_lane_i32_with_folded_gep_offset: ; CHECK-LABEL: store_lane_i32_with_folded_gep_offset:
; CHECK: .functype store_lane_i32_with_folded_gep_offset (v128, i32) -> () ; CHECK: .functype store_lane_i32_with_folded_gep_offset (v128, i32) -> ()
; CHECK-NEXT: # %bb.0: ; CHECK-NEXT: # %bb.0:
; CHECK-NEXT: local.get 1 ; CHECK-NEXT: local.get 1
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: v128.store32_lane 24, 0 ; CHECK-NEXT: v128.store32_lane 24, 0
; CHECK-NEXT: # fallthrough-return ; CHECK-NEXT: # fallthrough-return
;
; MEM64-LABEL: store_lane_i32_with_folded_gep_offset:
; MEM64: .functype store_lane_i32_with_folded_gep_offset (v128, i64) -> ()
; MEM64-NEXT: # %bb.0:
; MEM64-NEXT: local.get 1
; MEM64-NEXT: local.get 0
; MEM64-NEXT: v128.store32_lane 24, 0
; MEM64-NEXT: # fallthrough-return
%s = getelementptr inbounds i32, ptr %p, i32 6 %s = getelementptr inbounds i32, ptr %p, i32 6
%x = extractelement <4 x i32> %v, i32 0 %x = extractelement <4 x i32> %v, i32 0
store i32 %x, ptr %s store i32 %x, ptr %s
ret void ret void
} }
define void @store_lane_i32_with_unfolded_gep_negative_offset(<4 x i32> %v, ptr %p) { define void @store_lane_i32_with_unfolded_gep_negative_offset(<4 x i32> %v, ptr %p) {
; CHECK-LABEL: store_lane_i32_with_unfolded_gep_negative_offset: ; CHECK-LABEL: store_lane_i32_with_unfolded_gep_negative_offset:
; CHECK: .functype store_lane_i32_with_unfolded_gep_negative_offset (v128, i32) -> () ; CHECK: .functype store_lane_i32_with_unfolded_gep_negative_offset (v128, i32) -> ()
; CHECK-NEXT: # %bb.0: ; CHECK-NEXT: # %bb.0:
; CHECK-NEXT: local.get 1 ; CHECK-NEXT: local.get 1
; CHECK-NEXT: i32.const -24 ; CHECK-NEXT: i32.const -24
; CHECK-NEXT: i32.add ; CHECK-NEXT: i32.add
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: v128.store32_lane 0, 0 ; CHECK-NEXT: v128.store32_lane 0, 0
; CHECK-NEXT: # fallthrough-return ; CHECK-NEXT: # fallthrough-return
;
; MEM64-LABEL: store_lane_i32_with_unfolded_gep_negative_offset:
; MEM64: .functype store_lane_i32_with_unfolded_gep_negative_offset (v128, i64) -> ()
; MEM64-NEXT: # %bb.0:
; MEM64-NEXT: local.get 1
; MEM64-NEXT: i64.const -24
; MEM64-NEXT: i64.add
; MEM64-NEXT: local.get 0
; MEM64-NEXT: v128.store32_lane 0, 0
; MEM64-NEXT: # fallthrough-return
%s = getelementptr inbounds i32, ptr %p, i32 -6 %s = getelementptr inbounds i32, ptr %p, i32 -6
%x = extractelement <4 x i32> %v, i32 0 %x = extractelement <4 x i32> %v, i32 0
store i32 %x, ptr %s store i32 %x, ptr %s
ret void ret void
} }
define void @store_lane_i32_with_unfolded_offset(<4 x i32> %v, ptr %p) { define void @store_lane_i32_with_unfolded_offset(<4 x i32> %v, ptr %p) {
; CHECK-LABEL: store_lane_i32_with_unfolded_offset: ; CHECK-LABEL: store_lane_i32_with_unfolded_offset:
; CHECK: .functype store_lane_i32_with_unfolded_offset (v128, i32) -> () ; CHECK: .functype store_lane_i32_with_unfolded_offset (v128, i32) -> ()
; CHECK-NEXT: # %bb.0: ; CHECK-NEXT: # %bb.0:
; CHECK-NEXT: local.get 1 ; CHECK-NEXT: local.get 1
; CHECK-NEXT: i32.const 24 ; CHECK-NEXT: i32.const 24
; CHECK-NEXT: i32.add ; CHECK-NEXT: i32.add
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: v128.store32_lane 0, 0 ; CHECK-NEXT: v128.store32_lane 0, 0
; CHECK-NEXT: # fallthrough-return ; CHECK-NEXT: # fallthrough-return
;
; MEM64-LABEL: store_lane_i32_with_unfolded_offset:
; MEM64: .functype store_lane_i32_with_unfolded_offset (v128, i64) -> ()
; MEM64-NEXT: # %bb.0:
; MEM64-NEXT: local.get 1
; MEM64-NEXT: i32.wrap_i64
; MEM64-NEXT: i32.const 24
; MEM64-NEXT: i32.add
; MEM64-NEXT: i64.extend_i32_u
; MEM64-NEXT: local.get 0
; MEM64-NEXT: v128.store32_lane 0, 0
; MEM64-NEXT: # fallthrough-return
%q = ptrtoint ptr %p to i32 %q = ptrtoint ptr %p to i32
%r = add nsw i32 %q, 24 %r = add nsw i32 %q, 24
%s = inttoptr i32 %r to ptr %s = inttoptr i32 %r to ptr
%x = extractelement <4 x i32> %v, i32 0 %x = extractelement <4 x i32> %v, i32 0
store i32 %x, ptr %s store i32 %x, ptr %s
ret void ret void
} }
define void @store_lane_i32_with_unfolded_gep_offset(<4 x i32> %v, ptr %p) { define void @store_lane_i32_with_unfolded_gep_offset(<4 x i32> %v, ptr %p) {
; CHECK-LABEL: store_lane_i32_with_unfolded_gep_offset: ; CHECK-LABEL: store_lane_i32_with_unfolded_gep_offset:
; CHECK: .functype store_lane_i32_with_unfolded_gep_offset (v128, i32) -> () ; CHECK: .functype store_lane_i32_with_unfolded_gep_offset (v128, i32) -> ()
; CHECK-NEXT: # %bb.0: ; CHECK-NEXT: # %bb.0:
; CHECK-NEXT: local.get 1 ; CHECK-NEXT: local.get 1
; CHECK-NEXT: i32.const 24 ; CHECK-NEXT: i32.const 24
; CHECK-NEXT: i32.add ; CHECK-NEXT: i32.add
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: v128.store32_lane 0, 0 ; CHECK-NEXT: v128.store32_lane 0, 0
; CHECK-NEXT: # fallthrough-return ; CHECK-NEXT: # fallthrough-return
;
; MEM64-LABEL: store_lane_i32_with_unfolded_gep_offset:
; MEM64: .functype store_lane_i32_with_unfolded_gep_offset (v128, i64) -> ()
; MEM64-NEXT: # %bb.0:
; MEM64-NEXT: local.get 1
; MEM64-NEXT: i64.const 24
; MEM64-NEXT: i64.add
; MEM64-NEXT: local.get 0
; MEM64-NEXT: v128.store32_lane 0, 0
; MEM64-NEXT: # fallthrough-return
%s = getelementptr i32, ptr %p, i32 6 %s = getelementptr i32, ptr %p, i32 6
%x = extractelement <4 x i32> %v, i32 0 %x = extractelement <4 x i32> %v, i32 0
store i32 %x, ptr %s store i32 %x, ptr %s
ret void ret void
} }
define void @store_lane_i32_to_numeric_address(<4 x i32> %v) { define void @store_lane_i32_to_numeric_address(<4 x i32> %v) {
; CHECK-LABEL: store_lane_i32_to_numeric_address: ; CHECK-LABEL: store_lane_i32_to_numeric_address:
; CHECK: .functype store_lane_i32_to_numeric_address (v128) -> () ; CHECK: .functype store_lane_i32_to_numeric_address (v128) -> ()
; CHECK-NEXT: # %bb.0: ; CHECK-NEXT: # %bb.0:
; CHECK-NEXT: i32.const 0 ; CHECK-NEXT: i32.const 0
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: v128.store32_lane 42, 0 ; CHECK-NEXT: v128.store32_lane 42, 0
; CHECK-NEXT: # fallthrough-return ; CHECK-NEXT: # fallthrough-return
;
; MEM64-LABEL: store_lane_i32_to_numeric_address:
; MEM64: .functype store_lane_i32_to_numeric_address (v128) -> ()
; MEM64-NEXT: # %bb.0:
; MEM64-NEXT: i64.const 0
; MEM64-NEXT: local.get 0
; MEM64-NEXT: v128.store32_lane 42, 0
; MEM64-NEXT: # fallthrough-return
%s = inttoptr i32 42 to ptr %s = inttoptr i32 42 to ptr
%x = extractelement <4 x i32> %v, i32 0 %x = extractelement <4 x i32> %v, i32 0
store i32 %x, ptr %s store i32 %x, ptr %s
ret void ret void
} }
define void @store_lane_i32_from_global_address(<4 x i32> %v) { define void @store_lane_i32_from_global_address(<4 x i32> %v) {
; CHECK-LABEL: store_lane_i32_from_global_address: ; CHECK-LABEL: store_lane_i32_from_global_address:
; CHECK: .functype store_lane_i32_from_global_address (v128) -> () ; CHECK: .functype store_lane_i32_from_global_address (v128) -> ()
; CHECK-NEXT: # %bb.0: ; CHECK-NEXT: # %bb.0:
; CHECK-NEXT: i32.const 0 ; CHECK-NEXT: i32.const 0
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: v128.store32_lane gv_i32, 0 ; CHECK-NEXT: v128.store32_lane gv_i32, 0
; CHECK-NEXT: # fallthrough-return ; CHECK-NEXT: # fallthrough-return
;
; MEM64-LABEL: store_lane_i32_from_global_address:
; MEM64: .functype store_lane_i32_from_global_address (v128) -> ()
; MEM64-NEXT: # %bb.0:
; MEM64-NEXT: i64.const 0
; MEM64-NEXT: local.get 0
; MEM64-NEXT: v128.store32_lane gv_i32, 0
; MEM64-NEXT: # fallthrough-return
%x = extractelement <4 x i32> %v, i32 0 %x = extractelement <4 x i32> %v, i32 0
store i32 %x, ptr @gv_i32 store i32 %x, ptr @gv_i32
ret void ret void
} }
;===---------------------------------------------------------------------------- ;===----------------------------------------------------------------------------
; v128.load64_lane / v128.store64_lane ; v128.load64_lane / v128.store64_lane
;===---------------------------------------------------------------------------- ;===----------------------------------------------------------------------------
define <2 x i64> @load_lane_i64_no_offset(ptr %p, <2 x i64> %v) { define <2 x i64> @load_lane_i64_no_offset(ptr %p, <2 x i64> %v) {
; CHECK-LABEL: load_lane_i64_no_offset: ; CHECK-LABEL: load_lane_i64_no_offset:
; CHECK: .functype load_lane_i64_no_offset (i32, v128) -> (v128) ; CHECK: .functype load_lane_i64_no_offset (i32, v128) -> (v128)
; CHECK-NEXT: # %bb.0: ; CHECK-NEXT: # %bb.0:
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: local.get 1 ; CHECK-NEXT: local.get 1
; CHECK-NEXT: v128.load64_lane 0, 0 ; CHECK-NEXT: v128.load64_lane 0, 0
; CHECK-NEXT: # fallthrough-return ; CHECK-NEXT: # fallthrough-return
;
; MEM64-LABEL: load_lane_i64_no_offset:
; MEM64: .functype load_lane_i64_no_offset (i64, v128) -> (v128)
; MEM64-NEXT: # %bb.0:
; MEM64-NEXT: local.get 0
; MEM64-NEXT: local.get 1
; MEM64-NEXT: v128.load64_lane 0, 0
; MEM64-NEXT: # fallthrough-return
%x = load i64, ptr %p %x = load i64, ptr %p
%t = insertelement <2 x i64> %v, i64 %x, i32 0 %t = insertelement <2 x i64> %v, i64 %x, i32 0
ret <2 x i64> %t ret <2 x i64> %t
} }
define <2 x i64> @load_lane_i64_with_folded_offset(ptr %p, <2 x i64> %v) { define <2 x i64> @load_lane_i64_with_folded_offset(ptr %p, <2 x i64> %v) {
; CHECK-LABEL: load_lane_i64_with_folded_offset: ; CHECK-LABEL: load_lane_i64_with_folded_offset:
; CHECK: .functype load_lane_i64_with_folded_offset (i32, v128) -> (v128) ; CHECK: .functype load_lane_i64_with_folded_offset (i32, v128) -> (v128)
; CHECK-NEXT: # %bb.0: ; CHECK-NEXT: # %bb.0:
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: i32.const 24 ; CHECK-NEXT: i32.const 24
; CHECK-NEXT: i32.add ; CHECK-NEXT: i32.add
; CHECK-NEXT: local.get 1 ; CHECK-NEXT: local.get 1
; CHECK-NEXT: v128.load64_lane 0, 0 ; CHECK-NEXT: v128.load64_lane 0, 0
; CHECK-NEXT: # fallthrough-return ; CHECK-NEXT: # fallthrough-return
;
; MEM64-LABEL: load_lane_i64_with_folded_offset:
; MEM64: .functype load_lane_i64_with_folded_offset (i64, v128) -> (v128)
; MEM64-NEXT: # %bb.0:
; MEM64-NEXT: local.get 0
; MEM64-NEXT: i32.wrap_i64
; MEM64-NEXT: i32.const 24
; MEM64-NEXT: i32.add
; MEM64-NEXT: i64.extend_i32_u
; MEM64-NEXT: local.get 1
; MEM64-NEXT: v128.load64_lane 0, 0
; MEM64-NEXT: # fallthrough-return
%q = ptrtoint ptr %p to i32 %q = ptrtoint ptr %p to i32
%r = add nuw i32 %q, 24 %r = add nuw i32 %q, 24
%s = inttoptr i32 %r to ptr %s = inttoptr i32 %r to ptr
%x = load i64, ptr %s %x = load i64, ptr %s
%t = insertelement <2 x i64> %v, i64 %x, i32 0 %t = insertelement <2 x i64> %v, i64 %x, i32 0
ret <2 x i64> %t ret <2 x i64> %t
} }
define <2 x i64> @load_lane_i64_with_folded_gep_offset(ptr %p, <2 x i64> %v) { define <2 x i64> @load_lane_i64_with_folded_gep_offset(ptr %p, <2 x i64> %v) {
; CHECK-LABEL: load_lane_i64_with_folded_gep_offset: ; CHECK-LABEL: load_lane_i64_with_folded_gep_offset:
; CHECK: .functype load_lane_i64_with_folded_gep_offset (i32, v128) -> (v128) ; CHECK: .functype load_lane_i64_with_folded_gep_offset (i32, v128) -> (v128)
; CHECK-NEXT: # %bb.0: ; CHECK-NEXT: # %bb.0:
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: i32.const 48 ; CHECK-NEXT: i32.const 48
; CHECK-NEXT: i32.add ; CHECK-NEXT: i32.add
; CHECK-NEXT: local.get 1 ; CHECK-NEXT: local.get 1
; CHECK-NEXT: v128.load64_lane 0, 0 ; CHECK-NEXT: v128.load64_lane 0, 0
; CHECK-NEXT: # fallthrough-return ; CHECK-NEXT: # fallthrough-return
;
; MEM64-LABEL: load_lane_i64_with_folded_gep_offset:
; MEM64: .functype load_lane_i64_with_folded_gep_offset (i64, v128) -> (v128)
; MEM64-NEXT: # %bb.0:
; MEM64-NEXT: local.get 0
; MEM64-NEXT: i64.const 48
; MEM64-NEXT: i64.add
; MEM64-NEXT: local.get 1
; MEM64-NEXT: v128.load64_lane 0, 0
; MEM64-NEXT: # fallthrough-return
%s = getelementptr inbounds i64, ptr %p, i32 6 %s = getelementptr inbounds i64, ptr %p, i32 6
%x = load i64, ptr %s %x = load i64, ptr %s
%t = insertelement <2 x i64> %v, i64 %x, i32 0 %t = insertelement <2 x i64> %v, i64 %x, i32 0
ret <2 x i64> %t ret <2 x i64> %t
} }
define <2 x i64> @load_lane_i64_with_unfolded_gep_negative_offset(ptr %p, <2 x i64> %v) { define <2 x i64> @load_lane_i64_with_unfolded_gep_negative_offset(ptr %p, <2 x i64> %v) {
; CHECK-LABEL: load_lane_i64_with_unfolded_gep_negative_offset: ; CHECK-LABEL: load_lane_i64_with_unfolded_gep_negative_offset:
; CHECK: .functype load_lane_i64_with_unfolded_gep_negative_offset (i32, v128) -> (v128) ; CHECK: .functype load_lane_i64_with_unfolded_gep_negative_offset (i32, v128) -> (v128)
; CHECK-NEXT: # %bb.0: ; CHECK-NEXT: # %bb.0:
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: i32.const -48 ; CHECK-NEXT: i32.const -48
; CHECK-NEXT: i32.add ; CHECK-NEXT: i32.add
; CHECK-NEXT: local.get 1 ; CHECK-NEXT: local.get 1
; CHECK-NEXT: v128.load64_lane 0, 0 ; CHECK-NEXT: v128.load64_lane 0, 0
; CHECK-NEXT: # fallthrough-return ; CHECK-NEXT: # fallthrough-return
;
; MEM64-LABEL: load_lane_i64_with_unfolded_gep_negative_offset:
; MEM64: .functype load_lane_i64_with_unfolded_gep_negative_offset (i64, v128) -> (v128)
; MEM64-NEXT: # %bb.0:
; MEM64-NEXT: local.get 0
; MEM64-NEXT: i64.const -48
; MEM64-NEXT: i64.add
; MEM64-NEXT: local.get 1
; MEM64-NEXT: v128.load64_lane 0, 0
; MEM64-NEXT: # fallthrough-return
%s = getelementptr inbounds i64, ptr %p, i32 -6 %s = getelementptr inbounds i64, ptr %p, i32 -6
%x = load i64, ptr %s %x = load i64, ptr %s
%t = insertelement <2 x i64> %v, i64 %x, i32 0 %t = insertelement <2 x i64> %v, i64 %x, i32 0
ret <2 x i64> %t ret <2 x i64> %t
} }
define <2 x i64> @load_lane_i64_with_unfolded_offset(ptr %p, <2 x i64> %v) { define <2 x i64> @load_lane_i64_with_unfolded_offset(ptr %p, <2 x i64> %v) {
; CHECK-LABEL: load_lane_i64_with_unfolded_offset: ; CHECK-LABEL: load_lane_i64_with_unfolded_offset:
; CHECK: .functype load_lane_i64_with_unfolded_offset (i32, v128) -> (v128) ; CHECK: .functype load_lane_i64_with_unfolded_offset (i32, v128) -> (v128)
; CHECK-NEXT: # %bb.0: ; CHECK-NEXT: # %bb.0:
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: i32.const 24 ; CHECK-NEXT: i32.const 24
; CHECK-NEXT: i32.add ; CHECK-NEXT: i32.add
; CHECK-NEXT: local.get 1 ; CHECK-NEXT: local.get 1
; CHECK-NEXT: v128.load64_lane 0, 0 ; CHECK-NEXT: v128.load64_lane 0, 0
; CHECK-NEXT: # fallthrough-return ; CHECK-NEXT: # fallthrough-return
;
; MEM64-LABEL: load_lane_i64_with_unfolded_offset:
; MEM64: .functype load_lane_i64_with_unfolded_offset (i64, v128) -> (v128)
; MEM64-NEXT: # %bb.0:
; MEM64-NEXT: local.get 0
; MEM64-NEXT: i32.wrap_i64
; MEM64-NEXT: i32.const 24
; MEM64-NEXT: i32.add
; MEM64-NEXT: i64.extend_i32_u
; MEM64-NEXT: local.get 1
; MEM64-NEXT: v128.load64_lane 0, 0
; MEM64-NEXT: # fallthrough-return
%q = ptrtoint ptr %p to i32 %q = ptrtoint ptr %p to i32
%r = add nsw i32 %q, 24 %r = add nsw i32 %q, 24
%s = inttoptr i32 %r to ptr %s = inttoptr i32 %r to ptr
%x = load i64, ptr %s %x = load i64, ptr %s
%t = insertelement <2 x i64> %v, i64 %x, i32 0 %t = insertelement <2 x i64> %v, i64 %x, i32 0
ret <2 x i64> %t ret <2 x i64> %t
} }
define <2 x i64> @load_lane_i64_with_unfolded_gep_offset(ptr %p, <2 x i64> %v) { define <2 x i64> @load_lane_i64_with_unfolded_gep_offset(ptr %p, <2 x i64> %v) {
; CHECK-LABEL: load_lane_i64_with_unfolded_gep_offset: ; CHECK-LABEL: load_lane_i64_with_unfolded_gep_offset:
; CHECK: .functype load_lane_i64_with_unfolded_gep_offset (i32, v128) -> (v128) ; CHECK: .functype load_lane_i64_with_unfolded_gep_offset (i32, v128) -> (v128)
; CHECK-NEXT: # %bb.0: ; CHECK-NEXT: # %bb.0:
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: i32.const 48 ; CHECK-NEXT: i32.const 48
; CHECK-NEXT: i32.add ; CHECK-NEXT: i32.add
; CHECK-NEXT: local.get 1 ; CHECK-NEXT: local.get 1
; CHECK-NEXT: v128.load64_lane 0, 0 ; CHECK-NEXT: v128.load64_lane 0, 0
; CHECK-NEXT: # fallthrough-return ; CHECK-NEXT: # fallthrough-return
;
; MEM64-LABEL: load_lane_i64_with_unfolded_gep_offset:
; MEM64: .functype load_lane_i64_with_unfolded_gep_offset (i64, v128) -> (v128)
; MEM64-NEXT: # %bb.0:
; MEM64-NEXT: local.get 0
; MEM64-NEXT: i64.const 48
; MEM64-NEXT: i64.add
; MEM64-NEXT: local.get 1
; MEM64-NEXT: v128.load64_lane 0, 0
; MEM64-NEXT: # fallthrough-return
%s = getelementptr i64, ptr %p, i32 6 %s = getelementptr i64, ptr %p, i32 6
%x = load i64, ptr %s %x = load i64, ptr %s
%t = insertelement <2 x i64> %v, i64 %x, i32 0 %t = insertelement <2 x i64> %v, i64 %x, i32 0
ret <2 x i64> %t ret <2 x i64> %t
} }
define <2 x i64> @load_lane_i64_from_numeric_address(<2 x i64> %v) { define <2 x i64> @load_lane_i64_from_numeric_address(<2 x i64> %v) {
; CHECK-LABEL: load_lane_i64_from_numeric_address: ; CHECK-LABEL: load_lane_i64_from_numeric_address:
; CHECK: .functype load_lane_i64_from_numeric_address (v128) -> (v128) ; CHECK: .functype load_lane_i64_from_numeric_address (v128) -> (v128)
; CHECK-NEXT: # %bb.0: ; CHECK-NEXT: # %bb.0:
; CHECK-NEXT: i32.const 42 ; CHECK-NEXT: i32.const 42
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: v128.load64_lane 0, 0 ; CHECK-NEXT: v128.load64_lane 0, 0
; CHECK-NEXT: # fallthrough-return ; CHECK-NEXT: # fallthrough-return
;
; MEM64-LABEL: load_lane_i64_from_numeric_address:
; MEM64: .functype load_lane_i64_from_numeric_address (v128) -> (v128)
; MEM64-NEXT: # %bb.0:
; MEM64-NEXT: i64.const 42
; MEM64-NEXT: local.get 0
; MEM64-NEXT: v128.load64_lane 0, 0
; MEM64-NEXT: # fallthrough-return
%s = inttoptr i32 42 to ptr %s = inttoptr i32 42 to ptr
%x = load i64, ptr %s %x = load i64, ptr %s
%t = insertelement <2 x i64> %v, i64 %x, i32 0 %t = insertelement <2 x i64> %v, i64 %x, i32 0
ret <2 x i64> %t ret <2 x i64> %t
} }
@gv_i64 = global i64 0 @gv_i64 = global i64 0
define <2 x i64> @load_lane_i64_from_global_address(<2 x i64> %v) { define <2 x i64> @load_lane_i64_from_global_address(<2 x i64> %v) {
; CHECK-LABEL: load_lane_i64_from_global_address: ; CHECK-LABEL: load_lane_i64_from_global_address:
; CHECK: .functype load_lane_i64_from_global_address (v128) -> (v128) ; CHECK: .functype load_lane_i64_from_global_address (v128) -> (v128)
; CHECK-NEXT: # %bb.0: ; CHECK-NEXT: # %bb.0:
; CHECK-NEXT: i32.const gv_i64 ; CHECK-NEXT: i32.const gv_i64
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: v128.load64_lane 0, 0 ; CHECK-NEXT: v128.load64_lane 0, 0
; CHECK-NEXT: # fallthrough-return ; CHECK-NEXT: # fallthrough-return
;
; MEM64-LABEL: load_lane_i64_from_global_address:
; MEM64: .functype load_lane_i64_from_global_address (v128) -> (v128)
; MEM64-NEXT: # %bb.0:
; MEM64-NEXT: i64.const gv_i64
; MEM64-NEXT: local.get 0
; MEM64-NEXT: v128.load64_lane 0, 0
; MEM64-NEXT: # fallthrough-return
%x = load i64, ptr @gv_i64 %x = load i64, ptr @gv_i64
%t = insertelement <2 x i64> %v, i64 %x, i32 0 %t = insertelement <2 x i64> %v, i64 %x, i32 0
ret <2 x i64> %t ret <2 x i64> %t
} }
define void @store_lane_i64_no_offset(<2 x i64> %v, ptr %p) { define void @store_lane_i64_no_offset(<2 x i64> %v, ptr %p) {
; CHECK-LABEL: store_lane_i64_no_offset: ; CHECK-LABEL: store_lane_i64_no_offset:
; CHECK: .functype store_lane_i64_no_offset (v128, i32) -> () ; CHECK: .functype store_lane_i64_no_offset (v128, i32) -> ()
; CHECK-NEXT: # %bb.0: ; CHECK-NEXT: # %bb.0:
; CHECK-NEXT: local.get 1 ; CHECK-NEXT: local.get 1
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: v128.store64_lane 0, 0 ; CHECK-NEXT: v128.store64_lane 0, 0
; CHECK-NEXT: # fallthrough-return ; CHECK-NEXT: # fallthrough-return
;
; MEM64-LABEL: store_lane_i64_no_offset:
; MEM64: .functype store_lane_i64_no_offset (v128, i64) -> ()
; MEM64-NEXT: # %bb.0:
; MEM64-NEXT: local.get 1
; MEM64-NEXT: local.get 0
; MEM64-NEXT: v128.store64_lane 0, 0
; MEM64-NEXT: # fallthrough-return
%x = extractelement <2 x i64> %v, i32 0 %x = extractelement <2 x i64> %v, i32 0
store i64 %x, ptr %p store i64 %x, ptr %p
ret void ret void
} }
define void @store_lane_i64_with_folded_offset(<2 x i64> %v, ptr %p) { define void @store_lane_i64_with_folded_offset(<2 x i64> %v, ptr %p) {
; CHECK-LABEL: store_lane_i64_with_folded_offset: ; CHECK-LABEL: store_lane_i64_with_folded_offset:
; CHECK: .functype store_lane_i64_with_folded_offset (v128, i32) -> () ; CHECK: .functype store_lane_i64_with_folded_offset (v128, i32) -> ()
; CHECK-NEXT: # %bb.0: ; CHECK-NEXT: # %bb.0:
; CHECK-NEXT: local.get 1 ; CHECK-NEXT: local.get 1
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: v128.store64_lane 24, 0 ; CHECK-NEXT: v128.store64_lane 24, 0
; CHECK-NEXT: # fallthrough-return ; CHECK-NEXT: # fallthrough-return
;
; MEM64-LABEL: store_lane_i64_with_folded_offset:
; MEM64: .functype store_lane_i64_with_folded_offset (v128, i64) -> ()
; MEM64-NEXT: # %bb.0:
; MEM64-NEXT: local.get 1
; MEM64-NEXT: i32.wrap_i64
; MEM64-NEXT: i32.const 24
; MEM64-NEXT: i32.add
; MEM64-NEXT: i64.extend_i32_u
; MEM64-NEXT: local.get 0
; MEM64-NEXT: v128.store64_lane 0, 0
; MEM64-NEXT: # fallthrough-return
%q = ptrtoint ptr %p to i32 %q = ptrtoint ptr %p to i32
%r = add nuw i32 %q, 24 %r = add nuw i32 %q, 24
%s = inttoptr i32 %r to ptr %s = inttoptr i32 %r to ptr
%x = extractelement <2 x i64> %v, i32 0 %x = extractelement <2 x i64> %v, i32 0
store i64 %x, ptr %s store i64 %x, ptr %s
ret void ret void
} }
define void @store_lane_i64_with_folded_gep_offset(<2 x i64> %v, ptr %p) { define void @store_lane_i64_with_folded_gep_offset(<2 x i64> %v, ptr %p) {
; CHECK-LABEL: store_lane_i64_with_folded_gep_offset: ; CHECK-LABEL: store_lane_i64_with_folded_gep_offset:
; CHECK: .functype store_lane_i64_with_folded_gep_offset (v128, i32) -> () ; CHECK: .functype store_lane_i64_with_folded_gep_offset (v128, i32) -> ()
; CHECK-NEXT: # %bb.0: ; CHECK-NEXT: # %bb.0:
; CHECK-NEXT: local.get 1 ; CHECK-NEXT: local.get 1
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: v128.store64_lane 48, 0 ; CHECK-NEXT: v128.store64_lane 48, 0
; CHECK-NEXT: # fallthrough-return ; CHECK-NEXT: # fallthrough-return
;
; MEM64-LABEL: store_lane_i64_with_folded_gep_offset:
; MEM64: .functype store_lane_i64_with_folded_gep_offset (v128, i64) -> ()
; MEM64-NEXT: # %bb.0:
; MEM64-NEXT: local.get 1
; MEM64-NEXT: local.get 0
; MEM64-NEXT: v128.store64_lane 48, 0
; MEM64-NEXT: # fallthrough-return
%s = getelementptr inbounds i64, ptr %p, i32 6 %s = getelementptr inbounds i64, ptr %p, i32 6
%x = extractelement <2 x i64> %v, i32 0 %x = extractelement <2 x i64> %v, i32 0
store i64 %x, ptr %s store i64 %x, ptr %s
ret void ret void
} }
define void @store_lane_i64_with_unfolded_gep_negative_offset(<2 x i64> %v, ptr %p) { define void @store_lane_i64_with_unfolded_gep_negative_offset(<2 x i64> %v, ptr %p) {
; CHECK-LABEL: store_lane_i64_with_unfolded_gep_negative_offset: ; CHECK-LABEL: store_lane_i64_with_unfolded_gep_negative_offset:
; CHECK: .functype store_lane_i64_with_unfolded_gep_negative_offset (v128, i32) -> () ; CHECK: .functype store_lane_i64_with_unfolded_gep_negative_offset (v128, i32) -> ()
; CHECK-NEXT: # %bb.0: ; CHECK-NEXT: # %bb.0:
; CHECK-NEXT: local.get 1 ; CHECK-NEXT: local.get 1
; CHECK-NEXT: i32.const -48 ; CHECK-NEXT: i32.const -48
; CHECK-NEXT: i32.add ; CHECK-NEXT: i32.add
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: v128.store64_lane 0, 0 ; CHECK-NEXT: v128.store64_lane 0, 0
; CHECK-NEXT: # fallthrough-return ; CHECK-NEXT: # fallthrough-return
;
; MEM64-LABEL: store_lane_i64_with_unfolded_gep_negative_offset:
; MEM64: .functype store_lane_i64_with_unfolded_gep_negative_offset (v128, i64) -> ()
; MEM64-NEXT: # %bb.0:
; MEM64-NEXT: local.get 1
; MEM64-NEXT: i64.const -48
; MEM64-NEXT: i64.add
; MEM64-NEXT: local.get 0
; MEM64-NEXT: v128.store64_lane 0, 0
; MEM64-NEXT: # fallthrough-return
%s = getelementptr inbounds i64, ptr %p, i32 -6 %s = getelementptr inbounds i64, ptr %p, i32 -6
%x = extractelement <2 x i64> %v, i32 0 %x = extractelement <2 x i64> %v, i32 0
store i64 %x, ptr %s store i64 %x, ptr %s
ret void ret void
} }
define void @store_lane_i64_with_unfolded_offset(<2 x i64> %v, ptr %p) { define void @store_lane_i64_with_unfolded_offset(<2 x i64> %v, ptr %p) {
; CHECK-LABEL: store_lane_i64_with_unfolded_offset: ; CHECK-LABEL: store_lane_i64_with_unfolded_offset:
; CHECK: .functype store_lane_i64_with_unfolded_offset (v128, i32) -> () ; CHECK: .functype store_lane_i64_with_unfolded_offset (v128, i32) -> ()
; CHECK-NEXT: # %bb.0: ; CHECK-NEXT: # %bb.0:
; CHECK-NEXT: local.get 1 ; CHECK-NEXT: local.get 1
; CHECK-NEXT: i32.const 24 ; CHECK-NEXT: i32.const 24
; CHECK-NEXT: i32.add ; CHECK-NEXT: i32.add
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: v128.store64_lane 0, 0 ; CHECK-NEXT: v128.store64_lane 0, 0
; CHECK-NEXT: # fallthrough-return ; CHECK-NEXT: # fallthrough-return
;
; MEM64-LABEL: store_lane_i64_with_unfolded_offset:
; MEM64: .functype store_lane_i64_with_unfolded_offset (v128, i64) -> ()
; MEM64-NEXT: # %bb.0:
; MEM64-NEXT: local.get 1
; MEM64-NEXT: i32.wrap_i64
; MEM64-NEXT: i32.const 24
; MEM64-NEXT: i32.add
; MEM64-NEXT: i64.extend_i32_u
; MEM64-NEXT: local.get 0
; MEM64-NEXT: v128.store64_lane 0, 0
; MEM64-NEXT: # fallthrough-return
%q = ptrtoint ptr %p to i32 %q = ptrtoint ptr %p to i32
%r = add nsw i32 %q, 24 %r = add nsw i32 %q, 24
%s = inttoptr i32 %r to ptr %s = inttoptr i32 %r to ptr
%x = extractelement <2 x i64> %v, i32 0 %x = extractelement <2 x i64> %v, i32 0
store i64 %x, ptr %s store i64 %x, ptr %s
ret void ret void
} }
define void @store_lane_i64_with_unfolded_gep_offset(<2 x i64> %v, ptr %p) { define void @store_lane_i64_with_unfolded_gep_offset(<2 x i64> %v, ptr %p) {
; CHECK-LABEL: store_lane_i64_with_unfolded_gep_offset: ; CHECK-LABEL: store_lane_i64_with_unfolded_gep_offset:
; CHECK: .functype store_lane_i64_with_unfolded_gep_offset (v128, i32) -> () ; CHECK: .functype store_lane_i64_with_unfolded_gep_offset (v128, i32) -> ()
; CHECK-NEXT: # %bb.0: ; CHECK-NEXT: # %bb.0:
; CHECK-NEXT: local.get 1 ; CHECK-NEXT: local.get 1
; CHECK-NEXT: i32.const 48 ; CHECK-NEXT: i32.const 48
; CHECK-NEXT: i32.add ; CHECK-NEXT: i32.add
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: v128.store64_lane 0, 0 ; CHECK-NEXT: v128.store64_lane 0, 0
; CHECK-NEXT: # fallthrough-return ; CHECK-NEXT: # fallthrough-return
;
; MEM64-LABEL: store_lane_i64_with_unfolded_gep_offset:
; MEM64: .functype store_lane_i64_with_unfolded_gep_offset (v128, i64) -> ()
; MEM64-NEXT: # %bb.0:
; MEM64-NEXT: local.get 1
; MEM64-NEXT: i64.const 48
; MEM64-NEXT: i64.add
; MEM64-NEXT: local.get 0
; MEM64-NEXT: v128.store64_lane 0, 0
; MEM64-NEXT: # fallthrough-return
%s = getelementptr i64, ptr %p, i32 6 %s = getelementptr i64, ptr %p, i32 6
%x = extractelement <2 x i64> %v, i32 0 %x = extractelement <2 x i64> %v, i32 0
store i64 %x, ptr %s store i64 %x, ptr %s
ret void ret void
} }
define void @store_lane_i64_to_numeric_address(<2 x i64> %v) { define void @store_lane_i64_to_numeric_address(<2 x i64> %v) {
; CHECK-LABEL: store_lane_i64_to_numeric_address: ; CHECK-LABEL: store_lane_i64_to_numeric_address:
; CHECK: .functype store_lane_i64_to_numeric_address (v128) -> () ; CHECK: .functype store_lane_i64_to_numeric_address (v128) -> ()
; CHECK-NEXT: # %bb.0: ; CHECK-NEXT: # %bb.0:
; CHECK-NEXT: i32.const 0 ; CHECK-NEXT: i32.const 0
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: v128.store64_lane 42, 0 ; CHECK-NEXT: v128.store64_lane 42, 0
; CHECK-NEXT: # fallthrough-return ; CHECK-NEXT: # fallthrough-return
;
; MEM64-LABEL: store_lane_i64_to_numeric_address:
; MEM64: .functype store_lane_i64_to_numeric_address (v128) -> ()
; MEM64-NEXT: # %bb.0:
; MEM64-NEXT: i64.const 0
; MEM64-NEXT: local.get 0
; MEM64-NEXT: v128.store64_lane 42, 0
; MEM64-NEXT: # fallthrough-return
%s = inttoptr i32 42 to ptr %s = inttoptr i32 42 to ptr
%x = extractelement <2 x i64> %v, i32 0 %x = extractelement <2 x i64> %v, i32 0
store i64 %x, ptr %s store i64 %x, ptr %s
ret void ret void
} }
define void @store_lane_i64_from_global_address(<2 x i64> %v) { define void @store_lane_i64_from_global_address(<2 x i64> %v) {
; CHECK-LABEL: store_lane_i64_from_global_address: ; CHECK-LABEL: store_lane_i64_from_global_address:
; CHECK: .functype store_lane_i64_from_global_address (v128) -> () ; CHECK: .functype store_lane_i64_from_global_address (v128) -> ()
; CHECK-NEXT: # %bb.0: ; CHECK-NEXT: # %bb.0:
; CHECK-NEXT: i32.const 0 ; CHECK-NEXT: i32.const 0
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: v128.store64_lane gv_i64, 0 ; CHECK-NEXT: v128.store64_lane gv_i64, 0
; CHECK-NEXT: # fallthrough-return ; CHECK-NEXT: # fallthrough-return
;
; MEM64-LABEL: store_lane_i64_from_global_address:
; MEM64: .functype store_lane_i64_from_global_address (v128) -> ()
; MEM64-NEXT: # %bb.0:
; MEM64-NEXT: i64.const 0
; MEM64-NEXT: local.get 0
; MEM64-NEXT: v128.store64_lane gv_i64, 0
; MEM64-NEXT: # fallthrough-return
%x = extractelement <2 x i64> %v, i32 0 %x = extractelement <2 x i64> %v, i32 0
store i64 %x, ptr @gv_i64 store i64 %x, ptr @gv_i64
ret void ret void
} }