llvm/test/CodeGen/AArch64/stackmap.ll

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