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 144 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 177define void @constantargs() { 178entry: 179 %0 = inttoptr i64 12345 to i8* 180 tail call void (i64, i32, i8*, i32, ...) @llvm.experimental.patchpoint.void(i64 1, i32 16, 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, 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 201define void @osrinline(i64 %a, i64 %b) { 202entry: 203 ; Runtime void->void call. 204 call void inttoptr (i64 -559038737 to void ()*)() 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 229define void @osrcold(i64 %a, i64 %b) { 230entry: 231 %test = icmp slt i64 %a, %b 232 br i1 %test, label %ret, label %cold 233cold: 234 ; OSR patchpoint with 12-byte nop-slide and 2 live vars. 235 %thunk = inttoptr i64 3735928559 to i8* 236 call void (i64, i32, i8*, i32, ...) @llvm.experimental.patchpoint.void(i64 4, i32 16, i8* %thunk, i32 0, i64 %a, i64 %b) 237 unreachable 238ret: 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 258define i64 @propertyRead(i64* %obj) { 259entry: 260 %resolveRead = inttoptr i64 3735928559 to i8* 261 %result = call anyregcc i64 (i64, i32, i8*, i32, ...) @llvm.experimental.patchpoint.i64(i64 5, i32 16, i8* %resolveRead, i32 1, i64* %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 282define void @propertyWrite(i64 %dummy1, i64* %obj, i64 %dummy2, i64 %a) { 283entry: 284 %resolveWrite = inttoptr i64 3735928559 to i8* 285 call anyregcc void (i64, i32, i8*, i32, ...) @llvm.experimental.patchpoint.void(i64 6, i32 16, i8* %resolveWrite, i32 2, i64* %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 308define void @jsVoidCall(i64 %dummy1, i64* %obj, i64 %arg, i64 %l1, i64 %l2) { 309entry: 310 %resolveCall = inttoptr i64 3735928559 to i8* 311 call void (i64, i32, i8*, i32, ...) @llvm.experimental.patchpoint.void(i64 7, i32 16, i8* %resolveCall, i32 2, i64* %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 334define i64 @jsIntCall(i64 %dummy1, i64* %obj, i64 %arg, i64 %l1, i64 %l2) { 335entry: 336 %resolveCall = inttoptr i64 3735928559 to i8* 337 %result = call i64 (i64, i32, i8*, i32, ...) @llvm.experimental.patchpoint.i64(i64 8, i32 16, i8* %resolveCall, i32 2, i64* %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 358define 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) { 359entry: 360 call void (i64, i32, i8*, i32, ...) @llvm.experimental.patchpoint.void(i64 11, i32 20, 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, 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 380define 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) { 381entry: 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 400define 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 439define void @directFrameIdx() { 440entry: 441 %metadata1 = alloca i64, i32 3, align 8 442 store i64 11, i64* %metadata1 443 store i64 12, i64* %metadata1 444 store i64 13, i64* %metadata1 445 call void (i64, i32, ...) @llvm.experimental.stackmap(i64 16, i32 0, i64* %metadata1) 446 %metadata2 = alloca i8, i32 4, align 8 447 %metadata3 = alloca i16, i32 4, align 8 448 call void (i64, i32, i8*, i32, ...) @llvm.experimental.patchpoint.void(i64 17, i32 4, i8* null, i32 0, i8* %metadata2, i16* %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 462define void @longid() { 463entry: 464 tail call void (i64, i32, i8*, i32, ...) @llvm.experimental.patchpoint.void(i64 4294967295, i32 0, i8* null, i32 0) 465 tail call void (i64, i32, i8*, i32, ...) @llvm.experimental.patchpoint.void(i64 4294967296, i32 0, i8* null, i32 0) 466 tail call void (i64, i32, i8*, i32, ...) @llvm.experimental.patchpoint.void(i64 9223372036854775807, i32 0, i8* null, i32 0) 467 tail call void (i64, i32, i8*, i32, ...) @llvm.experimental.patchpoint.void(i64 -1, i32 0, i8* 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]+}} 485define 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 497define void @needsStackRealignment() { 498 %val = alloca i64, i32 3, align 128 499 tail call void (...) @escape_values(i64* %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} 506declare 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 -{{.*}} 554define 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, float* %ff, double* %gg) 559 ret void 560} 561 562declare void @llvm.experimental.stackmap(i64, i32, ...) 563declare void @llvm.experimental.patchpoint.void(i64, i32, i8*, i32, ...) 564declare i64 @llvm.experimental.patchpoint.i64(i64, i32, i8*, i32, ...) 565