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