1 ; RUN: llc < %s -mtriple=s390x-linux-gnu | FileCheck %s 2 ; 3 ; Note: Print verbose stackmaps using -debug-only=stackmaps. 4 5 ; CHECK: .section .llvm_stackmaps 6 ; CHECK-NEXT: __LLVM_StackMaps: 7 ; Header 8 ; CHECK-NEXT: .byte 3 9 ; CHECK-NEXT: .byte 0 10 ; CHECK-NEXT: .short 0 11 ; Num Functions 12 ; CHECK-NEXT: .long 15 13 ; Num LargeConstants 14 ; CHECK-NEXT: .long 3 15 ; Num Callsites 16 ; CHECK-NEXT: .long 19 17 18 ; Functions and stack size 19 ; CHECK-NEXT: .quad constantargs 20 ; CHECK-NEXT: .quad 160 21 ; CHECK-NEXT: .quad 1 22 ; CHECK-NEXT: .quad osrinline 23 ; CHECK-NEXT: .quad 160 24 ; CHECK-NEXT: .quad 1 25 ; CHECK-NEXT: .quad osrcold 26 ; CHECK-NEXT: .quad 160 27 ; CHECK-NEXT: .quad 1 28 ; CHECK-NEXT: .quad propertyRead 29 ; CHECK-NEXT: .quad 160 30 ; CHECK-NEXT: .quad 1 31 ; CHECK-NEXT: .quad propertyWrite 32 ; CHECK-NEXT: .quad 160 33 ; CHECK-NEXT: .quad 1 34 ; CHECK-NEXT: .quad jsVoidCall 35 ; CHECK-NEXT: .quad 160 36 ; CHECK-NEXT: .quad 1 37 ; CHECK-NEXT: .quad jsIntCall 38 ; CHECK-NEXT: .quad 160 39 ; CHECK-NEXT: .quad 1 40 ; CHECK-NEXT: .quad spilledValue 41 ; CHECK-NEXT: .quad 240 42 ; CHECK-NEXT: .quad 1 43 ; CHECK-NEXT: .quad spilledStackMapValue 44 ; CHECK-NEXT: .quad 200 45 ; CHECK-NEXT: .quad 1 46 ; CHECK-NEXT: .quad spillSubReg 47 ; CHECK-NEXT: .quad 168 48 ; CHECK-NEXT: .quad 1 49 ; CHECK-NEXT: .quad liveConstant 50 ; CHECK-NEXT: .quad 160 51 ; CHECK-NEXT: .quad 1 52 ; CHECK-NEXT: .quad directFrameIdx 53 ; CHECK-NEXT: .quad 200 54 ; CHECK-NEXT: .quad 2 55 ; CHECK-NEXT: .quad longid 56 ; CHECK-NEXT: .quad 160 57 ; CHECK-NEXT: .quad 4 58 ; CHECK-NEXT: .quad clobberScratch 59 ; CHECK-NEXT: .quad 168 60 ; CHECK-NEXT: .quad 1 61 ; CHECK-NEXT: .quad needsStackRealignment 62 ; CHECK-NEXT: .quad -1 63 ; CHECK-NEXT: .quad 1 64 65 ; Large Constants 66 ; CHECK-NEXT: .quad 2147483648 67 ; CHECK-NEXT: .quad 4294967295 68 ; CHECK-NEXT: .quad 4294967296 69 70 ; Callsites 71 ; Constant arguments 72 ; 73 ; CHECK-NEXT: .quad 1 74 ; CHECK-NEXT: .long .L{{.*}}-constantargs 75 ; CHECK-NEXT: .short 0 76 ; CHECK-NEXT: .short 12 77 ; SmallConstant 78 ; CHECK-NEXT: .byte 4 79 ; CHECK-NEXT: .byte 0 80 ; CHECK-NEXT: .short 8 81 ; CHECK-NEXT: .short 0 82 ; CHECK-NEXT: .short 0 83 ; CHECK-NEXT: .long -1 84 ; SmallConstant 85 ; CHECK-NEXT: .byte 4 86 ; CHECK-NEXT: .byte 0 87 ; CHECK-NEXT: .short 8 88 ; CHECK-NEXT: .short 0 89 ; CHECK-NEXT: .short 0 90 ; CHECK-NEXT: .long -1 91 ; SmallConstant 92 ; CHECK-NEXT: .byte 4 93 ; CHECK-NEXT: .byte 0 94 ; CHECK-NEXT: .short 8 95 ; CHECK-NEXT: .short 0 96 ; CHECK-NEXT: .short 0 97 ; CHECK-NEXT: .long 65536 98 ; SmallConstant 99 ; CHECK-NEXT: .byte 4 100 ; CHECK-NEXT: .byte 0 101 ; CHECK-NEXT: .short 8 102 ; CHECK-NEXT: .short 0 103 ; CHECK-NEXT: .short 0 104 ; CHECK-NEXT: .long 2000000000 105 ; SmallConstant 106 ; CHECK-NEXT: .byte 4 107 ; CHECK-NEXT: .byte 0 108 ; CHECK-NEXT: .short 8 109 ; CHECK-NEXT: .short 0 110 ; CHECK-NEXT: .short 0 111 ; CHECK-NEXT: .long 2147483647 112 ; SmallConstant 113 ; CHECK-NEXT: .byte 4 114 ; CHECK-NEXT: .byte 0 115 ; CHECK-NEXT: .short 8 116 ; CHECK-NEXT: .short 0 117 ; CHECK-NEXT: .short 0 118 ; CHECK-NEXT: .long -1 119 ; SmallConstant 120 ; CHECK-NEXT: .byte 4 121 ; CHECK-NEXT: .byte 0 122 ; CHECK-NEXT: .short 8 123 ; CHECK-NEXT: .short 0 124 ; CHECK-NEXT: .short 0 125 ; CHECK-NEXT: .long -1 126 ; SmallConstant 127 ; CHECK-NEXT: .byte 4 128 ; CHECK-NEXT: .byte 0 129 ; CHECK-NEXT: .short 8 130 ; CHECK-NEXT: .short 0 131 ; CHECK-NEXT: .short 0 132 ; CHECK-NEXT: .long 0 133 ; LargeConstant at index 0 134 ; CHECK-NEXT: .byte 5 135 ; CHECK-NEXT: .byte 0 136 ; CHECK-NEXT: .short 8 137 ; CHECK-NEXT: .short 0 138 ; CHECK-NEXT: .short 0 139 ; CHECK-NEXT: .long 0 140 ; LargeConstant at index 1 141 ; CHECK-NEXT: .byte 5 142 ; CHECK-NEXT: .byte 0 143 ; CHECK-NEXT: .short 8 144 ; CHECK-NEXT: .short 0 145 ; CHECK-NEXT: .short 0 146 ; CHECK-NEXT: .long 1 147 ; LargeConstant at index 2 148 ; CHECK-NEXT: .byte 5 149 ; CHECK-NEXT: .byte 0 150 ; CHECK-NEXT: .short 8 151 ; CHECK-NEXT: .short 0 152 ; CHECK-NEXT: .short 0 153 ; CHECK-NEXT: .long 2 154 ; SmallConstant 155 ; CHECK-NEXT: .byte 4 156 ; CHECK-NEXT: .byte 0 157 ; CHECK-NEXT: .short 8 158 ; CHECK-NEXT: .short 0 159 ; CHECK-NEXT: .short 0 160 ; CHECK-NEXT: .long -1 161 162 define void @constantargs() { 163 entry: 164 %0 = inttoptr i64 12345 to i8* 165 tail call void (i64, i32, i8*, i32, ...) @llvm.experimental.patchpoint.void(i64 1, i32 14, i8* %0, i32 0, i16 65535, i16 -1, i32 65536, i32 2000000000, i32 2147483647, i32 -1, i32 4294967295, i32 4294967296, i64 2147483648, i64 4294967295, i64 4294967296, i64 -1) 166 ret void 167 } 168 169 ; Inline OSR Exit 170 ; 171 ; CHECK: .long .L{{.*}}-osrinline 172 ; CHECK-NEXT: .short 0 173 ; CHECK-NEXT: .short 2 174 ; CHECK-NEXT: .byte 1 175 ; CHECK-NEXT: .byte 0 176 ; CHECK-NEXT: .short 8 177 ; CHECK-NEXT: .short {{[0-9]+}} 178 ; CHECK-NEXT: .short 0 179 ; CHECK-NEXT: .long 0 180 ; CHECK-NEXT: .byte 1 181 ; CHECK-NEXT: .byte 0 182 ; CHECK-NEXT: .short 8 183 ; CHECK-NEXT: .short {{[0-9]+}} 184 ; CHECK-NEXT: .short 0 185 ; CHECK-NEXT: .long 0 186 define void @osrinline(i64 %a, i64 %b) { 187 entry: 188 ; Runtime void->void call. 189 call void inttoptr (i64 -559038737 to void ()*)() 190 ; Followed by inline OSR patchpoint with 12-byte shadow and 2 live vars. 191 call void (i64, i32, ...) @llvm.experimental.stackmap(i64 3, i32 12, i64 %a, i64 %b) 192 ret void 193 } 194 195 ; Cold OSR Exit 196 ; 197 ; 2 live variables in register. 198 ; 199 ; CHECK: .long .L{{.*}}-osrcold 200 ; CHECK-NEXT: .short 0 201 ; CHECK-NEXT: .short 2 202 ; CHECK-NEXT: .byte 1 203 ; CHECK-NEXT: .byte 0 204 ; CHECK-NEXT: .short 8 205 ; CHECK-NEXT: .short {{[0-9]+}} 206 ; CHECK-NEXT: .short 0 207 ; CHECK-NEXT: .long 0 208 ; CHECK-NEXT: .byte 1 209 ; CHECK-NEXT: .byte 0 210 ; CHECK-NEXT: .short 8 211 ; CHECK-NEXT: .short {{[0-9]+}} 212 ; CHECK-NEXT: .short 0 213 ; CHECK-NEXT: .long 0 214 define void @osrcold(i64 %a, i64 %b) { 215 entry: 216 %test = icmp slt i64 %a, %b 217 br i1 %test, label %ret, label %cold 218 cold: 219 ; OSR patchpoint with 12-byte nop-slide and 2 live vars. 220 %thunk = inttoptr i64 -559038737 to i8* 221 call void (i64, i32, i8*, i32, ...) @llvm.experimental.patchpoint.void(i64 4, i32 14, i8* %thunk, i32 0, i64 %a, i64 %b) 222 unreachable 223 ret: 224 ret void 225 } 226 227 ; Property Read 228 ; CHECK: .long .L{{.*}}-propertyRead 229 ; CHECK-NEXT: .short 0 230 ; CHECK-NEXT: .short 2 231 ; CHECK-NEXT: .byte 1 232 ; CHECK-NEXT: .byte 0 233 ; CHECK-NEXT: .short 8 234 ; CHECK-NEXT: .short {{[0-9]+}} 235 ; CHECK-NEXT: .short 0 236 ; CHECK-NEXT: .long 0 237 ; CHECK-NEXT: .byte 1 238 ; CHECK-NEXT: .byte 0 239 ; CHECK-NEXT: .short 8 240 ; CHECK-NEXT: .short {{[0-9]+}} 241 ; CHECK-NEXT: .short 0 242 ; CHECK-NEXT: .long 0 243 define i64 @propertyRead(i64* %obj) { 244 entry: 245 %resolveRead = inttoptr i64 -559038737 to i8* 246 %result = call anyregcc i64 (i64, i32, i8*, i32, ...) @llvm.experimental.patchpoint.i64(i64 5, i32 14, i8* %resolveRead, i32 1, i64* %obj) 247 %add = add i64 %result, 3 248 ret i64 %add 249 } 250 251 ; Property Write 252 ; CHECK: .long .L{{.*}}-propertyWrite 253 ; CHECK-NEXT: .short 0 254 ; CHECK-NEXT: .short 2 255 ; CHECK-NEXT: .byte 1 256 ; CHECK-NEXT: .byte 0 257 ; CHECK-NEXT: .short 8 258 ; CHECK-NEXT: .short {{[0-9]+}} 259 ; CHECK-NEXT: .short 0 260 ; CHECK-NEXT: .long 0 261 ; CHECK-NEXT: .byte 1 262 ; CHECK-NEXT: .byte 0 263 ; CHECK-NEXT: .short 8 264 ; CHECK-NEXT: .short {{[0-9]+}} 265 ; CHECK-NEXT: .short 0 266 ; CHECK-NEXT: .long 0 267 define void @propertyWrite(i64 %dummy1, i64* %obj, i64 %dummy2, i64 %a) { 268 entry: 269 %resolveWrite = inttoptr i64 -559038737 to i8* 270 call anyregcc void (i64, i32, i8*, i32, ...) @llvm.experimental.patchpoint.void(i64 6, i32 14, i8* %resolveWrite, i32 2, i64* %obj, i64 %a) 271 ret void 272 } 273 274 ; Void JS Call 275 ; 276 ; 2 live variables in registers. 277 ; 278 ; CHECK: .long .L{{.*}}-jsVoidCall 279 ; CHECK-NEXT: .short 0 280 ; CHECK-NEXT: .short 2 281 ; CHECK-NEXT: .byte 1 282 ; CHECK-NEXT: .byte 0 283 ; CHECK-NEXT: .short 8 284 ; CHECK-NEXT: .short {{[0-9]+}} 285 ; CHECK-NEXT: .short 0 286 ; CHECK-NEXT: .long 0 287 ; CHECK-NEXT: .byte 1 288 ; CHECK-NEXT: .byte 0 289 ; CHECK-NEXT: .short 8 290 ; CHECK-NEXT: .short {{[0-9]+}} 291 ; CHECK-NEXT: .short 0 292 ; CHECK-NEXT: .long 0 293 define void @jsVoidCall(i64 %dummy1, i64* %obj, i64 %arg, i64 %l1, i64 %l2) { 294 entry: 295 %resolveCall = inttoptr i64 -559038737 to i8* 296 call void (i64, i32, i8*, i32, ...) @llvm.experimental.patchpoint.void(i64 7, i32 14, i8* %resolveCall, i32 2, i64* %obj, i64 %arg, i64 %l1, i64 %l2) 297 ret void 298 } 299 300 ; i64 JS Call 301 ; 302 ; 2 live variables in registers. 303 ; 304 ; CHECK: .long .L{{.*}}-jsIntCall 305 ; CHECK-NEXT: .short 0 306 ; CHECK-NEXT: .short 2 307 ; CHECK-NEXT: .byte 1 308 ; CHECK-NEXT: .byte 0 309 ; CHECK-NEXT: .short 8 310 ; CHECK-NEXT: .short {{[0-9]+}} 311 ; CHECK-NEXT: .short 0 312 ; CHECK-NEXT: .long 0 313 ; CHECK-NEXT: .byte 1 314 ; CHECK-NEXT: .byte 0 315 ; CHECK-NEXT: .short 8 316 ; CHECK-NEXT: .short {{[0-9]+}} 317 ; CHECK-NEXT: .short 0 318 ; CHECK-NEXT: .long 0 319 define i64 @jsIntCall(i64 %dummy1, i64* %obj, i64 %arg, i64 %l1, i64 %l2) { 320 entry: 321 %resolveCall = inttoptr i64 -559038737 to i8* 322 %result = call i64 (i64, i32, i8*, i32, ...) @llvm.experimental.patchpoint.i64(i64 8, i32 14, i8* %resolveCall, i32 2, i64* %obj, i64 %arg, i64 %l1, i64 %l2) 323 %add = add i64 %result, 3 324 ret i64 %add 325 } 326 327 ; Spilled stack map values. 328 ; 329 ; Verify 17 stack map entries. 330 ; 331 ; CHECK: .long .L{{.*}}-spilledValue 332 ; CHECK-NEXT: .short 0 333 ; CHECK-NEXT: .short 17 334 ; 335 ; Check that at least one is a spilled entry from the parameter area. 336 ; Location: Indirect r15 + XX 337 ; CHECK: .byte 3 338 ; CHECK-NEXT: .byte 0 339 ; CHECK-NEXT: .short 8 340 ; CHECK-NEXT: .short 15 341 ; CHECK-NEXT: .short 0 342 ; CHECK-NEXT: .long 343 define void @spilledValue(i64 %arg0, i64 %arg1, i64 %arg2, i64 %arg3, i64 %arg4, i64 %l0, i64 %l1, i64 %l2, i64 %l3, i64 %l4, i64 %l5, i64 %l6, i64 %l7, i64 %l8, i64 %l9, i64 %l10, i64 %l11, i64 %l12, i64 %l13, i64 %l14, i64 %l15, i64 %l16) { 344 entry: 345 call void (i64, i32, i8*, i32, ...) @llvm.experimental.patchpoint.void(i64 11, i32 14, i8* null, i32 5, i64 %arg0, i64 %arg1, i64 %arg2, i64 %arg3, i64 %arg4, i64 %l0, i64 %l1, i64 %l2, i64 %l3, i64 %l4, i64 %l5, i64 %l6, i64 %l7, i64 %l8, i64 %l9, i64 %l10, i64 %l11, i64 %l12, i64 %l13, i64 %l14, i64 %l15, i64 %l16) 346 ret void 347 } 348 349 ; Spilled stack map values. 350 ; 351 ; Verify 17 stack map entries. 352 ; 353 ; CHECK: .long .L{{.*}}-spilledStackMapValue 354 ; CHECK-NEXT: .short 0 355 ; CHECK-NEXT: .short 17 356 ; 357 ; Check that at least one is a spilled entry from the parameter area. 358 ; Location: Indirect r15 + XX 359 ; CHECK: .byte 3 360 ; CHECK-NEXT: .byte 0 361 ; CHECK-NEXT: .short 8 362 ; CHECK-NEXT: .short 15 363 ; CHECK-NEXT: .short 0 364 ; CHECK-NEXT: .long 365 define void @spilledStackMapValue(i64 %l0, i64 %l1, i64 %l2, i64 %l3, i64 %l4, i64 %l5, i64 %l6, i64 %l7, i64 %l8, i64 %l9, i64 %l10, i64 %l11, i64 %l12, i64 %l13, i64 %l14, i64 %l15, i64 %l16) { 366 entry: 367 call void (i64, i32, ...) @llvm.experimental.stackmap(i64 12, i32 16, i64 %l0, i64 %l1, i64 %l2, i64 %l3, i64 %l4, i64 %l5, i64 %l6, i64 %l7, i64 %l8, i64 %l9, i64 %l10, i64 %l11, i64 %l12, i64 %l13, i64 %l14, i64 %l15, i64 %l16) 368 ret void 369 } 370 371 ; Spill a subregister stackmap operand. 372 ; 373 ; CHECK: .long .L{{.*}}-spillSubReg 374 ; CHECK-NEXT: .short 0 375 ; 4 locations 376 ; CHECK-NEXT: .short 1 377 ; 378 ; Check that the subregister operand is a 4-byte spill. 379 ; Location: Indirect, 4-byte, %r15 + 164 380 ; CHECK: .byte 3 381 ; CHECK-NEXT: .byte 0 382 ; CHECK-NEXT: .short 4 383 ; CHECK-NEXT: .short 15 384 ; CHECK-NEXT: .short 0 385 ; CHECK-NEXT: .long 164 386 define void @spillSubReg(i64 %arg) #0 { 387 bb: 388 br i1 undef, label %bb1, label %bb2 389 390 bb1: 391 unreachable 392 393 bb2: 394 %tmp = load i64, i64* inttoptr (i64 140685446136880 to i64*) 395 br i1 undef, label %bb16, label %bb17 396 397 bb16: 398 unreachable 399 400 bb17: 401 %tmp32 = trunc i64 %tmp to i32 402 br i1 undef, label %bb60, label %bb61 403 404 bb60: 405 tail call void asm sideeffect "nopr %r0", "~{r0},~{r1},~{r2},~{r3},~{r4},~{r5},~{r6},~{r7},~{r8},~{r9},~{r10},~{r11},~{r12},~{r13},~{r14}"() nounwind 406 tail call void (i64, i32, ...) @llvm.experimental.stackmap(i64 13, i32 6, i32 %tmp32) 407 unreachable 408 409 bb61: 410 unreachable 411 } 412 413 ; Map a constant value. 414 ; 415 ; CHECK: .long .L{{.*}}-liveConstant 416 ; CHECK-NEXT: .short 0 417 ; 1 location 418 ; CHECK-NEXT: .short 1 419 ; Loc 0: SmallConstant 420 ; CHECK-NEXT: .byte 4 421 ; CHECK-NEXT: .byte 0 422 ; CHECK-NEXT: .short 8 423 ; CHECK-NEXT: .short 0 424 ; CHECK-NEXT: .short 0 425 ; CHECK-NEXT: .long 33 426 427 define void @liveConstant() { 428 tail call void (i64, i32, ...) @llvm.experimental.stackmap(i64 15, i32 6, i32 33) 429 ret void 430 } 431 432 ; Directly map an alloca's address. 433 ; 434 ; Callsite 16 435 ; CHECK: .long .L{{.*}}-directFrameIdx 436 ; CHECK-NEXT: .short 0 437 ; 1 location 438 ; CHECK-NEXT: .short 1 439 ; Loc 0: Direct %r15 + ofs 440 ; CHECK-NEXT: .byte 2 441 ; CHECK-NEXT: .byte 0 442 ; CHECK-NEXT: .short 8 443 ; CHECK-NEXT: .short 15 444 ; CHECK-NEXT: .short 0 445 ; CHECK-NEXT: .long 446 447 ; Callsite 17 448 ; CHECK: .long .L{{.*}}-directFrameIdx 449 ; CHECK-NEXT: .short 0 450 ; 2 locations 451 ; CHECK-NEXT: .short 2 452 ; Loc 0: Direct %r15 + ofs 453 ; CHECK-NEXT: .byte 2 454 ; CHECK-NEXT: .byte 0 455 ; CHECK-NEXT: .short 8 456 ; CHECK-NEXT: .short 15 457 ; CHECK-NEXT: .short 0 458 ; CHECK-NEXT: .long 459 ; Loc 1: Direct %r15 + ofs 460 ; CHECK-NEXT: .byte 2 461 ; CHECK-NEXT: .byte 0 462 ; CHECK-NEXT: .short 8 463 ; CHECK-NEXT: .short 15 464 ; CHECK-NEXT: .short 0 465 ; CHECK-NEXT: .long 466 define void @directFrameIdx() { 467 entry: 468 %metadata1 = alloca i64, i32 3, align 8 469 store i64 11, i64* %metadata1 470 store i64 12, i64* %metadata1 471 store i64 13, i64* %metadata1 472 call void (i64, i32, ...) @llvm.experimental.stackmap(i64 16, i32 0, i64* %metadata1) 473 %metadata2 = alloca i8, i32 4, align 8 474 %metadata3 = alloca i16, i32 4, align 8 475 call void (i64, i32, i8*, i32, ...) @llvm.experimental.patchpoint.void(i64 17, i32 6, i8* null, i32 0, i8* %metadata2, i16* %metadata3) 476 ret void 477 } 478 479 ; Test a 64-bit ID. 480 ; 481 ; CHECK: .quad 4294967295 482 ; CHECK: .long .L{{.*}}-longid 483 ; CHECK: .quad 4294967296 484 ; CHECK: .long .L{{.*}}-longid 485 ; CHECK: .quad 9223372036854775807 486 ; CHECK: .long .L{{.*}}-longid 487 ; CHECK: .quad -1 488 ; CHECK: .long .L{{.*}}-longid 489 define void @longid() { 490 entry: 491 tail call void (i64, i32, i8*, i32, ...) @llvm.experimental.patchpoint.void(i64 4294967295, i32 0, i8* null, i32 0) 492 tail call void (i64, i32, i8*, i32, ...) @llvm.experimental.patchpoint.void(i64 4294967296, i32 0, i8* null, i32 0) 493 tail call void (i64, i32, i8*, i32, ...) @llvm.experimental.patchpoint.void(i64 9223372036854775807, i32 0, i8* null, i32 0) 494 tail call void (i64, i32, i8*, i32, ...) @llvm.experimental.patchpoint.void(i64 -1, i32 0, i8* null, i32 0) 495 ret void 496 } 497 498 ; Map a value when %r0 and %r1 are the only free registers. 499 ; The scratch registers should not be used for a live stackmap value. 500 ; 501 ; CHECK: .long .L{{.*}}-clobberScratch 502 ; CHECK-NEXT: .short 0 503 ; 1 location 504 ; CHECK-NEXT: .short 1 505 ; Loc 0: Indirect %r15 + offset 506 ; CHECK-NEXT: .byte 3 507 ; CHECK-NEXT: .byte 0 508 ; CHECK-NEXT: .short 4 509 ; CHECK-NEXT: .short 15 510 ; CHECK-NEXT: .short 0 511 ; CHECK-NEXT: .long 164 512 define void @clobberScratch(i32 %a) { 513 tail call void asm sideeffect "nopr %r0", "~{r2},~{r3},~{r4},~{r5},~{r6},~{r7},~{r8},~{r9},~{r10},~{r11},~{r12},~{r13},~{r14}"() nounwind 514 tail call void (i64, i32, ...) @llvm.experimental.stackmap(i64 16, i32 8, i32 %a) 515 ret void 516 } 517 518 ; A stack frame which needs to be realigned at runtime (to meet alignment 519 ; criteria for values on the stack) does not have a fixed frame size. 520 ; CHECK: .long .L{{.*}}-needsStackRealignment 521 ; CHECK-NEXT: .short 0 522 ; 0 locations 523 ; CHECK-NEXT: .short 0 524 define void @needsStackRealignment() { 525 %val = alloca i64, i32 3, align 128 526 tail call void (...) @escape_values(i64* %val) 527 ; Note: Adding any non-constant to the stackmap would fail because we 528 ; expected to be able to address off the frame pointer. In a realigned 529 ; frame, we must use the stack pointer instead. This is a separate bug. 530 tail call void (i64, i32, ...) @llvm.experimental.stackmap(i64 0, i32 0) 531 ret void 532 } 533 declare void @escape_values(...) 534 535 declare void @llvm.experimental.stackmap(i64, i32, ...) 536 declare void @llvm.experimental.patchpoint.void(i64, i32, i8*, i32, ...) 537 declare i64 @llvm.experimental.patchpoint.i64(i64, i32, i8*, i32, ...) 538
