1 ; RUN: llc < %s -march=arm64 -aarch64-redzone | FileCheck %s 2 3 define void @store64(i64** nocapture %out, i64 %index, i64 %spacing) nounwind noinline ssp { 4 ; CHECK-LABEL: store64: 5 ; CHECK: str x{{[0-9+]}}, [x{{[0-9+]}}], #8 6 ; CHECK: ret 7 %tmp = load i64*, i64** %out, align 8 8 %incdec.ptr = getelementptr inbounds i64, i64* %tmp, i64 1 9 store i64 %spacing, i64* %tmp, align 4 10 store i64* %incdec.ptr, i64** %out, align 8 11 ret void 12 } 13 14 define void @store32(i32** nocapture %out, i32 %index, i32 %spacing) nounwind noinline ssp { 15 ; CHECK-LABEL: store32: 16 ; CHECK: str w{{[0-9+]}}, [x{{[0-9+]}}], #4 17 ; CHECK: ret 18 %tmp = load i32*, i32** %out, align 8 19 %incdec.ptr = getelementptr inbounds i32, i32* %tmp, i64 1 20 store i32 %spacing, i32* %tmp, align 4 21 store i32* %incdec.ptr, i32** %out, align 8 22 ret void 23 } 24 25 define void @store16(i16** nocapture %out, i16 %index, i16 %spacing) nounwind noinline ssp { 26 ; CHECK-LABEL: store16: 27 ; CHECK: strh w{{[0-9+]}}, [x{{[0-9+]}}], #2 28 ; CHECK: ret 29 %tmp = load i16*, i16** %out, align 8 30 %incdec.ptr = getelementptr inbounds i16, i16* %tmp, i64 1 31 store i16 %spacing, i16* %tmp, align 4 32 store i16* %incdec.ptr, i16** %out, align 8 33 ret void 34 } 35 36 define void @store8(i8** nocapture %out, i8 %index, i8 %spacing) nounwind noinline ssp { 37 ; CHECK-LABEL: store8: 38 ; CHECK: strb w{{[0-9+]}}, [x{{[0-9+]}}], #1 39 ; CHECK: ret 40 %tmp = load i8*, i8** %out, align 8 41 %incdec.ptr = getelementptr inbounds i8, i8* %tmp, i64 1 42 store i8 %spacing, i8* %tmp, align 4 43 store i8* %incdec.ptr, i8** %out, align 8 44 ret void 45 } 46 47 define void @truncst64to32(i32** nocapture %out, i32 %index, i64 %spacing) nounwind noinline ssp { 48 ; CHECK-LABEL: truncst64to32: 49 ; CHECK: str w{{[0-9+]}}, [x{{[0-9+]}}], #4 50 ; CHECK: ret 51 %tmp = load i32*, i32** %out, align 8 52 %incdec.ptr = getelementptr inbounds i32, i32* %tmp, i64 1 53 %trunc = trunc i64 %spacing to i32 54 store i32 %trunc, i32* %tmp, align 4 55 store i32* %incdec.ptr, i32** %out, align 8 56 ret void 57 } 58 59 define void @truncst64to16(i16** nocapture %out, i16 %index, i64 %spacing) nounwind noinline ssp { 60 ; CHECK-LABEL: truncst64to16: 61 ; CHECK: strh w{{[0-9+]}}, [x{{[0-9+]}}], #2 62 ; CHECK: ret 63 %tmp = load i16*, i16** %out, align 8 64 %incdec.ptr = getelementptr inbounds i16, i16* %tmp, i64 1 65 %trunc = trunc i64 %spacing to i16 66 store i16 %trunc, i16* %tmp, align 4 67 store i16* %incdec.ptr, i16** %out, align 8 68 ret void 69 } 70 71 define void @truncst64to8(i8** nocapture %out, i8 %index, i64 %spacing) nounwind noinline ssp { 72 ; CHECK-LABEL: truncst64to8: 73 ; CHECK: strb w{{[0-9+]}}, [x{{[0-9+]}}], #1 74 ; CHECK: ret 75 %tmp = load i8*, i8** %out, align 8 76 %incdec.ptr = getelementptr inbounds i8, i8* %tmp, i64 1 77 %trunc = trunc i64 %spacing to i8 78 store i8 %trunc, i8* %tmp, align 4 79 store i8* %incdec.ptr, i8** %out, align 8 80 ret void 81 } 82 83 84 define void @storef16(half** %out, half %index, half %spacing) nounwind { 85 ; CHECK-LABEL: storef16: 86 ; CHECK: str h{{[0-9+]}}, [x{{[0-9+]}}], #2 87 ; CHECK: ret 88 %tmp = load half*, half** %out, align 2 89 %incdec.ptr = getelementptr inbounds half, half* %tmp, i64 1 90 store half %spacing, half* %tmp, align 2 91 store half* %incdec.ptr, half** %out, align 2 92 ret void 93 } 94 95 define void @storef32(float** nocapture %out, float %index, float %spacing) nounwind noinline ssp { 96 ; CHECK-LABEL: storef32: 97 ; CHECK: str s{{[0-9+]}}, [x{{[0-9+]}}], #4 98 ; CHECK: ret 99 %tmp = load float*, float** %out, align 8 100 %incdec.ptr = getelementptr inbounds float, float* %tmp, i64 1 101 store float %spacing, float* %tmp, align 4 102 store float* %incdec.ptr, float** %out, align 8 103 ret void 104 } 105 106 define void @storef64(double** nocapture %out, double %index, double %spacing) nounwind noinline ssp { 107 ; CHECK-LABEL: storef64: 108 ; CHECK: str d{{[0-9+]}}, [x{{[0-9+]}}], #8 109 ; CHECK: ret 110 %tmp = load double*, double** %out, align 8 111 %incdec.ptr = getelementptr inbounds double, double* %tmp, i64 1 112 store double %spacing, double* %tmp, align 4 113 store double* %incdec.ptr, double** %out, align 8 114 ret void 115 } 116 117 define double * @pref64(double** nocapture %out, double %spacing) nounwind noinline ssp { 118 ; CHECK-LABEL: pref64: 119 ; CHECK: ldr x0, [x0] 120 ; CHECK-NEXT: str d0, [x0, #32]! 121 ; CHECK-NEXT: ret 122 %tmp = load double*, double** %out, align 8 123 %ptr = getelementptr inbounds double, double* %tmp, i64 4 124 store double %spacing, double* %ptr, align 4 125 ret double *%ptr 126 } 127 128 define float * @pref32(float** nocapture %out, float %spacing) nounwind noinline ssp { 129 ; CHECK-LABEL: pref32: 130 ; CHECK: ldr x0, [x0] 131 ; CHECK-NEXT: str s0, [x0, #12]! 132 ; CHECK-NEXT: ret 133 %tmp = load float*, float** %out, align 8 134 %ptr = getelementptr inbounds float, float* %tmp, i64 3 135 store float %spacing, float* %ptr, align 4 136 ret float *%ptr 137 } 138 139 define half* @pref16(half** %out, half %spacing) nounwind { 140 ; CHECK-LABEL: pref16: 141 ; CHECK: ldr x0, [x0] 142 ; CHECK-NEXT: str h0, [x0, #6]! 143 ; CHECK-NEXT: ret 144 %tmp = load half*, half** %out, align 2 145 %ptr = getelementptr inbounds half, half* %tmp, i64 3 146 store half %spacing, half* %ptr, align 2 147 ret half *%ptr 148 } 149 150 define i64 * @pre64(i64** nocapture %out, i64 %spacing) nounwind noinline ssp { 151 ; CHECK-LABEL: pre64: 152 ; CHECK: ldr x0, [x0] 153 ; CHECK-NEXT: str x1, [x0, #16]! 154 ; CHECK-NEXT: ret 155 %tmp = load i64*, i64** %out, align 8 156 %ptr = getelementptr inbounds i64, i64* %tmp, i64 2 157 store i64 %spacing, i64* %ptr, align 4 158 ret i64 *%ptr 159 } 160 161 define i32 * @pre32(i32** nocapture %out, i32 %spacing) nounwind noinline ssp { 162 ; CHECK-LABEL: pre32: 163 ; CHECK: ldr x0, [x0] 164 ; CHECK-NEXT: str w1, [x0, #8]! 165 ; CHECK-NEXT: ret 166 %tmp = load i32*, i32** %out, align 8 167 %ptr = getelementptr inbounds i32, i32* %tmp, i64 2 168 store i32 %spacing, i32* %ptr, align 4 169 ret i32 *%ptr 170 } 171 172 define i16 * @pre16(i16** nocapture %out, i16 %spacing) nounwind noinline ssp { 173 ; CHECK-LABEL: pre16: 174 ; CHECK: ldr x0, [x0] 175 ; CHECK-NEXT: strh w1, [x0, #4]! 176 ; CHECK-NEXT: ret 177 %tmp = load i16*, i16** %out, align 8 178 %ptr = getelementptr inbounds i16, i16* %tmp, i64 2 179 store i16 %spacing, i16* %ptr, align 4 180 ret i16 *%ptr 181 } 182 183 define i8 * @pre8(i8** nocapture %out, i8 %spacing) nounwind noinline ssp { 184 ; CHECK-LABEL: pre8: 185 ; CHECK: ldr x0, [x0] 186 ; CHECK-NEXT: strb w1, [x0, #2]! 187 ; CHECK-NEXT: ret 188 %tmp = load i8*, i8** %out, align 8 189 %ptr = getelementptr inbounds i8, i8* %tmp, i64 2 190 store i8 %spacing, i8* %ptr, align 4 191 ret i8 *%ptr 192 } 193 194 define i32 * @pretrunc64to32(i32** nocapture %out, i64 %spacing) nounwind noinline ssp { 195 ; CHECK-LABEL: pretrunc64to32: 196 ; CHECK: ldr x0, [x0] 197 ; CHECK-NEXT: str w1, [x0, #8]! 198 ; CHECK-NEXT: ret 199 %tmp = load i32*, i32** %out, align 8 200 %ptr = getelementptr inbounds i32, i32* %tmp, i64 2 201 %trunc = trunc i64 %spacing to i32 202 store i32 %trunc, i32* %ptr, align 4 203 ret i32 *%ptr 204 } 205 206 define i16 * @pretrunc64to16(i16** nocapture %out, i64 %spacing) nounwind noinline ssp { 207 ; CHECK-LABEL: pretrunc64to16: 208 ; CHECK: ldr x0, [x0] 209 ; CHECK-NEXT: strh w1, [x0, #4]! 210 ; CHECK-NEXT: ret 211 %tmp = load i16*, i16** %out, align 8 212 %ptr = getelementptr inbounds i16, i16* %tmp, i64 2 213 %trunc = trunc i64 %spacing to i16 214 store i16 %trunc, i16* %ptr, align 4 215 ret i16 *%ptr 216 } 217 218 define i8 * @pretrunc64to8(i8** nocapture %out, i64 %spacing) nounwind noinline ssp { 219 ; CHECK-LABEL: pretrunc64to8: 220 ; CHECK: ldr x0, [x0] 221 ; CHECK-NEXT: strb w1, [x0, #2]! 222 ; CHECK-NEXT: ret 223 %tmp = load i8*, i8** %out, align 8 224 %ptr = getelementptr inbounds i8, i8* %tmp, i64 2 225 %trunc = trunc i64 %spacing to i8 226 store i8 %trunc, i8* %ptr, align 4 227 ret i8 *%ptr 228 } 229 230 ;----- 231 ; Pre-indexed loads 232 ;----- 233 define double* @preidxf64(double* %src, double* %out) { 234 ; CHECK-LABEL: preidxf64: 235 ; CHECK: ldr d0, [x0, #8]! 236 ; CHECK: str d0, [x1] 237 ; CHECK: ret 238 %ptr = getelementptr inbounds double, double* %src, i64 1 239 %tmp = load double, double* %ptr, align 4 240 store double %tmp, double* %out, align 4 241 ret double* %ptr 242 } 243 244 define float* @preidxf32(float* %src, float* %out) { 245 ; CHECK-LABEL: preidxf32: 246 ; CHECK: ldr s0, [x0, #4]! 247 ; CHECK: str s0, [x1] 248 ; CHECK: ret 249 %ptr = getelementptr inbounds float, float* %src, i64 1 250 %tmp = load float, float* %ptr, align 4 251 store float %tmp, float* %out, align 4 252 ret float* %ptr 253 } 254 255 define half* @preidxf16(half* %src, half* %out) { 256 ; CHECK-LABEL: preidxf16: 257 ; CHECK: ldr h0, [x0, #2]! 258 ; CHECK: str h0, [x1] 259 ; CHECK: ret 260 %ptr = getelementptr inbounds half, half* %src, i64 1 261 %tmp = load half, half* %ptr, align 2 262 store half %tmp, half* %out, align 2 263 ret half* %ptr 264 } 265 266 define i64* @preidx64(i64* %src, i64* %out) { 267 ; CHECK-LABEL: preidx64: 268 ; CHECK: ldr x[[REG:[0-9]+]], [x0, #8]! 269 ; CHECK: str x[[REG]], [x1] 270 ; CHECK: ret 271 %ptr = getelementptr inbounds i64, i64* %src, i64 1 272 %tmp = load i64, i64* %ptr, align 4 273 store i64 %tmp, i64* %out, align 4 274 ret i64* %ptr 275 } 276 277 define i32* @preidx32(i32* %src, i32* %out) { 278 ; CHECK: ldr w[[REG:[0-9]+]], [x0, #4]! 279 ; CHECK: str w[[REG]], [x1] 280 ; CHECK: ret 281 %ptr = getelementptr inbounds i32, i32* %src, i64 1 282 %tmp = load i32, i32* %ptr, align 4 283 store i32 %tmp, i32* %out, align 4 284 ret i32* %ptr 285 } 286 287 define i16* @preidx16zext32(i16* %src, i32* %out) { 288 ; CHECK: ldrh w[[REG:[0-9]+]], [x0, #2]! 289 ; CHECK: str w[[REG]], [x1] 290 ; CHECK: ret 291 %ptr = getelementptr inbounds i16, i16* %src, i64 1 292 %tmp = load i16, i16* %ptr, align 4 293 %ext = zext i16 %tmp to i32 294 store i32 %ext, i32* %out, align 4 295 ret i16* %ptr 296 } 297 298 define i16* @preidx16zext64(i16* %src, i64* %out) { 299 ; CHECK: ldrh w[[REG:[0-9]+]], [x0, #2]! 300 ; CHECK: str x[[REG]], [x1] 301 ; CHECK: ret 302 %ptr = getelementptr inbounds i16, i16* %src, i64 1 303 %tmp = load i16, i16* %ptr, align 4 304 %ext = zext i16 %tmp to i64 305 store i64 %ext, i64* %out, align 4 306 ret i16* %ptr 307 } 308 309 define i8* @preidx8zext32(i8* %src, i32* %out) { 310 ; CHECK: ldrb w[[REG:[0-9]+]], [x0, #1]! 311 ; CHECK: str w[[REG]], [x1] 312 ; CHECK: ret 313 %ptr = getelementptr inbounds i8, i8* %src, i64 1 314 %tmp = load i8, i8* %ptr, align 4 315 %ext = zext i8 %tmp to i32 316 store i32 %ext, i32* %out, align 4 317 ret i8* %ptr 318 } 319 320 define i8* @preidx8zext64(i8* %src, i64* %out) { 321 ; CHECK: ldrb w[[REG:[0-9]+]], [x0, #1]! 322 ; CHECK: str x[[REG]], [x1] 323 ; CHECK: ret 324 %ptr = getelementptr inbounds i8, i8* %src, i64 1 325 %tmp = load i8, i8* %ptr, align 4 326 %ext = zext i8 %tmp to i64 327 store i64 %ext, i64* %out, align 4 328 ret i8* %ptr 329 } 330 331 define i32* @preidx32sext64(i32* %src, i64* %out) { 332 ; CHECK: ldrsw x[[REG:[0-9]+]], [x0, #4]! 333 ; CHECK: str x[[REG]], [x1] 334 ; CHECK: ret 335 %ptr = getelementptr inbounds i32, i32* %src, i64 1 336 %tmp = load i32, i32* %ptr, align 4 337 %ext = sext i32 %tmp to i64 338 store i64 %ext, i64* %out, align 8 339 ret i32* %ptr 340 } 341 342 define i16* @preidx16sext32(i16* %src, i32* %out) { 343 ; CHECK: ldrsh w[[REG:[0-9]+]], [x0, #2]! 344 ; CHECK: str w[[REG]], [x1] 345 ; CHECK: ret 346 %ptr = getelementptr inbounds i16, i16* %src, i64 1 347 %tmp = load i16, i16* %ptr, align 4 348 %ext = sext i16 %tmp to i32 349 store i32 %ext, i32* %out, align 4 350 ret i16* %ptr 351 } 352 353 define i16* @preidx16sext64(i16* %src, i64* %out) { 354 ; CHECK: ldrsh x[[REG:[0-9]+]], [x0, #2]! 355 ; CHECK: str x[[REG]], [x1] 356 ; CHECK: ret 357 %ptr = getelementptr inbounds i16, i16* %src, i64 1 358 %tmp = load i16, i16* %ptr, align 4 359 %ext = sext i16 %tmp to i64 360 store i64 %ext, i64* %out, align 4 361 ret i16* %ptr 362 } 363 364 define i8* @preidx8sext32(i8* %src, i32* %out) { 365 ; CHECK: ldrsb w[[REG:[0-9]+]], [x0, #1]! 366 ; CHECK: str w[[REG]], [x1] 367 ; CHECK: ret 368 %ptr = getelementptr inbounds i8, i8* %src, i64 1 369 %tmp = load i8, i8* %ptr, align 4 370 %ext = sext i8 %tmp to i32 371 store i32 %ext, i32* %out, align 4 372 ret i8* %ptr 373 } 374 375 define i8* @preidx8sext64(i8* %src, i64* %out) { 376 ; CHECK: ldrsb x[[REG:[0-9]+]], [x0, #1]! 377 ; CHECK: str x[[REG]], [x1] 378 ; CHECK: ret 379 %ptr = getelementptr inbounds i8, i8* %src, i64 1 380 %tmp = load i8, i8* %ptr, align 4 381 %ext = sext i8 %tmp to i64 382 store i64 %ext, i64* %out, align 4 383 ret i8* %ptr 384 } 385 386 ; This test checks if illegal post-index is generated 387 388 define i64* @postidx_clobber(i64* %addr) nounwind noinline ssp { 389 ; CHECK-LABEL: postidx_clobber: 390 ; CHECK-NOT: str x0, [x0], #8 391 ; ret 392 %paddr = bitcast i64* %addr to i64** 393 store i64* %addr, i64** %paddr 394 %newaddr = getelementptr i64, i64* %addr, i32 1 395 ret i64* %newaddr 396 } 397
