1; RUN: llc -mtriple=arm64-apple-darwin -mattr=+reserve-x18 < %s | FileCheck %s 2; RUN: llc -mtriple=arm64-apple-darwin -mattr=+reserve-x18 -fast-isel -fast-isel-abort=1 < %s | FileCheck %s 3; 4; Note: Print verbose stackmaps using -debug-only=stackmaps. 5 6; We are not getting the correct stack alignment when cross compiling for arm64. 7; So specify a datalayout here. 8target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" 9 10; CHECK-LABEL: .section __LLVM_STACKMAPS,__llvm_stackmaps 11; CHECK-NEXT: __LLVM_StackMaps: 12; Header 13; CHECK-NEXT: .byte 3 14; CHECK-NEXT: .byte 0 15; CHECK-NEXT: .short 0 16; Num Functions 17; CHECK-NEXT: .long 11 18; Num LargeConstants 19; CHECK-NEXT: .long 3 20; Num Callsites 21; CHECK-NEXT: .long 11 22 23; Functions and stack size 24; CHECK-NEXT: .quad _constantargs 25; CHECK-NEXT: .quad 16 26; CHECK-NEXT: .quad 1 27; CHECK-NEXT: .quad _osrinline 28; CHECK-NEXT: .quad 32 29; CHECK-NEXT: .quad 1 30; CHECK-NEXT: .quad _osrcold 31; CHECK-NEXT: .quad 16 32; CHECK-NEXT: .quad 1 33; CHECK-NEXT: .quad _propertyRead 34; CHECK-NEXT: .quad 16 35; CHECK-NEXT: .quad 1 36; CHECK-NEXT: .quad _propertyWrite 37; CHECK-NEXT: .quad 16 38; CHECK-NEXT: .quad 1 39; CHECK-NEXT: .quad _jsVoidCall 40; CHECK-NEXT: .quad 16 41; CHECK-NEXT: .quad 1 42; CHECK-NEXT: .quad _jsIntCall 43; CHECK-NEXT: .quad 16 44; CHECK-NEXT: .quad 1 45; CHECK-NEXT: .quad _spilledValue 46; CHECK-NEXT: .quad 160 47; CHECK-NEXT: .quad 1 48; CHECK-NEXT: .quad _spilledStackMapValue 49; CHECK-NEXT: .quad 128 50; CHECK-NEXT: .quad 1 51; CHECK-NEXT: .quad _liveConstant 52; CHECK-NEXT: .quad 16 53; CHECK-NEXT: .quad 1 54; CHECK-NEXT: .quad _clobberLR 55; CHECK-NEXT: .quad 112 56; CHECK-NEXT: .quad 1 57 58; Num LargeConstants 59; CHECK-NEXT: .quad 4294967295 60; CHECK-NEXT: .quad 4294967296 61; CHECK-NEXT: .quad 4294967297 62 63; Constant arguments 64; 65; CHECK-NEXT: .quad 1 66; CHECK-NEXT: .long L{{.*}}-_constantargs 67; CHECK-NEXT: .short 0 68; CHECK-NEXT: .short 6 69; SmallConstant 70; CHECK-NEXT: .byte 4 71; CHECK-NEXT: .byte 0 72; CHECK-NEXT: .short 8 73; CHECK-NEXT: .short 0 74; CHECK-NEXT: .short 0 75; CHECK-NEXT: .long 65535 76; SmallConstant 77; CHECK-NEXT: .byte 4 78; CHECK-NEXT: .byte 0 79; CHECK-NEXT: .short 8 80; CHECK-NEXT: .short 0 81; CHECK-NEXT: .short 0 82; CHECK-NEXT: .long 65536 83; LargeConstant at index 0 84; CHECK-NEXT: .byte 5 85; CHECK-NEXT: .byte 0 86; CHECK-NEXT: .short 8 87; CHECK-NEXT: .short 0 88; CHECK-NEXT: .short 0 89; CHECK-NEXT: .long 0 90; LargeConstant at index 1 91; CHECK-NEXT: .byte 5 92; CHECK-NEXT: .byte 0 93; CHECK-NEXT: .short 8 94; CHECK-NEXT: .short 0 95; CHECK-NEXT: .short 0 96; CHECK-NEXT: .long 1 97; SmallConstant 98; CHECK-NEXT: .byte 4 99; CHECK-NEXT: .byte 0 100; CHECK-NEXT: .short 8 101; CHECK-NEXT: .short 0 102; CHECK-NEXT: .short 0 103; CHECK-NEXT: .long 66 104; LargeConstant at index 2 105; CHECK-NEXT: .byte 5 106; CHECK-NEXT: .byte 0 107; CHECK-NEXT: .short 8 108; CHECK-NEXT: .short 0 109; CHECK-NEXT: .short 0 110; CHECK-NEXT: .long 2 111 112define void @constantargs() { 113entry: 114 %0 = inttoptr i64 244837814094590 to i8* 115 tail call void (i64, i32, i8*, i32, ...) @llvm.experimental.patchpoint.void(i64 1, i32 20, i8* %0, i32 0, i64 65535, i64 65536, i64 4294967295, i64 4294967296, i128 66, i128 4294967297) 116 ret void 117} 118 119; Inline OSR Exit 120; 121; CHECK-LABEL: .long L{{.*}}-_osrinline 122; CHECK-NEXT: .short 0 123; CHECK-NEXT: .short 2 124; CHECK-NEXT: .byte 1 125; CHECK-NEXT: .byte 0 126; CHECK-NEXT: .short 8 127; CHECK-NEXT: .short {{[0-9]+}} 128; CHECK-NEXT: .short 0 129; CHECK-NEXT: .long 0 130; CHECK-NEXT: .byte 1 131; CHECK-NEXT: .byte 0 132; CHECK-NEXT: .short 8 133; CHECK-NEXT: .short {{[0-9]+}} 134; CHECK-NEXT: .short 0 135; CHECK-NEXT: .long 0 136define void @osrinline(i64 %a, i64 %b) { 137entry: 138 ; Runtime void->void call. 139 call void inttoptr (i64 244837814094590 to void ()*)() 140 ; Followed by inline OSR patchpoint with 12-byte shadow and 2 live vars. 141 call void (i64, i32, ...) @llvm.experimental.stackmap(i64 3, i32 12, i64 %a, i64 %b) 142 ret void 143} 144 145; Cold OSR Exit 146; 147; 2 live variables in register. 148; 149; CHECK-LABEL: .long L{{.*}}-_osrcold 150; CHECK-NEXT: .short 0 151; CHECK-NEXT: .short 2 152; CHECK-NEXT: .byte 1 153; CHECK-NEXT: .byte 0 154; CHECK-NEXT: .short 8 155; CHECK-NEXT: .short {{[0-9]+}} 156; CHECK-NEXT: .short 0 157; CHECK-NEXT: .long 0 158; CHECK-NEXT: .byte 1 159; CHECK-NEXT: .byte 0 160; CHECK-NEXT: .short 8 161; CHECK-NEXT: .short {{[0-9]+}} 162; CHECK-NEXT: .short 0 163; CHECK-NEXT: .long 0 164define void @osrcold(i64 %a, i64 %b) { 165entry: 166 %test = icmp slt i64 %a, %b 167 br i1 %test, label %ret, label %cold 168cold: 169 ; OSR patchpoint with 12-byte nop-slide and 2 live vars. 170 %thunk = inttoptr i64 244837814094590 to i8* 171 call void (i64, i32, i8*, i32, ...) @llvm.experimental.patchpoint.void(i64 4, i32 20, i8* %thunk, i32 0, i64 %a, i64 %b) 172 unreachable 173ret: 174 ret void 175} 176 177; Property Read 178; CHECK-LABEL: .long L{{.*}}-_propertyRead 179; CHECK-NEXT: .short 0 180; CHECK-NEXT: .short 0 181; 182; FIXME: There are currently no stackmap entries. After moving to 183; AnyRegCC, we will have entries for the object and return value. 184define i64 @propertyRead(i64* %obj) { 185entry: 186 %resolveRead = inttoptr i64 244837814094590 to i8* 187 %result = call i64 (i64, i32, i8*, i32, ...) @llvm.experimental.patchpoint.i64(i64 5, i32 20, i8* %resolveRead, i32 1, i64* %obj) 188 %add = add i64 %result, 3 189 ret i64 %add 190} 191 192; Property Write 193; CHECK-LABEL: .long L{{.*}}-_propertyWrite 194; CHECK-NEXT: .short 0 195; CHECK-NEXT: .short 2 196; CHECK-NEXT: .byte 1 197; CHECK-NEXT: .byte 0 198; CHECK-NEXT: .short 8 199; CHECK-NEXT: .short {{[0-9]+}} 200; CHECK-NEXT: .short 0 201; CHECK-NEXT: .long 0 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 208define void @propertyWrite(i64 %dummy1, i64* %obj, i64 %dummy2, i64 %a) { 209entry: 210 %resolveWrite = inttoptr i64 244837814094590 to i8* 211 call anyregcc void (i64, i32, i8*, i32, ...) @llvm.experimental.patchpoint.void(i64 6, i32 20, i8* %resolveWrite, i32 2, i64* %obj, i64 %a) 212 ret void 213} 214 215; Void JS Call 216; 217; 2 live variables in registers. 218; 219; CHECK-LABEL: .long L{{.*}}-_jsVoidCall 220; CHECK-NEXT: .short 0 221; CHECK-NEXT: .short 2 222; CHECK-NEXT: .byte 1 223; CHECK-NEXT: .byte 0 224; CHECK-NEXT: .short 8 225; CHECK-NEXT: .short {{[0-9]+}} 226; CHECK-NEXT: .short 0 227; CHECK-NEXT: .long 0 228; CHECK-NEXT: .byte 1 229; CHECK-NEXT: .byte 0 230; CHECK-NEXT: .short 8 231; CHECK-NEXT: .short {{[0-9]+}} 232; CHECK-NEXT: .short 0 233; CHECK-NEXT: .long 0 234define void @jsVoidCall(i64 %dummy1, i64* %obj, i64 %arg, i64 %l1, i64 %l2) { 235entry: 236 %resolveCall = inttoptr i64 244837814094590 to i8* 237 call void (i64, i32, i8*, i32, ...) @llvm.experimental.patchpoint.void(i64 7, i32 20, i8* %resolveCall, i32 2, i64* %obj, i64 %arg, i64 %l1, i64 %l2) 238 ret void 239} 240 241; i64 JS Call 242; 243; 2 live variables in registers. 244; 245; CHECK-LABEL: .long L{{.*}}-_jsIntCall 246; CHECK-NEXT: .short 0 247; CHECK-NEXT: .short 2 248; CHECK-NEXT: .byte 1 249; CHECK-NEXT: .byte 0 250; CHECK-NEXT: .short 8 251; CHECK-NEXT: .short {{[0-9]+}} 252; CHECK-NEXT: .short 0 253; CHECK-NEXT: .long 0 254; CHECK-NEXT: .byte 1 255; CHECK-NEXT: .byte 0 256; CHECK-NEXT: .short 8 257; CHECK-NEXT: .short {{[0-9]+}} 258; CHECK-NEXT: .short 0 259; CHECK-NEXT: .long 0 260define i64 @jsIntCall(i64 %dummy1, i64* %obj, i64 %arg, i64 %l1, i64 %l2) { 261entry: 262 %resolveCall = inttoptr i64 244837814094590 to i8* 263 %result = call i64 (i64, i32, i8*, i32, ...) @llvm.experimental.patchpoint.i64(i64 8, i32 20, i8* %resolveCall, i32 2, i64* %obj, i64 %arg, i64 %l1, i64 %l2) 264 %add = add i64 %result, 3 265 ret i64 %add 266} 267 268; Spilled stack map values. 269; 270; Verify 28 stack map entries. 271; 272; CHECK-LABEL: .long L{{.*}}-_spilledValue 273; CHECK-NEXT: .short 0 274; CHECK-NEXT: .short 28 275; 276; Check that at least one is a spilled entry from RBP. 277; Location: Indirect FP + ... 278; CHECK: .byte 3 279; CHECK-NEXT: .byte 0 280; CHECK-NEXT: .short 281; CHECK-NEXT: .short 29 282; CHECK-NEXT: .short 0 283; CHECK-NEXT: .long 284define 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) { 285entry: 286 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) 287 ret void 288} 289 290; Spilled stack map values. 291; 292; Verify 23 stack map entries. 293; 294; CHECK-LABEL: .long L{{.*}}-_spilledStackMapValue 295; CHECK-NEXT: .short 0 296; CHECK-NEXT: .short 30 297; 298; Check that at least one is a spilled entry from RBP. 299; Location: Indirect FP + ... 300; CHECK: .byte 3 301; CHECK-NEXT: .byte 0 302; CHECK-NEXT: .short 303; CHECK-NEXT: .short 29 304; CHECK-NEXT: .short 0 305; CHECK-NEXT: .long 306define 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) { 307entry: 308 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) 309 ret void 310} 311 312 313; Map a constant value. 314; 315; CHECK-LABEL: .long L{{.*}}-_liveConstant 316; CHECK-NEXT: .short 0 317; 1 location 318; CHECK-NEXT: .short 1 319; Loc 0: SmallConstant 320; CHECK-NEXT: .byte 4 321; CHECK-NEXT: .byte 0 322; CHECK-NEXT: .short 8 323; CHECK-NEXT: .short 0 324; CHECK-NEXT: .short 0 325; CHECK-NEXT: .long 33 326 327define void @liveConstant() { 328 tail call void (i64, i32, ...) @llvm.experimental.stackmap(i64 15, i32 8, i32 33) 329 ret void 330} 331 332; Map a value when LR is the only free register. 333; 334; CHECK-LABEL: .long L{{.*}}-_clobberLR 335; CHECK-NEXT: .short 0 336; 1 location 337; CHECK-NEXT: .short 1 338; Loc 0: Indirect FP (r29) - offset 339; CHECK-NEXT: .byte 3 340; CHECK-NEXT: .byte 0 341; CHECK-NEXT: .short 4 342; CHECK-NEXT: .short 29 343; CHECK-NEXT: .short 0 344; CHECK-NEXT: .long -{{[0-9]+}} 345define void @clobberLR(i32 %a) { 346 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 347 tail call void (i64, i32, ...) @llvm.experimental.stackmap(i64 16, i32 8, i32 %a) 348 ret void 349} 350 351declare void @llvm.experimental.stackmap(i64, i32, ...) 352declare void @llvm.experimental.patchpoint.void(i64, i32, i8*, i32, ...) 353declare i64 @llvm.experimental.patchpoint.i64(i64, i32, i8*, i32, ...) 354