1 ; Test spilling using MVC. The tests here assume z10 register pressure, 2 ; without the high words being available. 3 ; 4 ; RUN: llc < %s -mtriple=s390x-linux-gnu -mcpu=z10 -verify-machineinstrs | FileCheck %s 5 6 declare void @foo() 7 8 @g0 = global i32 0 9 @g1 = global i32 1 10 @g2 = global i32 2 11 @g3 = global i32 3 12 @g4 = global i32 4 13 @g5 = global i32 5 14 @g6 = global i32 6 15 @g7 = global i32 7 16 @g8 = global i32 8 17 @g9 = global i32 9 18 19 @h0 = global i64 0 20 @h1 = global i64 1 21 @h2 = global i64 2 22 @h3 = global i64 3 23 @h4 = global i64 4 24 @h5 = global i64 5 25 @h6 = global i64 6 26 @h7 = global i64 7 27 @h8 = global i64 8 28 @h9 = global i64 9 29 30 ; This function shouldn't spill anything 31 define void @f1(i32 *%ptr0) { 32 ; CHECK-LABEL: f1: 33 ; CHECK: stmg 34 ; CHECK: aghi %r15, -160 35 ; CHECK-NOT: %r15 36 ; CHECK: brasl %r14, foo@PLT 37 ; CHECK-NOT: %r15 38 ; CHECK: lmg 39 ; CHECK: br %r14 40 %ptr1 = getelementptr i32, i32 *%ptr0, i32 2 41 %ptr2 = getelementptr i32, i32 *%ptr0, i32 4 42 %ptr3 = getelementptr i32, i32 *%ptr0, i32 6 43 %ptr4 = getelementptr i32, i32 *%ptr0, i32 8 44 %ptr5 = getelementptr i32, i32 *%ptr0, i32 10 45 %ptr6 = getelementptr i32, i32 *%ptr0, i32 12 46 47 %val0 = load i32 , i32 *%ptr0 48 %val1 = load i32 , i32 *%ptr1 49 %val2 = load i32 , i32 *%ptr2 50 %val3 = load i32 , i32 *%ptr3 51 %val4 = load i32 , i32 *%ptr4 52 %val5 = load i32 , i32 *%ptr5 53 %val6 = load i32 , i32 *%ptr6 54 55 call void @foo() 56 57 store i32 %val0, i32 *%ptr0 58 store i32 %val1, i32 *%ptr1 59 store i32 %val2, i32 *%ptr2 60 store i32 %val3, i32 *%ptr3 61 store i32 %val4, i32 *%ptr4 62 store i32 %val5, i32 *%ptr5 63 store i32 %val6, i32 *%ptr6 64 65 ret void 66 } 67 68 ; Test a case where at least one i32 load and at least one i32 store 69 ; need spills. 70 define void @f2(i32 *%ptr0) { 71 ; CHECK-LABEL: f2: 72 ; CHECK: mvc [[OFFSET1:16[04]]](4,%r15), [[OFFSET2:[0-9]+]]({{%r[0-9]+}}) 73 ; CHECK: brasl %r14, foo@PLT 74 ; CHECK: mvc [[OFFSET2]](4,{{%r[0-9]+}}), [[OFFSET1]](%r15) 75 ; CHECK: br %r14 76 %ptr1 = getelementptr i32, i32 *%ptr0, i64 2 77 %ptr2 = getelementptr i32, i32 *%ptr0, i64 4 78 %ptr3 = getelementptr i32, i32 *%ptr0, i64 6 79 %ptr4 = getelementptr i32, i32 *%ptr0, i64 8 80 %ptr5 = getelementptr i32, i32 *%ptr0, i64 10 81 %ptr6 = getelementptr i32, i32 *%ptr0, i64 12 82 %ptr7 = getelementptr i32, i32 *%ptr0, i64 14 83 %ptr8 = getelementptr i32, i32 *%ptr0, i64 16 84 85 %val0 = load i32 , i32 *%ptr0 86 %val1 = load i32 , i32 *%ptr1 87 %val2 = load i32 , i32 *%ptr2 88 %val3 = load i32 , i32 *%ptr3 89 %val4 = load i32 , i32 *%ptr4 90 %val5 = load i32 , i32 *%ptr5 91 %val6 = load i32 , i32 *%ptr6 92 %val7 = load i32 , i32 *%ptr7 93 %val8 = load i32 , i32 *%ptr8 94 95 call void @foo() 96 97 store i32 %val0, i32 *%ptr0 98 store i32 %val1, i32 *%ptr1 99 store i32 %val2, i32 *%ptr2 100 store i32 %val3, i32 *%ptr3 101 store i32 %val4, i32 *%ptr4 102 store i32 %val5, i32 *%ptr5 103 store i32 %val6, i32 *%ptr6 104 store i32 %val7, i32 *%ptr7 105 store i32 %val8, i32 *%ptr8 106 107 ret void 108 } 109 110 ; Test a case where at least one i64 load and at least one i64 store 111 ; need spills. 112 define void @f3(i64 *%ptr0) { 113 ; CHECK-LABEL: f3: 114 ; CHECK: mvc 160(8,%r15), [[OFFSET:[0-9]+]]({{%r[0-9]+}}) 115 ; CHECK: brasl %r14, foo@PLT 116 ; CHECK: mvc [[OFFSET]](8,{{%r[0-9]+}}), 160(%r15) 117 ; CHECK: br %r14 118 %ptr1 = getelementptr i64, i64 *%ptr0, i64 2 119 %ptr2 = getelementptr i64, i64 *%ptr0, i64 4 120 %ptr3 = getelementptr i64, i64 *%ptr0, i64 6 121 %ptr4 = getelementptr i64, i64 *%ptr0, i64 8 122 %ptr5 = getelementptr i64, i64 *%ptr0, i64 10 123 %ptr6 = getelementptr i64, i64 *%ptr0, i64 12 124 %ptr7 = getelementptr i64, i64 *%ptr0, i64 14 125 %ptr8 = getelementptr i64, i64 *%ptr0, i64 16 126 127 %val0 = load i64 , i64 *%ptr0 128 %val1 = load i64 , i64 *%ptr1 129 %val2 = load i64 , i64 *%ptr2 130 %val3 = load i64 , i64 *%ptr3 131 %val4 = load i64 , i64 *%ptr4 132 %val5 = load i64 , i64 *%ptr5 133 %val6 = load i64 , i64 *%ptr6 134 %val7 = load i64 , i64 *%ptr7 135 %val8 = load i64 , i64 *%ptr8 136 137 call void @foo() 138 139 store i64 %val0, i64 *%ptr0 140 store i64 %val1, i64 *%ptr1 141 store i64 %val2, i64 *%ptr2 142 store i64 %val3, i64 *%ptr3 143 store i64 %val4, i64 *%ptr4 144 store i64 %val5, i64 *%ptr5 145 store i64 %val6, i64 *%ptr6 146 store i64 %val7, i64 *%ptr7 147 store i64 %val8, i64 *%ptr8 148 149 ret void 150 } 151 152 153 ; Test a case where at least at least one f32 load and at least one f32 store 154 ; need spills. The 8 call-saved FPRs could be used for 8 of the %vals 155 ; (and are at the time of writing), but it would really be better to use 156 ; MVC for all 10. 157 define void @f4(float *%ptr0) { 158 ; CHECK-LABEL: f4: 159 ; CHECK: mvc [[OFFSET1:16[04]]](4,%r15), [[OFFSET2:[0-9]+]]({{%r[0-9]+}}) 160 ; CHECK: brasl %r14, foo@PLT 161 ; CHECK: mvc [[OFFSET2]](4,{{%r[0-9]+}}), [[OFFSET1]](%r15) 162 ; CHECK: br %r14 163 %ptr1 = getelementptr float, float *%ptr0, i64 2 164 %ptr2 = getelementptr float, float *%ptr0, i64 4 165 %ptr3 = getelementptr float, float *%ptr0, i64 6 166 %ptr4 = getelementptr float, float *%ptr0, i64 8 167 %ptr5 = getelementptr float, float *%ptr0, i64 10 168 %ptr6 = getelementptr float, float *%ptr0, i64 12 169 %ptr7 = getelementptr float, float *%ptr0, i64 14 170 %ptr8 = getelementptr float, float *%ptr0, i64 16 171 %ptr9 = getelementptr float, float *%ptr0, i64 18 172 173 %val0 = load float , float *%ptr0 174 %val1 = load float , float *%ptr1 175 %val2 = load float , float *%ptr2 176 %val3 = load float , float *%ptr3 177 %val4 = load float , float *%ptr4 178 %val5 = load float , float *%ptr5 179 %val6 = load float , float *%ptr6 180 %val7 = load float , float *%ptr7 181 %val8 = load float , float *%ptr8 182 %val9 = load float , float *%ptr9 183 184 call void @foo() 185 186 store float %val0, float *%ptr0 187 store float %val1, float *%ptr1 188 store float %val2, float *%ptr2 189 store float %val3, float *%ptr3 190 store float %val4, float *%ptr4 191 store float %val5, float *%ptr5 192 store float %val6, float *%ptr6 193 store float %val7, float *%ptr7 194 store float %val8, float *%ptr8 195 store float %val9, float *%ptr9 196 197 ret void 198 } 199 200 ; Similarly for f64. 201 define void @f5(double *%ptr0) { 202 ; CHECK-LABEL: f5: 203 ; CHECK: mvc 160(8,%r15), [[OFFSET:[0-9]+]]({{%r[0-9]+}}) 204 ; CHECK: brasl %r14, foo@PLT 205 ; CHECK: mvc [[OFFSET]](8,{{%r[0-9]+}}), 160(%r15) 206 ; CHECK: br %r14 207 %ptr1 = getelementptr double, double *%ptr0, i64 2 208 %ptr2 = getelementptr double, double *%ptr0, i64 4 209 %ptr3 = getelementptr double, double *%ptr0, i64 6 210 %ptr4 = getelementptr double, double *%ptr0, i64 8 211 %ptr5 = getelementptr double, double *%ptr0, i64 10 212 %ptr6 = getelementptr double, double *%ptr0, i64 12 213 %ptr7 = getelementptr double, double *%ptr0, i64 14 214 %ptr8 = getelementptr double, double *%ptr0, i64 16 215 %ptr9 = getelementptr double, double *%ptr0, i64 18 216 217 %val0 = load double , double *%ptr0 218 %val1 = load double , double *%ptr1 219 %val2 = load double , double *%ptr2 220 %val3 = load double , double *%ptr3 221 %val4 = load double , double *%ptr4 222 %val5 = load double , double *%ptr5 223 %val6 = load double , double *%ptr6 224 %val7 = load double , double *%ptr7 225 %val8 = load double , double *%ptr8 226 %val9 = load double , double *%ptr9 227 228 call void @foo() 229 230 store double %val0, double *%ptr0 231 store double %val1, double *%ptr1 232 store double %val2, double *%ptr2 233 store double %val3, double *%ptr3 234 store double %val4, double *%ptr4 235 store double %val5, double *%ptr5 236 store double %val6, double *%ptr6 237 store double %val7, double *%ptr7 238 store double %val8, double *%ptr8 239 store double %val9, double *%ptr9 240 241 ret void 242 } 243 244 ; Repeat f2 with atomic accesses. We shouldn't use MVC here. 245 define void @f6(i32 *%ptr0) { 246 ; CHECK-LABEL: f6: 247 ; CHECK-NOT: mvc 248 ; CHECK: br %r14 249 %ptr1 = getelementptr i32, i32 *%ptr0, i64 2 250 %ptr2 = getelementptr i32, i32 *%ptr0, i64 4 251 %ptr3 = getelementptr i32, i32 *%ptr0, i64 6 252 %ptr4 = getelementptr i32, i32 *%ptr0, i64 8 253 %ptr5 = getelementptr i32, i32 *%ptr0, i64 10 254 %ptr6 = getelementptr i32, i32 *%ptr0, i64 12 255 %ptr7 = getelementptr i32, i32 *%ptr0, i64 14 256 %ptr8 = getelementptr i32, i32 *%ptr0, i64 16 257 258 %val0 = load atomic i32 , i32 *%ptr0 unordered, align 4 259 %val1 = load atomic i32 , i32 *%ptr1 unordered, align 4 260 %val2 = load atomic i32 , i32 *%ptr2 unordered, align 4 261 %val3 = load atomic i32 , i32 *%ptr3 unordered, align 4 262 %val4 = load atomic i32 , i32 *%ptr4 unordered, align 4 263 %val5 = load atomic i32 , i32 *%ptr5 unordered, align 4 264 %val6 = load atomic i32 , i32 *%ptr6 unordered, align 4 265 %val7 = load atomic i32 , i32 *%ptr7 unordered, align 4 266 %val8 = load atomic i32 , i32 *%ptr8 unordered, align 4 267 268 call void @foo() 269 270 store atomic i32 %val0, i32 *%ptr0 unordered, align 4 271 store atomic i32 %val1, i32 *%ptr1 unordered, align 4 272 store atomic i32 %val2, i32 *%ptr2 unordered, align 4 273 store atomic i32 %val3, i32 *%ptr3 unordered, align 4 274 store atomic i32 %val4, i32 *%ptr4 unordered, align 4 275 store atomic i32 %val5, i32 *%ptr5 unordered, align 4 276 store atomic i32 %val6, i32 *%ptr6 unordered, align 4 277 store atomic i32 %val7, i32 *%ptr7 unordered, align 4 278 store atomic i32 %val8, i32 *%ptr8 unordered, align 4 279 280 ret void 281 } 282 283 ; ...likewise volatile accesses. 284 define void @f7(i32 *%ptr0) { 285 ; CHECK-LABEL: f7: 286 ; CHECK-NOT: mvc 287 ; CHECK: br %r14 288 %ptr1 = getelementptr i32, i32 *%ptr0, i64 2 289 %ptr2 = getelementptr i32, i32 *%ptr0, i64 4 290 %ptr3 = getelementptr i32, i32 *%ptr0, i64 6 291 %ptr4 = getelementptr i32, i32 *%ptr0, i64 8 292 %ptr5 = getelementptr i32, i32 *%ptr0, i64 10 293 %ptr6 = getelementptr i32, i32 *%ptr0, i64 12 294 %ptr7 = getelementptr i32, i32 *%ptr0, i64 14 295 %ptr8 = getelementptr i32, i32 *%ptr0, i64 16 296 297 %val0 = load volatile i32 , i32 *%ptr0 298 %val1 = load volatile i32 , i32 *%ptr1 299 %val2 = load volatile i32 , i32 *%ptr2 300 %val3 = load volatile i32 , i32 *%ptr3 301 %val4 = load volatile i32 , i32 *%ptr4 302 %val5 = load volatile i32 , i32 *%ptr5 303 %val6 = load volatile i32 , i32 *%ptr6 304 %val7 = load volatile i32 , i32 *%ptr7 305 %val8 = load volatile i32 , i32 *%ptr8 306 307 call void @foo() 308 309 store volatile i32 %val0, i32 *%ptr0 310 store volatile i32 %val1, i32 *%ptr1 311 store volatile i32 %val2, i32 *%ptr2 312 store volatile i32 %val3, i32 *%ptr3 313 store volatile i32 %val4, i32 *%ptr4 314 store volatile i32 %val5, i32 *%ptr5 315 store volatile i32 %val6, i32 *%ptr6 316 store volatile i32 %val7, i32 *%ptr7 317 store volatile i32 %val8, i32 *%ptr8 318 319 ret void 320 } 321 322 ; Check that LRL and STRL are not converted. 323 define void @f8() { 324 ; CHECK-LABEL: f8: 325 ; CHECK-NOT: mvc 326 ; CHECK: br %r14 327 %val0 = load i32 , i32 *@g0 328 %val1 = load i32 , i32 *@g1 329 %val2 = load i32 , i32 *@g2 330 %val3 = load i32 , i32 *@g3 331 %val4 = load i32 , i32 *@g4 332 %val5 = load i32 , i32 *@g5 333 %val6 = load i32 , i32 *@g6 334 %val7 = load i32 , i32 *@g7 335 %val8 = load i32 , i32 *@g8 336 %val9 = load i32 , i32 *@g9 337 338 call void @foo() 339 340 store i32 %val0, i32 *@g0 341 store i32 %val1, i32 *@g1 342 store i32 %val2, i32 *@g2 343 store i32 %val3, i32 *@g3 344 store i32 %val4, i32 *@g4 345 store i32 %val5, i32 *@g5 346 store i32 %val6, i32 *@g6 347 store i32 %val7, i32 *@g7 348 store i32 %val8, i32 *@g8 349 store i32 %val9, i32 *@g9 350 351 ret void 352 } 353 354 ; Likewise LGRL and STGRL. 355 define void @f9() { 356 ; CHECK-LABEL: f9: 357 ; CHECK-NOT: mvc 358 ; CHECK: br %r14 359 %val0 = load i64 , i64 *@h0 360 %val1 = load i64 , i64 *@h1 361 %val2 = load i64 , i64 *@h2 362 %val3 = load i64 , i64 *@h3 363 %val4 = load i64 , i64 *@h4 364 %val5 = load i64 , i64 *@h5 365 %val6 = load i64 , i64 *@h6 366 %val7 = load i64 , i64 *@h7 367 %val8 = load i64 , i64 *@h8 368 %val9 = load i64 , i64 *@h9 369 370 call void @foo() 371 372 store i64 %val0, i64 *@h0 373 store i64 %val1, i64 *@h1 374 store i64 %val2, i64 *@h2 375 store i64 %val3, i64 *@h3 376 store i64 %val4, i64 *@h4 377 store i64 %val5, i64 *@h5 378 store i64 %val6, i64 *@h6 379 store i64 %val7, i64 *@h7 380 store i64 %val8, i64 *@h8 381 store i64 %val9, i64 *@h9 382 383 ret void 384 } 385 386 ; This showed a problem with the way stack coloring updated instructions. 387 ; The copy from %val9 to %newval8 can be done using an MVC, which then 388 ; has two frame index operands. Stack coloring chose a valid renumbering 389 ; [FI0, FI1] -> [FI1, FI2], but applied it in the form FI0 -> FI1 -> FI2, 390 ; so that both operands ended up being the same. 391 define void @f10() { 392 ; CHECK-LABEL: f10: 393 ; CHECK: lgrl [[REG:%r[0-9]+]], h9 394 ; CHECK: stg [[REG]], [[VAL9:[0-9]+]](%r15) 395 ; CHECK: brasl %r14, foo@PLT 396 ; CHECK: brasl %r14, foo@PLT 397 ; CHECK: mvc [[NEWVAL8:[0-9]+]](8,%r15), [[VAL9]](%r15) 398 ; CHECK: brasl %r14, foo@PLT 399 ; CHECK: lg [[REG:%r[0-9]+]], [[NEWVAL8]](%r15) 400 ; CHECK: stgrl [[REG]], h8 401 ; CHECK: br %r14 402 entry: 403 %val8 = load volatile i64 , i64 *@h8 404 %val0 = load volatile i64 , i64 *@h0 405 %val1 = load volatile i64 , i64 *@h1 406 %val2 = load volatile i64 , i64 *@h2 407 %val3 = load volatile i64 , i64 *@h3 408 %val4 = load volatile i64 , i64 *@h4 409 %val5 = load volatile i64 , i64 *@h5 410 %val6 = load volatile i64 , i64 *@h6 411 %val7 = load volatile i64 , i64 *@h7 412 %val9 = load volatile i64 , i64 *@h9 413 414 call void @foo() 415 416 store volatile i64 %val0, i64 *@h0 417 store volatile i64 %val1, i64 *@h1 418 store volatile i64 %val2, i64 *@h2 419 store volatile i64 %val3, i64 *@h3 420 store volatile i64 %val4, i64 *@h4 421 store volatile i64 %val5, i64 *@h5 422 store volatile i64 %val6, i64 *@h6 423 store volatile i64 %val7, i64 *@h7 424 425 %check = load volatile i64 , i64 *@h0 426 %cond = icmp eq i64 %check, 0 427 br i1 %cond, label %skip, label %fallthru 428 429 fallthru: 430 call void @foo() 431 432 store volatile i64 %val0, i64 *@h0 433 store volatile i64 %val1, i64 *@h1 434 store volatile i64 %val2, i64 *@h2 435 store volatile i64 %val3, i64 *@h3 436 store volatile i64 %val4, i64 *@h4 437 store volatile i64 %val5, i64 *@h5 438 store volatile i64 %val6, i64 *@h6 439 store volatile i64 %val7, i64 *@h7 440 store volatile i64 %val8, i64 *@h8 441 br label %skip 442 443 skip: 444 %newval8 = phi i64 [ %val8, %entry ], [ %val9, %fallthru ] 445 call void @foo() 446 447 store volatile i64 %val0, i64 *@h0 448 store volatile i64 %val1, i64 *@h1 449 store volatile i64 %val2, i64 *@h2 450 store volatile i64 %val3, i64 *@h3 451 store volatile i64 %val4, i64 *@h4 452 store volatile i64 %val5, i64 *@h5 453 store volatile i64 %val6, i64 *@h6 454 store volatile i64 %val7, i64 *@h7 455 store volatile i64 %newval8, i64 *@h8 456 store volatile i64 %val9, i64 *@h9 457 458 ret void 459 } 460 461 ; This used to generate a no-op MVC. It is very sensitive to spill heuristics. 462 define void @f11() { 463 ; CHECK-LABEL: f11: 464 ; CHECK-NOT: mvc [[OFFSET:[0-9]+]](8,%r15), [[OFFSET]](%r15) 465 ; CHECK: br %r14 466 entry: 467 %val0 = load volatile i64 , i64 *@h0 468 %val1 = load volatile i64 , i64 *@h1 469 %val2 = load volatile i64 , i64 *@h2 470 %val3 = load volatile i64 , i64 *@h3 471 %val4 = load volatile i64 , i64 *@h4 472 %val5 = load volatile i64 , i64 *@h5 473 %val6 = load volatile i64 , i64 *@h6 474 %val7 = load volatile i64 , i64 *@h7 475 476 %altval0 = load volatile i64 , i64 *@h0 477 %altval1 = load volatile i64 , i64 *@h1 478 479 call void @foo() 480 481 store volatile i64 %val0, i64 *@h0 482 store volatile i64 %val1, i64 *@h1 483 store volatile i64 %val2, i64 *@h2 484 store volatile i64 %val3, i64 *@h3 485 store volatile i64 %val4, i64 *@h4 486 store volatile i64 %val5, i64 *@h5 487 store volatile i64 %val6, i64 *@h6 488 store volatile i64 %val7, i64 *@h7 489 490 %check = load volatile i64 , i64 *@h0 491 %cond = icmp eq i64 %check, 0 492 br i1 %cond, label %a1, label %b1 493 494 a1: 495 call void @foo() 496 br label %join1 497 498 b1: 499 call void @foo() 500 br label %join1 501 502 join1: 503 %newval0 = phi i64 [ %val0, %a1 ], [ %altval0, %b1 ] 504 505 call void @foo() 506 507 store volatile i64 %val1, i64 *@h1 508 store volatile i64 %val2, i64 *@h2 509 store volatile i64 %val3, i64 *@h3 510 store volatile i64 %val4, i64 *@h4 511 store volatile i64 %val5, i64 *@h5 512 store volatile i64 %val6, i64 *@h6 513 store volatile i64 %val7, i64 *@h7 514 br i1 %cond, label %a2, label %b2 515 516 a2: 517 call void @foo() 518 br label %join2 519 520 b2: 521 call void @foo() 522 br label %join2 523 524 join2: 525 %newval1 = phi i64 [ %val1, %a2 ], [ %altval1, %b2 ] 526 527 call void @foo() 528 529 store volatile i64 %val2, i64 *@h2 530 store volatile i64 %val3, i64 *@h3 531 store volatile i64 %val4, i64 *@h4 532 store volatile i64 %val5, i64 *@h5 533 store volatile i64 %val6, i64 *@h6 534 store volatile i64 %val7, i64 *@h7 535 536 call void @foo() 537 538 store volatile i64 %newval0, i64 *@h0 539 store volatile i64 %newval1, i64 *@h1 540 store volatile i64 %val2, i64 *@h2 541 store volatile i64 %val3, i64 *@h3 542 store volatile i64 %val4, i64 *@h4 543 store volatile i64 %val5, i64 *@h5 544 store volatile i64 %val6, i64 *@h6 545 store volatile i64 %val7, i64 *@h7 546 547 ret void 548 } 549
