[llvm] [UpdateTestChecks][X86] Allow --no_x86_scrub_sp to disable folded stack spill/restore stack math scrubing (PR #221788)
Simon Pilgrim via llvm-commits
llvm-commits at lists.llvm.org
Mon Sep 7 22:51:47 PDT 2026
https://github.com/RKSimon updated https://github.com/llvm/llvm-project/pull/221788
>From 343358d2793d35393d94e66d1246509d677fc26e Mon Sep 17 00:00:00 2001
From: Simon Pilgrim <llvm-dev at redking.me.uk>
Date: Mon, 7 Sep 2026 18:00:53 +0100
Subject: [PATCH] [UpdateTestChecks][X86] Allow --no_x86_scrub_sp to disable
folded stack spill/restore scrubing
We were handling cases to show general load/store stack math, but had missed the r/w/rmw folded cases
---
llvm/test/CodeGen/X86/huge-stack.ll | 16 +-
llvm/test/CodeGen/X86/llvm.sincos.vec.ll | 108 ++++-----
llvm/test/CodeGen/X86/pr1505b.ll | 8 +-
llvm/test/CodeGen/X86/stack-align.ll | 8 +-
llvm/test/CodeGen/X86/subcarry.ll | 100 ++++-----
llvm/test/CodeGen/X86/swifterror.ll | 274 +++++++++++------------
llvm/test/CodeGen/X86/var-permute-128.ll | 8 +-
llvm/utils/UpdateTestChecks/asm.py | 6 +-
8 files changed, 264 insertions(+), 264 deletions(-)
diff --git a/llvm/test/CodeGen/X86/huge-stack.ll b/llvm/test/CodeGen/X86/huge-stack.ll
index 04cab8f010acc..0276abf07e166 100644
--- a/llvm/test/CodeGen/X86/huge-stack.ll
+++ b/llvm/test/CodeGen/X86/huge-stack.ll
@@ -36,21 +36,21 @@ define ptr @scavenge_spill() unnamed_addr #0 {
; CHECK-NEXT: leaq (%rsp,%rax), %rdi
; CHECK-NEXT: movabsq $17179869226, %rax # imm = 0x40000002A
; CHECK-NEXT: leaq (%rsp,%rax), %rsi
-; CHECK-NEXT: movq %rsi, {{[-0-9]+}}(%r{{[sb]}}p) # 8-byte Spill
+; CHECK-NEXT: movq %rsi, 8(%rsp) # 8-byte Spill
; CHECK-NEXT: movabsq $12884901931, %rax # imm = 0x30000002B
; CHECK-NEXT: leaq (%rsp,%rax), %rdx
-; CHECK-NEXT: movq %rdx, {{[-0-9]+}}(%r{{[sb]}}p) # 8-byte Spill
+; CHECK-NEXT: movq %rdx, 16(%rsp) # 8-byte Spill
; CHECK-NEXT: movabsq $8589934636, %rax # imm = 0x20000002C
; CHECK-NEXT: leaq (%rsp,%rax), %rcx
-; CHECK-NEXT: movq %rcx, {{[-0-9]+}}(%r{{[sb]}}p) # 8-byte Spill
+; CHECK-NEXT: movq %rcx, 24(%rsp) # 8-byte Spill
; CHECK-NEXT: callq baz at PLT
-; CHECK-NEXT: movq {{[-0-9]+}}(%r{{[sb]}}p), %rsi # 8-byte Reload
-; CHECK-NEXT: movq {{[-0-9]+}}(%r{{[sb]}}p), %rdx # 8-byte Reload
-; CHECK-NEXT: movq {{[-0-9]+}}(%r{{[sb]}}p), %rcx # 8-byte Reload
-; CHECK-NEXT: movq %rax, {{[-0-9]+}}(%r{{[sb]}}p) # 8-byte Spill
+; CHECK-NEXT: movq 8(%rsp), %rsi # 8-byte Reload
+; CHECK-NEXT: movq 16(%rsp), %rdx # 8-byte Reload
+; CHECK-NEXT: movq 24(%rsp), %rcx # 8-byte Reload
+; CHECK-NEXT: movq %rax, 32(%rsp) # 8-byte Spill
; CHECK-NEXT: leaq 46(%rsp), %rdi
; CHECK-NEXT: callq baz at PLT
-; CHECK-NEXT: movq {{[-0-9]+}}(%r{{[sb]}}p), %rax # 8-byte Reload
+; CHECK-NEXT: movq 32(%rsp), %rax # 8-byte Reload
; CHECK-NEXT: movabsq $25769803816, %rcx # imm = 0x600000028
; CHECK-NEXT: addq %rcx, %rsp
; CHECK-NEXT: .cfi_def_cfa_offset 8
diff --git a/llvm/test/CodeGen/X86/llvm.sincos.vec.ll b/llvm/test/CodeGen/X86/llvm.sincos.vec.ll
index 9b02438952035..01c9a938054a5 100644
--- a/llvm/test/CodeGen/X86/llvm.sincos.vec.ll
+++ b/llvm/test/CodeGen/X86/llvm.sincos.vec.ll
@@ -12,11 +12,11 @@ define void @test_sincos_v4f32(<4 x float> %x, ptr noalias %out_sin, ptr noalias
; X86-NEXT: subl $52, %esp
; X86-NEXT: movl 84(%esp), %esi
; X86-NEXT: flds 76(%esp)
-; X86-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; X86-NEXT: fstps 32(%esp) # 4-byte Folded Spill
; X86-NEXT: flds 64(%esp)
-; X86-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; X86-NEXT: fstps 28(%esp) # 4-byte Folded Spill
; X86-NEXT: flds 72(%esp)
-; X86-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Spill
+; X86-NEXT: fstps 24(%esp) # 4-byte Folded Spill
; X86-NEXT: flds 68(%esp)
; X86-NEXT: movl 80(%esp), %edi
; X86-NEXT: leal 40(%esp), %eax
@@ -29,20 +29,20 @@ define void @test_sincos_v4f32(<4 x float> %x, ptr noalias %out_sin, ptr noalias
; X86-NEXT: movl %eax, 8(%esp)
; X86-NEXT: leal 8(%edi), %eax
; X86-NEXT: movl %eax, 4(%esp)
-; X86-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; X86-NEXT: flds 24(%esp) # 4-byte Folded Reload
; X86-NEXT: fstps (%esp)
; X86-NEXT: calll sincosf
; X86-NEXT: leal 36(%esp), %eax
; X86-NEXT: movl %eax, 8(%esp)
; X86-NEXT: movl %edi, 4(%esp)
-; X86-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; X86-NEXT: flds 28(%esp) # 4-byte Folded Reload
; X86-NEXT: fstps (%esp)
; X86-NEXT: calll sincosf
; X86-NEXT: leal 48(%esp), %eax
; X86-NEXT: movl %eax, 8(%esp)
; X86-NEXT: addl $12, %edi
; X86-NEXT: movl %edi, 4(%esp)
-; X86-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Folded Reload
+; X86-NEXT: flds 32(%esp) # 4-byte Folded Reload
; X86-NEXT: fstps (%esp)
; X86-NEXT: calll sincosf
; X86-NEXT: flds 36(%esp)
@@ -65,21 +65,21 @@ define void @test_sincos_v4f32(<4 x float> %x, ptr noalias %out_sin, ptr noalias
; X64-NEXT: subq $56, %rsp
; X64-NEXT: movq %rsi, %rbx
; X64-NEXT: movq %rdi, %r14
-; X64-NEXT: movaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
+; X64-NEXT: movaps %xmm0, 32(%rsp) # 16-byte Spill
; X64-NEXT: shufps {{.*#+}} xmm0 = xmm0[3,3,3,3]
; X64-NEXT: leaq 4(%rsp), %rdi
; X64-NEXT: movq %rsp, %rsi
; X64-NEXT: callq sincosf at PLT
-; X64-NEXT: movaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
+; X64-NEXT: movaps 32(%rsp), %xmm0 # 16-byte Reload
; X64-NEXT: movhlps {{.*#+}} xmm0 = xmm0[1,1]
; X64-NEXT: leaq 12(%rsp), %rdi
; X64-NEXT: leaq 8(%rsp), %rsi
; X64-NEXT: callq sincosf at PLT
; X64-NEXT: leaq 28(%rsp), %rdi
; X64-NEXT: leaq 24(%rsp), %rsi
-; X64-NEXT: movaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
+; X64-NEXT: movaps 32(%rsp), %xmm0 # 16-byte Reload
; X64-NEXT: callq sincosf at PLT
-; X64-NEXT: movaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
+; X64-NEXT: movaps 32(%rsp), %xmm0 # 16-byte Reload
; X64-NEXT: shufps {{.*#+}} xmm0 = xmm0[1,1,1,1]
; X64-NEXT: leaq 20(%rsp), %rdi
; X64-NEXT: leaq 16(%rsp), %rsi
@@ -112,38 +112,38 @@ define void @test_sincos_v4f32(<4 x float> %x, ptr noalias %out_sin, ptr noalias
; MACOS-SINCOS-STRET-NEXT: subq $104, %rsp
; MACOS-SINCOS-STRET-NEXT: movq %rsi, %rbx
; MACOS-SINCOS-STRET-NEXT: movq %rdi, %r14
-; MACOS-SINCOS-STRET-NEXT: movaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) ## 16-byte Spill
+; MACOS-SINCOS-STRET-NEXT: movaps %xmm0, 16(%rsp) ## 16-byte Spill
; MACOS-SINCOS-STRET-NEXT: shufps {{.*#+}} xmm0 = xmm0[3,3,3,3]
; MACOS-SINCOS-STRET-NEXT: callq ___sincosf_stret
-; MACOS-SINCOS-STRET-NEXT: movaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) ## 16-byte Spill
+; MACOS-SINCOS-STRET-NEXT: movaps %xmm0, 80(%rsp) ## 16-byte Spill
; MACOS-SINCOS-STRET-NEXT: shufps {{.*#+}} xmm0 = xmm0[1,1,1,1]
; MACOS-SINCOS-STRET-NEXT: movaps %xmm0, (%rsp) ## 16-byte Spill
-; MACOS-SINCOS-STRET-NEXT: movaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 ## 16-byte Reload
+; MACOS-SINCOS-STRET-NEXT: movaps 16(%rsp), %xmm0 ## 16-byte Reload
; MACOS-SINCOS-STRET-NEXT: movhlps {{.*#+}} xmm0 = xmm0[1,1]
; MACOS-SINCOS-STRET-NEXT: callq ___sincosf_stret
-; MACOS-SINCOS-STRET-NEXT: movaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) ## 16-byte Spill
+; MACOS-SINCOS-STRET-NEXT: movaps %xmm0, 64(%rsp) ## 16-byte Spill
; MACOS-SINCOS-STRET-NEXT: shufps {{.*#+}} xmm0 = xmm0[1,1,1,1]
; MACOS-SINCOS-STRET-NEXT: unpcklps (%rsp), %xmm0 ## 16-byte Folded Reload
; MACOS-SINCOS-STRET-NEXT: ## xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
; MACOS-SINCOS-STRET-NEXT: movaps %xmm0, (%rsp) ## 16-byte Spill
-; MACOS-SINCOS-STRET-NEXT: movaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 ## 16-byte Reload
+; MACOS-SINCOS-STRET-NEXT: movaps 16(%rsp), %xmm0 ## 16-byte Reload
; MACOS-SINCOS-STRET-NEXT: callq ___sincosf_stret
-; MACOS-SINCOS-STRET-NEXT: movaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) ## 16-byte Spill
+; MACOS-SINCOS-STRET-NEXT: movaps %xmm0, 32(%rsp) ## 16-byte Spill
; MACOS-SINCOS-STRET-NEXT: movaps %xmm0, %xmm1
; MACOS-SINCOS-STRET-NEXT: shufps {{.*#+}} xmm1 = xmm1[1,1],xmm0[1,1]
-; MACOS-SINCOS-STRET-NEXT: movaps %xmm1, {{[-0-9]+}}(%r{{[sb]}}p) ## 16-byte Spill
-; MACOS-SINCOS-STRET-NEXT: movaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 ## 16-byte Reload
+; MACOS-SINCOS-STRET-NEXT: movaps %xmm1, 48(%rsp) ## 16-byte Spill
+; MACOS-SINCOS-STRET-NEXT: movaps 16(%rsp), %xmm0 ## 16-byte Reload
; MACOS-SINCOS-STRET-NEXT: shufps {{.*#+}} xmm0 = xmm0[1,1,1,1]
; MACOS-SINCOS-STRET-NEXT: callq ___sincosf_stret
-; MACOS-SINCOS-STRET-NEXT: movaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm1 ## 16-byte Reload
+; MACOS-SINCOS-STRET-NEXT: movaps 32(%rsp), %xmm1 ## 16-byte Reload
; MACOS-SINCOS-STRET-NEXT: unpcklps {{.*#+}} xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
; MACOS-SINCOS-STRET-NEXT: shufps {{.*#+}} xmm0 = xmm0[1,1,1,1]
-; MACOS-SINCOS-STRET-NEXT: movaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm2 ## 16-byte Reload
+; MACOS-SINCOS-STRET-NEXT: movaps 48(%rsp), %xmm2 ## 16-byte Reload
; MACOS-SINCOS-STRET-NEXT: unpcklps {{.*#+}} xmm2 = xmm2[0],xmm0[0],xmm2[1],xmm0[1]
; MACOS-SINCOS-STRET-NEXT: unpcklpd (%rsp), %xmm2 ## 16-byte Folded Reload
; MACOS-SINCOS-STRET-NEXT: ## xmm2 = xmm2[0],mem[0]
-; MACOS-SINCOS-STRET-NEXT: movaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 ## 16-byte Reload
-; MACOS-SINCOS-STRET-NEXT: unpcklps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 ## 16-byte Folded Reload
+; MACOS-SINCOS-STRET-NEXT: movaps 64(%rsp), %xmm0 ## 16-byte Reload
+; MACOS-SINCOS-STRET-NEXT: unpcklps 80(%rsp), %xmm0 ## 16-byte Folded Reload
; MACOS-SINCOS-STRET-NEXT: ## xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
; MACOS-SINCOS-STRET-NEXT: movlhps {{.*#+}} xmm1 = xmm1[0],xmm0[0]
; MACOS-SINCOS-STRET-NEXT: movups %xmm1, (%r14)
@@ -162,47 +162,47 @@ define void @test_sincos_v4f32(<4 x float> %x, ptr noalias %out_sin, ptr noalias
; MACOS-NOSINCOS-STRET-NEXT: movq %rdi, %r14
; MACOS-NOSINCOS-STRET-NEXT: movaps %xmm0, (%rsp) ## 16-byte Spill
; MACOS-NOSINCOS-STRET-NEXT: shufps {{.*#+}} xmm0 = xmm0[3,3,3,3]
-; MACOS-NOSINCOS-STRET-NEXT: movaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) ## 16-byte Spill
+; MACOS-NOSINCOS-STRET-NEXT: movaps %xmm0, 16(%rsp) ## 16-byte Spill
; MACOS-NOSINCOS-STRET-NEXT: callq _cosf
-; MACOS-NOSINCOS-STRET-NEXT: movaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) ## 16-byte Spill
+; MACOS-NOSINCOS-STRET-NEXT: movaps %xmm0, 32(%rsp) ## 16-byte Spill
; MACOS-NOSINCOS-STRET-NEXT: movaps (%rsp), %xmm0 ## 16-byte Reload
; MACOS-NOSINCOS-STRET-NEXT: movhlps {{.*#+}} xmm0 = xmm0[1,1]
-; MACOS-NOSINCOS-STRET-NEXT: movaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) ## 16-byte Spill
+; MACOS-NOSINCOS-STRET-NEXT: movaps %xmm0, 80(%rsp) ## 16-byte Spill
; MACOS-NOSINCOS-STRET-NEXT: callq _cosf
-; MACOS-NOSINCOS-STRET-NEXT: unpcklps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 ## 16-byte Folded Reload
+; MACOS-NOSINCOS-STRET-NEXT: unpcklps 32(%rsp), %xmm0 ## 16-byte Folded Reload
; MACOS-NOSINCOS-STRET-NEXT: ## xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
-; MACOS-NOSINCOS-STRET-NEXT: movaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) ## 16-byte Spill
+; MACOS-NOSINCOS-STRET-NEXT: movaps %xmm0, 48(%rsp) ## 16-byte Spill
; MACOS-NOSINCOS-STRET-NEXT: movaps (%rsp), %xmm0 ## 16-byte Reload
; MACOS-NOSINCOS-STRET-NEXT: callq _cosf
-; MACOS-NOSINCOS-STRET-NEXT: movaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) ## 16-byte Spill
+; MACOS-NOSINCOS-STRET-NEXT: movaps %xmm0, 32(%rsp) ## 16-byte Spill
; MACOS-NOSINCOS-STRET-NEXT: movaps (%rsp), %xmm0 ## 16-byte Reload
; MACOS-NOSINCOS-STRET-NEXT: shufps {{.*#+}} xmm0 = xmm0[1,1,1,1]
-; MACOS-NOSINCOS-STRET-NEXT: movaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) ## 16-byte Spill
+; MACOS-NOSINCOS-STRET-NEXT: movaps %xmm0, 64(%rsp) ## 16-byte Spill
; MACOS-NOSINCOS-STRET-NEXT: callq _cosf
-; MACOS-NOSINCOS-STRET-NEXT: movaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm1 ## 16-byte Reload
+; MACOS-NOSINCOS-STRET-NEXT: movaps 32(%rsp), %xmm1 ## 16-byte Reload
; MACOS-NOSINCOS-STRET-NEXT: unpcklps {{.*#+}} xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
-; MACOS-NOSINCOS-STRET-NEXT: unpcklpd {{[-0-9]+}}(%r{{[sb]}}p), %xmm1 ## 16-byte Folded Reload
+; MACOS-NOSINCOS-STRET-NEXT: unpcklpd 48(%rsp), %xmm1 ## 16-byte Folded Reload
; MACOS-NOSINCOS-STRET-NEXT: ## xmm1 = xmm1[0],mem[0]
-; MACOS-NOSINCOS-STRET-NEXT: movaps %xmm1, {{[-0-9]+}}(%r{{[sb]}}p) ## 16-byte Spill
-; MACOS-NOSINCOS-STRET-NEXT: movaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 ## 16-byte Reload
+; MACOS-NOSINCOS-STRET-NEXT: movaps %xmm1, 32(%rsp) ## 16-byte Spill
+; MACOS-NOSINCOS-STRET-NEXT: movaps 16(%rsp), %xmm0 ## 16-byte Reload
; MACOS-NOSINCOS-STRET-NEXT: callq _sinf
-; MACOS-NOSINCOS-STRET-NEXT: movaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) ## 16-byte Spill
-; MACOS-NOSINCOS-STRET-NEXT: movaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 ## 16-byte Reload
+; MACOS-NOSINCOS-STRET-NEXT: movaps %xmm0, 16(%rsp) ## 16-byte Spill
+; MACOS-NOSINCOS-STRET-NEXT: movaps 80(%rsp), %xmm0 ## 16-byte Reload
; MACOS-NOSINCOS-STRET-NEXT: callq _sinf
-; MACOS-NOSINCOS-STRET-NEXT: unpcklps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 ## 16-byte Folded Reload
+; MACOS-NOSINCOS-STRET-NEXT: unpcklps 16(%rsp), %xmm0 ## 16-byte Folded Reload
; MACOS-NOSINCOS-STRET-NEXT: ## xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
-; MACOS-NOSINCOS-STRET-NEXT: movaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) ## 16-byte Spill
+; MACOS-NOSINCOS-STRET-NEXT: movaps %xmm0, 16(%rsp) ## 16-byte Spill
; MACOS-NOSINCOS-STRET-NEXT: movaps (%rsp), %xmm0 ## 16-byte Reload
; MACOS-NOSINCOS-STRET-NEXT: callq _sinf
; MACOS-NOSINCOS-STRET-NEXT: movaps %xmm0, (%rsp) ## 16-byte Spill
-; MACOS-NOSINCOS-STRET-NEXT: movaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 ## 16-byte Reload
+; MACOS-NOSINCOS-STRET-NEXT: movaps 64(%rsp), %xmm0 ## 16-byte Reload
; MACOS-NOSINCOS-STRET-NEXT: callq _sinf
; MACOS-NOSINCOS-STRET-NEXT: movaps (%rsp), %xmm1 ## 16-byte Reload
; MACOS-NOSINCOS-STRET-NEXT: unpcklps {{.*#+}} xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
-; MACOS-NOSINCOS-STRET-NEXT: unpcklpd {{[-0-9]+}}(%r{{[sb]}}p), %xmm1 ## 16-byte Folded Reload
+; MACOS-NOSINCOS-STRET-NEXT: unpcklpd 16(%rsp), %xmm1 ## 16-byte Folded Reload
; MACOS-NOSINCOS-STRET-NEXT: ## xmm1 = xmm1[0],mem[0]
; MACOS-NOSINCOS-STRET-NEXT: movups %xmm1, (%r14)
-; MACOS-NOSINCOS-STRET-NEXT: movaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 ## 16-byte Reload
+; MACOS-NOSINCOS-STRET-NEXT: movaps 32(%rsp), %xmm0 ## 16-byte Reload
; MACOS-NOSINCOS-STRET-NEXT: movups %xmm0, (%rbx)
; MACOS-NOSINCOS-STRET-NEXT: addq $104, %rsp
; MACOS-NOSINCOS-STRET-NEXT: popq %rbx
@@ -224,7 +224,7 @@ define void @test_sincos_v2f64(<2 x double> %x, ptr noalias %out_sin, ptr noalia
; X86-NEXT: subl $52, %esp
; X86-NEXT: movl 84(%esp), %esi
; X86-NEXT: fldl 72(%esp)
-; X86-NEXT: fstpl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Spill
+; X86-NEXT: fstpl 44(%esp) # 8-byte Folded Spill
; X86-NEXT: fldl 64(%esp)
; X86-NEXT: movl 80(%esp), %edi
; X86-NEXT: leal 24(%esp), %eax
@@ -236,7 +236,7 @@ define void @test_sincos_v2f64(<2 x double> %x, ptr noalias %out_sin, ptr noalia
; X86-NEXT: movl %eax, 12(%esp)
; X86-NEXT: addl $8, %edi
; X86-NEXT: movl %edi, 8(%esp)
-; X86-NEXT: fldl {{[-0-9]+}}(%e{{[sb]}}p) # 8-byte Folded Reload
+; X86-NEXT: fldl 44(%esp) # 8-byte Folded Reload
; X86-NEXT: fstpl (%esp)
; X86-NEXT: calll sincos
; X86-NEXT: fldl 24(%esp)
@@ -255,11 +255,11 @@ define void @test_sincos_v2f64(<2 x double> %x, ptr noalias %out_sin, ptr noalia
; X64-NEXT: subq $56, %rsp
; X64-NEXT: movq %rsi, %rbx
; X64-NEXT: movq %rdi, %r14
-; X64-NEXT: movaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
+; X64-NEXT: movaps %xmm0, 32(%rsp) # 16-byte Spill
; X64-NEXT: leaq 24(%rsp), %rdi
; X64-NEXT: leaq 16(%rsp), %rsi
; X64-NEXT: callq sincos at PLT
-; X64-NEXT: movaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
+; X64-NEXT: movaps 32(%rsp), %xmm0 # 16-byte Reload
; X64-NEXT: movhlps {{.*#+}} xmm0 = xmm0[1,1]
; X64-NEXT: leaq 8(%rsp), %rdi
; X64-NEXT: movq %rsp, %rsi
@@ -284,14 +284,14 @@ define void @test_sincos_v2f64(<2 x double> %x, ptr noalias %out_sin, ptr noalia
; MACOS-SINCOS-STRET-NEXT: movq %rdi, %r14
; MACOS-SINCOS-STRET-NEXT: movaps %xmm0, (%rsp) ## 16-byte Spill
; MACOS-SINCOS-STRET-NEXT: callq ___sincos_stret
-; MACOS-SINCOS-STRET-NEXT: movaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) ## 16-byte Spill
-; MACOS-SINCOS-STRET-NEXT: movaps %xmm1, {{[-0-9]+}}(%r{{[sb]}}p) ## 16-byte Spill
+; MACOS-SINCOS-STRET-NEXT: movaps %xmm0, 32(%rsp) ## 16-byte Spill
+; MACOS-SINCOS-STRET-NEXT: movaps %xmm1, 16(%rsp) ## 16-byte Spill
; MACOS-SINCOS-STRET-NEXT: movaps (%rsp), %xmm0 ## 16-byte Reload
; MACOS-SINCOS-STRET-NEXT: movhlps {{.*#+}} xmm0 = xmm0[1,1]
; MACOS-SINCOS-STRET-NEXT: callq ___sincos_stret
-; MACOS-SINCOS-STRET-NEXT: movaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm2 ## 16-byte Reload
+; MACOS-SINCOS-STRET-NEXT: movaps 16(%rsp), %xmm2 ## 16-byte Reload
; MACOS-SINCOS-STRET-NEXT: movlhps {{.*#+}} xmm2 = xmm2[0],xmm1[0]
-; MACOS-SINCOS-STRET-NEXT: movaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm1 ## 16-byte Reload
+; MACOS-SINCOS-STRET-NEXT: movaps 32(%rsp), %xmm1 ## 16-byte Reload
; MACOS-SINCOS-STRET-NEXT: movlhps {{.*#+}} xmm1 = xmm1[0],xmm0[0]
; MACOS-SINCOS-STRET-NEXT: movups %xmm1, (%r14)
; MACOS-SINCOS-STRET-NEXT: movups %xmm2, (%rbx)
@@ -309,23 +309,23 @@ define void @test_sincos_v2f64(<2 x double> %x, ptr noalias %out_sin, ptr noalia
; MACOS-NOSINCOS-STRET-NEXT: movq %rdi, %r14
; MACOS-NOSINCOS-STRET-NEXT: movaps %xmm0, (%rsp) ## 16-byte Spill
; MACOS-NOSINCOS-STRET-NEXT: callq _cos
-; MACOS-NOSINCOS-STRET-NEXT: movaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) ## 16-byte Spill
+; MACOS-NOSINCOS-STRET-NEXT: movaps %xmm0, 16(%rsp) ## 16-byte Spill
; MACOS-NOSINCOS-STRET-NEXT: movaps (%rsp), %xmm0 ## 16-byte Reload
; MACOS-NOSINCOS-STRET-NEXT: movhlps {{.*#+}} xmm0 = xmm0[1,1]
-; MACOS-NOSINCOS-STRET-NEXT: movaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) ## 16-byte Spill
+; MACOS-NOSINCOS-STRET-NEXT: movaps %xmm0, 32(%rsp) ## 16-byte Spill
; MACOS-NOSINCOS-STRET-NEXT: callq _cos
-; MACOS-NOSINCOS-STRET-NEXT: movaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm1 ## 16-byte Reload
+; MACOS-NOSINCOS-STRET-NEXT: movaps 16(%rsp), %xmm1 ## 16-byte Reload
; MACOS-NOSINCOS-STRET-NEXT: movlhps {{.*#+}} xmm1 = xmm1[0],xmm0[0]
-; MACOS-NOSINCOS-STRET-NEXT: movaps %xmm1, {{[-0-9]+}}(%r{{[sb]}}p) ## 16-byte Spill
+; MACOS-NOSINCOS-STRET-NEXT: movaps %xmm1, 16(%rsp) ## 16-byte Spill
; MACOS-NOSINCOS-STRET-NEXT: movaps (%rsp), %xmm0 ## 16-byte Reload
; MACOS-NOSINCOS-STRET-NEXT: callq _sin
; MACOS-NOSINCOS-STRET-NEXT: movaps %xmm0, (%rsp) ## 16-byte Spill
-; MACOS-NOSINCOS-STRET-NEXT: movaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 ## 16-byte Reload
+; MACOS-NOSINCOS-STRET-NEXT: movaps 32(%rsp), %xmm0 ## 16-byte Reload
; MACOS-NOSINCOS-STRET-NEXT: callq _sin
; MACOS-NOSINCOS-STRET-NEXT: movaps (%rsp), %xmm1 ## 16-byte Reload
; MACOS-NOSINCOS-STRET-NEXT: movlhps {{.*#+}} xmm1 = xmm1[0],xmm0[0]
; MACOS-NOSINCOS-STRET-NEXT: movups %xmm1, (%r14)
-; MACOS-NOSINCOS-STRET-NEXT: movaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 ## 16-byte Reload
+; MACOS-NOSINCOS-STRET-NEXT: movaps 16(%rsp), %xmm0 ## 16-byte Reload
; MACOS-NOSINCOS-STRET-NEXT: movups %xmm0, (%rbx)
; MACOS-NOSINCOS-STRET-NEXT: addq $56, %rsp
; MACOS-NOSINCOS-STRET-NEXT: popq %rbx
diff --git a/llvm/test/CodeGen/X86/pr1505b.ll b/llvm/test/CodeGen/X86/pr1505b.ll
index b4e2d610ecdd0..4e2383da38789 100644
--- a/llvm/test/CodeGen/X86/pr1505b.ll
+++ b/llvm/test/CodeGen/X86/pr1505b.ll
@@ -38,18 +38,18 @@ define i32 @main() nounwind {
; CHECK-NEXT: flds _a
; CHECK-NEXT: fstps (%esp)
; CHECK-NEXT: calll _tanf
-; CHECK-NEXT: fstpl {{[-0-9]+}}(%e{{[sb]}}p) ## 8-byte Folded Spill
+; CHECK-NEXT: fstpl 24(%esp) ## 8-byte Folded Spill
; CHECK-NEXT: fldl _b
; CHECK-NEXT: fstpl (%esp)
; CHECK-NEXT: calll _tan
; CHECK-NEXT: fstps 20(%esp)
; CHECK-NEXT: flds 20(%esp)
-; CHECK-NEXT: fstpl {{[-0-9]+}}(%e{{[sb]}}p) ## 8-byte Folded Spill
+; CHECK-NEXT: fstpl 32(%esp) ## 8-byte Folded Spill
; CHECK-NEXT: movl L__ZSt4cout$non_lazy_ptr, %esi
; CHECK-NEXT: movl %esi, (%esp)
; CHECK-NEXT: movl $_.str, 4(%esp)
; CHECK-NEXT: calll __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc
-; CHECK-NEXT: fldl {{[-0-9]+}}(%e{{[sb]}}p) ## 8-byte Folded Reload
+; CHECK-NEXT: fldl 24(%esp) ## 8-byte Folded Reload
; CHECK-NEXT: fstpl 4(%esp)
; CHECK-NEXT: movl %eax, (%esp)
; CHECK-NEXT: calll __ZNSolsEd
@@ -58,7 +58,7 @@ define i32 @main() nounwind {
; CHECK-NEXT: movl %esi, (%esp)
; CHECK-NEXT: movl $_.str1, 4(%esp)
; CHECK-NEXT: calll __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc
-; CHECK-NEXT: fldl {{[-0-9]+}}(%e{{[sb]}}p) ## 8-byte Folded Reload
+; CHECK-NEXT: fldl 32(%esp) ## 8-byte Folded Reload
; CHECK-NEXT: fstpl 4(%esp)
; CHECK-NEXT: movl %eax, (%esp)
; CHECK-NEXT: calll __ZNSolsEd
diff --git a/llvm/test/CodeGen/X86/stack-align.ll b/llvm/test/CodeGen/X86/stack-align.ll
index 334a81787b84b..e229e31135d2a 100644
--- a/llvm/test/CodeGen/X86/stack-align.ll
+++ b/llvm/test/CodeGen/X86/stack-align.ll
@@ -57,11 +57,11 @@ define <2 x double> @test3(<2 x double> %x, <2 x double> %y) alignstack(32) noun
; CHECK-NEXT: movl %esp, %ebp
; CHECK-NEXT: andl $-32, %esp
; CHECK-NEXT: subl $64, %esp
-; CHECK-NEXT: movaps %xmm1, {{[-0-9]+}}(%e{{[sb]}}p) ## 16-byte Spill
-; CHECK-NEXT: movaps %xmm0, {{[-0-9]+}}(%e{{[sb]}}p) ## 16-byte Spill
+; CHECK-NEXT: movaps %xmm1, 32(%esp) ## 16-byte Spill
+; CHECK-NEXT: movaps %xmm0, 16(%esp) ## 16-byte Spill
; CHECK-NEXT: calll _test2
-; CHECK-NEXT: movapd {{[-0-9]+}}(%e{{[sb]}}p), %xmm0 ## 16-byte Reload
-; CHECK-NEXT: mulpd {{[-0-9]+}}(%e{{[sb]}}p), %xmm0 ## 16-byte Folded Reload
+; CHECK-NEXT: movapd 16(%esp), %xmm0 ## 16-byte Reload
+; CHECK-NEXT: mulpd 32(%esp), %xmm0 ## 16-byte Folded Reload
; CHECK-NEXT: movl %ebp, %esp
; CHECK-NEXT: popl %ebp
; CHECK-NEXT: retl
diff --git a/llvm/test/CodeGen/X86/subcarry.ll b/llvm/test/CodeGen/X86/subcarry.ll
index 32ac59763f997..ca6a623a2b8f3 100644
--- a/llvm/test/CodeGen/X86/subcarry.ll
+++ b/llvm/test/CodeGen/X86/subcarry.ll
@@ -122,10 +122,10 @@ define %S @negate(ptr nocapture readonly %this) nounwind {
; X86-NEXT: movl $0, (%esp) # 4-byte Folded Spill
; X86-NEXT: xorl %ecx, %ecx
; X86-NEXT: subl (%eax), %ecx
-; X86-NEXT: movl %ecx, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
+; X86-NEXT: movl %ecx, 8(%esp) # 4-byte Spill
; X86-NEXT: movl $0, %ecx
; X86-NEXT: sbbl 4(%eax), %ecx
-; X86-NEXT: movl %ecx, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
+; X86-NEXT: movl %ecx, 4(%esp) # 4-byte Spill
; X86-NEXT: movl $0, %edi
; X86-NEXT: sbbl 8(%eax), %edi
; X86-NEXT: movl $0, %ebx
@@ -140,9 +140,9 @@ define %S @negate(ptr nocapture readonly %this) nounwind {
; X86-NEXT: sbbl 28(%eax), %esi
; X86-NEXT: movl %esi, (%esp) # 4-byte Spill
; X86-NEXT: movl 32(%esp), %eax
-; X86-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %esi # 4-byte Reload
+; X86-NEXT: movl 8(%esp), %esi # 4-byte Reload
; X86-NEXT: movl %esi, (%eax)
-; X86-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %esi # 4-byte Reload
+; X86-NEXT: movl 4(%esp), %esi # 4-byte Reload
; X86-NEXT: movl %esi, 4(%eax)
; X86-NEXT: movl %edi, 8(%eax)
; X86-NEXT: movl %ebx, 12(%eax)
@@ -238,7 +238,7 @@ define %S @sub(ptr nocapture readonly %this, %S %arg.b) nounwind {
; X86-NEXT: movzbl %al, %edi
; X86-NEXT: addl $1, %esi
; X86-NEXT: adcl $0, %ecx
-; X86-NEXT: movl %ecx, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
+; X86-NEXT: movl %ecx, 4(%esp) # 4-byte Spill
; X86-NEXT: setb %cl
; X86-NEXT: movl %edi, %eax
; X86-NEXT: adcl $0, %eax
@@ -289,7 +289,7 @@ define %S @sub(ptr nocapture readonly %this, %S %arg.b) nounwind {
; X86-NEXT: adcl %eax, %edx
; X86-NEXT: movl 28(%esp), %eax
; X86-NEXT: movl %esi, (%eax)
-; X86-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %esi # 4-byte Reload
+; X86-NEXT: movl 4(%esp), %esi # 4-byte Reload
; X86-NEXT: movl %esi, 4(%eax)
; X86-NEXT: movl (%esp), %esi # 4-byte Reload
; X86-NEXT: movl %esi, 8(%eax)
@@ -831,61 +831,61 @@ define i32 @sub_U320_without_i128_or(ptr nocapture dereferenceable(40) %0, i64 %
; X86-NEXT: movl 8(%edi), %eax
; X86-NEXT: movl 12(%edi), %esi
; X86-NEXT: movl 20(%edi), %ecx
-; X86-NEXT: movl %ecx, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
+; X86-NEXT: movl %ecx, 4(%esp) # 4-byte Spill
; X86-NEXT: movl 16(%edi), %ecx
-; X86-NEXT: movl %ecx, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
+; X86-NEXT: movl %ecx, 12(%esp) # 4-byte Spill
; X86-NEXT: movl 28(%edi), %ecx
-; X86-NEXT: movl %ecx, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
+; X86-NEXT: movl %ecx, 8(%esp) # 4-byte Spill
; X86-NEXT: subl 60(%esp), %eax
; X86-NEXT: movl %eax, %ecx
; X86-NEXT: movl %esi, %eax
; X86-NEXT: sbbl 64(%esp), %eax
-; X86-NEXT: setb {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Folded Spill
+; X86-NEXT: setb 3(%esp) # 1-byte Folded Spill
; X86-NEXT: movl 24(%edi), %ebp
; X86-NEXT: movl 36(%edi), %edx
-; X86-NEXT: movl %edx, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
+; X86-NEXT: movl %edx, 16(%esp) # 4-byte Spill
; X86-NEXT: movl 32(%edi), %ebx
; X86-NEXT: movl 52(%esp), %edx
; X86-NEXT: subl %edx, (%edi)
; X86-NEXT: movl 56(%esp), %esi
; X86-NEXT: sbbl %esi, 4(%edi)
; X86-NEXT: sbbl $0, %ecx
-; X86-NEXT: movl %ecx, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
+; X86-NEXT: movl %ecx, 24(%esp) # 4-byte Spill
; X86-NEXT: sbbl $0, %eax
-; X86-NEXT: movl %eax, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
+; X86-NEXT: movl %eax, 20(%esp) # 4-byte Spill
; X86-NEXT: setb %dl
-; X86-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
+; X86-NEXT: movl 12(%esp), %eax # 4-byte Reload
; X86-NEXT: subl 68(%esp), %eax
-; X86-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %ecx # 4-byte Reload
+; X86-NEXT: movl 4(%esp), %ecx # 4-byte Reload
; X86-NEXT: sbbl 72(%esp), %ecx
; X86-NEXT: setb %dh
-; X86-NEXT: orb {{[-0-9]+}}(%e{{[sb]}}p), %dl # 1-byte Folded Reload
+; X86-NEXT: orb 3(%esp), %dl # 1-byte Folded Reload
; X86-NEXT: movzbl %dl, %esi
; X86-NEXT: subl %esi, %eax
-; X86-NEXT: movl %eax, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
+; X86-NEXT: movl %eax, 12(%esp) # 4-byte Spill
; X86-NEXT: sbbl $0, %ecx
; X86-NEXT: setb %al
; X86-NEXT: subl 76(%esp), %ebp
-; X86-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %esi # 4-byte Reload
+; X86-NEXT: movl 8(%esp), %esi # 4-byte Reload
; X86-NEXT: sbbl 80(%esp), %esi
-; X86-NEXT: setb {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Folded Spill
+; X86-NEXT: setb 4(%esp) # 1-byte Folded Spill
; X86-NEXT: orb %dh, %al
; X86-NEXT: movzbl %al, %eax
; X86-NEXT: subl %eax, %ebp
; X86-NEXT: sbbl $0, %esi
; X86-NEXT: setb %al
; X86-NEXT: subl 84(%esp), %ebx
-; X86-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %edx # 4-byte Reload
+; X86-NEXT: movl 16(%esp), %edx # 4-byte Reload
; X86-NEXT: sbbl 88(%esp), %edx
-; X86-NEXT: setb {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Folded Spill
-; X86-NEXT: orb {{[-0-9]+}}(%e{{[sb]}}p), %al # 1-byte Folded Reload
+; X86-NEXT: setb 8(%esp) # 1-byte Folded Spill
+; X86-NEXT: orb 4(%esp), %al # 1-byte Folded Reload
; X86-NEXT: movzbl %al, %eax
; X86-NEXT: subl %eax, %ebx
-; X86-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
+; X86-NEXT: movl 24(%esp), %eax # 4-byte Reload
; X86-NEXT: movl %eax, 8(%edi)
-; X86-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
+; X86-NEXT: movl 20(%esp), %eax # 4-byte Reload
; X86-NEXT: movl %eax, 12(%edi)
-; X86-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
+; X86-NEXT: movl 12(%esp), %eax # 4-byte Reload
; X86-NEXT: movl %eax, 16(%edi)
; X86-NEXT: movl %ecx, 20(%edi)
; X86-NEXT: movl %ebp, 24(%edi)
@@ -895,7 +895,7 @@ define i32 @sub_U320_without_i128_or(ptr nocapture dereferenceable(40) %0, i64 %
; X86-NEXT: sbbl $0, %eax
; X86-NEXT: movl %eax, 36(%edi)
; X86-NEXT: setb %al
-; X86-NEXT: orb {{[-0-9]+}}(%e{{[sb]}}p), %al # 1-byte Folded Reload
+; X86-NEXT: orb 8(%esp), %al # 1-byte Folded Reload
; X86-NEXT: movzbl %al, %eax
; X86-NEXT: addl $28, %esp
; X86-NEXT: popl %esi
@@ -970,16 +970,16 @@ define i32 @sub_U320_usubo(ptr nocapture dereferenceable(40) %0, i64 %1, i64 %2,
; X86-NEXT: movl 8(%edx), %eax
; X86-NEXT: movl 12(%edx), %esi
; X86-NEXT: movl 20(%edx), %ecx
-; X86-NEXT: movl %ecx, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
+; X86-NEXT: movl %ecx, 12(%esp) # 4-byte Spill
; X86-NEXT: movl 16(%edx), %ecx
-; X86-NEXT: movl %ecx, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
+; X86-NEXT: movl %ecx, 8(%esp) # 4-byte Spill
; X86-NEXT: movl 28(%edx), %ecx
-; X86-NEXT: movl %ecx, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
+; X86-NEXT: movl %ecx, 4(%esp) # 4-byte Spill
; X86-NEXT: subl 56(%esp), %eax
; X86-NEXT: movl %eax, %ecx
; X86-NEXT: movl %esi, %eax
; X86-NEXT: sbbl 60(%esp), %eax
-; X86-NEXT: setb {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Folded Spill
+; X86-NEXT: setb 3(%esp) # 1-byte Folded Spill
; X86-NEXT: movl 24(%edx), %edi
; X86-NEXT: movl 36(%edx), %ebp
; X86-NEXT: movl 32(%edx), %ebx
@@ -988,42 +988,42 @@ define i32 @sub_U320_usubo(ptr nocapture dereferenceable(40) %0, i64 %1, i64 %2,
; X86-NEXT: movl 52(%esp), %esi
; X86-NEXT: sbbl %esi, 4(%edx)
; X86-NEXT: sbbl $0, %ecx
-; X86-NEXT: movl %ecx, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
+; X86-NEXT: movl %ecx, 20(%esp) # 4-byte Spill
; X86-NEXT: sbbl $0, %eax
-; X86-NEXT: movl %eax, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
+; X86-NEXT: movl %eax, 16(%esp) # 4-byte Spill
; X86-NEXT: setb %al
-; X86-NEXT: orb {{[-0-9]+}}(%e{{[sb]}}p), %al # 1-byte Folded Reload
-; X86-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %ecx # 4-byte Reload
+; X86-NEXT: orb 3(%esp), %al # 1-byte Folded Reload
+; X86-NEXT: movl 8(%esp), %ecx # 4-byte Reload
; X86-NEXT: subl 64(%esp), %ecx
-; X86-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %esi # 4-byte Reload
+; X86-NEXT: movl 12(%esp), %esi # 4-byte Reload
; X86-NEXT: sbbl 68(%esp), %esi
; X86-NEXT: movzbl %al, %eax
-; X86-NEXT: setb {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Folded Spill
+; X86-NEXT: setb 8(%esp) # 1-byte Folded Spill
; X86-NEXT: subl %eax, %ecx
; X86-NEXT: sbbl $0, %esi
-; X86-NEXT: movl %esi, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
+; X86-NEXT: movl %esi, 12(%esp) # 4-byte Spill
; X86-NEXT: setb %al
-; X86-NEXT: orb {{[-0-9]+}}(%e{{[sb]}}p), %al # 1-byte Folded Reload
+; X86-NEXT: orb 8(%esp), %al # 1-byte Folded Reload
; X86-NEXT: subl 72(%esp), %edi
-; X86-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %esi # 4-byte Reload
+; X86-NEXT: movl 4(%esp), %esi # 4-byte Reload
; X86-NEXT: sbbl 76(%esp), %esi
; X86-NEXT: movzbl %al, %eax
-; X86-NEXT: setb {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Folded Spill
+; X86-NEXT: setb 4(%esp) # 1-byte Folded Spill
; X86-NEXT: subl %eax, %edi
; X86-NEXT: sbbl $0, %esi
; X86-NEXT: setb %al
-; X86-NEXT: orb {{[-0-9]+}}(%e{{[sb]}}p), %al # 1-byte Folded Reload
+; X86-NEXT: orb 4(%esp), %al # 1-byte Folded Reload
; X86-NEXT: subl 80(%esp), %ebx
; X86-NEXT: sbbl 84(%esp), %ebp
; X86-NEXT: movzbl %al, %eax
-; X86-NEXT: setb {{[-0-9]+}}(%e{{[sb]}}p) # 1-byte Folded Spill
+; X86-NEXT: setb 4(%esp) # 1-byte Folded Spill
; X86-NEXT: subl %eax, %ebx
-; X86-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
+; X86-NEXT: movl 20(%esp), %eax # 4-byte Reload
; X86-NEXT: movl %eax, 8(%edx)
-; X86-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
+; X86-NEXT: movl 16(%esp), %eax # 4-byte Reload
; X86-NEXT: movl %eax, 12(%edx)
; X86-NEXT: movl %ecx, 16(%edx)
-; X86-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %eax # 4-byte Reload
+; X86-NEXT: movl 12(%esp), %eax # 4-byte Reload
; X86-NEXT: movl %eax, 20(%edx)
; X86-NEXT: movl %edi, 24(%edx)
; X86-NEXT: movl %esi, 28(%edx)
@@ -1031,7 +1031,7 @@ define i32 @sub_U320_usubo(ptr nocapture dereferenceable(40) %0, i64 %1, i64 %2,
; X86-NEXT: sbbl $0, %ebp
; X86-NEXT: movl %ebp, 36(%edx)
; X86-NEXT: setb %al
-; X86-NEXT: orb {{[-0-9]+}}(%e{{[sb]}}p), %al # 1-byte Folded Reload
+; X86-NEXT: orb 4(%esp), %al # 1-byte Folded Reload
; X86-NEXT: movzbl %al, %eax
; X86-NEXT: addl $24, %esp
; X86-NEXT: popl %esi
@@ -1225,9 +1225,9 @@ define void @sub_U256_without_i128_or_recursive(ptr sret(%uint256) %0, ptr %1, p
; X86-NEXT: sbbl 12(%ebp), %esi
; X86-NEXT: setb %dl
; X86-NEXT: subl (%ebp), %ecx
-; X86-NEXT: movl %ecx, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
+; X86-NEXT: movl %ecx, 8(%esp) # 4-byte Spill
; X86-NEXT: sbbl 4(%ebp), %ebx
-; X86-NEXT: movl %ebx, {{[-0-9]+}}(%e{{[sb]}}p) # 4-byte Spill
+; X86-NEXT: movl %ebx, 4(%esp) # 4-byte Spill
; X86-NEXT: sbbl $0, %edi
; X86-NEXT: sbbl $0, %esi
; X86-NEXT: movl %esi, (%esp) # 4-byte Spill
@@ -1247,9 +1247,9 @@ define void @sub_U256_without_i128_or_recursive(ptr sret(%uint256) %0, ptr %1, p
; X86-NEXT: movzbl %cl, %ecx
; X86-NEXT: subl %ecx, %edx
; X86-NEXT: movl 32(%esp), %ecx
-; X86-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %esi # 4-byte Reload
+; X86-NEXT: movl 8(%esp), %esi # 4-byte Reload
; X86-NEXT: movl %esi, (%ecx)
-; X86-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %esi # 4-byte Reload
+; X86-NEXT: movl 4(%esp), %esi # 4-byte Reload
; X86-NEXT: movl %esi, 4(%ecx)
; X86-NEXT: movl %edi, 8(%ecx)
; X86-NEXT: movl (%esp), %esi # 4-byte Reload
diff --git a/llvm/test/CodeGen/X86/swifterror.ll b/llvm/test/CodeGen/X86/swifterror.ll
index 5699c447baf41..d6dc273f415ab 100644
--- a/llvm/test/CodeGen/X86/swifterror.ll
+++ b/llvm/test/CodeGen/X86/swifterror.ll
@@ -97,20 +97,20 @@ define float @caller(ptr %error_ref) {
; CHECK-O0-NEXT: .cfi_def_cfa_offset 48
; CHECK-O0-NEXT: .cfi_offset %r12, -16
; CHECK-O0-NEXT: ## implicit-def: $rax
-; CHECK-O0-NEXT: movq %rdi, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
+; CHECK-O0-NEXT: movq %rdi, 8(%rsp) ## 8-byte Spill
; CHECK-O0-NEXT: xorl %eax, %eax
; CHECK-O0-NEXT: movl %eax, %r12d
; CHECK-O0-NEXT: callq _foo
-; CHECK-O0-NEXT: movq %r12, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
+; CHECK-O0-NEXT: movq %r12, 16(%rsp) ## 8-byte Spill
; CHECK-O0-NEXT: cmpq $0, %r12
; CHECK-O0-NEXT: jne LBB1_2
; CHECK-O0-NEXT: ## %bb.1: ## %cont
-; CHECK-O0-NEXT: movq {{[-0-9]+}}(%r{{[sb]}}p), %rax ## 8-byte Reload
-; CHECK-O0-NEXT: movq {{[-0-9]+}}(%r{{[sb]}}p), %rcx ## 8-byte Reload
+; CHECK-O0-NEXT: movq 8(%rsp), %rax ## 8-byte Reload
+; CHECK-O0-NEXT: movq 16(%rsp), %rcx ## 8-byte Reload
; CHECK-O0-NEXT: movb 8(%rcx), %cl
; CHECK-O0-NEXT: movb %cl, (%rax)
; CHECK-O0-NEXT: LBB1_2: ## %handler
-; CHECK-O0-NEXT: movq {{[-0-9]+}}(%r{{[sb]}}p), %rdi ## 8-byte Reload
+; CHECK-O0-NEXT: movq 16(%rsp), %rdi ## 8-byte Reload
; CHECK-O0-NEXT: callq _free
; CHECK-O0-NEXT: movss {{.*#+}} xmm0 = [1.0E+0,0.0E+0,0.0E+0,0.0E+0]
; CHECK-O0-NEXT: addq $32, %rsp
@@ -201,30 +201,30 @@ define float @caller2(ptr %error_ref) {
; CHECK-O0-NEXT: .cfi_def_cfa_offset 48
; CHECK-O0-NEXT: .cfi_offset %r12, -16
; CHECK-O0-NEXT: ## implicit-def: $rax
-; CHECK-O0-NEXT: movq %rdi, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
+; CHECK-O0-NEXT: movq %rdi, 16(%rsp) ## 8-byte Spill
; CHECK-O0-NEXT: LBB2_1: ## %bb_loop
; CHECK-O0-NEXT: ## =>This Inner Loop Header: Depth=1
; CHECK-O0-NEXT: xorl %eax, %eax
; CHECK-O0-NEXT: movl %eax, %r12d
; CHECK-O0-NEXT: callq _foo
-; CHECK-O0-NEXT: movss %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) ## 4-byte Spill
-; CHECK-O0-NEXT: movq %r12, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
+; CHECK-O0-NEXT: movss %xmm0, 4(%rsp) ## 4-byte Spill
+; CHECK-O0-NEXT: movq %r12, 8(%rsp) ## 8-byte Spill
; CHECK-O0-NEXT: cmpq $0, %r12
; CHECK-O0-NEXT: jne LBB2_4
; CHECK-O0-NEXT: ## %bb.2: ## %cont
; CHECK-O0-NEXT: ## in Loop: Header=BB2_1 Depth=1
-; CHECK-O0-NEXT: movss {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 ## 4-byte Reload
+; CHECK-O0-NEXT: movss 4(%rsp), %xmm0 ## 4-byte Reload
; CHECK-O0-NEXT: ## xmm0 = mem[0],zero,zero,zero
; CHECK-O0-NEXT: movss {{.*#+}} xmm1 = [1.0E+0,0.0E+0,0.0E+0,0.0E+0]
; CHECK-O0-NEXT: ucomiss %xmm1, %xmm0
; CHECK-O0-NEXT: jbe LBB2_1
; CHECK-O0-NEXT: ## %bb.3: ## %bb_end
-; CHECK-O0-NEXT: movq {{[-0-9]+}}(%r{{[sb]}}p), %rax ## 8-byte Reload
-; CHECK-O0-NEXT: movq {{[-0-9]+}}(%r{{[sb]}}p), %rcx ## 8-byte Reload
+; CHECK-O0-NEXT: movq 16(%rsp), %rax ## 8-byte Reload
+; CHECK-O0-NEXT: movq 8(%rsp), %rcx ## 8-byte Reload
; CHECK-O0-NEXT: movb 8(%rcx), %cl
; CHECK-O0-NEXT: movb %cl, (%rax)
; CHECK-O0-NEXT: LBB2_4: ## %handler
-; CHECK-O0-NEXT: movq {{[-0-9]+}}(%r{{[sb]}}p), %rdi ## 8-byte Reload
+; CHECK-O0-NEXT: movq 8(%rsp), %rdi ## 8-byte Reload
; CHECK-O0-NEXT: callq _free
; CHECK-O0-NEXT: movss {{.*#+}} xmm0 = [1.0E+0,0.0E+0,0.0E+0,0.0E+0]
; CHECK-O0-NEXT: addq $32, %rsp
@@ -391,7 +391,7 @@ define float @foo_loop(ptr swifterror %error_ptr_ref, i32 %cc, float %cc2) {
; CHECK-APPLE-NEXT: subq $16, %rsp
; CHECK-APPLE-NEXT: .cfi_def_cfa_offset 32
; CHECK-APPLE-NEXT: .cfi_offset %rbx, -16
-; CHECK-APPLE-NEXT: movss %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) ## 4-byte Spill
+; CHECK-APPLE-NEXT: movss %xmm0, 12(%rsp) ## 4-byte Spill
; CHECK-APPLE-NEXT: movl %edi, %ebx
; CHECK-APPLE-NEXT: movq %r12, %rax
; CHECK-APPLE-NEXT: LBB4_1: ## %bb_loop
@@ -405,7 +405,7 @@ define float @foo_loop(ptr swifterror %error_ptr_ref, i32 %cc, float %cc2) {
; CHECK-APPLE-NEXT: movb $1, 8(%rax)
; CHECK-APPLE-NEXT: LBB4_3: ## %bb_cont
; CHECK-APPLE-NEXT: ## in Loop: Header=BB4_1 Depth=1
-; CHECK-APPLE-NEXT: movss {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 ## 4-byte Reload
+; CHECK-APPLE-NEXT: movss 12(%rsp), %xmm0 ## 4-byte Reload
; CHECK-APPLE-NEXT: ## xmm0 = mem[0],zero,zero,zero
; CHECK-APPLE-NEXT: ucomiss {{\.?LCPI[0-9]+_[0-9]+}}(%rip), %xmm0
; CHECK-APPLE-NEXT: jbe LBB4_1
@@ -420,16 +420,16 @@ define float @foo_loop(ptr swifterror %error_ptr_ref, i32 %cc, float %cc2) {
; CHECK-O0: ## %bb.0: ## %entry
; CHECK-O0-NEXT: subq $40, %rsp
; CHECK-O0-NEXT: .cfi_def_cfa_offset 48
-; CHECK-O0-NEXT: movss %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) ## 4-byte Spill
-; CHECK-O0-NEXT: movl %edi, {{[-0-9]+}}(%r{{[sb]}}p) ## 4-byte Spill
-; CHECK-O0-NEXT: movq %r12, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
+; CHECK-O0-NEXT: movss %xmm0, 24(%rsp) ## 4-byte Spill
+; CHECK-O0-NEXT: movl %edi, 28(%rsp) ## 4-byte Spill
+; CHECK-O0-NEXT: movq %r12, 32(%rsp) ## 8-byte Spill
; CHECK-O0-NEXT: jmp LBB4_1
; CHECK-O0-NEXT: LBB4_1: ## %bb_loop
; CHECK-O0-NEXT: ## =>This Inner Loop Header: Depth=1
-; CHECK-O0-NEXT: movl {{[-0-9]+}}(%r{{[sb]}}p), %ecx ## 4-byte Reload
-; CHECK-O0-NEXT: movq {{[-0-9]+}}(%r{{[sb]}}p), %rax ## 8-byte Reload
+; CHECK-O0-NEXT: movl 28(%rsp), %ecx ## 4-byte Reload
+; CHECK-O0-NEXT: movq 32(%rsp), %rax ## 8-byte Reload
; CHECK-O0-NEXT: cmpl $0, %ecx
-; CHECK-O0-NEXT: movq %rax, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
+; CHECK-O0-NEXT: movq %rax, 16(%rsp) ## 8-byte Spill
; CHECK-O0-NEXT: je LBB4_3
; CHECK-O0-NEXT: ## %bb.2: ## %gen_error
; CHECK-O0-NEXT: ## in Loop: Header=BB4_1 Depth=1
@@ -437,19 +437,19 @@ define float @foo_loop(ptr swifterror %error_ptr_ref, i32 %cc, float %cc2) {
; CHECK-O0-NEXT: callq _malloc
; CHECK-O0-NEXT: movq %rax, %rcx
; CHECK-O0-NEXT: movb $1, 8(%rcx)
-; CHECK-O0-NEXT: movq %rax, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
+; CHECK-O0-NEXT: movq %rax, 16(%rsp) ## 8-byte Spill
; CHECK-O0-NEXT: LBB4_3: ## %bb_cont
; CHECK-O0-NEXT: ## in Loop: Header=BB4_1 Depth=1
-; CHECK-O0-NEXT: movss {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 ## 4-byte Reload
+; CHECK-O0-NEXT: movss 24(%rsp), %xmm0 ## 4-byte Reload
; CHECK-O0-NEXT: ## xmm0 = mem[0],zero,zero,zero
-; CHECK-O0-NEXT: movq {{[-0-9]+}}(%r{{[sb]}}p), %rax ## 8-byte Reload
-; CHECK-O0-NEXT: movq %rax, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
+; CHECK-O0-NEXT: movq 16(%rsp), %rax ## 8-byte Reload
+; CHECK-O0-NEXT: movq %rax, 8(%rsp) ## 8-byte Spill
; CHECK-O0-NEXT: movss {{.*#+}} xmm1 = [1.0E+0,0.0E+0,0.0E+0,0.0E+0]
; CHECK-O0-NEXT: ucomiss %xmm1, %xmm0
-; CHECK-O0-NEXT: movq %rax, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
+; CHECK-O0-NEXT: movq %rax, 32(%rsp) ## 8-byte Spill
; CHECK-O0-NEXT: jbe LBB4_1
; CHECK-O0-NEXT: ## %bb.4: ## %bb_end
-; CHECK-O0-NEXT: movq {{[-0-9]+}}(%r{{[sb]}}p), %r12 ## 8-byte Reload
+; CHECK-O0-NEXT: movq 8(%rsp), %r12 ## 8-byte Reload
; CHECK-O0-NEXT: xorps %xmm0, %xmm0
; CHECK-O0-NEXT: addq $40, %rsp
; CHECK-O0-NEXT: retq
@@ -465,7 +465,7 @@ define float @foo_loop(ptr swifterror %error_ptr_ref, i32 %cc, float %cc2) {
; CHECK-i386-NEXT: .cfi_offset %esi, -12
; CHECK-i386-NEXT: .cfi_offset %edi, -8
; CHECK-i386-NEXT: flds 40(%esp)
-; CHECK-i386-NEXT: fstps {{[-0-9]+}}(%e{{[sb]}}p) ## 4-byte Folded Spill
+; CHECK-i386-NEXT: fstps 16(%esp) ## 4-byte Folded Spill
; CHECK-i386-NEXT: movl 36(%esp), %esi
; CHECK-i386-NEXT: movl 32(%esp), %edi
; CHECK-i386-NEXT: LBB4_1: ## %bb_loop
@@ -481,7 +481,7 @@ define float @foo_loop(ptr swifterror %error_ptr_ref, i32 %cc, float %cc2) {
; CHECK-i386-NEXT: movb $1, 8(%eax)
; CHECK-i386-NEXT: LBB4_3: ## %bb_cont
; CHECK-i386-NEXT: ## in Loop: Header=BB4_1 Depth=1
-; CHECK-i386-NEXT: flds {{[-0-9]+}}(%e{{[sb]}}p) ## 4-byte Folded Reload
+; CHECK-i386-NEXT: flds 16(%esp) ## 4-byte Folded Reload
; CHECK-i386-NEXT: fld1
; CHECK-i386-NEXT: fxch %st(1)
; CHECK-i386-NEXT: fucompp
@@ -551,15 +551,15 @@ define void @foo_sret(ptr sret(%struct.S) %agg.result, i32 %val1, ptr swifterror
; CHECK-O0: ## %bb.0: ## %entry
; CHECK-O0-NEXT: subq $24, %rsp
; CHECK-O0-NEXT: .cfi_def_cfa_offset 32
-; CHECK-O0-NEXT: movl %esi, {{[-0-9]+}}(%r{{[sb]}}p) ## 4-byte Spill
-; CHECK-O0-NEXT: movq %rdi, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
-; CHECK-O0-NEXT: movq %rdi, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
+; CHECK-O0-NEXT: movl %esi, 4(%rsp) ## 4-byte Spill
+; CHECK-O0-NEXT: movq %rdi, 8(%rsp) ## 8-byte Spill
+; CHECK-O0-NEXT: movq %rdi, 16(%rsp) ## 8-byte Spill
; CHECK-O0-NEXT: movl $16, %edi
; CHECK-O0-NEXT: callq _malloc
-; CHECK-O0-NEXT: movl {{[-0-9]+}}(%r{{[sb]}}p), %esi ## 4-byte Reload
-; CHECK-O0-NEXT: movq {{[-0-9]+}}(%r{{[sb]}}p), %rdi ## 8-byte Reload
+; CHECK-O0-NEXT: movl 4(%rsp), %esi ## 4-byte Reload
+; CHECK-O0-NEXT: movq 8(%rsp), %rdi ## 8-byte Reload
; CHECK-O0-NEXT: movq %rax, %rcx
-; CHECK-O0-NEXT: movq {{[-0-9]+}}(%r{{[sb]}}p), %rax ## 8-byte Reload
+; CHECK-O0-NEXT: movq 16(%rsp), %rax ## 8-byte Reload
; CHECK-O0-NEXT: movq %rcx, %r12
; CHECK-O0-NEXT: movb $1, 8(%rcx)
; CHECK-O0-NEXT: movl %esi, 4(%rdi)
@@ -652,16 +652,16 @@ define float @caller3(ptr %error_ref) {
; CHECK-O0-NEXT: leaq 24(%rsp), %rdi
; CHECK-O0-NEXT: movl $1, %esi
; CHECK-O0-NEXT: callq _foo_sret
-; CHECK-O0-NEXT: movq %r12, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
+; CHECK-O0-NEXT: movq %r12, 8(%rsp) ## 8-byte Spill
; CHECK-O0-NEXT: cmpq $0, %r12
; CHECK-O0-NEXT: jne LBB6_2
; CHECK-O0-NEXT: ## %bb.1: ## %cont
; CHECK-O0-NEXT: movq (%rsp), %rax ## 8-byte Reload
-; CHECK-O0-NEXT: movq {{[-0-9]+}}(%r{{[sb]}}p), %rcx ## 8-byte Reload
+; CHECK-O0-NEXT: movq 8(%rsp), %rcx ## 8-byte Reload
; CHECK-O0-NEXT: movb 8(%rcx), %cl
; CHECK-O0-NEXT: movb %cl, (%rax)
; CHECK-O0-NEXT: LBB6_2: ## %handler
-; CHECK-O0-NEXT: movq {{[-0-9]+}}(%r{{[sb]}}p), %rdi ## 8-byte Reload
+; CHECK-O0-NEXT: movq 8(%rsp), %rdi ## 8-byte Reload
; CHECK-O0-NEXT: callq _free
; CHECK-O0-NEXT: movss {{.*#+}} xmm0 = [1.0E+0,0.0E+0,0.0E+0,0.0E+0]
; CHECK-O0-NEXT: addq $48, %rsp
@@ -777,21 +777,21 @@ define float @caller_with_multiple_swifterror_values(ptr %error_ref, ptr %error_
; CHECK-O0-NEXT: .cfi_offset %r12, -24
; CHECK-O0-NEXT: ## implicit-def: $rax
; CHECK-O0-NEXT: ## implicit-def: $rax
-; CHECK-O0-NEXT: movq %rdi, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
-; CHECK-O0-NEXT: movq %rsi, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
+; CHECK-O0-NEXT: movq %rdi, -40(%rbp) ## 8-byte Spill
+; CHECK-O0-NEXT: movq %rsi, -32(%rbp) ## 8-byte Spill
; CHECK-O0-NEXT: xorl %eax, %eax
; CHECK-O0-NEXT: movl %eax, %r12d
; CHECK-O0-NEXT: callq _foo
-; CHECK-O0-NEXT: movq %r12, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
+; CHECK-O0-NEXT: movq %r12, -24(%rbp) ## 8-byte Spill
; CHECK-O0-NEXT: cmpq $0, %r12
; CHECK-O0-NEXT: jne LBB7_2
; CHECK-O0-NEXT: ## %bb.1: ## %cont
-; CHECK-O0-NEXT: movq {{[-0-9]+}}(%r{{[sb]}}p), %rax ## 8-byte Reload
-; CHECK-O0-NEXT: movq {{[-0-9]+}}(%r{{[sb]}}p), %rcx ## 8-byte Reload
+; CHECK-O0-NEXT: movq -40(%rbp), %rax ## 8-byte Reload
+; CHECK-O0-NEXT: movq -24(%rbp), %rcx ## 8-byte Reload
; CHECK-O0-NEXT: movb 8(%rcx), %cl
; CHECK-O0-NEXT: movb %cl, (%rax)
; CHECK-O0-NEXT: LBB7_2: ## %handler
-; CHECK-O0-NEXT: movq {{[-0-9]+}}(%r{{[sb]}}p), %rdi ## 8-byte Reload
+; CHECK-O0-NEXT: movq -24(%rbp), %rdi ## 8-byte Reload
; CHECK-O0-NEXT: callq _free
; CHECK-O0-NEXT: movq %rsp, %rax
; CHECK-O0-NEXT: addq $-16, %rax
@@ -799,16 +799,16 @@ define float @caller_with_multiple_swifterror_values(ptr %error_ref, ptr %error_
; CHECK-O0-NEXT: xorl %eax, %eax
; CHECK-O0-NEXT: movl %eax, %r12d
; CHECK-O0-NEXT: callq _foo
-; CHECK-O0-NEXT: movq %r12, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
+; CHECK-O0-NEXT: movq %r12, -48(%rbp) ## 8-byte Spill
; CHECK-O0-NEXT: cmpq $0, %r12
; CHECK-O0-NEXT: jne LBB7_4
; CHECK-O0-NEXT: ## %bb.3: ## %cont2
-; CHECK-O0-NEXT: movq {{[-0-9]+}}(%r{{[sb]}}p), %rax ## 8-byte Reload
-; CHECK-O0-NEXT: movq {{[-0-9]+}}(%r{{[sb]}}p), %rcx ## 8-byte Reload
+; CHECK-O0-NEXT: movq -32(%rbp), %rax ## 8-byte Reload
+; CHECK-O0-NEXT: movq -48(%rbp), %rcx ## 8-byte Reload
; CHECK-O0-NEXT: movb 8(%rcx), %cl
; CHECK-O0-NEXT: movb %cl, (%rax)
; CHECK-O0-NEXT: LBB7_4: ## %handler2
-; CHECK-O0-NEXT: movq {{[-0-9]+}}(%r{{[sb]}}p), %rdi ## 8-byte Reload
+; CHECK-O0-NEXT: movq -48(%rbp), %rdi ## 8-byte Reload
; CHECK-O0-NEXT: callq _free
; CHECK-O0-NEXT: movss {{.*#+}} xmm0 = [1.0E+0,0.0E+0,0.0E+0,0.0E+0]
; CHECK-O0-NEXT: leaq -8(%rbp), %rsp
@@ -957,24 +957,24 @@ define void @swifterror_isel(ptr) {
; CHECK-O0-NEXT: .cfi_def_cfa_offset 64
; CHECK-O0-NEXT: .cfi_offset %r12, -24
; CHECK-O0-NEXT: .cfi_offset %r13, -16
-; CHECK-O0-NEXT: movq %rdi, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
+; CHECK-O0-NEXT: movq %rdi, 24(%rsp) ## 8-byte Spill
; CHECK-O0-NEXT: ## implicit-def: $al
; CHECK-O0-NEXT: testb $1, %al
; CHECK-O0-NEXT: ## implicit-def: $ax
; CHECK-O0-NEXT: ## implicit-def: $r12
; CHECK-O0-NEXT: jne LBB8_2
; CHECK-O0-NEXT: LBB8_1: ## =>This Inner Loop Header: Depth=1
-; CHECK-O0-NEXT: movq {{[-0-9]+}}(%r{{[sb]}}p), %r12 ## 8-byte Reload
-; CHECK-O0-NEXT: movw {{[-0-9]+}}(%r{{[sb]}}p), %ax ## 2-byte Reload
-; CHECK-O0-NEXT: movq {{[-0-9]+}}(%r{{[sb]}}p), %r13 ## 8-byte Reload
+; CHECK-O0-NEXT: movq 16(%rsp), %r12 ## 8-byte Reload
+; CHECK-O0-NEXT: movw 14(%rsp), %ax ## 2-byte Reload
+; CHECK-O0-NEXT: movq 24(%rsp), %r13 ## 8-byte Reload
; CHECK-O0-NEXT: ## implicit-def: $edi
; CHECK-O0-NEXT: movw %ax, %di
; CHECK-O0-NEXT: ## implicit-def: $rax
; CHECK-O0-NEXT: callq *%rax
; CHECK-O0-NEXT: ## implicit-def: $rax
; CHECK-O0-NEXT: movw (%rax), %ax
-; CHECK-O0-NEXT: movw %ax, {{[-0-9]+}}(%r{{[sb]}}p) ## 2-byte Spill
-; CHECK-O0-NEXT: movq %r12, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
+; CHECK-O0-NEXT: movw %ax, 14(%rsp) ## 2-byte Spill
+; CHECK-O0-NEXT: movq %r12, 16(%rsp) ## 8-byte Spill
; CHECK-O0-NEXT: jmp LBB8_1
; CHECK-O0-NEXT: LBB8_2:
; CHECK-O0-NEXT: addq $40, %rsp
@@ -1310,11 +1310,11 @@ define swiftcc void @swifterror_clobber(ptr nocapture swifterror %err) {
;
; CHECK-O0-LABEL: swifterror_clobber:
; CHECK-O0: ## %bb.0:
-; CHECK-O0-NEXT: movq %r12, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
+; CHECK-O0-NEXT: movq %r12, -8(%rsp) ## 8-byte Spill
; CHECK-O0-NEXT: ## InlineAsm Start
; CHECK-O0-NEXT: nop
; CHECK-O0-NEXT: ## InlineAsm End
-; CHECK-O0-NEXT: movq {{[-0-9]+}}(%r{{[sb]}}p), %r12 ## 8-byte Reload
+; CHECK-O0-NEXT: movq -8(%rsp), %r12 ## 8-byte Reload
; CHECK-O0-NEXT: retq
;
; CHECK-i386-LABEL: swifterror_clobber:
@@ -1380,10 +1380,10 @@ define swiftcc void @params_in_reg(i64, i64, i64, i64, i64, i64, ptr swiftself,
; CHECK-APPLE-NEXT: .cfi_offset %r14, -32
; CHECK-APPLE-NEXT: .cfi_offset %r15, -24
; CHECK-APPLE-NEXT: .cfi_offset %rbp, -16
-; CHECK-APPLE-NEXT: movq %r12, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
-; CHECK-APPLE-NEXT: movq %r13, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
-; CHECK-APPLE-NEXT: movq %r9, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
-; CHECK-APPLE-NEXT: movq %r8, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
+; CHECK-APPLE-NEXT: movq %r12, 32(%rsp) ## 8-byte Spill
+; CHECK-APPLE-NEXT: movq %r13, 24(%rsp) ## 8-byte Spill
+; CHECK-APPLE-NEXT: movq %r9, 16(%rsp) ## 8-byte Spill
+; CHECK-APPLE-NEXT: movq %r8, 8(%rsp) ## 8-byte Spill
; CHECK-APPLE-NEXT: movq %rcx, %rbx
; CHECK-APPLE-NEXT: movq %rdx, %r14
; CHECK-APPLE-NEXT: movq %rsi, %r15
@@ -1401,10 +1401,10 @@ define swiftcc void @params_in_reg(i64, i64, i64, i64, i64, i64, ptr swiftself,
; CHECK-APPLE-NEXT: movq %r15, %rsi
; CHECK-APPLE-NEXT: movq %r14, %rdx
; CHECK-APPLE-NEXT: movq %rbx, %rcx
-; CHECK-APPLE-NEXT: movq {{[-0-9]+}}(%r{{[sb]}}p), %r8 ## 8-byte Reload
-; CHECK-APPLE-NEXT: movq {{[-0-9]+}}(%r{{[sb]}}p), %r9 ## 8-byte Reload
-; CHECK-APPLE-NEXT: movq {{[-0-9]+}}(%r{{[sb]}}p), %r13 ## 8-byte Reload
-; CHECK-APPLE-NEXT: movq {{[-0-9]+}}(%r{{[sb]}}p), %r12 ## 8-byte Reload
+; CHECK-APPLE-NEXT: movq 8(%rsp), %r8 ## 8-byte Reload
+; CHECK-APPLE-NEXT: movq 16(%rsp), %r9 ## 8-byte Reload
+; CHECK-APPLE-NEXT: movq 24(%rsp), %r13 ## 8-byte Reload
+; CHECK-APPLE-NEXT: movq 32(%rsp), %r12 ## 8-byte Reload
; CHECK-APPLE-NEXT: callq _params_in_reg2
; CHECK-APPLE-NEXT: addq $48, %rsp
; CHECK-APPLE-NEXT: popq %rbx
@@ -1421,14 +1421,14 @@ define swiftcc void @params_in_reg(i64, i64, i64, i64, i64, i64, ptr swiftself,
; CHECK-O0-NEXT: subq $80, %rsp
; CHECK-O0-NEXT: .cfi_def_cfa_offset 96
; CHECK-O0-NEXT: .cfi_offset %r13, -16
-; CHECK-O0-NEXT: movq %r12, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
-; CHECK-O0-NEXT: movq %r13, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
-; CHECK-O0-NEXT: movq %r9, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
-; CHECK-O0-NEXT: movq %r8, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
-; CHECK-O0-NEXT: movq %rcx, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
-; CHECK-O0-NEXT: movq %rdx, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
-; CHECK-O0-NEXT: movq %rsi, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
-; CHECK-O0-NEXT: movq %rdi, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
+; CHECK-O0-NEXT: movq %r12, 64(%rsp) ## 8-byte Spill
+; CHECK-O0-NEXT: movq %r13, 8(%rsp) ## 8-byte Spill
+; CHECK-O0-NEXT: movq %r9, 56(%rsp) ## 8-byte Spill
+; CHECK-O0-NEXT: movq %r8, 48(%rsp) ## 8-byte Spill
+; CHECK-O0-NEXT: movq %rcx, 40(%rsp) ## 8-byte Spill
+; CHECK-O0-NEXT: movq %rdx, 32(%rsp) ## 8-byte Spill
+; CHECK-O0-NEXT: movq %rsi, 24(%rsp) ## 8-byte Spill
+; CHECK-O0-NEXT: movq %rdi, 16(%rsp) ## 8-byte Spill
; CHECK-O0-NEXT: ## implicit-def: $rax
; CHECK-O0-NEXT: xorl %eax, %eax
; CHECK-O0-NEXT: movl %eax, %r12d
@@ -1440,15 +1440,15 @@ define swiftcc void @params_in_reg(i64, i64, i64, i64, i64, i64, ptr swiftself,
; CHECK-O0-NEXT: movl $6, %r9d
; CHECK-O0-NEXT: movq %r12, %r13
; CHECK-O0-NEXT: callq _params_in_reg2
-; CHECK-O0-NEXT: movq {{[-0-9]+}}(%r{{[sb]}}p), %r13 ## 8-byte Reload
-; CHECK-O0-NEXT: movq {{[-0-9]+}}(%r{{[sb]}}p), %rdi ## 8-byte Reload
-; CHECK-O0-NEXT: movq {{[-0-9]+}}(%r{{[sb]}}p), %rsi ## 8-byte Reload
-; CHECK-O0-NEXT: movq {{[-0-9]+}}(%r{{[sb]}}p), %rdx ## 8-byte Reload
-; CHECK-O0-NEXT: movq {{[-0-9]+}}(%r{{[sb]}}p), %rcx ## 8-byte Reload
-; CHECK-O0-NEXT: movq {{[-0-9]+}}(%r{{[sb]}}p), %r8 ## 8-byte Reload
-; CHECK-O0-NEXT: movq {{[-0-9]+}}(%r{{[sb]}}p), %r9 ## 8-byte Reload
+; CHECK-O0-NEXT: movq 8(%rsp), %r13 ## 8-byte Reload
+; CHECK-O0-NEXT: movq 16(%rsp), %rdi ## 8-byte Reload
+; CHECK-O0-NEXT: movq 24(%rsp), %rsi ## 8-byte Reload
+; CHECK-O0-NEXT: movq 32(%rsp), %rdx ## 8-byte Reload
+; CHECK-O0-NEXT: movq 40(%rsp), %rcx ## 8-byte Reload
+; CHECK-O0-NEXT: movq 48(%rsp), %r8 ## 8-byte Reload
+; CHECK-O0-NEXT: movq 56(%rsp), %r9 ## 8-byte Reload
; CHECK-O0-NEXT: movq %r12, %rax
-; CHECK-O0-NEXT: movq {{[-0-9]+}}(%r{{[sb]}}p), %r12 ## 8-byte Reload
+; CHECK-O0-NEXT: movq 64(%rsp), %r12 ## 8-byte Reload
; CHECK-O0-NEXT: callq _params_in_reg2
; CHECK-O0-NEXT: addq $80, %rsp
; CHECK-O0-NEXT: popq %r13
@@ -1551,9 +1551,9 @@ define swiftcc { i64, i64, i64, i64} @params_and_return_in_reg(i64, i64, i64, i6
; CHECK-APPLE-NEXT: .cfi_offset %r15, -24
; CHECK-APPLE-NEXT: .cfi_offset %rbp, -16
; CHECK-APPLE-NEXT: movq %r12, (%rsp) ## 8-byte Spill
-; CHECK-APPLE-NEXT: movq %r13, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
-; CHECK-APPLE-NEXT: movq %r9, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
-; CHECK-APPLE-NEXT: movq %r8, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
+; CHECK-APPLE-NEXT: movq %r13, 32(%rsp) ## 8-byte Spill
+; CHECK-APPLE-NEXT: movq %r9, 24(%rsp) ## 8-byte Spill
+; CHECK-APPLE-NEXT: movq %r8, 8(%rsp) ## 8-byte Spill
; CHECK-APPLE-NEXT: movq %rcx, %rbx
; CHECK-APPLE-NEXT: movq %rdx, %r14
; CHECK-APPLE-NEXT: movq %rsi, %r15
@@ -1567,14 +1567,14 @@ define swiftcc { i64, i64, i64, i64} @params_and_return_in_reg(i64, i64, i64, i6
; CHECK-APPLE-NEXT: xorl %r13d, %r13d
; CHECK-APPLE-NEXT: xorl %r12d, %r12d
; CHECK-APPLE-NEXT: callq _params_in_reg2
-; CHECK-APPLE-NEXT: movq %r12, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
+; CHECK-APPLE-NEXT: movq %r12, 16(%rsp) ## 8-byte Spill
; CHECK-APPLE-NEXT: movq %rbp, %rdi
; CHECK-APPLE-NEXT: movq %r15, %rsi
; CHECK-APPLE-NEXT: movq %r14, %rdx
; CHECK-APPLE-NEXT: movq %rbx, %rcx
-; CHECK-APPLE-NEXT: movq {{[-0-9]+}}(%r{{[sb]}}p), %r8 ## 8-byte Reload
-; CHECK-APPLE-NEXT: movq {{[-0-9]+}}(%r{{[sb]}}p), %r9 ## 8-byte Reload
-; CHECK-APPLE-NEXT: movq {{[-0-9]+}}(%r{{[sb]}}p), %r13 ## 8-byte Reload
+; CHECK-APPLE-NEXT: movq 8(%rsp), %r8 ## 8-byte Reload
+; CHECK-APPLE-NEXT: movq 24(%rsp), %r9 ## 8-byte Reload
+; CHECK-APPLE-NEXT: movq 32(%rsp), %r13 ## 8-byte Reload
; CHECK-APPLE-NEXT: movq (%rsp), %r12 ## 8-byte Reload
; CHECK-APPLE-NEXT: callq _params_and_return_in_reg2
; CHECK-APPLE-NEXT: movq %rax, %rbx
@@ -1589,7 +1589,7 @@ define swiftcc { i64, i64, i64, i64} @params_and_return_in_reg(i64, i64, i64, i6
; CHECK-APPLE-NEXT: movl $5, %r8d
; CHECK-APPLE-NEXT: movl $6, %r9d
; CHECK-APPLE-NEXT: xorl %r13d, %r13d
-; CHECK-APPLE-NEXT: movq {{[-0-9]+}}(%r{{[sb]}}p), %r12 ## 8-byte Reload
+; CHECK-APPLE-NEXT: movq 16(%rsp), %r12 ## 8-byte Reload
; CHECK-APPLE-NEXT: callq _params_in_reg2
; CHECK-APPLE-NEXT: movq %rbx, %rax
; CHECK-APPLE-NEXT: movq %r14, %rdx
@@ -1611,67 +1611,67 @@ define swiftcc { i64, i64, i64, i64} @params_and_return_in_reg(i64, i64, i64, i6
; CHECK-O0-NEXT: subq $176, %rsp
; CHECK-O0-NEXT: .cfi_def_cfa_offset 192
; CHECK-O0-NEXT: .cfi_offset %r13, -16
-; CHECK-O0-NEXT: movq %r12, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
+; CHECK-O0-NEXT: movq %r12, 56(%rsp) ## 8-byte Spill
; CHECK-O0-NEXT: movq %r13, (%rsp) ## 8-byte Spill
-; CHECK-O0-NEXT: movq %r9, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
-; CHECK-O0-NEXT: movq %r8, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
-; CHECK-O0-NEXT: movq %rcx, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
-; CHECK-O0-NEXT: movq %rdx, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
-; CHECK-O0-NEXT: movq %rsi, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
-; CHECK-O0-NEXT: movq %rdi, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
+; CHECK-O0-NEXT: movq %r9, 48(%rsp) ## 8-byte Spill
+; CHECK-O0-NEXT: movq %r8, 40(%rsp) ## 8-byte Spill
+; CHECK-O0-NEXT: movq %rcx, 32(%rsp) ## 8-byte Spill
+; CHECK-O0-NEXT: movq %rdx, 24(%rsp) ## 8-byte Spill
+; CHECK-O0-NEXT: movq %rsi, 16(%rsp) ## 8-byte Spill
+; CHECK-O0-NEXT: movq %rdi, 8(%rsp) ## 8-byte Spill
; CHECK-O0-NEXT: ## implicit-def: $rax
; CHECK-O0-NEXT: xorl %eax, %eax
; CHECK-O0-NEXT: movl %eax, %r12d
-; CHECK-O0-NEXT: movq %r12, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
+; CHECK-O0-NEXT: movq %r12, 64(%rsp) ## 8-byte Spill
; CHECK-O0-NEXT: movl $1, %edi
-; CHECK-O0-NEXT: movq %rdi, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
+; CHECK-O0-NEXT: movq %rdi, 72(%rsp) ## 8-byte Spill
; CHECK-O0-NEXT: movl $2, %esi
-; CHECK-O0-NEXT: movq %rsi, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
+; CHECK-O0-NEXT: movq %rsi, 80(%rsp) ## 8-byte Spill
; CHECK-O0-NEXT: movl $3, %edx
-; CHECK-O0-NEXT: movq %rdx, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
+; CHECK-O0-NEXT: movq %rdx, 96(%rsp) ## 8-byte Spill
; CHECK-O0-NEXT: movl $4, %ecx
-; CHECK-O0-NEXT: movq %rcx, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
+; CHECK-O0-NEXT: movq %rcx, 104(%rsp) ## 8-byte Spill
; CHECK-O0-NEXT: movl $5, %r8d
-; CHECK-O0-NEXT: movq %r8, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
+; CHECK-O0-NEXT: movq %r8, 112(%rsp) ## 8-byte Spill
; CHECK-O0-NEXT: movl $6, %r9d
-; CHECK-O0-NEXT: movq %r9, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
+; CHECK-O0-NEXT: movq %r9, 88(%rsp) ## 8-byte Spill
; CHECK-O0-NEXT: movq %r12, %r13
; CHECK-O0-NEXT: callq _params_in_reg2
; CHECK-O0-NEXT: movq (%rsp), %r13 ## 8-byte Reload
-; CHECK-O0-NEXT: movq {{[-0-9]+}}(%r{{[sb]}}p), %rdi ## 8-byte Reload
-; CHECK-O0-NEXT: movq {{[-0-9]+}}(%r{{[sb]}}p), %rsi ## 8-byte Reload
-; CHECK-O0-NEXT: movq {{[-0-9]+}}(%r{{[sb]}}p), %rdx ## 8-byte Reload
-; CHECK-O0-NEXT: movq {{[-0-9]+}}(%r{{[sb]}}p), %rcx ## 8-byte Reload
-; CHECK-O0-NEXT: movq {{[-0-9]+}}(%r{{[sb]}}p), %r8 ## 8-byte Reload
-; CHECK-O0-NEXT: movq {{[-0-9]+}}(%r{{[sb]}}p), %r9 ## 8-byte Reload
+; CHECK-O0-NEXT: movq 8(%rsp), %rdi ## 8-byte Reload
+; CHECK-O0-NEXT: movq 16(%rsp), %rsi ## 8-byte Reload
+; CHECK-O0-NEXT: movq 24(%rsp), %rdx ## 8-byte Reload
+; CHECK-O0-NEXT: movq 32(%rsp), %rcx ## 8-byte Reload
+; CHECK-O0-NEXT: movq 40(%rsp), %r8 ## 8-byte Reload
+; CHECK-O0-NEXT: movq 48(%rsp), %r9 ## 8-byte Reload
; CHECK-O0-NEXT: movq %r12, %rax
-; CHECK-O0-NEXT: movq {{[-0-9]+}}(%r{{[sb]}}p), %r12 ## 8-byte Reload
-; CHECK-O0-NEXT: movq %rax, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
+; CHECK-O0-NEXT: movq 56(%rsp), %r12 ## 8-byte Reload
+; CHECK-O0-NEXT: movq %rax, 120(%rsp) ## 8-byte Spill
; CHECK-O0-NEXT: callq _params_and_return_in_reg2
-; CHECK-O0-NEXT: movq {{[-0-9]+}}(%r{{[sb]}}p), %r13 ## 8-byte Reload
-; CHECK-O0-NEXT: movq {{[-0-9]+}}(%r{{[sb]}}p), %rdi ## 8-byte Reload
-; CHECK-O0-NEXT: movq {{[-0-9]+}}(%r{{[sb]}}p), %rsi ## 8-byte Reload
-; CHECK-O0-NEXT: movq {{[-0-9]+}}(%r{{[sb]}}p), %r9 ## 8-byte Reload
-; CHECK-O0-NEXT: movq %rax, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
+; CHECK-O0-NEXT: movq 64(%rsp), %r13 ## 8-byte Reload
+; CHECK-O0-NEXT: movq 72(%rsp), %rdi ## 8-byte Reload
+; CHECK-O0-NEXT: movq 80(%rsp), %rsi ## 8-byte Reload
+; CHECK-O0-NEXT: movq 88(%rsp), %r9 ## 8-byte Reload
+; CHECK-O0-NEXT: movq %rax, 128(%rsp) ## 8-byte Spill
; CHECK-O0-NEXT: movq %rdx, %rax
-; CHECK-O0-NEXT: movq {{[-0-9]+}}(%r{{[sb]}}p), %rdx ## 8-byte Reload
-; CHECK-O0-NEXT: movq %rax, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
+; CHECK-O0-NEXT: movq 96(%rsp), %rdx ## 8-byte Reload
+; CHECK-O0-NEXT: movq %rax, 136(%rsp) ## 8-byte Spill
; CHECK-O0-NEXT: movq %rcx, %rax
-; CHECK-O0-NEXT: movq {{[-0-9]+}}(%r{{[sb]}}p), %rcx ## 8-byte Reload
-; CHECK-O0-NEXT: movq %rax, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
+; CHECK-O0-NEXT: movq 104(%rsp), %rcx ## 8-byte Reload
+; CHECK-O0-NEXT: movq %rax, 144(%rsp) ## 8-byte Spill
; CHECK-O0-NEXT: movq %r8, %rax
-; CHECK-O0-NEXT: movq {{[-0-9]+}}(%r{{[sb]}}p), %r8 ## 8-byte Reload
-; CHECK-O0-NEXT: movq %rax, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
+; CHECK-O0-NEXT: movq 112(%rsp), %r8 ## 8-byte Reload
+; CHECK-O0-NEXT: movq %rax, 152(%rsp) ## 8-byte Spill
; CHECK-O0-NEXT: movq %r12, %rax
-; CHECK-O0-NEXT: movq {{[-0-9]+}}(%r{{[sb]}}p), %r12 ## 8-byte Reload
-; CHECK-O0-NEXT: movq %rax, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
+; CHECK-O0-NEXT: movq 120(%rsp), %r12 ## 8-byte Reload
+; CHECK-O0-NEXT: movq %rax, 160(%rsp) ## 8-byte Spill
; CHECK-O0-NEXT: callq _params_in_reg2
-; CHECK-O0-NEXT: movq {{[-0-9]+}}(%r{{[sb]}}p), %rax ## 8-byte Reload
-; CHECK-O0-NEXT: movq {{[-0-9]+}}(%r{{[sb]}}p), %rdx ## 8-byte Reload
-; CHECK-O0-NEXT: movq {{[-0-9]+}}(%r{{[sb]}}p), %rcx ## 8-byte Reload
-; CHECK-O0-NEXT: movq {{[-0-9]+}}(%r{{[sb]}}p), %r8 ## 8-byte Reload
+; CHECK-O0-NEXT: movq 128(%rsp), %rax ## 8-byte Reload
+; CHECK-O0-NEXT: movq 136(%rsp), %rdx ## 8-byte Reload
+; CHECK-O0-NEXT: movq 144(%rsp), %rcx ## 8-byte Reload
+; CHECK-O0-NEXT: movq 152(%rsp), %r8 ## 8-byte Reload
; CHECK-O0-NEXT: movq %r12, %rsi
-; CHECK-O0-NEXT: movq {{[-0-9]+}}(%r{{[sb]}}p), %r12 ## 8-byte Reload
+; CHECK-O0-NEXT: movq 160(%rsp), %r12 ## 8-byte Reload
; CHECK-O0-NEXT: addq $176, %rsp
; CHECK-O0-NEXT: popq %r13
; CHECK-O0-NEXT: retq
@@ -1742,13 +1742,13 @@ define swiftcc { i64, i64, i64, i64} @params_and_return_in_reg(i64, i64, i64, i6
; CHECK-i386-NEXT: calll _params_and_return_in_reg2
; CHECK-i386-NEXT: subl $4, %esp
; CHECK-i386-NEXT: movl 88(%esp), %eax
-; CHECK-i386-NEXT: movl %eax, {{[-0-9]+}}(%e{{[sb]}}p) ## 4-byte Spill
+; CHECK-i386-NEXT: movl %eax, 84(%esp) ## 4-byte Spill
; CHECK-i386-NEXT: movl 92(%esp), %eax
-; CHECK-i386-NEXT: movl %eax, {{[-0-9]+}}(%e{{[sb]}}p) ## 4-byte Spill
+; CHECK-i386-NEXT: movl %eax, 80(%esp) ## 4-byte Spill
; CHECK-i386-NEXT: movl 96(%esp), %eax
-; CHECK-i386-NEXT: movl %eax, {{[-0-9]+}}(%e{{[sb]}}p) ## 4-byte Spill
+; CHECK-i386-NEXT: movl %eax, 76(%esp) ## 4-byte Spill
; CHECK-i386-NEXT: movl 100(%esp), %eax
-; CHECK-i386-NEXT: movl %eax, {{[-0-9]+}}(%e{{[sb]}}p) ## 4-byte Spill
+; CHECK-i386-NEXT: movl %eax, 72(%esp) ## 4-byte Spill
; CHECK-i386-NEXT: movl 104(%esp), %ebp
; CHECK-i386-NEXT: movl 108(%esp), %edi
; CHECK-i386-NEXT: movl 112(%esp), %esi
@@ -1774,13 +1774,13 @@ define swiftcc { i64, i64, i64, i64} @params_and_return_in_reg(i64, i64, i64, i6
; CHECK-i386-NEXT: movl %esi, 24(%eax)
; CHECK-i386-NEXT: movl %edi, 20(%eax)
; CHECK-i386-NEXT: movl %ebp, 16(%eax)
-; CHECK-i386-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %ecx ## 4-byte Reload
+; CHECK-i386-NEXT: movl 72(%esp), %ecx ## 4-byte Reload
; CHECK-i386-NEXT: movl %ecx, 12(%eax)
-; CHECK-i386-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %ecx ## 4-byte Reload
+; CHECK-i386-NEXT: movl 76(%esp), %ecx ## 4-byte Reload
; CHECK-i386-NEXT: movl %ecx, 8(%eax)
-; CHECK-i386-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %ecx ## 4-byte Reload
+; CHECK-i386-NEXT: movl 80(%esp), %ecx ## 4-byte Reload
; CHECK-i386-NEXT: movl %ecx, 4(%eax)
-; CHECK-i386-NEXT: movl {{[-0-9]+}}(%e{{[sb]}}p), %ecx ## 4-byte Reload
+; CHECK-i386-NEXT: movl 84(%esp), %ecx ## 4-byte Reload
; CHECK-i386-NEXT: movl %ecx, (%eax)
; CHECK-i386-NEXT: addl $124, %esp
; CHECK-i386-NEXT: popl %esi
@@ -1969,10 +1969,10 @@ define swiftcc ptr @testAssign2(ptr %error_ref, ptr swifterror %err) {
;
; CHECK-O0-LABEL: testAssign2:
; CHECK-O0: ## %bb.0: ## %entry
-; CHECK-O0-NEXT: movq %r12, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
+; CHECK-O0-NEXT: movq %r12, -8(%rsp) ## 8-byte Spill
; CHECK-O0-NEXT: jmp LBB23_1
; CHECK-O0-NEXT: LBB23_1: ## %a
-; CHECK-O0-NEXT: movq {{[-0-9]+}}(%r{{[sb]}}p), %r12 ## 8-byte Reload
+; CHECK-O0-NEXT: movq -8(%rsp), %r12 ## 8-byte Reload
; CHECK-O0-NEXT: movq %r12, %rax
; CHECK-O0-NEXT: retq
;
diff --git a/llvm/test/CodeGen/X86/var-permute-128.ll b/llvm/test/CodeGen/X86/var-permute-128.ll
index dbfad9562d65a..a66c074425374 100644
--- a/llvm/test/CodeGen/X86/var-permute-128.ll
+++ b/llvm/test/CodeGen/X86/var-permute-128.ll
@@ -1578,7 +1578,7 @@ define <16 x i8> @var_shuffle_v16i8_from_v32i8_v16i8(<32 x i8> %v, <16 x i8> %in
; SSE3-NEXT: movaps %xmm1, 400(%rsp)
; SSE3-NEXT: movaps %xmm0, 384(%rsp)
; SSE3-NEXT: movzbl -128(%rsp), %eax
-; SSE3-NEXT: movq %rax, {{[-0-9]+}}(%r{{[sb]}}p) # 8-byte Spill
+; SSE3-NEXT: movq %rax, -104(%rsp) # 8-byte Spill
; SSE3-NEXT: movaps %xmm1, 368(%rsp)
; SSE3-NEXT: movaps %xmm0, 352(%rsp)
; SSE3-NEXT: movzbl -127(%rsp), %ecx
@@ -1669,7 +1669,7 @@ define <16 x i8> @var_shuffle_v16i8_from_v32i8_v16i8(<32 x i8> %v, <16 x i8> %in
; SSE3-NEXT: andl $31, %ecx
; SSE3-NEXT: movzbl 352(%rsp,%rcx), %eax
; SSE3-NEXT: movd %eax, %xmm15
-; SSE3-NEXT: movq {{[-0-9]+}}(%r{{[sb]}}p), %rax # 8-byte Reload
+; SSE3-NEXT: movq -104(%rsp), %rax # 8-byte Reload
; SSE3-NEXT: andl $31, %eax
; SSE3-NEXT: movzbl 384(%rsp,%rax), %eax
; SSE3-NEXT: movd %eax, %xmm0
@@ -1710,7 +1710,7 @@ define <16 x i8> @var_shuffle_v16i8_from_v32i8_v16i8(<32 x i8> %v, <16 x i8> %in
; SSSE3-NEXT: movaps %xmm1, 400(%rsp)
; SSSE3-NEXT: movaps %xmm0, 384(%rsp)
; SSSE3-NEXT: movzbl -128(%rsp), %eax
-; SSSE3-NEXT: movq %rax, {{[-0-9]+}}(%r{{[sb]}}p) # 8-byte Spill
+; SSSE3-NEXT: movq %rax, -104(%rsp) # 8-byte Spill
; SSSE3-NEXT: movaps %xmm1, 368(%rsp)
; SSSE3-NEXT: movaps %xmm0, 352(%rsp)
; SSSE3-NEXT: movzbl -127(%rsp), %ecx
@@ -1801,7 +1801,7 @@ define <16 x i8> @var_shuffle_v16i8_from_v32i8_v16i8(<32 x i8> %v, <16 x i8> %in
; SSSE3-NEXT: andl $31, %ecx
; SSSE3-NEXT: movzbl 352(%rsp,%rcx), %eax
; SSSE3-NEXT: movd %eax, %xmm15
-; SSSE3-NEXT: movq {{[-0-9]+}}(%r{{[sb]}}p), %rax # 8-byte Reload
+; SSSE3-NEXT: movq -104(%rsp), %rax # 8-byte Reload
; SSSE3-NEXT: andl $31, %eax
; SSSE3-NEXT: movzbl 384(%rsp,%rax), %eax
; SSSE3-NEXT: movd %eax, %xmm0
diff --git a/llvm/utils/UpdateTestChecks/asm.py b/llvm/utils/UpdateTestChecks/asm.py
index c017c8b4610c2..17aae40ea319b 100644
--- a/llvm/utils/UpdateTestChecks/asm.py
+++ b/llvm/utils/UpdateTestChecks/asm.py
@@ -307,10 +307,10 @@ def scrub_asm_x86(asm, args):
else:
asm = SCRUB_X86_SHUFFLES_RE.sub(r"\1 {{.*#+}} \2", asm)
- # Detect stack spills and reloads and hide their exact offset and whether
- # they used the stack pointer or frame pointer.
- asm = SCRUB_X86_SPILL_RELOAD_RE.sub(r"{{[-0-9]+}}(%\1{{[sb]}}p)\2", asm)
if getattr(args, "x86_scrub_sp", True):
+ # Detect stack spills and reloads and hide their exact offset and whether
+ # they used the stack pointer or frame pointer.
+ asm = SCRUB_X86_SPILL_RELOAD_RE.sub(r"{{[-0-9]+}}(%\1{{[sb]}}p)\2", asm)
# Generically match the stack offset of a memory operand.
asm = SCRUB_X86_SP_RE.sub(r"{{[0-9]+}}(%\1)", asm)
if getattr(args, "x86_scrub_rip", False):
More information about the llvm-commits
mailing list