llvm/test/CodeGen/SystemZ/stackmap.ll

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