llvm/test/CodeGen/AArch64/sme-vg-to-stack.ll

   1 ; RUN: llc -mtriple=aarch64-linux-gnu -mattr=+sve -mattr=+sme2 -verify-machineinstrs < %s | FileCheck %s
   2 ; RUN: llc -mtriple=aarch64-linux-gnu -mattr=+sve -mattr=+sme2 -frame-pointer=non-leaf -verify-machineinstrs < %s | FileCheck %s --check-prefix=FP-CHECK
   3 ; RUN: llc -mtriple=aarch64-linux-gnu -mattr=+sme2 -frame-pointer=non-leaf -verify-machineinstrs < %s | FileCheck %s --check-prefix=NO-SVE-CHECK
   4 ; RUN: llc -mtriple=aarch64-linux-gnu -mattr=+sve -mattr=+sme2 -verify-machineinstrs -enable-machine-outliner < %s | FileCheck %s --check-prefix=OUTLINER-CHECK
   5
   6 declare void @callee();
   7 declare void @fixed_callee(<4 x i32>);
   8 declare void @scalable_callee(<vscale x 2 x i64>);
   9
  10 declare void @streaming_callee() #0;
  11 declare void @streaming_callee_with_arg(i32) #0;
  12
  13 ; Simple example of a function with one call requiring a streaming mode change
  14 ;
  15 define void @vg_unwind_simple() #0 {
  16 ; CHECK-LABEL: vg_unwind_simple:
  17 ; CHECK:       // %bb.0:
  18 ; CHECK-NEXT:    stp d15, d14, [sp, #-80]! // 16-byte Folded Spill
  19 ; CHECK-NEXT:    .cfi_def_cfa_offset 80
  20 ; CHECK-NEXT:    cntd x9
  21 ; CHECK-NEXT:    stp d13, d12, [sp, #16] // 16-byte Folded Spill
  22 ; CHECK-NEXT:    stp d11, d10, [sp, #32] // 16-byte Folded Spill
  23 ; CHECK-NEXT:    stp d9, d8, [sp, #48] // 16-byte Folded Spill
  24 ; CHECK-NEXT:    stp x30, x9, [sp, #64] // 16-byte Folded Spill
  25 ; CHECK-NEXT:    .cfi_offset w30, -16
  26 ; CHECK-NEXT:    .cfi_offset b8, -24
  27 ; CHECK-NEXT:    .cfi_offset b9, -32
  28 ; CHECK-NEXT:    .cfi_offset b10, -40
  29 ; CHECK-NEXT:    .cfi_offset b11, -48
  30 ; CHECK-NEXT:    .cfi_offset b12, -56
  31 ; CHECK-NEXT:    .cfi_offset b13, -64
  32 ; CHECK-NEXT:    .cfi_offset b14, -72
  33 ; CHECK-NEXT:    .cfi_offset b15, -80
  34 ; CHECK-NEXT:    .cfi_offset vg, -8
  35 ; CHECK-NEXT:    smstop sm
  36 ; CHECK-NEXT:    bl callee
  37 ; CHECK-NEXT:    smstart sm
  38 ; CHECK-NEXT:    .cfi_restore vg
  39 ; CHECK-NEXT:    ldp d9, d8, [sp, #48] // 16-byte Folded Reload
  40 ; CHECK-NEXT:    ldr x30, [sp, #64] // 8-byte Folded Reload
  41 ; CHECK-NEXT:    ldp d11, d10, [sp, #32] // 16-byte Folded Reload
  42 ; CHECK-NEXT:    ldp d13, d12, [sp, #16] // 16-byte Folded Reload
  43 ; CHECK-NEXT:    ldp d15, d14, [sp], #80 // 16-byte Folded Reload
  44 ; CHECK-NEXT:    .cfi_def_cfa_offset 0
  45 ; CHECK-NEXT:    .cfi_restore w30
  46 ; CHECK-NEXT:    .cfi_restore b8
  47 ; CHECK-NEXT:    .cfi_restore b9
  48 ; CHECK-NEXT:    .cfi_restore b10
  49 ; CHECK-NEXT:    .cfi_restore b11
  50 ; CHECK-NEXT:    .cfi_restore b12
  51 ; CHECK-NEXT:    .cfi_restore b13
  52 ; CHECK-NEXT:    .cfi_restore b14
  53 ; CHECK-NEXT:    .cfi_restore b15
  54 ; CHECK-NEXT:    ret
  55 ;
  56 ; FP-CHECK-LABEL: vg_unwind_simple:
  57 ; FP-CHECK:       // %bb.0:
  58 ; FP-CHECK-NEXT:    stp d15, d14, [sp, #-96]! // 16-byte Folded Spill
  59 ; FP-CHECK-NEXT:    .cfi_def_cfa_offset 96
  60 ; FP-CHECK-NEXT:    cntd x9
  61 ; FP-CHECK-NEXT:    stp d13, d12, [sp, #16] // 16-byte Folded Spill
  62 ; FP-CHECK-NEXT:    stp d11, d10, [sp, #32] // 16-byte Folded Spill
  63 ; FP-CHECK-NEXT:    stp d9, d8, [sp, #48] // 16-byte Folded Spill
  64 ; FP-CHECK-NEXT:    stp x29, x30, [sp, #64] // 16-byte Folded Spill
  65 ; FP-CHECK-NEXT:    str x9, [sp, #80] // 8-byte Folded Spill
  66 ; FP-CHECK-NEXT:    add x29, sp, #64
  67 ; FP-CHECK-NEXT:    .cfi_def_cfa w29, 32
  68 ; FP-CHECK-NEXT:    .cfi_offset w30, -24
  69 ; FP-CHECK-NEXT:    .cfi_offset w29, -32
  70 ; FP-CHECK-NEXT:    .cfi_offset b8, -40
  71 ; FP-CHECK-NEXT:    .cfi_offset b9, -48
  72 ; FP-CHECK-NEXT:    .cfi_offset b10, -56
  73 ; FP-CHECK-NEXT:    .cfi_offset b11, -64
  74 ; FP-CHECK-NEXT:    .cfi_offset b12, -72
  75 ; FP-CHECK-NEXT:    .cfi_offset b13, -80
  76 ; FP-CHECK-NEXT:    .cfi_offset b14, -88
  77 ; FP-CHECK-NEXT:    .cfi_offset b15, -96
  78 ; FP-CHECK-NEXT:    .cfi_offset vg, -16
  79 ; FP-CHECK-NEXT:    smstop sm
  80 ; FP-CHECK-NEXT:    bl callee
  81 ; FP-CHECK-NEXT:    smstart sm
  82 ; FP-CHECK-NEXT:    .cfi_restore vg
  83 ; FP-CHECK-NEXT:    .cfi_def_cfa wsp, 96
  84 ; FP-CHECK-NEXT:    ldp x29, x30, [sp, #64] // 16-byte Folded Reload
  85 ; FP-CHECK-NEXT:    ldp d9, d8, [sp, #48] // 16-byte Folded Reload
  86 ; FP-CHECK-NEXT:    ldp d11, d10, [sp, #32] // 16-byte Folded Reload
  87 ; FP-CHECK-NEXT:    ldp d13, d12, [sp, #16] // 16-byte Folded Reload
  88 ; FP-CHECK-NEXT:    ldp d15, d14, [sp], #96 // 16-byte Folded Reload
  89 ; FP-CHECK-NEXT:    .cfi_def_cfa_offset 0
  90 ; FP-CHECK-NEXT:    .cfi_restore w30
  91 ; FP-CHECK-NEXT:    .cfi_restore w29
  92 ; FP-CHECK-NEXT:    .cfi_restore b8
  93 ; FP-CHECK-NEXT:    .cfi_restore b9
  94 ; FP-CHECK-NEXT:    .cfi_restore b10
  95 ; FP-CHECK-NEXT:    .cfi_restore b11
  96 ; FP-CHECK-NEXT:    .cfi_restore b12
  97 ; FP-CHECK-NEXT:    .cfi_restore b13
  98 ; FP-CHECK-NEXT:    .cfi_restore b14
  99 ; FP-CHECK-NEXT:    .cfi_restore b15
 100 ; FP-CHECK-NEXT:    ret
 101 ;
 102 ; OUTLINER-CHECK-LABEL: vg_unwind_simple:
 103 ; OUTLINER-CHECK-NOT: OUTLINED_FUNCTION_
 104 ;
 105   call void @callee();
 106   ret void;
 107 }
 108
 109 ; As above, with an extra register clobbered by the inline asm call which
 110 ; changes NeedsGapToAlignStack to false
 111 ;
 112 define void @vg_unwind_needs_gap() #0 {
 113 ; CHECK-LABEL: vg_unwind_needs_gap:
 114 ; CHECK:       // %bb.0:
 115 ; CHECK-NEXT:    stp d15, d14, [sp, #-96]! // 16-byte Folded Spill
 116 ; CHECK-NEXT:    .cfi_def_cfa_offset 96
 117 ; CHECK-NEXT:    cntd x9
 118 ; CHECK-NEXT:    stp d13, d12, [sp, #16] // 16-byte Folded Spill
 119 ; CHECK-NEXT:    stp d11, d10, [sp, #32] // 16-byte Folded Spill
 120 ; CHECK-NEXT:    stp d9, d8, [sp, #48] // 16-byte Folded Spill
 121 ; CHECK-NEXT:    stp x30, x9, [sp, #64] // 16-byte Folded Spill
 122 ; CHECK-NEXT:    str x20, [sp, #80] // 8-byte Folded Spill
 123 ; CHECK-NEXT:    .cfi_offset w20, -16
 124 ; CHECK-NEXT:    .cfi_offset w30, -32
 125 ; CHECK-NEXT:    .cfi_offset b8, -40
 126 ; CHECK-NEXT:    .cfi_offset b9, -48
 127 ; CHECK-NEXT:    .cfi_offset b10, -56
 128 ; CHECK-NEXT:    .cfi_offset b11, -64
 129 ; CHECK-NEXT:    .cfi_offset b12, -72
 130 ; CHECK-NEXT:    .cfi_offset b13, -80
 131 ; CHECK-NEXT:    .cfi_offset b14, -88
 132 ; CHECK-NEXT:    .cfi_offset b15, -96
 133 ; CHECK-NEXT:    //APP
 134 ; CHECK-NEXT:    //NO_APP
 135 ; CHECK-NEXT:    .cfi_offset vg, -24
 136 ; CHECK-NEXT:    smstop sm
 137 ; CHECK-NEXT:    bl callee
 138 ; CHECK-NEXT:    smstart sm
 139 ; CHECK-NEXT:    .cfi_restore vg
 140 ; CHECK-NEXT:    ldp d9, d8, [sp, #48] // 16-byte Folded Reload
 141 ; CHECK-NEXT:    ldr x20, [sp, #80] // 8-byte Folded Reload
 142 ; CHECK-NEXT:    ldp d11, d10, [sp, #32] // 16-byte Folded Reload
 143 ; CHECK-NEXT:    ldr x30, [sp, #64] // 8-byte Folded Reload
 144 ; CHECK-NEXT:    ldp d13, d12, [sp, #16] // 16-byte Folded Reload
 145 ; CHECK-NEXT:    ldp d15, d14, [sp], #96 // 16-byte Folded Reload
 146 ; CHECK-NEXT:    .cfi_def_cfa_offset 0
 147 ; CHECK-NEXT:    .cfi_restore w20
 148 ; CHECK-NEXT:    .cfi_restore w30
 149 ; CHECK-NEXT:    .cfi_restore b8
 150 ; CHECK-NEXT:    .cfi_restore b9
 151 ; CHECK-NEXT:    .cfi_restore b10
 152 ; CHECK-NEXT:    .cfi_restore b11
 153 ; CHECK-NEXT:    .cfi_restore b12
 154 ; CHECK-NEXT:    .cfi_restore b13
 155 ; CHECK-NEXT:    .cfi_restore b14
 156 ; CHECK-NEXT:    .cfi_restore b15
 157 ; CHECK-NEXT:    ret
 158 ;
 159 ; FP-CHECK-LABEL: vg_unwind_needs_gap:
 160 ; FP-CHECK:       // %bb.0:
 161 ; FP-CHECK-NEXT:    stp d15, d14, [sp, #-96]! // 16-byte Folded Spill
 162 ; FP-CHECK-NEXT:    .cfi_def_cfa_offset 96
 163 ; FP-CHECK-NEXT:    cntd x9
 164 ; FP-CHECK-NEXT:    stp d13, d12, [sp, #16] // 16-byte Folded Spill
 165 ; FP-CHECK-NEXT:    stp d11, d10, [sp, #32] // 16-byte Folded Spill
 166 ; FP-CHECK-NEXT:    stp d9, d8, [sp, #48] // 16-byte Folded Spill
 167 ; FP-CHECK-NEXT:    stp x29, x30, [sp, #64] // 16-byte Folded Spill
 168 ; FP-CHECK-NEXT:    stp x9, x20, [sp, #80] // 16-byte Folded Spill
 169 ; FP-CHECK-NEXT:    add x29, sp, #64
 170 ; FP-CHECK-NEXT:    .cfi_def_cfa w29, 32
 171 ; FP-CHECK-NEXT:    .cfi_offset w20, -8
 172 ; FP-CHECK-NEXT:    .cfi_offset w30, -24
 173 ; FP-CHECK-NEXT:    .cfi_offset w29, -32
 174 ; FP-CHECK-NEXT:    .cfi_offset b8, -40
 175 ; FP-CHECK-NEXT:    .cfi_offset b9, -48
 176 ; FP-CHECK-NEXT:    .cfi_offset b10, -56
 177 ; FP-CHECK-NEXT:    .cfi_offset b11, -64
 178 ; FP-CHECK-NEXT:    .cfi_offset b12, -72
 179 ; FP-CHECK-NEXT:    .cfi_offset b13, -80
 180 ; FP-CHECK-NEXT:    .cfi_offset b14, -88
 181 ; FP-CHECK-NEXT:    .cfi_offset b15, -96
 182 ; FP-CHECK-NEXT:    //APP
 183 ; FP-CHECK-NEXT:    //NO_APP
 184 ; FP-CHECK-NEXT:    .cfi_offset vg, -16
 185 ; FP-CHECK-NEXT:    smstop sm
 186 ; FP-CHECK-NEXT:    bl callee
 187 ; FP-CHECK-NEXT:    smstart sm
 188 ; FP-CHECK-NEXT:    .cfi_restore vg
 189 ; FP-CHECK-NEXT:    .cfi_def_cfa wsp, 96
 190 ; FP-CHECK-NEXT:    ldp x29, x30, [sp, #64] // 16-byte Folded Reload
 191 ; FP-CHECK-NEXT:    ldr x20, [sp, #88] // 8-byte Folded Reload
 192 ; FP-CHECK-NEXT:    ldp d9, d8, [sp, #48] // 16-byte Folded Reload
 193 ; FP-CHECK-NEXT:    ldp d11, d10, [sp, #32] // 16-byte Folded Reload
 194 ; FP-CHECK-NEXT:    ldp d13, d12, [sp, #16] // 16-byte Folded Reload
 195 ; FP-CHECK-NEXT:    ldp d15, d14, [sp], #96 // 16-byte Folded Reload
 196 ; FP-CHECK-NEXT:    .cfi_def_cfa_offset 0
 197 ; FP-CHECK-NEXT:    .cfi_restore w20
 198 ; FP-CHECK-NEXT:    .cfi_restore w30
 199 ; FP-CHECK-NEXT:    .cfi_restore w29
 200 ; FP-CHECK-NEXT:    .cfi_restore b8
 201 ; FP-CHECK-NEXT:    .cfi_restore b9
 202 ; FP-CHECK-NEXT:    .cfi_restore b10
 203 ; FP-CHECK-NEXT:    .cfi_restore b11
 204 ; FP-CHECK-NEXT:    .cfi_restore b12
 205 ; FP-CHECK-NEXT:    .cfi_restore b13
 206 ; FP-CHECK-NEXT:    .cfi_restore b14
 207 ; FP-CHECK-NEXT:    .cfi_restore b15
 208 ; FP-CHECK-NEXT:    ret
 209 ;
 210 ; OUTLINER-CHECK-LABEL: vg_unwind_needs_gap:
 211 ; OUTLINER-CHECK-NOT: OUTLINED_FUNCTION_
 212 ;
 213   call void asm sideeffect "", "~{x20}"()
 214   call void @callee();
 215   ret void;
 216 }
 217
 218 define void @vg_unwind_with_fixed_args(<4 x i32> %x) #0 {
 219 ; CHECK-LABEL: vg_unwind_with_fixed_args:
 220 ; CHECK:       // %bb.0:
 221 ; CHECK-NEXT:    sub sp, sp, #96
 222 ; CHECK-NEXT:    .cfi_def_cfa_offset 96
 223 ; CHECK-NEXT:    cntd x9
 224 ; CHECK-NEXT:    stp d15, d14, [sp, #16] // 16-byte Folded Spill
 225 ; CHECK-NEXT:    stp d13, d12, [sp, #32] // 16-byte Folded Spill
 226 ; CHECK-NEXT:    stp d11, d10, [sp, #48] // 16-byte Folded Spill
 227 ; CHECK-NEXT:    stp d9, d8, [sp, #64] // 16-byte Folded Spill
 228 ; CHECK-NEXT:    stp x30, x9, [sp, #80] // 16-byte Folded Spill
 229 ; CHECK-NEXT:    .cfi_offset w30, -16
 230 ; CHECK-NEXT:    .cfi_offset b8, -24
 231 ; CHECK-NEXT:    .cfi_offset b9, -32
 232 ; CHECK-NEXT:    .cfi_offset b10, -40
 233 ; CHECK-NEXT:    .cfi_offset b11, -48
 234 ; CHECK-NEXT:    .cfi_offset b12, -56
 235 ; CHECK-NEXT:    .cfi_offset b13, -64
 236 ; CHECK-NEXT:    .cfi_offset b14, -72
 237 ; CHECK-NEXT:    .cfi_offset b15, -80
 238 ; CHECK-NEXT:    str q0, [sp] // 16-byte Folded Spill
 239 ; CHECK-NEXT:    .cfi_offset vg, -8
 240 ; CHECK-NEXT:    smstop sm
 241 ; CHECK-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
 242 ; CHECK-NEXT:    bl fixed_callee
 243 ; CHECK-NEXT:    smstart sm
 244 ; CHECK-NEXT:    .cfi_restore vg
 245 ; CHECK-NEXT:    ldp d9, d8, [sp, #64] // 16-byte Folded Reload
 246 ; CHECK-NEXT:    ldr x30, [sp, #80] // 8-byte Folded Reload
 247 ; CHECK-NEXT:    ldp d11, d10, [sp, #48] // 16-byte Folded Reload
 248 ; CHECK-NEXT:    ldp d13, d12, [sp, #32] // 16-byte Folded Reload
 249 ; CHECK-NEXT:    ldp d15, d14, [sp, #16] // 16-byte Folded Reload
 250 ; CHECK-NEXT:    add sp, sp, #96
 251 ; CHECK-NEXT:    .cfi_def_cfa_offset 0
 252 ; CHECK-NEXT:    .cfi_restore w30
 253 ; CHECK-NEXT:    .cfi_restore b8
 254 ; CHECK-NEXT:    .cfi_restore b9
 255 ; CHECK-NEXT:    .cfi_restore b10
 256 ; CHECK-NEXT:    .cfi_restore b11
 257 ; CHECK-NEXT:    .cfi_restore b12
 258 ; CHECK-NEXT:    .cfi_restore b13
 259 ; CHECK-NEXT:    .cfi_restore b14
 260 ; CHECK-NEXT:    .cfi_restore b15
 261 ; CHECK-NEXT:    ret
 262 ;
 263 ; FP-CHECK-LABEL: vg_unwind_with_fixed_args:
 264 ; FP-CHECK:       // %bb.0:
 265 ; FP-CHECK-NEXT:    sub sp, sp, #112
 266 ; FP-CHECK-NEXT:    .cfi_def_cfa_offset 112
 267 ; FP-CHECK-NEXT:    cntd x9
 268 ; FP-CHECK-NEXT:    stp d15, d14, [sp, #16] // 16-byte Folded Spill
 269 ; FP-CHECK-NEXT:    stp d13, d12, [sp, #32] // 16-byte Folded Spill
 270 ; FP-CHECK-NEXT:    stp d11, d10, [sp, #48] // 16-byte Folded Spill
 271 ; FP-CHECK-NEXT:    stp d9, d8, [sp, #64] // 16-byte Folded Spill
 272 ; FP-CHECK-NEXT:    stp x29, x30, [sp, #80] // 16-byte Folded Spill
 273 ; FP-CHECK-NEXT:    str x9, [sp, #96] // 8-byte Folded Spill
 274 ; FP-CHECK-NEXT:    add x29, sp, #80
 275 ; FP-CHECK-NEXT:    .cfi_def_cfa w29, 32
 276 ; FP-CHECK-NEXT:    .cfi_offset w30, -24
 277 ; FP-CHECK-NEXT:    .cfi_offset w29, -32
 278 ; FP-CHECK-NEXT:    .cfi_offset b8, -40
 279 ; FP-CHECK-NEXT:    .cfi_offset b9, -48
 280 ; FP-CHECK-NEXT:    .cfi_offset b10, -56
 281 ; FP-CHECK-NEXT:    .cfi_offset b11, -64
 282 ; FP-CHECK-NEXT:    .cfi_offset b12, -72
 283 ; FP-CHECK-NEXT:    .cfi_offset b13, -80
 284 ; FP-CHECK-NEXT:    .cfi_offset b14, -88
 285 ; FP-CHECK-NEXT:    .cfi_offset b15, -96
 286 ; FP-CHECK-NEXT:    str q0, [sp] // 16-byte Folded Spill
 287 ; FP-CHECK-NEXT:    .cfi_offset vg, -16
 288 ; FP-CHECK-NEXT:    smstop sm
 289 ; FP-CHECK-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
 290 ; FP-CHECK-NEXT:    bl fixed_callee
 291 ; FP-CHECK-NEXT:    smstart sm
 292 ; FP-CHECK-NEXT:    .cfi_restore vg
 293 ; FP-CHECK-NEXT:    .cfi_def_cfa wsp, 112
 294 ; FP-CHECK-NEXT:    ldp x29, x30, [sp, #80] // 16-byte Folded Reload
 295 ; FP-CHECK-NEXT:    ldp d9, d8, [sp, #64] // 16-byte Folded Reload
 296 ; FP-CHECK-NEXT:    ldp d11, d10, [sp, #48] // 16-byte Folded Reload
 297 ; FP-CHECK-NEXT:    ldp d13, d12, [sp, #32] // 16-byte Folded Reload
 298 ; FP-CHECK-NEXT:    ldp d15, d14, [sp, #16] // 16-byte Folded Reload
 299 ; FP-CHECK-NEXT:    add sp, sp, #112
 300 ; FP-CHECK-NEXT:    .cfi_def_cfa_offset 0
 301 ; FP-CHECK-NEXT:    .cfi_restore w30
 302 ; FP-CHECK-NEXT:    .cfi_restore w29
 303 ; FP-CHECK-NEXT:    .cfi_restore b8
 304 ; FP-CHECK-NEXT:    .cfi_restore b9
 305 ; FP-CHECK-NEXT:    .cfi_restore b10
 306 ; FP-CHECK-NEXT:    .cfi_restore b11
 307 ; FP-CHECK-NEXT:    .cfi_restore b12
 308 ; FP-CHECK-NEXT:    .cfi_restore b13
 309 ; FP-CHECK-NEXT:    .cfi_restore b14
 310 ; FP-CHECK-NEXT:    .cfi_restore b15
 311 ; FP-CHECK-NEXT:    ret
 312 ;
 313 ; OUTLINER-CHECK-LABEL: vg_unwind_with_fixed_args:
 314 ; OUTLINER-CHECK-NOT: OUTLINED_FUNCTION_
 315 ;
 316   call void @fixed_callee(<4 x i32> %x);
 317   ret void;
 318 }
 319
 320 define void @vg_unwind_with_sve_args(<vscale x 2 x i64> %x) #0 {
 321 ; CHECK-LABEL: vg_unwind_with_sve_args:
 322 ; CHECK:       // %bb.0:
 323 ; CHECK-NEXT:    stp x29, x30, [sp, #-32]! // 16-byte Folded Spill
 324 ; CHECK-NEXT:    .cfi_def_cfa_offset 32
 325 ; CHECK-NEXT:    cntd x9
 326 ; CHECK-NEXT:    stp x9, x28, [sp, #16] // 16-byte Folded Spill
 327 ; CHECK-NEXT:    .cfi_offset w28, -8
 328 ; CHECK-NEXT:    .cfi_offset w30, -24
 329 ; CHECK-NEXT:    .cfi_offset w29, -32
 330 ; CHECK-NEXT:    addvl sp, sp, #-18
 331 ; CHECK-NEXT:    .cfi_escape 0x0f, 0x0d, 0x8f, 0x00, 0x11, 0x20, 0x22, 0x11, 0x90, 0x01, 0x92, 0x2e, 0x00, 0x1e, 0x22 // sp + 32 + 144 * VG
 332 ; CHECK-NEXT:    str p15, [sp, #4, mul vl] // 2-byte Folded Spill
 333 ; CHECK-NEXT:    str p14, [sp, #5, mul vl] // 2-byte Folded Spill
 334 ; CHECK-NEXT:    str p13, [sp, #6, mul vl] // 2-byte Folded Spill
 335 ; CHECK-NEXT:    str p12, [sp, #7, mul vl] // 2-byte Folded Spill
 336 ; CHECK-NEXT:    str p11, [sp, #8, mul vl] // 2-byte Folded Spill
 337 ; CHECK-NEXT:    str p10, [sp, #9, mul vl] // 2-byte Folded Spill
 338 ; CHECK-NEXT:    str p9, [sp, #10, mul vl] // 2-byte Folded Spill
 339 ; CHECK-NEXT:    str p8, [sp, #11, mul vl] // 2-byte Folded Spill
 340 ; CHECK-NEXT:    str p7, [sp, #12, mul vl] // 2-byte Folded Spill
 341 ; CHECK-NEXT:    str p6, [sp, #13, mul vl] // 2-byte Folded Spill
 342 ; CHECK-NEXT:    str p5, [sp, #14, mul vl] // 2-byte Folded Spill
 343 ; CHECK-NEXT:    str p4, [sp, #15, mul vl] // 2-byte Folded Spill
 344 ; CHECK-NEXT:    str z23, [sp, #2, mul vl] // 16-byte Folded Spill
 345 ; CHECK-NEXT:    str z22, [sp, #3, mul vl] // 16-byte Folded Spill
 346 ; CHECK-NEXT:    str z21, [sp, #4, mul vl] // 16-byte Folded Spill
 347 ; CHECK-NEXT:    str z20, [sp, #5, mul vl] // 16-byte Folded Spill
 348 ; CHECK-NEXT:    str z19, [sp, #6, mul vl] // 16-byte Folded Spill
 349 ; CHECK-NEXT:    str z18, [sp, #7, mul vl] // 16-byte Folded Spill
 350 ; CHECK-NEXT:    str z17, [sp, #8, mul vl] // 16-byte Folded Spill
 351 ; CHECK-NEXT:    str z16, [sp, #9, mul vl] // 16-byte Folded Spill
 352 ; CHECK-NEXT:    str z15, [sp, #10, mul vl] // 16-byte Folded Spill
 353 ; CHECK-NEXT:    str z14, [sp, #11, mul vl] // 16-byte Folded Spill
 354 ; CHECK-NEXT:    str z13, [sp, #12, mul vl] // 16-byte Folded Spill
 355 ; CHECK-NEXT:    str z12, [sp, #13, mul vl] // 16-byte Folded Spill
 356 ; CHECK-NEXT:    str z11, [sp, #14, mul vl] // 16-byte Folded Spill
 357 ; CHECK-NEXT:    str z10, [sp, #15, mul vl] // 16-byte Folded Spill
 358 ; CHECK-NEXT:    str z9, [sp, #16, mul vl] // 16-byte Folded Spill
 359 ; CHECK-NEXT:    str z8, [sp, #17, mul vl] // 16-byte Folded Spill
 360 ; CHECK-NEXT:    .cfi_escape 0x10, 0x48, 0x0a, 0x11, 0x60, 0x22, 0x11, 0x78, 0x92, 0x2e, 0x00, 0x1e, 0x22 // $d8 @ cfa - 32 - 8 * VG
 361 ; CHECK-NEXT:    .cfi_escape 0x10, 0x49, 0x0a, 0x11, 0x60, 0x22, 0x11, 0x70, 0x92, 0x2e, 0x00, 0x1e, 0x22 // $d9 @ cfa - 32 - 16 * VG
 362 ; CHECK-NEXT:    .cfi_escape 0x10, 0x4a, 0x0a, 0x11, 0x60, 0x22, 0x11, 0x68, 0x92, 0x2e, 0x00, 0x1e, 0x22 // $d10 @ cfa - 32 - 24 * VG
 363 ; CHECK-NEXT:    .cfi_escape 0x10, 0x4b, 0x0a, 0x11, 0x60, 0x22, 0x11, 0x60, 0x92, 0x2e, 0x00, 0x1e, 0x22 // $d11 @ cfa - 32 - 32 * VG
 364 ; CHECK-NEXT:    .cfi_escape 0x10, 0x4c, 0x0a, 0x11, 0x60, 0x22, 0x11, 0x58, 0x92, 0x2e, 0x00, 0x1e, 0x22 // $d12 @ cfa - 32 - 40 * VG
 365 ; CHECK-NEXT:    .cfi_escape 0x10, 0x4d, 0x0a, 0x11, 0x60, 0x22, 0x11, 0x50, 0x92, 0x2e, 0x00, 0x1e, 0x22 // $d13 @ cfa - 32 - 48 * VG
 366 ; CHECK-NEXT:    .cfi_escape 0x10, 0x4e, 0x0a, 0x11, 0x60, 0x22, 0x11, 0x48, 0x92, 0x2e, 0x00, 0x1e, 0x22 // $d14 @ cfa - 32 - 56 * VG
 367 ; CHECK-NEXT:    .cfi_escape 0x10, 0x4f, 0x0a, 0x11, 0x60, 0x22, 0x11, 0x40, 0x92, 0x2e, 0x00, 0x1e, 0x22 // $d15 @ cfa - 32 - 64 * VG
 368 ; CHECK-NEXT:    addvl sp, sp, #-1
 369 ; CHECK-NEXT:    .cfi_escape 0x0f, 0x0d, 0x8f, 0x00, 0x11, 0x20, 0x22, 0x11, 0x98, 0x01, 0x92, 0x2e, 0x00, 0x1e, 0x22 // sp + 32 + 152 * VG
 370 ; CHECK-NEXT:    str z0, [sp] // 16-byte Folded Spill
 371 ; CHECK-NEXT:    //APP
 372 ; CHECK-NEXT:    //NO_APP
 373 ; CHECK-NEXT:    .cfi_offset vg, -16
 374 ; CHECK-NEXT:    smstop sm
 375 ; CHECK-NEXT:    ldr z0, [sp] // 16-byte Folded Reload
 376 ; CHECK-NEXT:    bl scalable_callee
 377 ; CHECK-NEXT:    smstart sm
 378 ; CHECK-NEXT:    .cfi_restore vg
 379 ; CHECK-NEXT:    addvl sp, sp, #1
 380 ; CHECK-NEXT:    .cfi_escape 0x0f, 0x0d, 0x8f, 0x00, 0x11, 0x20, 0x22, 0x11, 0x90, 0x01, 0x92, 0x2e, 0x00, 0x1e, 0x22 // sp + 32 + 144 * VG
 381 ; CHECK-NEXT:    ldr z23, [sp, #2, mul vl] // 16-byte Folded Reload
 382 ; CHECK-NEXT:    ldr z22, [sp, #3, mul vl] // 16-byte Folded Reload
 383 ; CHECK-NEXT:    ldr z21, [sp, #4, mul vl] // 16-byte Folded Reload
 384 ; CHECK-NEXT:    ldr z20, [sp, #5, mul vl] // 16-byte Folded Reload
 385 ; CHECK-NEXT:    ldr z19, [sp, #6, mul vl] // 16-byte Folded Reload
 386 ; CHECK-NEXT:    ldr z18, [sp, #7, mul vl] // 16-byte Folded Reload
 387 ; CHECK-NEXT:    ldr z17, [sp, #8, mul vl] // 16-byte Folded Reload
 388 ; CHECK-NEXT:    ldr z16, [sp, #9, mul vl] // 16-byte Folded Reload
 389 ; CHECK-NEXT:    ldr z15, [sp, #10, mul vl] // 16-byte Folded Reload
 390 ; CHECK-NEXT:    ldr z14, [sp, #11, mul vl] // 16-byte Folded Reload
 391 ; CHECK-NEXT:    ldr z13, [sp, #12, mul vl] // 16-byte Folded Reload
 392 ; CHECK-NEXT:    ldr z12, [sp, #13, mul vl] // 16-byte Folded Reload
 393 ; CHECK-NEXT:    ldr z11, [sp, #14, mul vl] // 16-byte Folded Reload
 394 ; CHECK-NEXT:    ldr z10, [sp, #15, mul vl] // 16-byte Folded Reload
 395 ; CHECK-NEXT:    ldr z9, [sp, #16, mul vl] // 16-byte Folded Reload
 396 ; CHECK-NEXT:    ldr z8, [sp, #17, mul vl] // 16-byte Folded Reload
 397 ; CHECK-NEXT:    ldr p15, [sp, #4, mul vl] // 2-byte Folded Reload
 398 ; CHECK-NEXT:    ldr p14, [sp, #5, mul vl] // 2-byte Folded Reload
 399 ; CHECK-NEXT:    ldr p13, [sp, #6, mul vl] // 2-byte Folded Reload
 400 ; CHECK-NEXT:    ldr p12, [sp, #7, mul vl] // 2-byte Folded Reload
 401 ; CHECK-NEXT:    ldr p11, [sp, #8, mul vl] // 2-byte Folded Reload
 402 ; CHECK-NEXT:    ldr p10, [sp, #9, mul vl] // 2-byte Folded Reload
 403 ; CHECK-NEXT:    ldr p9, [sp, #10, mul vl] // 2-byte Folded Reload
 404 ; CHECK-NEXT:    ldr p8, [sp, #11, mul vl] // 2-byte Folded Reload
 405 ; CHECK-NEXT:    ldr p7, [sp, #12, mul vl] // 2-byte Folded Reload
 406 ; CHECK-NEXT:    ldr p6, [sp, #13, mul vl] // 2-byte Folded Reload
 407 ; CHECK-NEXT:    ldr p5, [sp, #14, mul vl] // 2-byte Folded Reload
 408 ; CHECK-NEXT:    ldr p4, [sp, #15, mul vl] // 2-byte Folded Reload
 409 ; CHECK-NEXT:    addvl sp, sp, #18
 410 ; CHECK-NEXT:    .cfi_def_cfa wsp, 32
 411 ; CHECK-NEXT:    .cfi_restore z8
 412 ; CHECK-NEXT:    .cfi_restore z9
 413 ; CHECK-NEXT:    .cfi_restore z10
 414 ; CHECK-NEXT:    .cfi_restore z11
 415 ; CHECK-NEXT:    .cfi_restore z12
 416 ; CHECK-NEXT:    .cfi_restore z13
 417 ; CHECK-NEXT:    .cfi_restore z14
 418 ; CHECK-NEXT:    .cfi_restore z15
 419 ; CHECK-NEXT:    ldr x28, [sp, #24] // 8-byte Folded Reload
 420 ; CHECK-NEXT:    ldp x29, x30, [sp], #32 // 16-byte Folded Reload
 421 ; CHECK-NEXT:    .cfi_def_cfa_offset 0
 422 ; CHECK-NEXT:    .cfi_restore w28
 423 ; CHECK-NEXT:    .cfi_restore w30
 424 ; CHECK-NEXT:    .cfi_restore w29
 425 ; CHECK-NEXT:    ret
 426 ;
 427 ; FP-CHECK-LABEL: vg_unwind_with_sve_args:
 428 ; FP-CHECK:       // %bb.0:
 429 ; FP-CHECK-NEXT:    stp x29, x30, [sp, #-48]! // 16-byte Folded Spill
 430 ; FP-CHECK-NEXT:    .cfi_def_cfa_offset 48
 431 ; FP-CHECK-NEXT:    cntd x9
 432 ; FP-CHECK-NEXT:    stp x28, x27, [sp, #32] // 16-byte Folded Spill
 433 ; FP-CHECK-NEXT:    str x9, [sp, #16] // 8-byte Folded Spill
 434 ; FP-CHECK-NEXT:    mov x29, sp
 435 ; FP-CHECK-NEXT:    .cfi_def_cfa w29, 48
 436 ; FP-CHECK-NEXT:    .cfi_offset w27, -8
 437 ; FP-CHECK-NEXT:    .cfi_offset w28, -16
 438 ; FP-CHECK-NEXT:    .cfi_offset w30, -40
 439 ; FP-CHECK-NEXT:    .cfi_offset w29, -48
 440 ; FP-CHECK-NEXT:    addvl sp, sp, #-18
 441 ; FP-CHECK-NEXT:    str p15, [sp, #4, mul vl] // 2-byte Folded Spill
 442 ; FP-CHECK-NEXT:    str p14, [sp, #5, mul vl] // 2-byte Folded Spill
 443 ; FP-CHECK-NEXT:    str p13, [sp, #6, mul vl] // 2-byte Folded Spill
 444 ; FP-CHECK-NEXT:    str p12, [sp, #7, mul vl] // 2-byte Folded Spill
 445 ; FP-CHECK-NEXT:    str p11, [sp, #8, mul vl] // 2-byte Folded Spill
 446 ; FP-CHECK-NEXT:    str p10, [sp, #9, mul vl] // 2-byte Folded Spill
 447 ; FP-CHECK-NEXT:    str p9, [sp, #10, mul vl] // 2-byte Folded Spill
 448 ; FP-CHECK-NEXT:    str p8, [sp, #11, mul vl] // 2-byte Folded Spill
 449 ; FP-CHECK-NEXT:    str p7, [sp, #12, mul vl] // 2-byte Folded Spill
 450 ; FP-CHECK-NEXT:    str p6, [sp, #13, mul vl] // 2-byte Folded Spill
 451 ; FP-CHECK-NEXT:    str p5, [sp, #14, mul vl] // 2-byte Folded Spill
 452 ; FP-CHECK-NEXT:    str p4, [sp, #15, mul vl] // 2-byte Folded Spill
 453 ; FP-CHECK-NEXT:    str z23, [sp, #2, mul vl] // 16-byte Folded Spill
 454 ; FP-CHECK-NEXT:    str z22, [sp, #3, mul vl] // 16-byte Folded Spill
 455 ; FP-CHECK-NEXT:    str z21, [sp, #4, mul vl] // 16-byte Folded Spill
 456 ; FP-CHECK-NEXT:    str z20, [sp, #5, mul vl] // 16-byte Folded Spill
 457 ; FP-CHECK-NEXT:    str z19, [sp, #6, mul vl] // 16-byte Folded Spill
 458 ; FP-CHECK-NEXT:    str z18, [sp, #7, mul vl] // 16-byte Folded Spill
 459 ; FP-CHECK-NEXT:    str z17, [sp, #8, mul vl] // 16-byte Folded Spill
 460 ; FP-CHECK-NEXT:    str z16, [sp, #9, mul vl] // 16-byte Folded Spill
 461 ; FP-CHECK-NEXT:    str z15, [sp, #10, mul vl] // 16-byte Folded Spill
 462 ; FP-CHECK-NEXT:    str z14, [sp, #11, mul vl] // 16-byte Folded Spill
 463 ; FP-CHECK-NEXT:    str z13, [sp, #12, mul vl] // 16-byte Folded Spill
 464 ; FP-CHECK-NEXT:    str z12, [sp, #13, mul vl] // 16-byte Folded Spill
 465 ; FP-CHECK-NEXT:    str z11, [sp, #14, mul vl] // 16-byte Folded Spill
 466 ; FP-CHECK-NEXT:    str z10, [sp, #15, mul vl] // 16-byte Folded Spill
 467 ; FP-CHECK-NEXT:    str z9, [sp, #16, mul vl] // 16-byte Folded Spill
 468 ; FP-CHECK-NEXT:    str z8, [sp, #17, mul vl] // 16-byte Folded Spill
 469 ; FP-CHECK-NEXT:    .cfi_escape 0x10, 0x48, 0x0a, 0x11, 0x50, 0x22, 0x11, 0x78, 0x92, 0x2e, 0x00, 0x1e, 0x22 // $d8 @ cfa - 48 - 8 * VG
 470 ; FP-CHECK-NEXT:    .cfi_escape 0x10, 0x49, 0x0a, 0x11, 0x50, 0x22, 0x11, 0x70, 0x92, 0x2e, 0x00, 0x1e, 0x22 // $d9 @ cfa - 48 - 16 * VG
 471 ; FP-CHECK-NEXT:    .cfi_escape 0x10, 0x4a, 0x0a, 0x11, 0x50, 0x22, 0x11, 0x68, 0x92, 0x2e, 0x00, 0x1e, 0x22 // $d10 @ cfa - 48 - 24 * VG
 472 ; FP-CHECK-NEXT:    .cfi_escape 0x10, 0x4b, 0x0a, 0x11, 0x50, 0x22, 0x11, 0x60, 0x92, 0x2e, 0x00, 0x1e, 0x22 // $d11 @ cfa - 48 - 32 * VG
 473 ; FP-CHECK-NEXT:    .cfi_escape 0x10, 0x4c, 0x0a, 0x11, 0x50, 0x22, 0x11, 0x58, 0x92, 0x2e, 0x00, 0x1e, 0x22 // $d12 @ cfa - 48 - 40 * VG
 474 ; FP-CHECK-NEXT:    .cfi_escape 0x10, 0x4d, 0x0a, 0x11, 0x50, 0x22, 0x11, 0x50, 0x92, 0x2e, 0x00, 0x1e, 0x22 // $d13 @ cfa - 48 - 48 * VG
 475 ; FP-CHECK-NEXT:    .cfi_escape 0x10, 0x4e, 0x0a, 0x11, 0x50, 0x22, 0x11, 0x48, 0x92, 0x2e, 0x00, 0x1e, 0x22 // $d14 @ cfa - 48 - 56 * VG
 476 ; FP-CHECK-NEXT:    .cfi_escape 0x10, 0x4f, 0x0a, 0x11, 0x50, 0x22, 0x11, 0x40, 0x92, 0x2e, 0x00, 0x1e, 0x22 // $d15 @ cfa - 48 - 64 * VG
 477 ; FP-CHECK-NEXT:    addvl sp, sp, #-1
 478 ; FP-CHECK-NEXT:    str z0, [x29, #-19, mul vl] // 16-byte Folded Spill
 479 ; FP-CHECK-NEXT:    //APP
 480 ; FP-CHECK-NEXT:    //NO_APP
 481 ; FP-CHECK-NEXT:    .cfi_offset vg, -32
 482 ; FP-CHECK-NEXT:    smstop sm
 483 ; FP-CHECK-NEXT:    ldr z0, [x29, #-19, mul vl] // 16-byte Folded Reload
 484 ; FP-CHECK-NEXT:    bl scalable_callee
 485 ; FP-CHECK-NEXT:    smstart sm
 486 ; FP-CHECK-NEXT:    .cfi_restore vg
 487 ; FP-CHECK-NEXT:    addvl sp, sp, #1
 488 ; FP-CHECK-NEXT:    ldr z23, [sp, #2, mul vl] // 16-byte Folded Reload
 489 ; FP-CHECK-NEXT:    ldr z22, [sp, #3, mul vl] // 16-byte Folded Reload
 490 ; FP-CHECK-NEXT:    ldr z21, [sp, #4, mul vl] // 16-byte Folded Reload
 491 ; FP-CHECK-NEXT:    ldr z20, [sp, #5, mul vl] // 16-byte Folded Reload
 492 ; FP-CHECK-NEXT:    ldr z19, [sp, #6, mul vl] // 16-byte Folded Reload
 493 ; FP-CHECK-NEXT:    ldr z18, [sp, #7, mul vl] // 16-byte Folded Reload
 494 ; FP-CHECK-NEXT:    ldr z17, [sp, #8, mul vl] // 16-byte Folded Reload
 495 ; FP-CHECK-NEXT:    ldr z16, [sp, #9, mul vl] // 16-byte Folded Reload
 496 ; FP-CHECK-NEXT:    ldr z15, [sp, #10, mul vl] // 16-byte Folded Reload
 497 ; FP-CHECK-NEXT:    ldr z14, [sp, #11, mul vl] // 16-byte Folded Reload
 498 ; FP-CHECK-NEXT:    ldr z13, [sp, #12, mul vl] // 16-byte Folded Reload
 499 ; FP-CHECK-NEXT:    ldr z12, [sp, #13, mul vl] // 16-byte Folded Reload
 500 ; FP-CHECK-NEXT:    ldr z11, [sp, #14, mul vl] // 16-byte Folded Reload
 501 ; FP-CHECK-NEXT:    ldr z10, [sp, #15, mul vl] // 16-byte Folded Reload
 502 ; FP-CHECK-NEXT:    ldr z9, [sp, #16, mul vl] // 16-byte Folded Reload
 503 ; FP-CHECK-NEXT:    ldr z8, [sp, #17, mul vl] // 16-byte Folded Reload
 504 ; FP-CHECK-NEXT:    ldr p15, [sp, #4, mul vl] // 2-byte Folded Reload
 505 ; FP-CHECK-NEXT:    ldr p14, [sp, #5, mul vl] // 2-byte Folded Reload
 506 ; FP-CHECK-NEXT:    ldr p13, [sp, #6, mul vl] // 2-byte Folded Reload
 507 ; FP-CHECK-NEXT:    ldr p12, [sp, #7, mul vl] // 2-byte Folded Reload
 508 ; FP-CHECK-NEXT:    ldr p11, [sp, #8, mul vl] // 2-byte Folded Reload
 509 ; FP-CHECK-NEXT:    ldr p10, [sp, #9, mul vl] // 2-byte Folded Reload
 510 ; FP-CHECK-NEXT:    ldr p9, [sp, #10, mul vl] // 2-byte Folded Reload
 511 ; FP-CHECK-NEXT:    ldr p8, [sp, #11, mul vl] // 2-byte Folded Reload
 512 ; FP-CHECK-NEXT:    ldr p7, [sp, #12, mul vl] // 2-byte Folded Reload
 513 ; FP-CHECK-NEXT:    ldr p6, [sp, #13, mul vl] // 2-byte Folded Reload
 514 ; FP-CHECK-NEXT:    ldr p5, [sp, #14, mul vl] // 2-byte Folded Reload
 515 ; FP-CHECK-NEXT:    ldr p4, [sp, #15, mul vl] // 2-byte Folded Reload
 516 ; FP-CHECK-NEXT:    addvl sp, sp, #18
 517 ; FP-CHECK-NEXT:    .cfi_restore z8
 518 ; FP-CHECK-NEXT:    .cfi_restore z9
 519 ; FP-CHECK-NEXT:    .cfi_restore z10
 520 ; FP-CHECK-NEXT:    .cfi_restore z11
 521 ; FP-CHECK-NEXT:    .cfi_restore z12
 522 ; FP-CHECK-NEXT:    .cfi_restore z13
 523 ; FP-CHECK-NEXT:    .cfi_restore z14
 524 ; FP-CHECK-NEXT:    .cfi_restore z15
 525 ; FP-CHECK-NEXT:    .cfi_def_cfa wsp, 48
 526 ; FP-CHECK-NEXT:    ldp x28, x27, [sp, #32] // 16-byte Folded Reload
 527 ; FP-CHECK-NEXT:    ldp x29, x30, [sp], #48 // 16-byte Folded Reload
 528 ; FP-CHECK-NEXT:    .cfi_def_cfa_offset 0
 529 ; FP-CHECK-NEXT:    .cfi_restore w27
 530 ; FP-CHECK-NEXT:    .cfi_restore w28
 531 ; FP-CHECK-NEXT:    .cfi_restore w30
 532 ; FP-CHECK-NEXT:    .cfi_restore w29
 533 ; FP-CHECK-NEXT:    ret
 534 ;
 535 ; OUTLINER-CHECK-LABEL: vg_unwind_with_sve_args:
 536 ; OUTLINER-CHECK-NOT: OUTLINED_FUNCTION_
 537 ;
 538   call void asm sideeffect "", "~{x28}"()
 539   call void @scalable_callee(<vscale x 2 x i64> %x);
 540   ret void;
 541 }
 542
 543 ; This test was based on stack-probing-64k.ll and tries to test multiple uses of
 544 ; findScratchNonCalleeSaveRegister.
 545 ;
 546 define void @vg_unwind_multiple_scratch_regs(ptr %out) #1 {
 547 ; CHECK-LABEL: vg_unwind_multiple_scratch_regs:
 548 ; CHECK:       // %bb.0: // %entry
 549 ; CHECK-NEXT:    stp d15, d14, [sp, #-96]! // 16-byte Folded Spill
 550 ; CHECK-NEXT:    .cfi_def_cfa_offset 96
 551 ; CHECK-NEXT:    cntd x9
 552 ; CHECK-NEXT:    stp d13, d12, [sp, #16] // 16-byte Folded Spill
 553 ; CHECK-NEXT:    stp d11, d10, [sp, #32] // 16-byte Folded Spill
 554 ; CHECK-NEXT:    stp d9, d8, [sp, #48] // 16-byte Folded Spill
 555 ; CHECK-NEXT:    stp x29, x30, [sp, #64] // 16-byte Folded Spill
 556 ; CHECK-NEXT:    str x9, [sp, #80] // 8-byte Folded Spill
 557 ; CHECK-NEXT:    .cfi_offset w30, -24
 558 ; CHECK-NEXT:    .cfi_offset w29, -32
 559 ; CHECK-NEXT:    .cfi_offset b8, -40
 560 ; CHECK-NEXT:    .cfi_offset b9, -48
 561 ; CHECK-NEXT:    .cfi_offset b10, -56
 562 ; CHECK-NEXT:    .cfi_offset b11, -64
 563 ; CHECK-NEXT:    .cfi_offset b12, -72
 564 ; CHECK-NEXT:    .cfi_offset b13, -80
 565 ; CHECK-NEXT:    .cfi_offset b14, -88
 566 ; CHECK-NEXT:    .cfi_offset b15, -96
 567 ; CHECK-NEXT:    sub x9, sp, #80, lsl #12 // =327680
 568 ; CHECK-NEXT:    .cfi_def_cfa w9, 327776
 569 ; CHECK-NEXT:  .LBB4_1: // %entry
 570 ; CHECK-NEXT:    // =>This Inner Loop Header: Depth=1
 571 ; CHECK-NEXT:    sub sp, sp, #1, lsl #12 // =4096
 572 ; CHECK-NEXT:    cmp sp, x9
 573 ; CHECK-NEXT:    str xzr, [sp]
 574 ; CHECK-NEXT:    b.ne .LBB4_1
 575 ; CHECK-NEXT:  // %bb.2: // %entry
 576 ; CHECK-NEXT:    .cfi_def_cfa_register wsp
 577 ; CHECK-NEXT:    mov x8, sp
 578 ; CHECK-NEXT:    str x8, [x0]
 579 ; CHECK-NEXT:    .cfi_offset vg, -16
 580 ; CHECK-NEXT:    smstop sm
 581 ; CHECK-NEXT:    bl callee
 582 ; CHECK-NEXT:    smstart sm
 583 ; CHECK-NEXT:    .cfi_restore vg
 584 ; CHECK-NEXT:    add sp, sp, #80, lsl #12 // =327680
 585 ; CHECK-NEXT:    .cfi_def_cfa_offset 96
 586 ; CHECK-NEXT:    ldp x29, x30, [sp, #64] // 16-byte Folded Reload
 587 ; CHECK-NEXT:    ldp d9, d8, [sp, #48] // 16-byte Folded Reload
 588 ; CHECK-NEXT:    ldp d11, d10, [sp, #32] // 16-byte Folded Reload
 589 ; CHECK-NEXT:    ldp d13, d12, [sp, #16] // 16-byte Folded Reload
 590 ; CHECK-NEXT:    ldp d15, d14, [sp], #96 // 16-byte Folded Reload
 591 ; CHECK-NEXT:    .cfi_def_cfa_offset 0
 592 ; CHECK-NEXT:    .cfi_restore w30
 593 ; CHECK-NEXT:    .cfi_restore w29
 594 ; CHECK-NEXT:    .cfi_restore b8
 595 ; CHECK-NEXT:    .cfi_restore b9
 596 ; CHECK-NEXT:    .cfi_restore b10
 597 ; CHECK-NEXT:    .cfi_restore b11
 598 ; CHECK-NEXT:    .cfi_restore b12
 599 ; CHECK-NEXT:    .cfi_restore b13
 600 ; CHECK-NEXT:    .cfi_restore b14
 601 ; CHECK-NEXT:    .cfi_restore b15
 602 ; CHECK-NEXT:    ret
 603 ;
 604 ; FP-CHECK-LABEL: vg_unwind_multiple_scratch_regs:
 605 ; FP-CHECK:       // %bb.0: // %entry
 606 ; FP-CHECK-NEXT:    stp d15, d14, [sp, #-96]! // 16-byte Folded Spill
 607 ; FP-CHECK-NEXT:    .cfi_def_cfa_offset 96
 608 ; FP-CHECK-NEXT:    cntd x9
 609 ; FP-CHECK-NEXT:    stp d13, d12, [sp, #16] // 16-byte Folded Spill
 610 ; FP-CHECK-NEXT:    stp d11, d10, [sp, #32] // 16-byte Folded Spill
 611 ; FP-CHECK-NEXT:    stp d9, d8, [sp, #48] // 16-byte Folded Spill
 612 ; FP-CHECK-NEXT:    stp x29, x30, [sp, #64] // 16-byte Folded Spill
 613 ; FP-CHECK-NEXT:    stp x9, x28, [sp, #80] // 16-byte Folded Spill
 614 ; FP-CHECK-NEXT:    add x29, sp, #64
 615 ; FP-CHECK-NEXT:    .cfi_def_cfa w29, 32
 616 ; FP-CHECK-NEXT:    .cfi_offset w28, -8
 617 ; FP-CHECK-NEXT:    .cfi_offset w30, -24
 618 ; FP-CHECK-NEXT:    .cfi_offset w29, -32
 619 ; FP-CHECK-NEXT:    .cfi_offset b8, -40
 620 ; FP-CHECK-NEXT:    .cfi_offset b9, -48
 621 ; FP-CHECK-NEXT:    .cfi_offset b10, -56
 622 ; FP-CHECK-NEXT:    .cfi_offset b11, -64
 623 ; FP-CHECK-NEXT:    .cfi_offset b12, -72
 624 ; FP-CHECK-NEXT:    .cfi_offset b13, -80
 625 ; FP-CHECK-NEXT:    .cfi_offset b14, -88
 626 ; FP-CHECK-NEXT:    .cfi_offset b15, -96
 627 ; FP-CHECK-NEXT:    sub x9, sp, #80, lsl #12 // =327680
 628 ; FP-CHECK-NEXT:  .LBB4_1: // %entry
 629 ; FP-CHECK-NEXT:    // =>This Inner Loop Header: Depth=1
 630 ; FP-CHECK-NEXT:    sub sp, sp, #1, lsl #12 // =4096
 631 ; FP-CHECK-NEXT:    cmp sp, x9
 632 ; FP-CHECK-NEXT:    str xzr, [sp]
 633 ; FP-CHECK-NEXT:    b.ne .LBB4_1
 634 ; FP-CHECK-NEXT:  // %bb.2: // %entry
 635 ; FP-CHECK-NEXT:    mov x8, sp
 636 ; FP-CHECK-NEXT:    str x8, [x0]
 637 ; FP-CHECK-NEXT:    .cfi_offset vg, -16
 638 ; FP-CHECK-NEXT:    smstop sm
 639 ; FP-CHECK-NEXT:    bl callee
 640 ; FP-CHECK-NEXT:    smstart sm
 641 ; FP-CHECK-NEXT:    .cfi_restore vg
 642 ; FP-CHECK-NEXT:    add sp, sp, #80, lsl #12 // =327680
 643 ; FP-CHECK-NEXT:    .cfi_def_cfa wsp, 96
 644 ; FP-CHECK-NEXT:    ldp x29, x30, [sp, #64] // 16-byte Folded Reload
 645 ; FP-CHECK-NEXT:    ldr x28, [sp, #88] // 8-byte Folded Reload
 646 ; FP-CHECK-NEXT:    ldp d9, d8, [sp, #48] // 16-byte Folded Reload
 647 ; FP-CHECK-NEXT:    ldp d11, d10, [sp, #32] // 16-byte Folded Reload
 648 ; FP-CHECK-NEXT:    ldp d13, d12, [sp, #16] // 16-byte Folded Reload
 649 ; FP-CHECK-NEXT:    ldp d15, d14, [sp], #96 // 16-byte Folded Reload
 650 ; FP-CHECK-NEXT:    .cfi_def_cfa_offset 0
 651 ; FP-CHECK-NEXT:    .cfi_restore w28
 652 ; FP-CHECK-NEXT:    .cfi_restore w30
 653 ; FP-CHECK-NEXT:    .cfi_restore w29
 654 ; FP-CHECK-NEXT:    .cfi_restore b8
 655 ; FP-CHECK-NEXT:    .cfi_restore b9
 656 ; FP-CHECK-NEXT:    .cfi_restore b10
 657 ; FP-CHECK-NEXT:    .cfi_restore b11
 658 ; FP-CHECK-NEXT:    .cfi_restore b12
 659 ; FP-CHECK-NEXT:    .cfi_restore b13
 660 ; FP-CHECK-NEXT:    .cfi_restore b14
 661 ; FP-CHECK-NEXT:    .cfi_restore b15
 662 ; FP-CHECK-NEXT:    ret
 663 ;
 664 ; OUTLINER-CHECK-LABEL: vg_unwind_multiple_scratch_regs:
 665 ; OUTLINER-CHECK-NOT: OUTLINED_FUNCTION_
 666 ;
 667 entry:
 668   %v = alloca i8, i64 327680, align 1
 669   store ptr %v, ptr %out, align 8
 670   call void @callee()
 671   ret void
 672 }
 673
 674 ; Locally streaming functions require storing both the streaming and
 675 ; non-streaming values of VG.
 676 ;
 677 define void @vg_locally_streaming_fn() #3 {
 678 ; CHECK-LABEL: vg_locally_streaming_fn:
 679 ; CHECK:       // %bb.0:
 680 ; CHECK-NEXT:    stp d15, d14, [sp, #-96]! // 16-byte Folded Spill
 681 ; CHECK-NEXT:    .cfi_def_cfa_offset 96
 682 ; CHECK-NEXT:    rdsvl x9, #1
 683 ; CHECK-NEXT:    stp d13, d12, [sp, #16] // 16-byte Folded Spill
 684 ; CHECK-NEXT:    lsr x9, x9, #3
 685 ; CHECK-NEXT:    stp d11, d10, [sp, #32] // 16-byte Folded Spill
 686 ; CHECK-NEXT:    stp d9, d8, [sp, #48] // 16-byte Folded Spill
 687 ; CHECK-NEXT:    stp x30, x9, [sp, #64] // 16-byte Folded Spill
 688 ; CHECK-NEXT:    cntd x9
 689 ; CHECK-NEXT:    str x9, [sp, #80] // 8-byte Folded Spill
 690 ; CHECK-NEXT:    .cfi_offset vg, -16
 691 ; CHECK-NEXT:    .cfi_offset w30, -32
 692 ; CHECK-NEXT:    .cfi_offset b8, -40
 693 ; CHECK-NEXT:    .cfi_offset b9, -48
 694 ; CHECK-NEXT:    .cfi_offset b10, -56
 695 ; CHECK-NEXT:    .cfi_offset b11, -64
 696 ; CHECK-NEXT:    .cfi_offset b12, -72
 697 ; CHECK-NEXT:    .cfi_offset b13, -80
 698 ; CHECK-NEXT:    .cfi_offset b14, -88
 699 ; CHECK-NEXT:    .cfi_offset b15, -96
 700 ; CHECK-NEXT:    smstart sm
 701 ; CHECK-NEXT:    .cfi_offset vg, -24
 702 ; CHECK-NEXT:    smstop sm
 703 ; CHECK-NEXT:    bl callee
 704 ; CHECK-NEXT:    smstart sm
 705 ; CHECK-NEXT:    .cfi_restore vg
 706 ; CHECK-NEXT:    bl streaming_callee
 707 ; CHECK-NEXT:    .cfi_offset vg, -24
 708 ; CHECK-NEXT:    smstop sm
 709 ; CHECK-NEXT:    bl callee
 710 ; CHECK-NEXT:    smstart sm
 711 ; CHECK-NEXT:    .cfi_restore vg
 712 ; CHECK-NEXT:    smstop sm
 713 ; CHECK-NEXT:    ldp d9, d8, [sp, #48] // 16-byte Folded Reload
 714 ; CHECK-NEXT:    ldr x30, [sp, #64] // 8-byte Folded Reload
 715 ; CHECK-NEXT:    ldp d11, d10, [sp, #32] // 16-byte Folded Reload
 716 ; CHECK-NEXT:    ldp d13, d12, [sp, #16] // 16-byte Folded Reload
 717 ; CHECK-NEXT:    ldp d15, d14, [sp], #96 // 16-byte Folded Reload
 718 ; CHECK-NEXT:    .cfi_def_cfa_offset 0
 719 ; CHECK-NEXT:    .cfi_restore w30
 720 ; CHECK-NEXT:    .cfi_restore b8
 721 ; CHECK-NEXT:    .cfi_restore b9
 722 ; CHECK-NEXT:    .cfi_restore b10
 723 ; CHECK-NEXT:    .cfi_restore b11
 724 ; CHECK-NEXT:    .cfi_restore b12
 725 ; CHECK-NEXT:    .cfi_restore b13
 726 ; CHECK-NEXT:    .cfi_restore b14
 727 ; CHECK-NEXT:    .cfi_restore b15
 728 ; CHECK-NEXT:    ret
 729 ;
 730 ; FP-CHECK-LABEL: vg_locally_streaming_fn:
 731 ; FP-CHECK:       // %bb.0:
 732 ; FP-CHECK-NEXT:    stp d15, d14, [sp, #-96]! // 16-byte Folded Spill
 733 ; FP-CHECK-NEXT:    .cfi_def_cfa_offset 96
 734 ; FP-CHECK-NEXT:    rdsvl x9, #1
 735 ; FP-CHECK-NEXT:    stp d13, d12, [sp, #16] // 16-byte Folded Spill
 736 ; FP-CHECK-NEXT:    lsr x9, x9, #3
 737 ; FP-CHECK-NEXT:    stp d11, d10, [sp, #32] // 16-byte Folded Spill
 738 ; FP-CHECK-NEXT:    stp d9, d8, [sp, #48] // 16-byte Folded Spill
 739 ; FP-CHECK-NEXT:    str x9, [sp, #80] // 8-byte Folded Spill
 740 ; FP-CHECK-NEXT:    cntd x9
 741 ; FP-CHECK-NEXT:    stp x29, x30, [sp, #64] // 16-byte Folded Spill
 742 ; FP-CHECK-NEXT:    str x9, [sp, #88] // 8-byte Folded Spill
 743 ; FP-CHECK-NEXT:    add x29, sp, #64
 744 ; FP-CHECK-NEXT:    .cfi_def_cfa w29, 32
 745 ; FP-CHECK-NEXT:    .cfi_offset vg, -8
 746 ; FP-CHECK-NEXT:    .cfi_offset w30, -24
 747 ; FP-CHECK-NEXT:    .cfi_offset w29, -32
 748 ; FP-CHECK-NEXT:    .cfi_offset b8, -40
 749 ; FP-CHECK-NEXT:    .cfi_offset b9, -48
 750 ; FP-CHECK-NEXT:    .cfi_offset b10, -56
 751 ; FP-CHECK-NEXT:    .cfi_offset b11, -64
 752 ; FP-CHECK-NEXT:    .cfi_offset b12, -72
 753 ; FP-CHECK-NEXT:    .cfi_offset b13, -80
 754 ; FP-CHECK-NEXT:    .cfi_offset b14, -88
 755 ; FP-CHECK-NEXT:    .cfi_offset b15, -96
 756 ; FP-CHECK-NEXT:    smstart sm
 757 ; FP-CHECK-NEXT:    .cfi_offset vg, -16
 758 ; FP-CHECK-NEXT:    smstop sm
 759 ; FP-CHECK-NEXT:    bl callee
 760 ; FP-CHECK-NEXT:    smstart sm
 761 ; FP-CHECK-NEXT:    .cfi_restore vg
 762 ; FP-CHECK-NEXT:    bl streaming_callee
 763 ; FP-CHECK-NEXT:    .cfi_offset vg, -16
 764 ; FP-CHECK-NEXT:    smstop sm
 765 ; FP-CHECK-NEXT:    bl callee
 766 ; FP-CHECK-NEXT:    smstart sm
 767 ; FP-CHECK-NEXT:    .cfi_restore vg
 768 ; FP-CHECK-NEXT:    smstop sm
 769 ; FP-CHECK-NEXT:    .cfi_def_cfa wsp, 96
 770 ; FP-CHECK-NEXT:    ldp x29, x30, [sp, #64] // 16-byte Folded Reload
 771 ; FP-CHECK-NEXT:    ldp d9, d8, [sp, #48] // 16-byte Folded Reload
 772 ; FP-CHECK-NEXT:    ldp d11, d10, [sp, #32] // 16-byte Folded Reload
 773 ; FP-CHECK-NEXT:    ldp d13, d12, [sp, #16] // 16-byte Folded Reload
 774 ; FP-CHECK-NEXT:    ldp d15, d14, [sp], #96 // 16-byte Folded Reload
 775 ; FP-CHECK-NEXT:    .cfi_def_cfa_offset 0
 776 ; FP-CHECK-NEXT:    .cfi_restore w30
 777 ; FP-CHECK-NEXT:    .cfi_restore w29
 778 ; FP-CHECK-NEXT:    .cfi_restore b8
 779 ; FP-CHECK-NEXT:    .cfi_restore b9
 780 ; FP-CHECK-NEXT:    .cfi_restore b10
 781 ; FP-CHECK-NEXT:    .cfi_restore b11
 782 ; FP-CHECK-NEXT:    .cfi_restore b12
 783 ; FP-CHECK-NEXT:    .cfi_restore b13
 784 ; FP-CHECK-NEXT:    .cfi_restore b14
 785 ; FP-CHECK-NEXT:    .cfi_restore b15
 786 ; FP-CHECK-NEXT:    ret
 787 ;
 788 ; OUTLINER-CHECK-LABEL: vg_locally_streaming_fn:
 789 ; OUTLINER-CHECK-NOT: OUTLINED_FUNCTION_
 790 ;
 791   call void @callee()
 792   call void @streaming_callee()
 793   call void @callee()
 794   ret void
 795 }
 796
 797 define void @streaming_compatible_to_streaming() #4 {
 798 ; CHECK-LABEL: streaming_compatible_to_streaming:
 799 ; CHECK:       // %bb.0:
 800 ; CHECK-NEXT:    stp d15, d14, [sp, #-96]! // 16-byte Folded Spill
 801 ; CHECK-NEXT:    .cfi_def_cfa_offset 96
 802 ; CHECK-NEXT:    cntd x9
 803 ; CHECK-NEXT:    stp d13, d12, [sp, #16] // 16-byte Folded Spill
 804 ; CHECK-NEXT:    stp d11, d10, [sp, #32] // 16-byte Folded Spill
 805 ; CHECK-NEXT:    stp d9, d8, [sp, #48] // 16-byte Folded Spill
 806 ; CHECK-NEXT:    stp x30, x9, [sp, #64] // 16-byte Folded Spill
 807 ; CHECK-NEXT:    str x19, [sp, #80] // 8-byte Folded Spill
 808 ; CHECK-NEXT:    .cfi_offset w19, -16
 809 ; CHECK-NEXT:    .cfi_offset w30, -32
 810 ; CHECK-NEXT:    .cfi_offset b8, -40
 811 ; CHECK-NEXT:    .cfi_offset b9, -48
 812 ; CHECK-NEXT:    .cfi_offset b10, -56
 813 ; CHECK-NEXT:    .cfi_offset b11, -64
 814 ; CHECK-NEXT:    .cfi_offset b12, -72
 815 ; CHECK-NEXT:    .cfi_offset b13, -80
 816 ; CHECK-NEXT:    .cfi_offset b14, -88
 817 ; CHECK-NEXT:    .cfi_offset b15, -96
 818 ; CHECK-NEXT:    bl __arm_sme_state
 819 ; CHECK-NEXT:    and x19, x0, #0x1
 820 ; CHECK-NEXT:    .cfi_offset vg, -24
 821 ; CHECK-NEXT:    tbnz w19, #0, .LBB6_2
 822 ; CHECK-NEXT:  // %bb.1:
 823 ; CHECK-NEXT:    smstart sm
 824 ; CHECK-NEXT:  .LBB6_2:
 825 ; CHECK-NEXT:    bl streaming_callee
 826 ; CHECK-NEXT:    tbnz w19, #0, .LBB6_4
 827 ; CHECK-NEXT:  // %bb.3:
 828 ; CHECK-NEXT:    smstop sm
 829 ; CHECK-NEXT:  .LBB6_4:
 830 ; CHECK-NEXT:    .cfi_restore vg
 831 ; CHECK-NEXT:    ldp d9, d8, [sp, #48] // 16-byte Folded Reload
 832 ; CHECK-NEXT:    ldr x19, [sp, #80] // 8-byte Folded Reload
 833 ; CHECK-NEXT:    ldp d11, d10, [sp, #32] // 16-byte Folded Reload
 834 ; CHECK-NEXT:    ldr x30, [sp, #64] // 8-byte Folded Reload
 835 ; CHECK-NEXT:    ldp d13, d12, [sp, #16] // 16-byte Folded Reload
 836 ; CHECK-NEXT:    ldp d15, d14, [sp], #96 // 16-byte Folded Reload
 837 ; CHECK-NEXT:    .cfi_def_cfa_offset 0
 838 ; CHECK-NEXT:    .cfi_restore w19
 839 ; CHECK-NEXT:    .cfi_restore w30
 840 ; CHECK-NEXT:    .cfi_restore b8
 841 ; CHECK-NEXT:    .cfi_restore b9
 842 ; CHECK-NEXT:    .cfi_restore b10
 843 ; CHECK-NEXT:    .cfi_restore b11
 844 ; CHECK-NEXT:    .cfi_restore b12
 845 ; CHECK-NEXT:    .cfi_restore b13
 846 ; CHECK-NEXT:    .cfi_restore b14
 847 ; CHECK-NEXT:    .cfi_restore b15
 848 ; CHECK-NEXT:    ret
 849 ;
 850 ; FP-CHECK-LABEL: streaming_compatible_to_streaming:
 851 ; FP-CHECK:       // %bb.0:
 852 ; FP-CHECK-NEXT:    stp d15, d14, [sp, #-96]! // 16-byte Folded Spill
 853 ; FP-CHECK-NEXT:    .cfi_def_cfa_offset 96
 854 ; FP-CHECK-NEXT:    cntd x9
 855 ; FP-CHECK-NEXT:    stp d13, d12, [sp, #16] // 16-byte Folded Spill
 856 ; FP-CHECK-NEXT:    stp d11, d10, [sp, #32] // 16-byte Folded Spill
 857 ; FP-CHECK-NEXT:    stp d9, d8, [sp, #48] // 16-byte Folded Spill
 858 ; FP-CHECK-NEXT:    stp x29, x30, [sp, #64] // 16-byte Folded Spill
 859 ; FP-CHECK-NEXT:    stp x9, x19, [sp, #80] // 16-byte Folded Spill
 860 ; FP-CHECK-NEXT:    add x29, sp, #64
 861 ; FP-CHECK-NEXT:    .cfi_def_cfa w29, 32
 862 ; FP-CHECK-NEXT:    .cfi_offset w19, -8
 863 ; FP-CHECK-NEXT:    .cfi_offset w30, -24
 864 ; FP-CHECK-NEXT:    .cfi_offset w29, -32
 865 ; FP-CHECK-NEXT:    .cfi_offset b8, -40
 866 ; FP-CHECK-NEXT:    .cfi_offset b9, -48
 867 ; FP-CHECK-NEXT:    .cfi_offset b10, -56
 868 ; FP-CHECK-NEXT:    .cfi_offset b11, -64
 869 ; FP-CHECK-NEXT:    .cfi_offset b12, -72
 870 ; FP-CHECK-NEXT:    .cfi_offset b13, -80
 871 ; FP-CHECK-NEXT:    .cfi_offset b14, -88
 872 ; FP-CHECK-NEXT:    .cfi_offset b15, -96
 873 ; FP-CHECK-NEXT:    bl __arm_sme_state
 874 ; FP-CHECK-NEXT:    and x19, x0, #0x1
 875 ; FP-CHECK-NEXT:    .cfi_offset vg, -16
 876 ; FP-CHECK-NEXT:    tbnz w19, #0, .LBB6_2
 877 ; FP-CHECK-NEXT:  // %bb.1:
 878 ; FP-CHECK-NEXT:    smstart sm
 879 ; FP-CHECK-NEXT:  .LBB6_2:
 880 ; FP-CHECK-NEXT:    bl streaming_callee
 881 ; FP-CHECK-NEXT:    tbnz w19, #0, .LBB6_4
 882 ; FP-CHECK-NEXT:  // %bb.3:
 883 ; FP-CHECK-NEXT:    smstop sm
 884 ; FP-CHECK-NEXT:  .LBB6_4:
 885 ; FP-CHECK-NEXT:    .cfi_restore vg
 886 ; FP-CHECK-NEXT:    .cfi_def_cfa wsp, 96
 887 ; FP-CHECK-NEXT:    ldp x29, x30, [sp, #64] // 16-byte Folded Reload
 888 ; FP-CHECK-NEXT:    ldr x19, [sp, #88] // 8-byte Folded Reload
 889 ; FP-CHECK-NEXT:    ldp d9, d8, [sp, #48] // 16-byte Folded Reload
 890 ; FP-CHECK-NEXT:    ldp d11, d10, [sp, #32] // 16-byte Folded Reload
 891 ; FP-CHECK-NEXT:    ldp d13, d12, [sp, #16] // 16-byte Folded Reload
 892 ; FP-CHECK-NEXT:    ldp d15, d14, [sp], #96 // 16-byte Folded Reload
 893 ; FP-CHECK-NEXT:    .cfi_def_cfa_offset 0
 894 ; FP-CHECK-NEXT:    .cfi_restore w19
 895 ; FP-CHECK-NEXT:    .cfi_restore w30
 896 ; FP-CHECK-NEXT:    .cfi_restore w29
 897 ; FP-CHECK-NEXT:    .cfi_restore b8
 898 ; FP-CHECK-NEXT:    .cfi_restore b9
 899 ; FP-CHECK-NEXT:    .cfi_restore b10
 900 ; FP-CHECK-NEXT:    .cfi_restore b11
 901 ; FP-CHECK-NEXT:    .cfi_restore b12
 902 ; FP-CHECK-NEXT:    .cfi_restore b13
 903 ; FP-CHECK-NEXT:    .cfi_restore b14
 904 ; FP-CHECK-NEXT:    .cfi_restore b15
 905 ; FP-CHECK-NEXT:    ret
 906 ;
 907 ; OUTLINER-CHECK-LABEL: streaming_compatible_to_streaming:
 908 ; OUTLINER-CHECK-NOT: OUTLINED_FUNCTION_
 909 ;
 910   call void @streaming_callee()
 911   ret void
 912 }
 913
 914 define void @streaming_compatible_to_non_streaming() #4 {
 915 ; CHECK-LABEL: streaming_compatible_to_non_streaming:
 916 ; CHECK:       // %bb.0:
 917 ; CHECK-NEXT:    stp d15, d14, [sp, #-96]! // 16-byte Folded Spill
 918 ; CHECK-NEXT:    .cfi_def_cfa_offset 96
 919 ; CHECK-NEXT:    cntd x9
 920 ; CHECK-NEXT:    stp d13, d12, [sp, #16] // 16-byte Folded Spill
 921 ; CHECK-NEXT:    stp d11, d10, [sp, #32] // 16-byte Folded Spill
 922 ; CHECK-NEXT:    stp d9, d8, [sp, #48] // 16-byte Folded Spill
 923 ; CHECK-NEXT:    stp x30, x9, [sp, #64] // 16-byte Folded Spill
 924 ; CHECK-NEXT:    str x19, [sp, #80] // 8-byte Folded Spill
 925 ; CHECK-NEXT:    .cfi_offset w19, -16
 926 ; CHECK-NEXT:    .cfi_offset w30, -32
 927 ; CHECK-NEXT:    .cfi_offset b8, -40
 928 ; CHECK-NEXT:    .cfi_offset b9, -48
 929 ; CHECK-NEXT:    .cfi_offset b10, -56
 930 ; CHECK-NEXT:    .cfi_offset b11, -64
 931 ; CHECK-NEXT:    .cfi_offset b12, -72
 932 ; CHECK-NEXT:    .cfi_offset b13, -80
 933 ; CHECK-NEXT:    .cfi_offset b14, -88
 934 ; CHECK-NEXT:    .cfi_offset b15, -96
 935 ; CHECK-NEXT:    bl __arm_sme_state
 936 ; CHECK-NEXT:    and x19, x0, #0x1
 937 ; CHECK-NEXT:    .cfi_offset vg, -24
 938 ; CHECK-NEXT:    tbz w19, #0, .LBB7_2
 939 ; CHECK-NEXT:  // %bb.1:
 940 ; CHECK-NEXT:    smstop sm
 941 ; CHECK-NEXT:  .LBB7_2:
 942 ; CHECK-NEXT:    bl callee
 943 ; CHECK-NEXT:    tbz w19, #0, .LBB7_4
 944 ; CHECK-NEXT:  // %bb.3:
 945 ; CHECK-NEXT:    smstart sm
 946 ; CHECK-NEXT:  .LBB7_4:
 947 ; CHECK-NEXT:    .cfi_restore vg
 948 ; CHECK-NEXT:    ldp d9, d8, [sp, #48] // 16-byte Folded Reload
 949 ; CHECK-NEXT:    ldr x19, [sp, #80] // 8-byte Folded Reload
 950 ; CHECK-NEXT:    ldp d11, d10, [sp, #32] // 16-byte Folded Reload
 951 ; CHECK-NEXT:    ldr x30, [sp, #64] // 8-byte Folded Reload
 952 ; CHECK-NEXT:    ldp d13, d12, [sp, #16] // 16-byte Folded Reload
 953 ; CHECK-NEXT:    ldp d15, d14, [sp], #96 // 16-byte Folded Reload
 954 ; CHECK-NEXT:    .cfi_def_cfa_offset 0
 955 ; CHECK-NEXT:    .cfi_restore w19
 956 ; CHECK-NEXT:    .cfi_restore w30
 957 ; CHECK-NEXT:    .cfi_restore b8
 958 ; CHECK-NEXT:    .cfi_restore b9
 959 ; CHECK-NEXT:    .cfi_restore b10
 960 ; CHECK-NEXT:    .cfi_restore b11
 961 ; CHECK-NEXT:    .cfi_restore b12
 962 ; CHECK-NEXT:    .cfi_restore b13
 963 ; CHECK-NEXT:    .cfi_restore b14
 964 ; CHECK-NEXT:    .cfi_restore b15
 965 ; CHECK-NEXT:    ret
 966 ;
 967 ; FP-CHECK-LABEL: streaming_compatible_to_non_streaming:
 968 ; FP-CHECK:       // %bb.0:
 969 ; FP-CHECK-NEXT:    stp d15, d14, [sp, #-96]! // 16-byte Folded Spill
 970 ; FP-CHECK-NEXT:    .cfi_def_cfa_offset 96
 971 ; FP-CHECK-NEXT:    cntd x9
 972 ; FP-CHECK-NEXT:    stp d13, d12, [sp, #16] // 16-byte Folded Spill
 973 ; FP-CHECK-NEXT:    stp d11, d10, [sp, #32] // 16-byte Folded Spill
 974 ; FP-CHECK-NEXT:    stp d9, d8, [sp, #48] // 16-byte Folded Spill
 975 ; FP-CHECK-NEXT:    stp x29, x30, [sp, #64] // 16-byte Folded Spill
 976 ; FP-CHECK-NEXT:    stp x9, x19, [sp, #80] // 16-byte Folded Spill
 977 ; FP-CHECK-NEXT:    add x29, sp, #64
 978 ; FP-CHECK-NEXT:    .cfi_def_cfa w29, 32
 979 ; FP-CHECK-NEXT:    .cfi_offset w19, -8
 980 ; FP-CHECK-NEXT:    .cfi_offset w30, -24
 981 ; FP-CHECK-NEXT:    .cfi_offset w29, -32
 982 ; FP-CHECK-NEXT:    .cfi_offset b8, -40
 983 ; FP-CHECK-NEXT:    .cfi_offset b9, -48
 984 ; FP-CHECK-NEXT:    .cfi_offset b10, -56
 985 ; FP-CHECK-NEXT:    .cfi_offset b11, -64
 986 ; FP-CHECK-NEXT:    .cfi_offset b12, -72
 987 ; FP-CHECK-NEXT:    .cfi_offset b13, -80
 988 ; FP-CHECK-NEXT:    .cfi_offset b14, -88
 989 ; FP-CHECK-NEXT:    .cfi_offset b15, -96
 990 ; FP-CHECK-NEXT:    bl __arm_sme_state
 991 ; FP-CHECK-NEXT:    and x19, x0, #0x1
 992 ; FP-CHECK-NEXT:    .cfi_offset vg, -16
 993 ; FP-CHECK-NEXT:    tbz w19, #0, .LBB7_2
 994 ; FP-CHECK-NEXT:  // %bb.1:
 995 ; FP-CHECK-NEXT:    smstop sm
 996 ; FP-CHECK-NEXT:  .LBB7_2:
 997 ; FP-CHECK-NEXT:    bl callee
 998 ; FP-CHECK-NEXT:    tbz w19, #0, .LBB7_4
 999 ; FP-CHECK-NEXT:  // %bb.3:
1000 ; FP-CHECK-NEXT:    smstart sm
1001 ; FP-CHECK-NEXT:  .LBB7_4:
1002 ; FP-CHECK-NEXT:    .cfi_restore vg
1003 ; FP-CHECK-NEXT:    .cfi_def_cfa wsp, 96
1004 ; FP-CHECK-NEXT:    ldp x29, x30, [sp, #64] // 16-byte Folded Reload
1005 ; FP-CHECK-NEXT:    ldr x19, [sp, #88] // 8-byte Folded Reload
1006 ; FP-CHECK-NEXT:    ldp d9, d8, [sp, #48] // 16-byte Folded Reload
1007 ; FP-CHECK-NEXT:    ldp d11, d10, [sp, #32] // 16-byte Folded Reload
1008 ; FP-CHECK-NEXT:    ldp d13, d12, [sp, #16] // 16-byte Folded Reload
1009 ; FP-CHECK-NEXT:    ldp d15, d14, [sp], #96 // 16-byte Folded Reload
1010 ; FP-CHECK-NEXT:    .cfi_def_cfa_offset 0
1011 ; FP-CHECK-NEXT:    .cfi_restore w19
1012 ; FP-CHECK-NEXT:    .cfi_restore w30
1013 ; FP-CHECK-NEXT:    .cfi_restore w29
1014 ; FP-CHECK-NEXT:    .cfi_restore b8
1015 ; FP-CHECK-NEXT:    .cfi_restore b9
1016 ; FP-CHECK-NEXT:    .cfi_restore b10
1017 ; FP-CHECK-NEXT:    .cfi_restore b11
1018 ; FP-CHECK-NEXT:    .cfi_restore b12
1019 ; FP-CHECK-NEXT:    .cfi_restore b13
1020 ; FP-CHECK-NEXT:    .cfi_restore b14
1021 ; FP-CHECK-NEXT:    .cfi_restore b15
1022 ; FP-CHECK-NEXT:    ret
1023 ;
1024 ; OUTLINER-CHECK-LABEL: streaming_compatible_to_non_streaming:
1025 ; OUTLINER-CHECK-NOT: OUTLINED_FUNCTION_
1026 ;
1027   call void @callee()
1028   ret void
1029 }
1030
1031 ; If the target does not have SVE, do not emit cntd in the prologue and
1032 ; instead spill the result returned by __arm_get_current_vg.
1033 ; This requires preserving the argument %x as the vg value is returned
1034 ; in X0.
1035 ;
1036 define void @streaming_compatible_no_sve(i32 noundef %x) #4 {
1037 ; NO-SVE-CHECK-LABEL: streaming_compatible_no_sve:
1038 ; NO-SVE-CHECK:       // %bb.0:
1039 ; NO-SVE-CHECK-NEXT:    stp d15, d14, [sp, #-96]! // 16-byte Folded Spill
1040 ; NO-SVE-CHECK-NEXT:    .cfi_def_cfa_offset 96
1041 ; NO-SVE-CHECK-NEXT:    stp d13, d12, [sp, #16] // 16-byte Folded Spill
1042 ; NO-SVE-CHECK-NEXT:    mov x9, x0
1043 ; NO-SVE-CHECK-NEXT:    stp d11, d10, [sp, #32] // 16-byte Folded Spill
1044 ; NO-SVE-CHECK-NEXT:    stp d9, d8, [sp, #48] // 16-byte Folded Spill
1045 ; NO-SVE-CHECK-NEXT:    stp x29, x30, [sp, #64] // 16-byte Folded Spill
1046 ; NO-SVE-CHECK-NEXT:    bl __arm_get_current_vg
1047 ; NO-SVE-CHECK-NEXT:    stp x0, x19, [sp, #80] // 16-byte Folded Spill
1048 ; NO-SVE-CHECK-NEXT:    mov x0, x9
1049 ; NO-SVE-CHECK-NEXT:    add x29, sp, #64
1050 ; NO-SVE-CHECK-NEXT:    .cfi_def_cfa w29, 32
1051 ; NO-SVE-CHECK-NEXT:    .cfi_offset w19, -8
1052 ; NO-SVE-CHECK-NEXT:    .cfi_offset w30, -24
1053 ; NO-SVE-CHECK-NEXT:    .cfi_offset w29, -32
1054 ; NO-SVE-CHECK-NEXT:    .cfi_offset b8, -40
1055 ; NO-SVE-CHECK-NEXT:    .cfi_offset b9, -48
1056 ; NO-SVE-CHECK-NEXT:    .cfi_offset b10, -56
1057 ; NO-SVE-CHECK-NEXT:    .cfi_offset b11, -64
1058 ; NO-SVE-CHECK-NEXT:    .cfi_offset b12, -72
1059 ; NO-SVE-CHECK-NEXT:    .cfi_offset b13, -80
1060 ; NO-SVE-CHECK-NEXT:    .cfi_offset b14, -88
1061 ; NO-SVE-CHECK-NEXT:    .cfi_offset b15, -96
1062 ; NO-SVE-CHECK-NEXT:    mov w8, w0
1063 ; NO-SVE-CHECK-NEXT:    bl __arm_sme_state
1064 ; NO-SVE-CHECK-NEXT:    and x19, x0, #0x1
1065 ; NO-SVE-CHECK-NEXT:    .cfi_offset vg, -16
1066 ; NO-SVE-CHECK-NEXT:    tbnz w19, #0, .LBB8_2
1067 ; NO-SVE-CHECK-NEXT:  // %bb.1:
1068 ; NO-SVE-CHECK-NEXT:    smstart sm
1069 ; NO-SVE-CHECK-NEXT:  .LBB8_2:
1070 ; NO-SVE-CHECK-NEXT:    mov w0, w8
1071 ; NO-SVE-CHECK-NEXT:    bl streaming_callee_with_arg
1072 ; NO-SVE-CHECK-NEXT:    tbnz w19, #0, .LBB8_4
1073 ; NO-SVE-CHECK-NEXT:  // %bb.3:
1074 ; NO-SVE-CHECK-NEXT:    smstop sm
1075 ; NO-SVE-CHECK-NEXT:  .LBB8_4:
1076 ; NO-SVE-CHECK-NEXT:    .cfi_restore vg
1077 ; NO-SVE-CHECK-NEXT:    .cfi_def_cfa wsp, 96
1078 ; NO-SVE-CHECK-NEXT:    ldp x29, x30, [sp, #64] // 16-byte Folded Reload
1079 ; NO-SVE-CHECK-NEXT:    ldr x19, [sp, #88] // 8-byte Folded Reload
1080 ; NO-SVE-CHECK-NEXT:    ldp d9, d8, [sp, #48] // 16-byte Folded Reload
1081 ; NO-SVE-CHECK-NEXT:    ldp d11, d10, [sp, #32] // 16-byte Folded Reload
1082 ; NO-SVE-CHECK-NEXT:    ldp d13, d12, [sp, #16] // 16-byte Folded Reload
1083 ; NO-SVE-CHECK-NEXT:    ldp d15, d14, [sp], #96 // 16-byte Folded Reload
1084 ; NO-SVE-CHECK-NEXT:    .cfi_def_cfa_offset 0
1085 ; NO-SVE-CHECK-NEXT:    .cfi_restore w19
1086 ; NO-SVE-CHECK-NEXT:    .cfi_restore w30
1087 ; NO-SVE-CHECK-NEXT:    .cfi_restore w29
1088 ; NO-SVE-CHECK-NEXT:    .cfi_restore b8
1089 ; NO-SVE-CHECK-NEXT:    .cfi_restore b9
1090 ; NO-SVE-CHECK-NEXT:    .cfi_restore b10
1091 ; NO-SVE-CHECK-NEXT:    .cfi_restore b11
1092 ; NO-SVE-CHECK-NEXT:    .cfi_restore b12
1093 ; NO-SVE-CHECK-NEXT:    .cfi_restore b13
1094 ; NO-SVE-CHECK-NEXT:    .cfi_restore b14
1095 ; NO-SVE-CHECK-NEXT:    .cfi_restore b15
1096 ; NO-SVE-CHECK-NEXT:    ret
1097 ;
1098 ; OUTLINER-CHECK-LABEL: streaming_compatible_no_sve:
1099 ; OUTLINER-CHECK-NOT: OUTLINED_FUNCTION_
1100 ;
1101   call void @streaming_callee_with_arg(i32 %x)
1102   ret void
1103 }
1104
1105 ; Ensure we still emit async unwind information with -fno-asynchronous-unwind-tables
1106 ; if the function contains a streaming-mode change.
1107
1108 define void @vg_unwind_noasync() #5 {
1109 ; CHECK-LABEL: vg_unwind_noasync:
1110 ; CHECK:       // %bb.0:
1111 ; CHECK-NEXT:    stp d15, d14, [sp, #-80]! // 16-byte Folded Spill
1112 ; CHECK-NEXT:    .cfi_def_cfa_offset 80
1113 ; CHECK-NEXT:    cntd x9
1114 ; CHECK-NEXT:    stp d13, d12, [sp, #16] // 16-byte Folded Spill
1115 ; CHECK-NEXT:    stp d11, d10, [sp, #32] // 16-byte Folded Spill
1116 ; CHECK-NEXT:    stp d9, d8, [sp, #48] // 16-byte Folded Spill
1117 ; CHECK-NEXT:    stp x30, x9, [sp, #64] // 16-byte Folded Spill
1118 ; CHECK-NEXT:    .cfi_offset w30, -16
1119 ; CHECK-NEXT:    .cfi_offset b8, -24
1120 ; CHECK-NEXT:    .cfi_offset b9, -32
1121 ; CHECK-NEXT:    .cfi_offset b10, -40
1122 ; CHECK-NEXT:    .cfi_offset b11, -48
1123 ; CHECK-NEXT:    .cfi_offset b12, -56
1124 ; CHECK-NEXT:    .cfi_offset b13, -64
1125 ; CHECK-NEXT:    .cfi_offset b14, -72
1126 ; CHECK-NEXT:    .cfi_offset b15, -80
1127 ; CHECK-NEXT:    .cfi_offset vg, -8
1128 ; CHECK-NEXT:    smstop sm
1129 ; CHECK-NEXT:    bl callee
1130 ; CHECK-NEXT:    smstart sm
1131 ; CHECK-NEXT:    .cfi_restore vg
1132 ; CHECK-NEXT:    ldp d9, d8, [sp, #48] // 16-byte Folded Reload
1133 ; CHECK-NEXT:    ldr x30, [sp, #64] // 8-byte Folded Reload
1134 ; CHECK-NEXT:    ldp d11, d10, [sp, #32] // 16-byte Folded Reload
1135 ; CHECK-NEXT:    ldp d13, d12, [sp, #16] // 16-byte Folded Reload
1136 ; CHECK-NEXT:    ldp d15, d14, [sp], #80 // 16-byte Folded Reload
1137 ; CHECK-NEXT:    .cfi_def_cfa_offset 0
1138 ; CHECK-NEXT:    .cfi_restore w30
1139 ; CHECK-NEXT:    .cfi_restore b8
1140 ; CHECK-NEXT:    .cfi_restore b9
1141 ; CHECK-NEXT:    .cfi_restore b10
1142 ; CHECK-NEXT:    .cfi_restore b11
1143 ; CHECK-NEXT:    .cfi_restore b12
1144 ; CHECK-NEXT:    .cfi_restore b13
1145 ; CHECK-NEXT:    .cfi_restore b14
1146 ; CHECK-NEXT:    .cfi_restore b15
1147 ; CHECK-NEXT:    ret
1148 ;
1149 ; FP-CHECK-LABEL: vg_unwind_noasync:
1150 ; FP-CHECK:       // %bb.0:
1151 ; FP-CHECK-NEXT:    stp d15, d14, [sp, #-96]! // 16-byte Folded Spill
1152 ; FP-CHECK-NEXT:    .cfi_def_cfa_offset 96
1153 ; FP-CHECK-NEXT:    cntd x9
1154 ; FP-CHECK-NEXT:    stp d13, d12, [sp, #16] // 16-byte Folded Spill
1155 ; FP-CHECK-NEXT:    stp d11, d10, [sp, #32] // 16-byte Folded Spill
1156 ; FP-CHECK-NEXT:    stp d9, d8, [sp, #48] // 16-byte Folded Spill
1157 ; FP-CHECK-NEXT:    stp x29, x30, [sp, #64] // 16-byte Folded Spill
1158 ; FP-CHECK-NEXT:    str x9, [sp, #80] // 8-byte Folded Spill
1159 ; FP-CHECK-NEXT:    add x29, sp, #64
1160 ; FP-CHECK-NEXT:    .cfi_def_cfa w29, 32
1161 ; FP-CHECK-NEXT:    .cfi_offset w30, -24
1162 ; FP-CHECK-NEXT:    .cfi_offset w29, -32
1163 ; FP-CHECK-NEXT:    .cfi_offset b8, -40
1164 ; FP-CHECK-NEXT:    .cfi_offset b9, -48
1165 ; FP-CHECK-NEXT:    .cfi_offset b10, -56
1166 ; FP-CHECK-NEXT:    .cfi_offset b11, -64
1167 ; FP-CHECK-NEXT:    .cfi_offset b12, -72
1168 ; FP-CHECK-NEXT:    .cfi_offset b13, -80
1169 ; FP-CHECK-NEXT:    .cfi_offset b14, -88
1170 ; FP-CHECK-NEXT:    .cfi_offset b15, -96
1171 ; FP-CHECK-NEXT:    .cfi_offset vg, -16
1172 ; FP-CHECK-NEXT:    smstop sm
1173 ; FP-CHECK-NEXT:    bl callee
1174 ; FP-CHECK-NEXT:    smstart sm
1175 ; FP-CHECK-NEXT:    .cfi_restore vg
1176 ; FP-CHECK-NEXT:    .cfi_def_cfa wsp, 96
1177 ; FP-CHECK-NEXT:    ldp x29, x30, [sp, #64] // 16-byte Folded Reload
1178 ; FP-CHECK-NEXT:    ldp d9, d8, [sp, #48] // 16-byte Folded Reload
1179 ; FP-CHECK-NEXT:    ldp d11, d10, [sp, #32] // 16-byte Folded Reload
1180 ; FP-CHECK-NEXT:    ldp d13, d12, [sp, #16] // 16-byte Folded Reload
1181 ; FP-CHECK-NEXT:    ldp d15, d14, [sp], #96 // 16-byte Folded Reload
1182 ; FP-CHECK-NEXT:    .cfi_def_cfa_offset 0
1183 ; FP-CHECK-NEXT:    .cfi_restore w30
1184 ; FP-CHECK-NEXT:    .cfi_restore w29
1185 ; FP-CHECK-NEXT:    .cfi_restore b8
1186 ; FP-CHECK-NEXT:    .cfi_restore b9
1187 ; FP-CHECK-NEXT:    .cfi_restore b10
1188 ; FP-CHECK-NEXT:    .cfi_restore b11
1189 ; FP-CHECK-NEXT:    .cfi_restore b12
1190 ; FP-CHECK-NEXT:    .cfi_restore b13
1191 ; FP-CHECK-NEXT:    .cfi_restore b14
1192 ; FP-CHECK-NEXT:    .cfi_restore b15
1193 ; FP-CHECK-NEXT:    ret
1194 ; OUTLINER-CHECK-LABEL: vg_unwind_noasync:
1195 ; OUTLINER-CHECK-NOT: OUTLINED_FUNCTION_
1196 ;
1197   call void @callee();
1198   ret void;
1199 }
1200
1201 attributes #0 = { "aarch64_pstate_sm_enabled" uwtable(async) }
1202 attributes #1 = { "probe-stack"="inline-asm" "aarch64_pstate_sm_enabled" uwtable(async) }
1203 attributes #3 = { "aarch64_pstate_sm_body" uwtable(async) }
1204 attributes #4 = { "aarch64_pstate_sm_compatible" uwtable(async) }
1205 attributes #5 = { "aarch64_pstate_sm_enabled" }