[ARM] More MVE compare vector splat combines for ANDs
[llvm-complete.git] / test / CodeGen / AArch64 / ldst-unsignedimm.ll
blob9777d3ed0ff9070b669deecdc5fd66e36151add4
1 ; RUN: llc -verify-machineinstrs -o - %s -mtriple=aarch64-none-linux-gnu | FileCheck %s
2 ; RUN: llc -verify-machineinstrs < %s -mtriple=aarch64-none-linux-gnu -mattr=-fp-armv8 | FileCheck --check-prefix=CHECK-NOFP %s
4 @var_8bit = global i8 0
5 @var_16bit = global i16 0
6 @var_32bit = global i32 0
7 @var_64bit = global i64 0
9 @var_float = global float 0.0
10 @var_double = global double 0.0
12 define void @ldst_8bit() {
13 ; CHECK-LABEL: ldst_8bit:
15 ; No architectural support for loads to 16-bit or 8-bit since we
16 ; promote i8 during lowering.
18 ; match a sign-extending load 8-bit -> 32-bit
19    %val8_sext32 = load volatile i8, i8* @var_8bit
20    %val32_signed = sext i8 %val8_sext32 to i32
21    store volatile i32 %val32_signed, i32* @var_32bit
22 ; CHECK: adrp {{x[0-9]+}}, var_8bit
23 ; CHECK: ldrsb {{w[0-9]+}}, [{{x[0-9]+}}, {{#?}}:lo12:var_8bit]
25 ; match a zero-extending load volatile 8-bit -> 32-bit
26   %val8_zext32 = load volatile i8, i8* @var_8bit
27   %val32_unsigned = zext i8 %val8_zext32 to i32
28   store volatile i32 %val32_unsigned, i32* @var_32bit
29 ; CHECK: ldrb {{w[0-9]+}}, [{{x[0-9]+}}, {{#?}}:lo12:var_8bit]
31 ; match an any-extending load volatile 8-bit -> 32-bit
32   %val8_anyext = load volatile i8, i8* @var_8bit
33   %newval8 = add i8 %val8_anyext, 1
34   store volatile i8 %newval8, i8* @var_8bit
35 ; CHECK: ldrb {{w[0-9]+}}, [{{x[0-9]+}}, {{#?}}:lo12:var_8bit]
37 ; match a sign-extending load volatile 8-bit -> 64-bit
38   %val8_sext64 = load volatile i8, i8* @var_8bit
39   %val64_signed = sext i8 %val8_sext64 to i64
40   store volatile i64 %val64_signed, i64* @var_64bit
41 ; CHECK: ldrsb {{x[0-9]+}}, [{{x[0-9]+}}, {{#?}}:lo12:var_8bit]
43 ; match a zero-extending load volatile 8-bit -> 64-bit.
44 ; This uses the fact that ldrb w0, [x0] will zero out the high 32-bits
45 ; of x0 so it's identical to load volatileing to 32-bits.
46   %val8_zext64 = load volatile i8, i8* @var_8bit
47   %val64_unsigned = zext i8 %val8_zext64 to i64
48   store volatile i64 %val64_unsigned, i64* @var_64bit
49 ; CHECK: ldrb {{w[0-9]+}}, [{{x[0-9]+}}, {{#?}}:lo12:var_8bit]
51 ; truncating store volatile 32-bits to 8-bits
52   %val32 = load volatile i32, i32* @var_32bit
53   %val8_trunc32 = trunc i32 %val32 to i8
54   store volatile i8 %val8_trunc32, i8* @var_8bit
55 ; CHECK: strb {{w[0-9]+}}, [{{x[0-9]+}}, {{#?}}:lo12:var_8bit]
57 ; truncating store volatile 64-bits to 8-bits
58   %val64 = load volatile i64, i64* @var_64bit
59   %val8_trunc64 = trunc i64 %val64 to i8
60   store volatile i8 %val8_trunc64, i8* @var_8bit
61 ; CHECK: strb {{w[0-9]+}}, [{{x[0-9]+}}, {{#?}}:lo12:var_8bit]
63    ret void
66 define void @ldst_16bit() {
67 ; CHECK-LABEL: ldst_16bit:
69 ; No architectural support for load volatiles to 16-bit promote i16 during
70 ; lowering.
72 ; match a sign-extending load volatile 16-bit -> 32-bit
73   %val16_sext32 = load volatile i16, i16* @var_16bit
74   %val32_signed = sext i16 %val16_sext32 to i32
75   store volatile i32 %val32_signed, i32* @var_32bit
76 ; CHECK: adrp {{x[0-9]+}}, var_16bit
77 ; CHECK: ldrsh {{w[0-9]+}}, [{{x[0-9]+}}, {{#?}}:lo12:var_16bit]
79 ; match a zero-extending load volatile 16-bit -> 32-bit
80   %val16_zext32 = load volatile i16, i16* @var_16bit
81   %val32_unsigned = zext i16 %val16_zext32 to i32
82   store volatile i32 %val32_unsigned, i32* @var_32bit
83 ; CHECK: ldrh {{w[0-9]+}}, [{{x[0-9]+}}, {{#?}}:lo12:var_16bit]
85 ; match an any-extending load volatile 16-bit -> 32-bit
86   %val16_anyext = load volatile i16, i16* @var_16bit
87   %newval16 = add i16 %val16_anyext, 1
88   store volatile i16 %newval16, i16* @var_16bit
89 ; CHECK: ldrh {{w[0-9]+}}, [{{x[0-9]+}}, {{#?}}:lo12:var_16bit]
91 ; match a sign-extending load volatile 16-bit -> 64-bit
92   %val16_sext64 = load volatile i16, i16* @var_16bit
93   %val64_signed = sext i16 %val16_sext64 to i64
94   store volatile i64 %val64_signed, i64* @var_64bit
95 ; CHECK: ldrsh {{x[0-9]+}}, [{{x[0-9]+}}, {{#?}}:lo12:var_16bit]
97 ; match a zero-extending load volatile 16-bit -> 64-bit.
98 ; This uses the fact that ldrb w0, [x0] will zero out the high 32-bits
99 ; of x0 so it's identical to load volatileing to 32-bits.
100   %val16_zext64 = load volatile i16, i16* @var_16bit
101   %val64_unsigned = zext i16 %val16_zext64 to i64
102   store volatile i64 %val64_unsigned, i64* @var_64bit
103 ; CHECK: ldrh {{w[0-9]+}}, [{{x[0-9]+}}, {{#?}}:lo12:var_16bit]
105 ; truncating store volatile 32-bits to 16-bits
106   %val32 = load volatile i32, i32* @var_32bit
107   %val16_trunc32 = trunc i32 %val32 to i16
108   store volatile i16 %val16_trunc32, i16* @var_16bit
109 ; CHECK: strh {{w[0-9]+}}, [{{x[0-9]+}}, {{#?}}:lo12:var_16bit]
111 ; truncating store volatile 64-bits to 16-bits
112   %val64 = load volatile i64, i64* @var_64bit
113   %val16_trunc64 = trunc i64 %val64 to i16
114   store volatile i16 %val16_trunc64, i16* @var_16bit
115 ; CHECK: strh {{w[0-9]+}}, [{{x[0-9]+}}, {{#?}}:lo12:var_16bit]
117   ret void
120 define void @ldst_32bit() {
121 ; CHECK-LABEL: ldst_32bit:
123 ; Straight 32-bit load/store
124   %val32_noext = load volatile i32, i32* @var_32bit
125   store volatile i32 %val32_noext, i32* @var_32bit
126 ; CHECK: adrp {{x[0-9]+}}, var_32bit
127 ; CHECK: ldr {{w[0-9]+}}, [{{x[0-9]+}}, {{#?}}:lo12:var_32bit]
128 ; CHECK: str {{w[0-9]+}}, [{{x[0-9]+}}, {{#?}}:lo12:var_32bit]
130 ; Zero-extension to 64-bits
131   %val32_zext = load volatile i32, i32* @var_32bit
132   %val64_unsigned = zext i32 %val32_zext to i64
133   store volatile i64 %val64_unsigned, i64* @var_64bit
134 ; CHECK: ldr {{w[0-9]+}}, [{{x[0-9]+}}, {{#?}}:lo12:var_32bit]
135 ; CHECK: str {{x[0-9]+}}, [{{x[0-9]+}}, {{#?}}:lo12:var_64bit]
137 ; Sign-extension to 64-bits
138   %val32_sext = load volatile i32, i32* @var_32bit
139   %val64_signed = sext i32 %val32_sext to i64
140   store volatile i64 %val64_signed, i64* @var_64bit
141 ; CHECK: ldrsw {{x[0-9]+}}, [{{x[0-9]+}}, {{#?}}:lo12:var_32bit]
142 ; CHECK: str {{x[0-9]+}}, [{{x[0-9]+}}, {{#?}}:lo12:var_64bit]
144 ; Truncation from 64-bits
145   %val64_trunc = load volatile i64, i64* @var_64bit
146   %val32_trunc = trunc i64 %val64_trunc to i32
147   store volatile i32 %val32_trunc, i32* @var_32bit
148 ; CHECK: ldr {{x[0-9]+}}, [{{x[0-9]+}}, {{#?}}:lo12:var_64bit]
149 ; CHECK: str {{w[0-9]+}}, [{{x[0-9]+}}, {{#?}}:lo12:var_32bit]
151   ret void
154 @arr8 = global i8* null
155 @arr16 = global i16* null
156 @arr32 = global i32* null
157 @arr64 = global i64* null
159 ; Now check that our selection copes with accesses more complex than a
160 ; single symbol. Permitted offsets should be folded into the loads and
161 ; stores. Since all forms use the same Operand it's only necessary to
162 ; check the various access-sizes involved.
164 define void @ldst_complex_offsets() {
165 ; CHECK: ldst_complex_offsets
166   %arr8_addr = load volatile i8*, i8** @arr8
167 ; CHECK: adrp {{x[0-9]+}}, arr8
168 ; CHECK: ldr {{x[0-9]+}}, [{{x[0-9]+}}, {{#?}}:lo12:arr8]
170   %arr8_sub1_addr = getelementptr i8, i8* %arr8_addr, i64 1
171   %arr8_sub1 = load volatile i8, i8* %arr8_sub1_addr
172   store volatile i8 %arr8_sub1, i8* @var_8bit
173 ; CHECK: ldrb {{w[0-9]+}}, [{{x[0-9]+}}, #1]
175   %arr8_sub4095_addr = getelementptr i8, i8* %arr8_addr, i64 4095
176   %arr8_sub4095 = load volatile i8, i8* %arr8_sub4095_addr
177   store volatile i8 %arr8_sub4095, i8* @var_8bit
178 ; CHECK: ldrb {{w[0-9]+}}, [{{x[0-9]+}}, #4095]
181   %arr16_addr = load volatile i16*, i16** @arr16
182 ; CHECK: adrp {{x[0-9]+}}, arr16
183 ; CHECK: ldr {{x[0-9]+}}, [{{x[0-9]+}}, {{#?}}:lo12:arr16]
185   %arr16_sub1_addr = getelementptr i16, i16* %arr16_addr, i64 1
186   %arr16_sub1 = load volatile i16, i16* %arr16_sub1_addr
187   store volatile i16 %arr16_sub1, i16* @var_16bit
188 ; CHECK: ldrh {{w[0-9]+}}, [{{x[0-9]+}}, #2]
190   %arr16_sub4095_addr = getelementptr i16, i16* %arr16_addr, i64 4095
191   %arr16_sub4095 = load volatile i16, i16* %arr16_sub4095_addr
192   store volatile i16 %arr16_sub4095, i16* @var_16bit
193 ; CHECK: ldrh {{w[0-9]+}}, [{{x[0-9]+}}, #8190]
196   %arr32_addr = load volatile i32*, i32** @arr32
197 ; CHECK: adrp {{x[0-9]+}}, arr32
198 ; CHECK: ldr {{x[0-9]+}}, [{{x[0-9]+}}, {{#?}}:lo12:arr32]
200   %arr32_sub1_addr = getelementptr i32, i32* %arr32_addr, i64 1
201   %arr32_sub1 = load volatile i32, i32* %arr32_sub1_addr
202   store volatile i32 %arr32_sub1, i32* @var_32bit
203 ; CHECK: ldr {{w[0-9]+}}, [{{x[0-9]+}}, #4]
205   %arr32_sub4095_addr = getelementptr i32, i32* %arr32_addr, i64 4095
206   %arr32_sub4095 = load volatile i32, i32* %arr32_sub4095_addr
207   store volatile i32 %arr32_sub4095, i32* @var_32bit
208 ; CHECK: ldr {{w[0-9]+}}, [{{x[0-9]+}}, #16380]
211   %arr64_addr = load volatile i64*, i64** @arr64
212 ; CHECK: adrp {{x[0-9]+}}, arr64
213 ; CHECK: ldr {{x[0-9]+}}, [{{x[0-9]+}}, {{#?}}:lo12:arr64]
215   %arr64_sub1_addr = getelementptr i64, i64* %arr64_addr, i64 1
216   %arr64_sub1 = load volatile i64, i64* %arr64_sub1_addr
217   store volatile i64 %arr64_sub1, i64* @var_64bit
218 ; CHECK: ldr {{x[0-9]+}}, [{{x[0-9]+}}, #8]
220   %arr64_sub4095_addr = getelementptr i64, i64* %arr64_addr, i64 4095
221   %arr64_sub4095 = load volatile i64, i64* %arr64_sub4095_addr
222   store volatile i64 %arr64_sub4095, i64* @var_64bit
223 ; CHECK: ldr {{x[0-9]+}}, [{{x[0-9]+}}, #32760]
225   ret void
228 define void @ldst_float() {
229 ; CHECK-LABEL: ldst_float:
231    %valfp = load volatile float, float* @var_float
232 ; CHECK: adrp {{x[0-9]+}}, var_float
233 ; CHECK: ldr {{s[0-9]+}}, [{{x[0-9]+}}, {{#?}}:lo12:var_float]
234 ; CHECK-NOFP-NOT: ldr {{s[0-9]+}},
236   store volatile float %valfp, float* @var_float
237 ; CHECK: str {{s[0-9]+}}, [{{x[0-9]+}}, {{#?}}:lo12:var_float]
238 ; CHECK-NOFP-NOT: str {{s[0-9]+}},
240    ret void
243 define void @ldst_double() {
244 ; CHECK-LABEL: ldst_double:
246    %valfp = load volatile double, double* @var_double
247 ; CHECK: adrp {{x[0-9]+}}, var_double
248 ; CHECK: ldr {{d[0-9]+}}, [{{x[0-9]+}}, {{#?}}:lo12:var_double]
249 ; CHECK-NOFP-NOT: ldr {{d[0-9]+}},
251   store volatile double %valfp, double* @var_double
252 ; CHECK: str {{d[0-9]+}}, [{{x[0-9]+}}, {{#?}}:lo12:var_double]
253 ; CHECK-NOFP-NOT: str {{d[0-9]+}},
255    ret void