test/CodeGen/AArch64/arm64-indexed-memory.ll

   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** %out, align 8
   8   %incdec.ptr = getelementptr inbounds 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** %out, align 8
  19   %incdec.ptr = getelementptr inbounds 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** %out, align 8
  30   %incdec.ptr = getelementptr inbounds 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** %out, align 8
  41   %incdec.ptr = getelementptr inbounds 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** %out, align 8
  52   %incdec.ptr = getelementptr inbounds 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** %out, align 8
  64   %incdec.ptr = getelementptr inbounds 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** %out, align 8
  76   %incdec.ptr = getelementptr inbounds 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 @storef32(float** nocapture %out, float %index, float %spacing) nounwind noinline ssp {
  85 ; CHECK-LABEL: storef32:
  86 ; CHECK: str s{{[0-9+]}}, [x{{[0-9+]}}], #4
  87 ; CHECK: ret
  88   %tmp = load float** %out, align 8
  89   %incdec.ptr = getelementptr inbounds float* %tmp, i64 1
  90   store float %spacing, float* %tmp, align 4
  91   store float* %incdec.ptr, float** %out, align 8
  92   ret void
  93 }
  94
  95 define void @storef64(double** nocapture %out, double %index, double %spacing) nounwind noinline ssp {
  96 ; CHECK-LABEL: storef64:
  97 ; CHECK: str d{{[0-9+]}}, [x{{[0-9+]}}], #8
  98 ; CHECK: ret
  99   %tmp = load double** %out, align 8
 100   %incdec.ptr = getelementptr inbounds double* %tmp, i64 1
 101   store double %spacing, double* %tmp, align 4
 102   store double* %incdec.ptr, double** %out, align 8
 103   ret void
 104 }
 105
 106 define double * @pref64(double** nocapture %out, double %spacing) nounwind noinline ssp {
 107 ; CHECK-LABEL: pref64:
 108 ; CHECK: ldr     x0, [x0]
 109 ; CHECK-NEXT: str     d0, [x0, #32]!
 110 ; CHECK-NEXT: ret
 111   %tmp = load double** %out, align 8
 112   %ptr = getelementptr inbounds double* %tmp, i64 4
 113   store double %spacing, double* %ptr, align 4
 114   ret double *%ptr
 115 }
 116
 117 define float * @pref32(float** nocapture %out, float %spacing) nounwind noinline ssp {
 118 ; CHECK-LABEL: pref32:
 119 ; CHECK: ldr     x0, [x0]
 120 ; CHECK-NEXT: str     s0, [x0, #12]!
 121 ; CHECK-NEXT: ret
 122   %tmp = load float** %out, align 8
 123   %ptr = getelementptr inbounds float* %tmp, i64 3
 124   store float %spacing, float* %ptr, align 4
 125   ret float *%ptr
 126 }
 127
 128 define i64 * @pre64(i64** nocapture %out, i64 %spacing) nounwind noinline ssp {
 129 ; CHECK-LABEL: pre64:
 130 ; CHECK: ldr     x0, [x0]
 131 ; CHECK-NEXT: str     x1, [x0, #16]!
 132 ; CHECK-NEXT: ret
 133   %tmp = load i64** %out, align 8
 134   %ptr = getelementptr inbounds i64* %tmp, i64 2
 135   store i64 %spacing, i64* %ptr, align 4
 136   ret i64 *%ptr
 137 }
 138
 139 define i32 * @pre32(i32** nocapture %out, i32 %spacing) nounwind noinline ssp {
 140 ; CHECK-LABEL: pre32:
 141 ; CHECK: ldr     x0, [x0]
 142 ; CHECK-NEXT: str     w1, [x0, #8]!
 143 ; CHECK-NEXT: ret
 144   %tmp = load i32** %out, align 8
 145   %ptr = getelementptr inbounds i32* %tmp, i64 2
 146   store i32 %spacing, i32* %ptr, align 4
 147   ret i32 *%ptr
 148 }
 149
 150 define i16 * @pre16(i16** nocapture %out, i16 %spacing) nounwind noinline ssp {
 151 ; CHECK-LABEL: pre16:
 152 ; CHECK: ldr     x0, [x0]
 153 ; CHECK-NEXT: strh    w1, [x0, #4]!
 154 ; CHECK-NEXT: ret
 155   %tmp = load i16** %out, align 8
 156   %ptr = getelementptr inbounds i16* %tmp, i64 2
 157   store i16 %spacing, i16* %ptr, align 4
 158   ret i16 *%ptr
 159 }
 160
 161 define i8 * @pre8(i8** nocapture %out, i8 %spacing) nounwind noinline ssp {
 162 ; CHECK-LABEL: pre8:
 163 ; CHECK: ldr     x0, [x0]
 164 ; CHECK-NEXT: strb    w1, [x0, #2]!
 165 ; CHECK-NEXT: ret
 166   %tmp = load i8** %out, align 8
 167   %ptr = getelementptr inbounds i8* %tmp, i64 2
 168   store i8 %spacing, i8* %ptr, align 4
 169   ret i8 *%ptr
 170 }
 171
 172 define i32 * @pretrunc64to32(i32** nocapture %out, i64 %spacing) nounwind noinline ssp {
 173 ; CHECK-LABEL: pretrunc64to32:
 174 ; CHECK: ldr     x0, [x0]
 175 ; CHECK-NEXT: str     w1, [x0, #8]!
 176 ; CHECK-NEXT: ret
 177   %tmp = load i32** %out, align 8
 178   %ptr = getelementptr inbounds i32* %tmp, i64 2
 179   %trunc = trunc i64 %spacing to i32
 180   store i32 %trunc, i32* %ptr, align 4
 181   ret i32 *%ptr
 182 }
 183
 184 define i16 * @pretrunc64to16(i16** nocapture %out, i64 %spacing) nounwind noinline ssp {
 185 ; CHECK-LABEL: pretrunc64to16:
 186 ; CHECK: ldr     x0, [x0]
 187 ; CHECK-NEXT: strh    w1, [x0, #4]!
 188 ; CHECK-NEXT: ret
 189   %tmp = load i16** %out, align 8
 190   %ptr = getelementptr inbounds i16* %tmp, i64 2
 191   %trunc = trunc i64 %spacing to i16
 192   store i16 %trunc, i16* %ptr, align 4
 193   ret i16 *%ptr
 194 }
 195
 196 define i8 * @pretrunc64to8(i8** nocapture %out, i64 %spacing) nounwind noinline ssp {
 197 ; CHECK-LABEL: pretrunc64to8:
 198 ; CHECK: ldr     x0, [x0]
 199 ; CHECK-NEXT: strb    w1, [x0, #2]!
 200 ; CHECK-NEXT: ret
 201   %tmp = load i8** %out, align 8
 202   %ptr = getelementptr inbounds i8* %tmp, i64 2
 203   %trunc = trunc i64 %spacing to i8
 204   store i8 %trunc, i8* %ptr, align 4
 205   ret i8 *%ptr
 206 }
 207
 208 ;-----
 209 ; Pre-indexed loads
 210 ;-----
 211 define double* @preidxf64(double* %src, double* %out) {
 212 ; CHECK-LABEL: preidxf64:
 213 ; CHECK: ldr     d0, [x0, #8]!
 214 ; CHECK: str     d0, [x1]
 215 ; CHECK: ret
 216   %ptr = getelementptr inbounds double* %src, i64 1
 217   %tmp = load double* %ptr, align 4
 218   store double %tmp, double* %out, align 4
 219   ret double* %ptr
 220 }
 221
 222 define float* @preidxf32(float* %src, float* %out) {
 223 ; CHECK-LABEL: preidxf32:
 224 ; CHECK: ldr     s0, [x0, #4]!
 225 ; CHECK: str     s0, [x1]
 226 ; CHECK: ret
 227   %ptr = getelementptr inbounds float* %src, i64 1
 228   %tmp = load float* %ptr, align 4
 229   store float %tmp, float* %out, align 4
 230   ret float* %ptr
 231 }
 232
 233 define i64* @preidx64(i64* %src, i64* %out) {
 234 ; CHECK-LABEL: preidx64:
 235 ; CHECK: ldr     x[[REG:[0-9]+]], [x0, #8]!
 236 ; CHECK: str     x[[REG]], [x1]
 237 ; CHECK: ret
 238   %ptr = getelementptr inbounds i64* %src, i64 1
 239   %tmp = load i64* %ptr, align 4
 240   store i64 %tmp, i64* %out, align 4
 241   ret i64* %ptr
 242 }
 243
 244 define i32* @preidx32(i32* %src, i32* %out) {
 245 ; CHECK: ldr     w[[REG:[0-9]+]], [x0, #4]!
 246 ; CHECK: str     w[[REG]], [x1]
 247 ; CHECK: ret
 248   %ptr = getelementptr inbounds i32* %src, i64 1
 249   %tmp = load i32* %ptr, align 4
 250   store i32 %tmp, i32* %out, align 4
 251   ret i32* %ptr
 252 }
 253
 254 define i16* @preidx16zext32(i16* %src, i32* %out) {
 255 ; CHECK: ldrh    w[[REG:[0-9]+]], [x0, #2]!
 256 ; CHECK: str     w[[REG]], [x1]
 257 ; CHECK: ret
 258   %ptr = getelementptr inbounds i16* %src, i64 1
 259   %tmp = load i16* %ptr, align 4
 260   %ext = zext i16 %tmp to i32
 261   store i32 %ext, i32* %out, align 4
 262   ret i16* %ptr
 263 }
 264
 265 define i16* @preidx16zext64(i16* %src, i64* %out) {
 266 ; CHECK: ldrh    w[[REG:[0-9]+]], [x0, #2]!
 267 ; CHECK: str     x[[REG]], [x1]
 268 ; CHECK: ret
 269   %ptr = getelementptr inbounds i16* %src, i64 1
 270   %tmp = load i16* %ptr, align 4
 271   %ext = zext i16 %tmp to i64
 272   store i64 %ext, i64* %out, align 4
 273   ret i16* %ptr
 274 }
 275
 276 define i8* @preidx8zext32(i8* %src, i32* %out) {
 277 ; CHECK: ldrb    w[[REG:[0-9]+]], [x0, #1]!
 278 ; CHECK: str     w[[REG]], [x1]
 279 ; CHECK: ret
 280   %ptr = getelementptr inbounds i8* %src, i64 1
 281   %tmp = load i8* %ptr, align 4
 282   %ext = zext i8 %tmp to i32
 283   store i32 %ext, i32* %out, align 4
 284   ret i8* %ptr
 285 }
 286
 287 define i8* @preidx8zext64(i8* %src, i64* %out) {
 288 ; CHECK: ldrb    w[[REG:[0-9]+]], [x0, #1]!
 289 ; CHECK: str     x[[REG]], [x1]
 290 ; CHECK: ret
 291   %ptr = getelementptr inbounds i8* %src, i64 1
 292   %tmp = load i8* %ptr, align 4
 293   %ext = zext i8 %tmp to i64
 294   store i64 %ext, i64* %out, align 4
 295   ret i8* %ptr
 296 }
 297
 298 define i32* @preidx32sext64(i32* %src, i64* %out) {
 299 ; CHECK: ldrsw   x[[REG:[0-9]+]], [x0, #4]!
 300 ; CHECK: str     x[[REG]], [x1]
 301 ; CHECK: ret
 302   %ptr = getelementptr inbounds i32* %src, i64 1
 303   %tmp = load i32* %ptr, align 4
 304   %ext = sext i32 %tmp to i64
 305   store i64 %ext, i64* %out, align 8
 306   ret i32* %ptr
 307 }
 308
 309 define i16* @preidx16sext32(i16* %src, i32* %out) {
 310 ; CHECK: ldrsh   w[[REG:[0-9]+]], [x0, #2]!
 311 ; CHECK: str     w[[REG]], [x1]
 312 ; CHECK: ret
 313   %ptr = getelementptr inbounds i16* %src, i64 1
 314   %tmp = load i16* %ptr, align 4
 315   %ext = sext i16 %tmp to i32
 316   store i32 %ext, i32* %out, align 4
 317   ret i16* %ptr
 318 }
 319
 320 define i16* @preidx16sext64(i16* %src, i64* %out) {
 321 ; CHECK: ldrsh   x[[REG:[0-9]+]], [x0, #2]!
 322 ; CHECK: str     x[[REG]], [x1]
 323 ; CHECK: ret
 324   %ptr = getelementptr inbounds i16* %src, i64 1
 325   %tmp = load i16* %ptr, align 4
 326   %ext = sext i16 %tmp to i64
 327   store i64 %ext, i64* %out, align 4
 328   ret i16* %ptr
 329 }
 330
 331 define i8* @preidx8sext32(i8* %src, i32* %out) {
 332 ; CHECK: ldrsb   w[[REG:[0-9]+]], [x0, #1]!
 333 ; CHECK: str     w[[REG]], [x1]
 334 ; CHECK: ret
 335   %ptr = getelementptr inbounds i8* %src, i64 1
 336   %tmp = load i8* %ptr, align 4
 337   %ext = sext i8 %tmp to i32
 338   store i32 %ext, i32* %out, align 4
 339   ret i8* %ptr
 340 }
 341
 342 define i8* @preidx8sext64(i8* %src, i64* %out) {
 343 ; CHECK: ldrsb   x[[REG:[0-9]+]], [x0, #1]!
 344 ; CHECK: str     x[[REG]], [x1]
 345 ; CHECK: ret
 346   %ptr = getelementptr inbounds i8* %src, i64 1
 347   %tmp = load i8* %ptr, align 4
 348   %ext = sext i8 %tmp to i64
 349   store i64 %ext, i64* %out, align 4
 350   ret i8* %ptr
 351 }
 352
 353 ; This test checks if illegal post-index is generated
 354
 355 define i64* @postidx_clobber(i64* %addr) nounwind noinline ssp {
 356 ; CHECK-LABEL: postidx_clobber:
 357 ; CHECK-NOT: str     x0, [x0], #8
 358 ; ret
 359  %paddr = bitcast i64* %addr to i64**
 360  store i64* %addr, i64** %paddr
 361  %newaddr = getelementptr i64* %addr, i32 1
 362  ret i64* %newaddr
 363 }