test/CodeGen/SystemZ/frame-15.ll

   1 ; Test the handling of base + index + 12-bit displacement addresses for
   2 ; large frames, in cases where no 20-bit form exists.
   3 ;
   4 ; RUN: llc < %s -mtriple=s390x-linux-gnu | FileCheck -check-prefix=CHECK-NOFP %s
   5 ; RUN: llc < %s -mtriple=s390x-linux-gnu -disable-fp-elim | FileCheck -check-prefix=CHECK-FP %s
   6
   7 declare void @foo(float *%ptr1, float *%ptr2)
   8
   9 ; This file tests what happens when a displacement is converted from
  10 ; being relative to the start of a frame object to being relative to
  11 ; the frame itself.  In some cases the test is only possible if two
  12 ; objects are allocated.
  13 ;
  14 ; Rather than rely on a particular order for those objects, the tests
  15 ; instead allocate two objects of the same size and apply the test to
  16 ; both of them.  For consistency, all tests follow this model, even if
  17 ; one object would actually be enough.
  18
  19 ; First check the highest in-range offset after conversion, which is 4092
  20 ; for word-addressing instructions like LDEB.
  21 ;
  22 ; The last in-range doubleword offset is 4088.  Since the frame has two
  23 ; emergency spill slots at 160(%r15), the amount that we need to allocate
  24 ; in order to put another object at offset 4088 is (4088 - 176) / 4 = 978
  25 ; words.
  26 define void @f1(double *%dst) {
  27 ; CHECK-NOFP-LABEL: f1:
  28 ; CHECK-NOFP: ldeb {{%f[0-7]}}, 4092(%r15)
  29 ; CHECK-NOFP: br %r14
  30 ;
  31 ; CHECK-FP-LABEL: f1:
  32 ; CHECK-FP: ldeb {{%f[0-7]}}, 4092(%r11)
  33 ; CHECK-FP: br %r14
  34   %region1 = alloca [978 x float], align 8
  35   %region2 = alloca [978 x float], align 8
  36   %start1 = getelementptr inbounds [978 x float]* %region1, i64 0, i64 0
  37   %start2 = getelementptr inbounds [978 x float]* %region2, i64 0, i64 0
  38   call void @foo(float *%start1, float *%start2)
  39   %ptr1 = getelementptr inbounds [978 x float]* %region1, i64 0, i64 1
  40   %ptr2 = getelementptr inbounds [978 x float]* %region2, i64 0, i64 1
  41   %float1 = load float *%ptr1
  42   %float2 = load float *%ptr2
  43   %double1 = fpext float %float1 to double
  44   %double2 = fpext float %float2 to double
  45   store volatile double %double1, double *%dst
  46   store volatile double %double2, double *%dst
  47   ret void
  48 }
  49
  50 ; Test the first out-of-range offset.
  51 define void @f2(double *%dst) {
  52 ; CHECK-NOFP-LABEL: f2:
  53 ; CHECK-NOFP: lghi %r1, 4096
  54 ; CHECK-NOFP: ldeb {{%f[0-7]}}, 0(%r1,%r15)
  55 ; CHECK-NOFP: br %r14
  56 ;
  57 ; CHECK-FP-LABEL: f2:
  58 ; CHECK-FP: lghi %r1, 4096
  59 ; CHECK-FP: ldeb {{%f[0-7]}}, 0(%r1,%r11)
  60 ; CHECK-FP: br %r14
  61   %region1 = alloca [978 x float], align 8
  62   %region2 = alloca [978 x float], align 8
  63   %start1 = getelementptr inbounds [978 x float]* %region1, i64 0, i64 0
  64   %start2 = getelementptr inbounds [978 x float]* %region2, i64 0, i64 0
  65   call void @foo(float *%start1, float *%start2)
  66   %ptr1 = getelementptr inbounds [978 x float]* %region1, i64 0, i64 2
  67   %ptr2 = getelementptr inbounds [978 x float]* %region2, i64 0, i64 2
  68   %float1 = load float *%ptr1
  69   %float2 = load float *%ptr2
  70   %double1 = fpext float %float1 to double
  71   %double2 = fpext float %float2 to double
  72   store volatile double %double1, double *%dst
  73   store volatile double %double2, double *%dst
  74   ret void
  75 }
  76
  77 ; Test the next offset after that.
  78 define void @f3(double *%dst) {
  79 ; CHECK-NOFP-LABEL: f3:
  80 ; CHECK-NOFP: lghi %r1, 4096
  81 ; CHECK-NOFP: ldeb {{%f[0-7]}}, 4(%r1,%r15)
  82 ; CHECK-NOFP: br %r14
  83 ;
  84 ; CHECK-FP-LABEL: f3:
  85 ; CHECK-FP: lghi %r1, 4096
  86 ; CHECK-FP: ldeb {{%f[0-7]}}, 4(%r1,%r11)
  87 ; CHECK-FP: br %r14
  88   %region1 = alloca [978 x float], align 8
  89   %region2 = alloca [978 x float], align 8
  90   %start1 = getelementptr inbounds [978 x float]* %region1, i64 0, i64 0
  91   %start2 = getelementptr inbounds [978 x float]* %region2, i64 0, i64 0
  92   call void @foo(float *%start1, float *%start2)
  93   %ptr1 = getelementptr inbounds [978 x float]* %region1, i64 0, i64 3
  94   %ptr2 = getelementptr inbounds [978 x float]* %region2, i64 0, i64 3
  95   %float1 = load float *%ptr1
  96   %float2 = load float *%ptr2
  97   %double1 = fpext float %float1 to double
  98   %double2 = fpext float %float2 to double
  99   store volatile double %double1, double *%dst
 100   store volatile double %double2, double *%dst
 101   ret void
 102 }
 103
 104 ; Add 4096 bytes (1024 words) to the size of each object and repeat.
 105 define void @f4(double *%dst) {
 106 ; CHECK-NOFP-LABEL: f4:
 107 ; CHECK-NOFP: lghi %r1, 4096
 108 ; CHECK-NOFP: ldeb {{%f[0-7]}}, 4092(%r1,%r15)
 109 ; CHECK-NOFP: br %r14
 110 ;
 111 ; CHECK-FP-LABEL: f4:
 112 ; CHECK-FP: lghi %r1, 4096
 113 ; CHECK-FP: ldeb {{%f[0-7]}}, 4092(%r1,%r11)
 114 ; CHECK-FP: br %r14
 115   %region1 = alloca [2002 x float], align 8
 116   %region2 = alloca [2002 x float], align 8
 117   %start1 = getelementptr inbounds [2002 x float]* %region1, i64 0, i64 0
 118   %start2 = getelementptr inbounds [2002 x float]* %region2, i64 0, i64 0
 119   call void @foo(float *%start1, float *%start2)
 120   %ptr1 = getelementptr inbounds [2002 x float]* %region1, i64 0, i64 1
 121   %ptr2 = getelementptr inbounds [2002 x float]* %region2, i64 0, i64 1
 122   %float1 = load float *%ptr1
 123   %float2 = load float *%ptr2
 124   %double1 = fpext float %float1 to double
 125   %double2 = fpext float %float2 to double
 126   store volatile double %double1, double *%dst
 127   store volatile double %double2, double *%dst
 128   ret void
 129 }
 130
 131 ; ...as above.
 132 define void @f5(double *%dst) {
 133 ; CHECK-NOFP-LABEL: f5:
 134 ; CHECK-NOFP: lghi %r1, 8192
 135 ; CHECK-NOFP: ldeb {{%f[0-7]}}, 0(%r1,%r15)
 136 ; CHECK-NOFP: br %r14
 137 ;
 138 ; CHECK-FP-LABEL: f5:
 139 ; CHECK-FP: lghi %r1, 8192
 140 ; CHECK-FP: ldeb {{%f[0-7]}}, 0(%r1,%r11)
 141 ; CHECK-FP: br %r14
 142   %region1 = alloca [2002 x float], align 8
 143   %region2 = alloca [2002 x float], align 8
 144   %start1 = getelementptr inbounds [2002 x float]* %region1, i64 0, i64 0
 145   %start2 = getelementptr inbounds [2002 x float]* %region2, i64 0, i64 0
 146   call void @foo(float *%start1, float *%start2)
 147   %ptr1 = getelementptr inbounds [2002 x float]* %region1, i64 0, i64 2
 148   %ptr2 = getelementptr inbounds [2002 x float]* %region2, i64 0, i64 2
 149   %float1 = load float *%ptr1
 150   %float2 = load float *%ptr2
 151   %double1 = fpext float %float1 to double
 152   %double2 = fpext float %float2 to double
 153   store volatile double %double1, double *%dst
 154   store volatile double %double2, double *%dst
 155   ret void
 156 }
 157
 158 ; ...as above.
 159 define void @f6(double *%dst) {
 160 ; CHECK-NOFP-LABEL: f6:
 161 ; CHECK-NOFP: lghi %r1, 8192
 162 ; CHECK-NOFP: ldeb {{%f[0-7]}}, 4(%r1,%r15)
 163 ; CHECK-NOFP: br %r14
 164 ;
 165 ; CHECK-FP-LABEL: f6:
 166 ; CHECK-FP: lghi %r1, 8192
 167 ; CHECK-FP: ldeb {{%f[0-7]}}, 4(%r1,%r11)
 168 ; CHECK-FP: br %r14
 169   %region1 = alloca [2002 x float], align 8
 170   %region2 = alloca [2002 x float], align 8
 171   %start1 = getelementptr inbounds [2002 x float]* %region1, i64 0, i64 0
 172   %start2 = getelementptr inbounds [2002 x float]* %region2, i64 0, i64 0
 173   call void @foo(float *%start1, float *%start2)
 174   %ptr1 = getelementptr inbounds [2002 x float]* %region1, i64 0, i64 3
 175   %ptr2 = getelementptr inbounds [2002 x float]* %region2, i64 0, i64 3
 176   %float1 = load float *%ptr1
 177   %float2 = load float *%ptr2
 178   %double1 = fpext float %float1 to double
 179   %double2 = fpext float %float2 to double
 180   store volatile double %double1, double *%dst
 181   store volatile double %double2, double *%dst
 182   ret void
 183 }
 184
 185 ; Now try an offset of 4092 from the start of the object, with the object
 186 ; being at offset 8192.  This time we need objects of (8192 - 168) / 4 = 2004
 187 ; words.
 188 define void @f7(double *%dst) {
 189 ; CHECK-NOFP-LABEL: f7:
 190 ; CHECK-NOFP: lghi %r1, 8192
 191 ; CHECK-NOFP: ldeb {{%f[0-7]}}, 4092(%r1,%r15)
 192 ; CHECK-NOFP: br %r14
 193 ;
 194 ; CHECK-FP-LABEL: f7:
 195 ; CHECK-FP: lghi %r1, 8192
 196 ; CHECK-FP: ldeb {{%f[0-7]}}, 4092(%r1,%r11)
 197 ; CHECK-FP: br %r14
 198   %region1 = alloca [2004 x float], align 8
 199   %region2 = alloca [2004 x float], align 8
 200   %start1 = getelementptr inbounds [2004 x float]* %region1, i64 0, i64 0
 201   %start2 = getelementptr inbounds [2004 x float]* %region2, i64 0, i64 0
 202   call void @foo(float *%start1, float *%start2)
 203   %ptr1 = getelementptr inbounds [2004 x float]* %region1, i64 0, i64 1023
 204   %ptr2 = getelementptr inbounds [2004 x float]* %region2, i64 0, i64 1023
 205   %float1 = load float *%ptr1
 206   %float2 = load float *%ptr2
 207   %double1 = fpext float %float1 to double
 208   %double2 = fpext float %float2 to double
 209   store volatile double %double1, double *%dst
 210   store volatile double %double2, double *%dst
 211   ret void
 212 }
 213
 214 ; Keep the object-relative offset the same but bump the size of the
 215 ; objects by one doubleword.
 216 define void @f8(double *%dst) {
 217 ; CHECK-NOFP-LABEL: f8:
 218 ; CHECK-NOFP: lghi %r1, 12288
 219 ; CHECK-NOFP: ldeb {{%f[0-7]}}, 4(%r1,%r15)
 220 ; CHECK-NOFP: br %r14
 221 ;
 222 ; CHECK-FP-LABEL: f8:
 223 ; CHECK-FP: lghi %r1, 12288
 224 ; CHECK-FP: ldeb {{%f[0-7]}}, 4(%r1,%r11)
 225 ; CHECK-FP: br %r14
 226   %region1 = alloca [2006 x float], align 8
 227   %region2 = alloca [2006 x float], align 8
 228   %start1 = getelementptr inbounds [2006 x float]* %region1, i64 0, i64 0
 229   %start2 = getelementptr inbounds [2006 x float]* %region2, i64 0, i64 0
 230   call void @foo(float *%start1, float *%start2)
 231   %ptr1 = getelementptr inbounds [2006 x float]* %region1, i64 0, i64 1023
 232   %ptr2 = getelementptr inbounds [2006 x float]* %region2, i64 0, i64 1023
 233   %float1 = load float *%ptr1
 234   %float2 = load float *%ptr2
 235   %double1 = fpext float %float1 to double
 236   %double2 = fpext float %float2 to double
 237   store volatile double %double1, double *%dst
 238   store volatile double %double2, double *%dst
 239   ret void
 240 }
 241
 242 ; Check a case where the original displacement is out of range.  The backend
 243 ; should force an LAY from the outset.  We don't yet do any kind of anchor
 244 ; optimization, so there should be no offset on the LDEB itself.
 245 define void @f9(double *%dst) {
 246 ; CHECK-NOFP-LABEL: f9:
 247 ; CHECK-NOFP: lay %r1, 12296(%r15)
 248 ; CHECK-NOFP: ldeb {{%f[0-7]}}, 0(%r1)
 249 ; CHECK-NOFP: br %r14
 250 ;
 251 ; CHECK-FP-LABEL: f9:
 252 ; CHECK-FP: lay %r1, 12296(%r11)
 253 ; CHECK-FP: ldeb {{%f[0-7]}}, 0(%r1)
 254 ; CHECK-FP: br %r14
 255   %region1 = alloca [2006 x float], align 8
 256   %region2 = alloca [2006 x float], align 8
 257   %start1 = getelementptr inbounds [2006 x float]* %region1, i64 0, i64 0
 258   %start2 = getelementptr inbounds [2006 x float]* %region2, i64 0, i64 0
 259   call void @foo(float *%start1, float *%start2)
 260   %ptr1 = getelementptr inbounds [2006 x float]* %region1, i64 0, i64 1024
 261   %ptr2 = getelementptr inbounds [2006 x float]* %region2, i64 0, i64 1024
 262   %float1 = load float *%ptr1
 263   %float2 = load float *%ptr2
 264   %double1 = fpext float %float1 to double
 265   %double2 = fpext float %float2 to double
 266   store volatile double %double1, double *%dst
 267   store volatile double %double2, double *%dst
 268   ret void
 269 }
 270
 271 ; Repeat f2 in a case that needs the emergency spill slots, because all
 272 ; call-clobbered and allocated call-saved registers are live.  Note that
 273 ; %vptr and %dst are copied to call-saved registers, freeing up %r2 and
 274 ; %r3 during the main test.
 275 define void @f10(i32 *%vptr, double *%dst) {
 276 ; CHECK-NOFP-LABEL: f10:
 277 ; CHECK-NOFP: stg [[REGISTER:%r[1-9][0-4]?]], [[OFFSET:160|168]](%r15)
 278 ; CHECK-NOFP: lghi [[REGISTER]], 4096
 279 ; CHECK-NOFP: ldeb {{%f[0-7]}}, 0([[REGISTER]],%r15)
 280 ; CHECK-NOFP: lg [[REGISTER]], [[OFFSET]](%r15)
 281 ; CHECK-NOFP: br %r14
 282 ;
 283 ; CHECK-FP-LABEL: f10:
 284 ; CHECK-FP: stg [[REGISTER:%r[1-9][0-4]?]], [[OFFSET:160|168]](%r11)
 285 ; CHECK-FP: lghi [[REGISTER]], 4096
 286 ; CHECK-FP: ldeb {{%f[0-7]}}, 0([[REGISTER]],%r11)
 287 ; CHECK-FP: lg [[REGISTER]], [[OFFSET]](%r11)
 288 ; CHECK-FP: br %r14
 289   %region1 = alloca [978 x float], align 8
 290   %region2 = alloca [978 x float], align 8
 291   %start1 = getelementptr inbounds [978 x float]* %region1, i64 0, i64 0
 292   %start2 = getelementptr inbounds [978 x float]* %region2, i64 0, i64 0
 293   call void @foo(float *%start1, float *%start2)
 294   %ptr1 = getelementptr inbounds [978 x float]* %region1, i64 0, i64 2
 295   %ptr2 = getelementptr inbounds [978 x float]* %region2, i64 0, i64 2
 296   %i0 = load volatile i32 *%vptr
 297   %i1 = load volatile i32 *%vptr
 298   %i2 = load volatile i32 *%vptr
 299   %i3 = load volatile i32 *%vptr
 300   %i4 = load volatile i32 *%vptr
 301   %i5 = load volatile i32 *%vptr
 302   %i14 = load volatile i32 *%vptr
 303   %float1 = load float *%ptr1
 304   %float2 = load float *%ptr2
 305   %double1 = fpext float %float1 to double
 306   %double2 = fpext float %float2 to double
 307   store volatile double %double1, double *%dst
 308   store volatile double %double2, double *%dst
 309   store volatile i32 %i0, i32 *%vptr
 310   store volatile i32 %i1, i32 *%vptr
 311   store volatile i32 %i2, i32 *%vptr
 312   store volatile i32 %i3, i32 *%vptr
 313   store volatile i32 %i4, i32 *%vptr
 314   store volatile i32 %i5, i32 *%vptr
 315   store volatile i32 %i14, i32 *%vptr
 316   ret void
 317 }
 318
 319 ; Repeat f2 in a case where the index register is already occupied.
 320 define void @f11(double *%dst, i64 %index) {
 321 ; CHECK-NOFP-LABEL: f11:
 322 ; CHECK-NOFP: lgr [[REGISTER:%r[1-9][0-5]?]], %r3
 323 ; CHECK-NOFP: lay %r1, 4096(%r15)
 324 ; CHECK-NOFP: ldeb {{%f[0-7]}}, 0([[REGISTER]],%r1)
 325 ; CHECK-NOFP: br %r14
 326 ;
 327 ; CHECK-FP-LABEL: f11:
 328 ; CHECK-FP: lgr [[REGISTER:%r[1-9][0-5]?]], %r3
 329 ; CHECK-FP: lay %r1, 4096(%r11)
 330 ; CHECK-FP: ldeb {{%f[0-7]}}, 0([[REGISTER]],%r1)
 331 ; CHECK-FP: br %r14
 332   %region1 = alloca [978 x float], align 8
 333   %region2 = alloca [978 x float], align 8
 334   %start1 = getelementptr inbounds [978 x float]* %region1, i64 0, i64 0
 335   %start2 = getelementptr inbounds [978 x float]* %region2, i64 0, i64 0
 336   call void @foo(float *%start1, float *%start2)
 337   %elem1 = getelementptr inbounds [978 x float]* %region1, i64 0, i64 2
 338   %elem2 = getelementptr inbounds [978 x float]* %region2, i64 0, i64 2
 339   %base1 = ptrtoint float *%elem1 to i64
 340   %base2 = ptrtoint float *%elem2 to i64
 341   %addr1 = add i64 %base1, %index
 342   %addr2 = add i64 %base2, %index
 343   %ptr1 = inttoptr i64 %addr1 to float *
 344   %ptr2 = inttoptr i64 %addr2 to float *
 345   %float1 = load float *%ptr1
 346   %float2 = load float *%ptr2
 347   %double1 = fpext float %float1 to double
 348   %double2 = fpext float %float2 to double
 349   store volatile double %double1, double *%dst
 350   store volatile double %double2, double *%dst
 351   ret void
 352 }