[X86][SSE] Added SSE fp stack folding tests.
[opencl/llvm.git] / test / CodeGen / X86 / stack-folding-fp-sse42.ll
1 ; RUN: llc -O3 -disable-peephole -mtriple=x86_64-unknown-unknown -mcpu=x86-64 -mattr=+sse4.2 < %s | FileCheck %s
3 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
4 target triple = "x86_64-unknown-unknown"
6 ; Stack reload folding tests.
7 ;
8 ; By including a nop call with sideeffects we can force a partial register spill of the
9 ; relevant registers and check that the reload is correctly folded into the instruction.
11 define <2 x double> @stack_fold_addpd(<2 x double> %a0, <2 x double> %a1) {
12   ;CHECK-LABEL: stack_fold_addpd
13   ;CHECK:       addpd {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
14   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
15   %2 = fadd <2 x double> %a0, %a1
16   ret <2 x double> %2
17 }
19 define <4 x float> @stack_fold_addps(<4 x float> %a0, <4 x float> %a1) {
20   ;CHECK-LABEL: stack_fold_addps
21   ;CHECK:       addps {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
22   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
23   %2 = fadd <4 x float> %a0, %a1
24   ret <4 x float> %2
25 }
27 define double @stack_fold_addsd(double %a0, double %a1) {
28   ;CHECK-LABEL: stack_fold_addsd
29   ;CHECK:       addsd {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 8-byte Folded Reload
30   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
31   %2 = fadd double %a0, %a1
32   ret double %2
33 }
35 define <2 x double> @stack_fold_addsd_int(<2 x double> %a0, <2 x double> %a1) {
36   ;CHECK-LABEL: stack_fold_addsd_int
37   ;CHECK:       addsd {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
38   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
39   %2 = call <2 x double> @llvm.x86.sse2.add.sd(<2 x double> %a0, <2 x double> %a1)
40   ret <2 x double> %2
41 }
42 declare <2 x double> @llvm.x86.sse2.add.sd(<2 x double>, <2 x double>) nounwind readnone
44 define float @stack_fold_addss(float %a0, float %a1) {
45   ;CHECK-LABEL: stack_fold_addss
46   ;CHECK:       addss {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 4-byte Folded Reload
47   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
48   %2 = fadd float %a0, %a1
49   ret float %2
50 }
52 define <4 x float> @stack_fold_addss_int(<4 x float> %a0, <4 x float> %a1) {
53   ;CHECK-LABEL: stack_fold_addss_int
54   ;CHECK:       addss {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
55   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
56   %2 = call <4 x float> @llvm.x86.sse.add.ss(<4 x float> %a0, <4 x float> %a1)
57   ret <4 x float> %2
58 }
59 declare <4 x float> @llvm.x86.sse.add.ss(<4 x float>, <4 x float>) nounwind readnone
61 define <2 x double> @stack_fold_addsubpd(<2 x double> %a0, <2 x double> %a1) {
62   ;CHECK-LABEL: stack_fold_addsubpd
63   ;CHECK:       addsubpd {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
64   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
65   %2 = call <2 x double> @llvm.x86.sse3.addsub.pd(<2 x double> %a0, <2 x double> %a1)
66   ret <2 x double> %2
67 }
68 declare <2 x double> @llvm.x86.sse3.addsub.pd(<2 x double>, <2 x double>) nounwind readnone
70 define <4 x float> @stack_fold_addsubps(<4 x float> %a0, <4 x float> %a1) {
71   ;CHECK-LABEL: stack_fold_addsubps
72   ;CHECK:       addsubps {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
73   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
74   %2 = call <4 x float> @llvm.x86.sse3.addsub.ps(<4 x float> %a0, <4 x float> %a1)
75   ret <4 x float> %2
76 }
77 declare <4 x float> @llvm.x86.sse3.addsub.ps(<4 x float>, <4 x float>) nounwind readnone
79 define <2 x double> @stack_fold_andnpd(<2 x double> %a0, <2 x double> %a1) {
80   ;CHECK-LABEL: stack_fold_andnpd
81   ;CHECK:       andnpd {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
82   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
83   %2 = bitcast <2 x double> %a0 to <2 x i64>
84   %3 = bitcast <2 x double> %a1 to <2 x i64>
85   %4 = xor <2 x i64> %2, <i64 -1, i64 -1>
86   %5 = and <2 x i64> %4, %3
87   %6 = bitcast <2 x i64> %5 to <2 x double>
88   ; fadd forces execution domain
89   %7 = fadd <2 x double> %6, <double 0x0, double 0x0>
90   ret <2 x double> %7
91 }
93 define <4 x float> @stack_fold_andnps(<4 x float> %a0, <4 x float> %a1) {
94   ;CHECK-LABEL: stack_fold_andnps
95   ;CHECK:       andnps {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
96   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
97   %2 = bitcast <4 x float> %a0 to <2 x i64>
98   %3 = bitcast <4 x float> %a1 to <2 x i64>
99   %4 = xor <2 x i64> %2, <i64 -1, i64 -1>
100   %5 = and <2 x i64> %4, %3
101   %6 = bitcast <2 x i64> %5 to <4 x float>
102   ret <4 x float> %6
105 define <2 x double> @stack_fold_andpd(<2 x double> %a0, <2 x double> %a1) {
106   ;CHECK-LABEL: stack_fold_andpd
107   ;CHECK:       andpd {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
108   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
109   %2 = bitcast <2 x double> %a0 to <2 x i64>
110   %3 = bitcast <2 x double> %a1 to <2 x i64>
111   %4 = and <2 x i64> %2, %3
112   %5 = bitcast <2 x i64> %4 to <2 x double>
113   ; fadd forces execution domain
114   %6 = fadd <2 x double> %5, <double 0x0, double 0x0>
115   ret <2 x double> %6
118 define <4 x float> @stack_fold_andps(<4 x float> %a0, <4 x float> %a1) {
119   ;CHECK-LABEL: stack_fold_andps
120   ;CHECK:       andps {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
121   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
122   %2 = bitcast <4 x float> %a0 to <2 x i64>
123   %3 = bitcast <4 x float> %a1 to <2 x i64>
124   %4 = and <2 x i64> %2, %3
125   %5 = bitcast <2 x i64> %4 to <4 x float>
126   ret <4 x float> %5
129 define <2 x double> @stack_fold_blendpd(<2 x double> %a0, <2 x double> %a1) {
130   ;CHECK-LABEL: stack_fold_blendpd
131   ;CHECK:       blendpd $2, {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
132   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
133   %2 = select <2 x i1> <i1 1, i1 0>, <2 x double> %a0, <2 x double> %a1
134   ret <2 x double> %2
137 define <4 x float> @stack_fold_blendps(<4 x float> %a0, <4 x float> %a1) {
138   ;CHECK-LABEL: stack_fold_blendps
139   ;CHECK:       blendps $6, {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
140   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
141   %2 = select <4 x i1> <i1 1, i1 0, i1 0, i1 1>, <4 x float> %a0, <4 x float> %a1
142   ret <4 x float> %2
145 define <2 x double> @stack_fold_blendvpd(<2 x double> %a0, <2 x double> %a1, <2 x double> %c) {
146   ;CHECK-LABEL: stack_fold_blendvpd
147   ;CHECK:       blendvpd {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
148   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
149   %2 = call <2 x double> @llvm.x86.sse41.blendvpd(<2 x double> %a1, <2 x double> %c, <2 x double> %a0)
150   ret <2 x double> %2
152 declare <2 x double> @llvm.x86.sse41.blendvpd(<2 x double>, <2 x double>, <2 x double>) nounwind readnone
154 define <4 x float> @stack_fold_blendvps(<4 x float> %a0, <4 x float> %a1, <4 x float> %c) {
155   ;CHECK-LABEL: stack_fold_blendvps
156   ;CHECK:       blendvps {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
157   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
158   %2 = call <4 x float> @llvm.x86.sse41.blendvps(<4 x float> %a1, <4 x float> %c, <4 x float> %a0)
159   ret <4 x float> %2
161 declare <4 x float> @llvm.x86.sse41.blendvps(<4 x float>, <4 x float>, <4 x float>) nounwind readnone
163 define <2 x double> @stack_fold_cmppd(<2 x double> %a0, <2 x double> %a1) {
164   ;CHECK-LABEL: stack_fold_cmppd
165   ;CHECK:       cmpeqpd {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
166   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
167   %2 = call <2 x double> @llvm.x86.sse2.cmp.pd(<2 x double> %a0, <2 x double> %a1, i8 0)
168   ret <2 x double> %2
170 declare <2 x double> @llvm.x86.sse2.cmp.pd(<2 x double>, <2 x double>, i8) nounwind readnone
172 define <4 x float> @stack_fold_cmpps(<4 x float> %a0, <4 x float> %a1) {
173   ;CHECK-LABEL: stack_fold_cmpps
174   ;CHECK:       cmpeqps {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
175   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
176   %2 = call <4 x float> @llvm.x86.sse.cmp.ps(<4 x float> %a0, <4 x float> %a1, i8 0)
177   ret <4 x float> %2
179 declare <4 x float> @llvm.x86.sse.cmp.ps(<4 x float>, <4 x float>, i8) nounwind readnone
181 define i32 @stack_fold_cmpsd(double %a0, double %a1) {
182   ;CHECK-LABEL: stack_fold_cmpsd
183   ;CHECK:       cmpeqsd {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 8-byte Folded Reload
184   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
185   %2 = fcmp oeq double %a0, %a1
186   %3 = zext i1 %2 to i32
187   ret i32 %3
190 define <2 x double> @stack_fold_cmpsd_int(<2 x double> %a0, <2 x double> %a1) {
191   ;CHECK-LABEL: stack_fold_cmpsd_int
192   ;CHECK:       cmpeqsd {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
193   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
194   %2 = call <2 x double> @llvm.x86.sse2.cmp.sd(<2 x double> %a0, <2 x double> %a1, i8 0)
195   ret <2 x double> %2
197 declare <2 x double> @llvm.x86.sse2.cmp.sd(<2 x double>, <2 x double>, i8) nounwind readnone
199 define i32 @stack_fold_cmpss(float %a0, float %a1) {
200   ;CHECK-LABEL: stack_fold_cmpss
201   ;CHECK:       cmpeqss {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 4-byte Folded Reload
202   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
203   %2 = fcmp oeq float %a0, %a1
204   %3 = zext i1 %2 to i32
205   ret i32 %3
208 define <4 x float> @stack_fold_cmpss_int(<4 x float> %a0, <4 x float> %a1) {
209   ;CHECK-LABEL: stack_fold_cmpss_int
210   ;CHECK:       cmpeqss {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
211   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
212   %2 = call <4 x float> @llvm.x86.sse.cmp.ss(<4 x float> %a0, <4 x float> %a1, i8 0)
213   ret <4 x float> %2
215 declare <4 x float> @llvm.x86.sse.cmp.ss(<4 x float>, <4 x float>, i8) nounwind readnone
217 ; TODO stack_fold_comisd
219 define i32 @stack_fold_comisd_int(<2 x double> %a0, <2 x double> %a1) {
220   ;CHECK-LABEL: stack_fold_comisd_int
221   ;CHECK:       comisd {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
222   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
223   %2 = call i32 @llvm.x86.sse2.comieq.sd(<2 x double> %a0, <2 x double> %a1)
224   ret i32 %2
226 declare i32 @llvm.x86.sse2.comieq.sd(<2 x double>, <2 x double>) nounwind readnone
228 ; TODO stack_fold_comiss
230 define i32 @stack_fold_comiss_int(<4 x float> %a0, <4 x float> %a1) {
231   ;CHECK-LABEL: stack_fold_comiss_int
232   ;CHECK:       comiss {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
233   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
234   %2 = call i32 @llvm.x86.sse.comieq.ss(<4 x float> %a0, <4 x float> %a1)
235   ret i32 %2
237 declare i32 @llvm.x86.sse.comieq.ss(<4 x float>, <4 x float>) nounwind readnone
239 define <2 x double> @stack_fold_cvtdq2pd(<4 x i32> %a0) {
240   ;CHECK-LABEL: stack_fold_cvtdq2pd
241   ;CHECK:       cvtdq2pd {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
242   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm1},~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
243   %2 = call <2 x double> @llvm.x86.sse2.cvtdq2pd(<4 x i32> %a0)
244   ret <2 x double> %2
246 declare <2 x double> @llvm.x86.sse2.cvtdq2pd(<4 x i32>) nounwind readnone
248 define <4 x float> @stack_fold_cvtdq2ps(<4 x i32> %a0) {
249   ;CHECK-LABEL: stack_fold_cvtdq2ps
250   ;CHECK:       cvtdq2ps {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
251   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm1},~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
252   %2 = sitofp <4 x i32> %a0 to <4 x float>
253   ret <4 x float> %2
256 define <4 x i32> @stack_fold_cvtpd2dq(<2 x double> %a0) {
257   ;CHECK-LABEL: stack_fold_cvtpd2dq
258   ;CHECK:       cvtpd2dq {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
259   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm1},~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
260   %2 = call <4 x i32> @llvm.x86.sse2.cvtpd2dq(<2 x double> %a0)
261   ret <4 x i32> %2
263 declare <4 x i32> @llvm.x86.sse2.cvtpd2dq(<2 x double>) nounwind readnone
265 define <2 x float> @stack_fold_cvtpd2ps(<2 x double> %a0) {
266   ;CHECK-LABEL: stack_fold_cvtpd2ps
267   ;CHECK:       cvtpd2ps {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
268   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm1},~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
269   %2 = fptrunc <2 x double> %a0 to <2 x float>
270   ret <2 x float> %2
273 define <4 x i32> @stack_fold_cvtps2dq(<4 x float> %a0) {
274   ;CHECK-LABEL: stack_fold_cvtps2dq
275   ;CHECK:       cvtps2dq {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
276   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm1},~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
277   %2 = call <4 x i32> @llvm.x86.sse2.cvtps2dq(<4 x float> %a0)
278   ret <4 x i32> %2
280 declare <4 x i32> @llvm.x86.sse2.cvtps2dq(<4 x float>) nounwind readnone
282 define <2 x double> @stack_fold_cvtps2pd(<4 x float> %a0) {
283   ;CHECK-LABEL: stack_fold_cvtps2pd
284   ;CHECK:       cvtps2pd {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
285   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm1},~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
286   %2 = call <2 x double> @llvm.x86.sse2.cvtps2pd(<4 x float> %a0)
287   ret <2 x double> %2
289 declare <2 x double> @llvm.x86.sse2.cvtps2pd(<4 x float>) nounwind readnone
291 ; TODO stack_fold_cvtsd2si
293 define i32 @stack_fold_cvtsd2si_int(<2 x double> %a0) {
294   ;CHECK-LABEL: stack_fold_cvtsd2si_int
295   ;CHECK:       cvtsd2si {{-?[0-9]*}}(%rsp), %eax {{.*#+}} 16-byte Folded Reload
296   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm1},~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
297   %2 = call i32 @llvm.x86.sse2.cvtsd2si(<2 x double> %a0)
298   ret i32 %2
300 declare i32 @llvm.x86.sse2.cvtsd2si(<2 x double>) nounwind readnone
302 ; TODO stack_fold_cvtsd2si64
304 define i64 @stack_fold_cvtsd2si64_int(<2 x double> %a0) {
305   ;CHECK-LABEL: stack_fold_cvtsd2si64_int
306   ;CHECK:       cvtsd2siq {{-?[0-9]*}}(%rsp), %rax {{.*#+}} 16-byte Folded Reload
307   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm1},~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
308   %2 = call i64 @llvm.x86.sse2.cvtsd2si64(<2 x double> %a0)
309   ret i64 %2
311 declare i64 @llvm.x86.sse2.cvtsd2si64(<2 x double>) nounwind readnone
313 ; TODO stack_fold_cvtsd2ss
315 define <4 x float> @stack_fold_cvtsd2ss_int(<2 x double> %a0) optsize {
316   ;CHECK-LABEL: stack_fold_cvtsd2ss_int
317   ;CHECK:       cvtsd2ss {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
318   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm1},~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
319   %2 = call <4 x float> @llvm.x86.sse2.cvtsd2ss(<4 x float> <float 0x0, float 0x0, float 0x0, float 0x0>, <2 x double> %a0)
320   ret <4 x float> %2
322 declare <4 x float> @llvm.x86.sse2.cvtsd2ss(<4 x float>, <2 x double>) nounwind readnone
324 define double @stack_fold_cvtsi2sd(i32 %a0) optsize {
325   ;CHECK-LABEL: stack_fold_cvtsi2sd
326   ;CHECK:       cvtsi2sdl {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 4-byte Folded Reload
327   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{rax},~{rbx},~{rcx},~{rdx},~{rsi},~{rdi},~{rbp},~{r8},~{r9},~{r10},~{r11},~{r12},~{r13},~{r14},~{r15}"()
328   %2 = sitofp i32 %a0 to double
329   ret double %2
332 define <2 x double> @stack_fold_cvtsi2sd_int(i32 %a0) {
333   ;CHECK-LABEL: stack_fold_cvtsi2sd_int
334   ;CHECK:       cvtsi2sdl {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 4-byte Folded Reload
335   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{rax},~{rbx},~{rcx},~{rdx},~{rsi},~{rdi},~{rbp},~{r8},~{r9},~{r10},~{r11},~{r12},~{r13},~{r14},~{r15}"()
336   %2 = call <2 x double> @llvm.x86.sse2.cvtsi2sd(<2 x double> <double 0x0, double 0x0>, i32 %a0)
337   ret <2 x double> %2
339 declare <2 x double> @llvm.x86.sse2.cvtsi2sd(<2 x double>, i32) nounwind readnone
341 define double @stack_fold_cvtsi642sd(i64 %a0) optsize {
342   ;CHECK-LABEL: stack_fold_cvtsi642sd
343   ;CHECK:       cvtsi2sdq {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 8-byte Folded Reload
344   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{rax},~{rbx},~{rcx},~{rdx},~{rsi},~{rdi},~{rbp},~{r8},~{r9},~{r10},~{r11},~{r12},~{r13},~{r14},~{r15}"()
345   %2 = sitofp i64 %a0 to double
346   ret double %2
349 define <2 x double> @stack_fold_cvtsi642sd_int(i64 %a0) {
350   ;CHECK-LABEL: stack_fold_cvtsi642sd_int
351   ;CHECK:       cvtsi2sdq {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 8-byte Folded Reload
352   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{rax},~{rbx},~{rcx},~{rdx},~{rsi},~{rdi},~{rbp},~{r8},~{r9},~{r10},~{r11},~{r12},~{r13},~{r14},~{r15}"()
353   %2 = call <2 x double> @llvm.x86.sse2.cvtsi642sd(<2 x double> <double 0x0, double 0x0>, i64 %a0)
354   ret <2 x double> %2
356 declare <2 x double> @llvm.x86.sse2.cvtsi642sd(<2 x double>, i64) nounwind readnone
358 define float @stack_fold_cvtsi2ss(i32 %a0) optsize {
359   ;CHECK-LABEL: stack_fold_cvtsi2ss
360   ;CHECK:       cvtsi2ssl {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 4-byte Folded Reload
361   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{rax},~{rbx},~{rcx},~{rdx},~{rsi},~{rdi},~{rbp},~{r8},~{r9},~{r10},~{r11},~{r12},~{r13},~{r14},~{r15}"()
362   %2 = sitofp i32 %a0 to float
363   ret float %2
366 define <4 x float> @stack_fold_cvtsi2ss_int(i32 %a0) {
367   ;CHECK-LABEL: stack_fold_cvtsi2ss_int
368   ;CHECK:  cvtsi2ssl {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 4-byte Folded Reload
369   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{rax},~{rbx},~{rcx},~{rdx},~{rsi},~{rdi},~{rbp},~{r8},~{r9},~{r10},~{r11},~{r12},~{r13},~{r14},~{r15}"()
370   %2 = call <4 x float> @llvm.x86.sse.cvtsi2ss(<4 x float> <float 0x0, float 0x0, float 0x0, float 0x0>, i32 %a0)
371   ret <4 x float> %2
373 declare <4 x float> @llvm.x86.sse.cvtsi2ss(<4 x float>, i32) nounwind readnone
375 define float @stack_fold_cvtsi642ss(i64 %a0) optsize {
376   ;CHECK-LABEL: stack_fold_cvtsi642ss
377   ;CHECK:       cvtsi2ssq {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 8-byte Folded Reload
378   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{rax},~{rbx},~{rcx},~{rdx},~{rsi},~{rdi},~{rbp},~{r8},~{r9},~{r10},~{r11},~{r12},~{r13},~{r14},~{r15}"()
379   %2 = sitofp i64 %a0 to float
380   ret float %2
383 define <4 x float> @stack_fold_cvtsi642ss_int(i64 %a0) {
384   ;CHECK-LABEL: stack_fold_cvtsi642ss_int
385   ;CHECK:  cvtsi2ssq {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 8-byte Folded Reload
386   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{rax},~{rbx},~{rcx},~{rdx},~{rsi},~{rdi},~{rbp},~{r8},~{r9},~{r10},~{r11},~{r12},~{r13},~{r14},~{r15}"()
387   %2 = call <4 x float> @llvm.x86.sse.cvtsi642ss(<4 x float> <float 0x0, float 0x0, float 0x0, float 0x0>, i64 %a0)
388   ret <4 x float> %2
390 declare <4 x float> @llvm.x86.sse.cvtsi642ss(<4 x float>, i64) nounwind readnone
392 define double @stack_fold_cvtss2sd(float %a0) optsize {
393   ;CHECK-LABEL: stack_fold_cvtss2sd
394   ;CHECK:       cvtss2sd {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 4-byte Folded Reload
395   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm1},~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
396   %2 = fpext float %a0 to double
397   ret double %2
400 define <2 x double> @stack_fold_cvtss2sd_int(<4 x float> %a0) optsize {
401   ;CHECK-LABEL: stack_fold_cvtss2sd_int
402   ;CHECK:       cvtss2sd {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
403   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm1},~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
404   %2 = call <2 x double> @llvm.x86.sse2.cvtss2sd(<2 x double> <double 0x0, double 0x0>, <4 x float> %a0)
405   ret <2 x double> %2
407 declare <2 x double> @llvm.x86.sse2.cvtss2sd(<2 x double>, <4 x float>) nounwind readnone
409 ; TODO stack_fold_cvtss2si
411 define i32 @stack_fold_cvtss2si_int(<4 x float> %a0) {
412   ;CHECK-LABEL: stack_fold_cvtss2si_int
413   ;CHECK:       cvtss2si {{-?[0-9]*}}(%rsp), %eax {{.*#+}} 16-byte Folded Reload
414   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm1},~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
415   %2 = call i32 @llvm.x86.sse.cvtss2si(<4 x float> %a0)
416   ret i32 %2
418 declare i32 @llvm.x86.sse.cvtss2si(<4 x float>) nounwind readnone
420 ; TODO stack_fold_cvtss2si64
422 define i64 @stack_fold_cvtss2si64_int(<4 x float> %a0) {
423   ;CHECK-LABEL: stack_fold_cvtss2si64_int
424   ;CHECK:       cvtss2si {{-?[0-9]*}}(%rsp), %rax {{.*#+}} 16-byte Folded Reload
425   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm1},~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
426   %2 = call i64 @llvm.x86.sse.cvtss2si64(<4 x float> %a0)
427   ret i64 %2
429 declare i64 @llvm.x86.sse.cvtss2si64(<4 x float>) nounwind readnone
431 define <4 x i32> @stack_fold_cvttpd2dq(<2 x double> %a0) {
432   ;CHECK-LABEL: stack_fold_cvttpd2dq
433   ;CHECK:       cvttpd2dq {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
434   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm1},~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
435   %2 = call <4 x i32> @llvm.x86.sse2.cvttpd2dq(<2 x double> %a0)
436   ret <4 x i32> %2
438 declare <4 x i32> @llvm.x86.sse2.cvttpd2dq(<2 x double>) nounwind readnone
440 define <4 x i32> @stack_fold_cvttps2dq(<4 x float> %a0) {
441   ;CHECK-LABEL: stack_fold_cvttps2dq
442   ;CHECK:       cvttps2dq {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
443   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm1},~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
444   %2 = fptosi <4 x float> %a0 to <4 x i32>
445   ret <4 x i32> %2
448 define i32 @stack_fold_cvttsd2si(double %a0) {
449   ;CHECK-LABEL: stack_fold_cvttsd2si
450   ;CHECK:       cvttsd2si {{-?[0-9]*}}(%rsp), %eax {{.*#+}} 8-byte Folded Reload
451   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm1},~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
452   %2 = fptosi double %a0 to i32
453   ret i32 %2
456 define i32 @stack_fold_cvttsd2si_int(<2 x double> %a0) {
457   ;CHECK-LABEL: stack_fold_cvttsd2si_int
458   ;CHECK:       cvttsd2si {{-?[0-9]*}}(%rsp), %eax {{.*#+}} 16-byte Folded Reload
459   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm1},~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
460   %2 = call i32 @llvm.x86.sse2.cvttsd2si(<2 x double> %a0)
461   ret i32 %2
463 declare i32 @llvm.x86.sse2.cvttsd2si(<2 x double>) nounwind readnone
465 define i64 @stack_fold_cvttsd2si64(double %a0) {
466   ;CHECK-LABEL: stack_fold_cvttsd2si64
467   ;CHECK:       cvttsd2si {{-?[0-9]*}}(%rsp), %rax {{.*#+}} 8-byte Folded Reload
468   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm1},~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
469   %2 = fptosi double %a0 to i64
470   ret i64 %2
473 define i64 @stack_fold_cvttsd2si64_int(<2 x double> %a0) {
474   ;CHECK-LABEL: stack_fold_cvttsd2si64_int
475   ;CHECK:       cvttsd2si {{-?[0-9]*}}(%rsp), %rax {{.*#+}} 16-byte Folded Reload
476   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm1},~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
477   %2 = call i64 @llvm.x86.sse2.cvttsd2si64(<2 x double> %a0)
478   ret i64 %2
480 declare i64 @llvm.x86.sse2.cvttsd2si64(<2 x double>) nounwind readnone
482 define i32 @stack_fold_cvttss2si(float %a0) {
483   ;CHECK-LABEL: stack_fold_cvttss2si
484   ;CHECK:       cvttss2si {{-?[0-9]*}}(%rsp), %eax {{.*#+}} 4-byte Folded Reload
485   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm1},~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
486   %2 = fptosi float %a0 to i32
487   ret i32 %2
490 define i32 @stack_fold_cvttss2si_int(<4 x float> %a0) {
491   ;CHECK-LABEL: stack_fold_cvttss2si_int
492   ;CHECK:       cvttss2si {{-?[0-9]*}}(%rsp), %eax {{.*#+}} 16-byte Folded Reload
493   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm1},~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
494   %2 = call i32 @llvm.x86.sse.cvttss2si(<4 x float> %a0)
495   ret i32 %2
497 declare i32 @llvm.x86.sse.cvttss2si(<4 x float>) nounwind readnone
499 define i64 @stack_fold_cvttss2si64(float %a0) {
500   ;CHECK-LABEL: stack_fold_cvttss2si64
501   ;CHECK:       cvttss2si {{-?[0-9]*}}(%rsp), %rax {{.*#+}} 4-byte Folded Reload
502   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm1},~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
503   %2 = fptosi float %a0 to i64
504   ret i64 %2
507 define i64 @stack_fold_cvttss2si64_int(<4 x float> %a0) {
508   ;CHECK-LABEL: stack_fold_cvttss2si64_int
509   ;CHECK:       cvttss2si {{-?[0-9]*}}(%rsp), %rax {{.*#+}} 16-byte Folded Reload
510   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm1},~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
511   %2 = call i64 @llvm.x86.sse.cvttss2si64(<4 x float> %a0)
512   ret i64 %2
514 declare i64 @llvm.x86.sse.cvttss2si64(<4 x float>) nounwind readnone
516 define <2 x double> @stack_fold_divpd(<2 x double> %a0, <2 x double> %a1) {
517   ;CHECK-LABEL: stack_fold_divpd
518   ;CHECK:       divpd {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
519   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
520   %2 = fdiv <2 x double> %a0, %a1
521   ret <2 x double> %2
524 define <4 x float> @stack_fold_divps(<4 x float> %a0, <4 x float> %a1) {
525   ;CHECK-LABEL: stack_fold_divps
526   ;CHECK:       divps {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
527   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
528   %2 = fdiv <4 x float> %a0, %a1
529   ret <4 x float> %2
532 define double @stack_fold_divsd(double %a0, double %a1) {
533   ;CHECK-LABEL: stack_fold_divsd
534   ;CHECK:       divsd {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 8-byte Folded Reload
535   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
536   %2 = fdiv double %a0, %a1
537   ret double %2
540 define <2 x double> @stack_fold_divsd_int(<2 x double> %a0, <2 x double> %a1) {
541   ;CHECK-LABEL: stack_fold_divsd_int
542   ;CHECK:       divsd {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
543   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
544   %2 = call <2 x double> @llvm.x86.sse2.div.sd(<2 x double> %a0, <2 x double> %a1)
545   ret <2 x double> %2
547 declare <2 x double> @llvm.x86.sse2.div.sd(<2 x double>, <2 x double>) nounwind readnone
549 define float @stack_fold_divss(float %a0, float %a1) {
550   ;CHECK-LABEL: stack_fold_divss
551   ;CHECK:       divss {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 4-byte Folded Reload
552   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
553   %2 = fdiv float %a0, %a1
554   ret float %2
557 define <4 x float> @stack_fold_divss_int(<4 x float> %a0, <4 x float> %a1) {
558   ;CHECK-LABEL: stack_fold_divss_int
559   ;CHECK:       divss {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
560   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
561   %2 = call <4 x float> @llvm.x86.sse.div.ss(<4 x float> %a0, <4 x float> %a1)
562   ret <4 x float> %2
564 declare <4 x float> @llvm.x86.sse.div.ss(<4 x float>, <4 x float>) nounwind readnone
566 define <2 x double> @stack_fold_dppd(<2 x double> %a0, <2 x double> %a1) {
567   ;CHECK-LABEL: stack_fold_dppd
568   ;CHECK:       dppd $7, {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
569   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
570   %2 = call <2 x double> @llvm.x86.sse41.dppd(<2 x double> %a0, <2 x double> %a1, i8 7)
571   ret <2 x double> %2
573 declare <2 x double> @llvm.x86.sse41.dppd(<2 x double>, <2 x double>, i8) nounwind readnone
575 define <4 x float> @stack_fold_dpps(<4 x float> %a0, <4 x float> %a1) {
576   ;CHECK-LABEL: stack_fold_dpps
577   ;CHECK:       dpps $7, {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
578   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
579   %2 = call <4 x float> @llvm.x86.sse41.dpps(<4 x float> %a0, <4 x float> %a1, i8 7)
580   ret <4 x float> %2
582 declare <4 x float> @llvm.x86.sse41.dpps(<4 x float>, <4 x float>, i8) nounwind readnone
584 define i32 @stack_fold_extractps(<4 x float> %a0) {
585   ;CHECK-LABEL: stack_fold_extractps
586   ;CHECK:       extractps $1, {{%xmm[0-9][0-9]*}}, {{-?[0-9]*}}(%rsp) {{.*#+}} 4-byte Folded Spill
587   ;CHECK:       movl    {{-?[0-9]*}}(%rsp), %eax {{.*#+}} 4-byte Reload
588   %1 = extractelement <4 x float> %a0, i32 1
589   %2 = bitcast float %1 to i32
590   %3 = tail call <2 x i64> asm sideeffect "nop", "=x,~{rax},~{rbx},~{rcx},~{rdx},~{rsi},~{rdi},~{rbp},~{r8},~{r9},~{r10},~{r11},~{r12},~{r13},~{r14},~{r15}"()
591   ret i32 %2
594 define <2 x double> @stack_fold_haddpd(<2 x double> %a0, <2 x double> %a1) {
595   ;CHECK-LABEL: stack_fold_haddpd
596   ;CHECK:       haddpd {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
597   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
598   %2 = call <2 x double> @llvm.x86.sse3.hadd.pd(<2 x double> %a0, <2 x double> %a1)
599   ret <2 x double> %2
601 declare <2 x double> @llvm.x86.sse3.hadd.pd(<2 x double>, <2 x double>) nounwind readnone
603 define <4 x float> @stack_fold_haddps(<4 x float> %a0, <4 x float> %a1) {
604   ;CHECK-LABEL: stack_fold_haddps
605   ;CHECK:       haddps {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
606   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
607   %2 = call <4 x float> @llvm.x86.sse3.hadd.ps(<4 x float> %a0, <4 x float> %a1)
608   ret <4 x float> %2
610 declare <4 x float> @llvm.x86.sse3.hadd.ps(<4 x float>, <4 x float>) nounwind readnone
612 define <2 x double> @stack_fold_hsubpd(<2 x double> %a0, <2 x double> %a1) {
613   ;CHECK-LABEL: stack_fold_hsubpd
614   ;CHECK:       hsubpd {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
615   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
616   %2 = call <2 x double> @llvm.x86.sse3.hsub.pd(<2 x double> %a0, <2 x double> %a1)
617   ret <2 x double> %2
619 declare <2 x double> @llvm.x86.sse3.hsub.pd(<2 x double>, <2 x double>) nounwind readnone
621 define <4 x float> @stack_fold_hsubps(<4 x float> %a0, <4 x float> %a1) {
622   ;CHECK-LABEL: stack_fold_hsubps
623   ;CHECK:       hsubps {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
624   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
625   %2 = call <4 x float> @llvm.x86.sse3.hsub.ps(<4 x float> %a0, <4 x float> %a1)
626   ret <4 x float> %2
628 declare <4 x float> @llvm.x86.sse3.hsub.ps(<4 x float>, <4 x float>) nounwind readnone
630 ; TODO stack_fold_insertps
632 define <2 x double> @stack_fold_maxpd(<2 x double> %a0, <2 x double> %a1) {
633   ;CHECK-LABEL: stack_fold_maxpd
634   ;CHECK:       maxpd {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
635   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
636   %2 = call <2 x double> @llvm.x86.sse2.max.pd(<2 x double> %a0, <2 x double> %a1)
637   ret <2 x double> %2
639 declare <2 x double> @llvm.x86.sse2.max.pd(<2 x double>, <2 x double>) nounwind readnone
641 define <4 x float> @stack_fold_maxps(<4 x float> %a0, <4 x float> %a1) {
642   ;CHECK-LABEL: stack_fold_maxps
643   ;CHECK:       maxps {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
644   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
645   %2 = call <4 x float> @llvm.x86.sse.max.ps(<4 x float> %a0, <4 x float> %a1)
646   ret <4 x float> %2
648 declare <4 x float> @llvm.x86.sse.max.ps(<4 x float>, <4 x float>) nounwind readnone
650 define double @stack_fold_maxsd(double %a0, double %a1) {
651   ;CHECK-LABEL: stack_fold_maxsd
652   ;CHECK:       maxsd {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 8-byte Folded Reload
653   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
654   %2 = fcmp ogt double %a0, %a1
655   %3 = select i1 %2, double %a0, double %a1
656   ret double %3
659 define <2 x double> @stack_fold_maxsd_int(<2 x double> %a0, <2 x double> %a1) {
660   ;CHECK-LABEL: stack_fold_maxsd_int
661   ;CHECK:       maxsd {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
662   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
663   %2 = call <2 x double> @llvm.x86.sse2.max.sd(<2 x double> %a0, <2 x double> %a1)
664   ret <2 x double> %2
666 declare <2 x double> @llvm.x86.sse2.max.sd(<2 x double>, <2 x double>) nounwind readnone
668 define float @stack_fold_maxss(float %a0, float %a1) {
669   ;CHECK-LABEL: stack_fold_maxss
670   ;CHECK:       maxss {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 4-byte Folded Reload
671   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
672   %2 = fcmp ogt float %a0, %a1
673   %3 = select i1 %2, float %a0, float %a1
674   ret float %3
677 define <4 x float> @stack_fold_maxss_int(<4 x float> %a0, <4 x float> %a1) {
678   ;CHECK-LABEL: stack_fold_maxss_int
679   ;CHECK:       maxss {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
680   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
681   %2 = call <4 x float> @llvm.x86.sse.max.ss(<4 x float> %a0, <4 x float> %a1)
682   ret <4 x float> %2
684 declare <4 x float> @llvm.x86.sse.max.ss(<4 x float>, <4 x float>) nounwind readnone
686 define <2 x double> @stack_fold_minpd(<2 x double> %a0, <2 x double> %a1) {
687   ;CHECK-LABEL: stack_fold_minpd
688   ;CHECK:       minpd {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
689   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
690   %2 = call <2 x double> @llvm.x86.sse2.min.pd(<2 x double> %a0, <2 x double> %a1)
691   ret <2 x double> %2
693 declare <2 x double> @llvm.x86.sse2.min.pd(<2 x double>, <2 x double>) nounwind readnone
695 define <4 x float> @stack_fold_minps(<4 x float> %a0, <4 x float> %a1) {
696   ;CHECK-LABEL: stack_fold_minps
697   ;CHECK:       minps {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
698   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
699   %2 = call <4 x float> @llvm.x86.sse.min.ps(<4 x float> %a0, <4 x float> %a1)
700   ret <4 x float> %2
702 declare <4 x float> @llvm.x86.sse.min.ps(<4 x float>, <4 x float>) nounwind readnone
704 define double @stack_fold_minsd(double %a0, double %a1) {
705   ;CHECK-LABEL: stack_fold_minsd
706   ;CHECK:       minsd {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 8-byte Folded Reload
707   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
708   %2 = fcmp olt double %a0, %a1
709   %3 = select i1 %2, double %a0, double %a1
710   ret double %3
713 define <2 x double> @stack_fold_minsd_int(<2 x double> %a0, <2 x double> %a1) {
714   ;CHECK-LABEL: stack_fold_minsd_int
715   ;CHECK:       minsd {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
716   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
717   %2 = call <2 x double> @llvm.x86.sse2.min.sd(<2 x double> %a0, <2 x double> %a1)
718   ret <2 x double> %2
720 declare <2 x double> @llvm.x86.sse2.min.sd(<2 x double>, <2 x double>) nounwind readnone
722 define float @stack_fold_minss(float %a0, float %a1) {
723   ;CHECK-LABEL: stack_fold_minss
724   ;CHECK:       minss {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 4-byte Folded Reload
725   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
726   %2 = fcmp olt float %a0, %a1
727   %3 = select i1 %2, float %a0, float %a1
728   ret float %3
731 define <4 x float> @stack_fold_minss_int(<4 x float> %a0, <4 x float> %a1) {
732   ;CHECK-LABEL: stack_fold_minss_int
733   ;CHECK:       minss {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
734   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
735   %2 = call <4 x float> @llvm.x86.sse.min.ss(<4 x float> %a0, <4 x float> %a1)
736   ret <4 x float> %2
738 declare <4 x float> @llvm.x86.sse.min.ss(<4 x float>, <4 x float>) nounwind readnone
740 ; TODO stack_fold_movd (load / store)
741 ; TODO stack_fold_movq (load / store)
743 ; TODO stack_fold_movddup
745 ; TODO stack_fold_movhpd (load / store)
746 ; TODO stack_fold_movhps (load / store)
748 ; TODO stack_fold_movlpd (load / store)
749 ; TODO stack_fold_movlps (load / store)
751 ; TODO stack_fold_movsd (load / store)
752 ; TODO stack_fold_movss (load / store)
754 define <4 x float> @stack_fold_movshdup(<4 x float> %a0) {
755   ;CHECK-LABEL: stack_fold_movshdup
756   ;CHECK:       movshdup {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
757   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm1},~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
758   %2 = shufflevector <4 x float> %a0, <4 x float> undef, <4 x i32> <i32 1, i32 1, i32 3, i32 3>
759   ret <4 x float> %2
762 define <4 x float> @stack_fold_movsldup(<4 x float> %a0) {
763   ;CHECK-LABEL: stack_fold_movsldup
764   ;CHECK:       movsldup {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
765   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm1},~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
766   %2 = shufflevector <4 x float> %a0, <4 x float> undef, <4 x i32> <i32 0, i32 0, i32 2, i32 2>
767   ret <4 x float> %2
770 define <2 x double> @stack_fold_mulpd(<2 x double> %a0, <2 x double> %a1) {
771   ;CHECK-LABEL: stack_fold_mulpd
772   ;CHECK:       mulpd {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
773   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
774   %2 = fmul <2 x double> %a0, %a1
775   ret <2 x double> %2
778 define <4 x float> @stack_fold_mulps(<4 x float> %a0, <4 x float> %a1) {
779   ;CHECK-LABEL: stack_fold_mulps
780   ;CHECK:       mulps {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
781   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
782   %2 = fmul <4 x float> %a0, %a1
783   ret <4 x float> %2
786 define double @stack_fold_mulsd(double %a0, double %a1) {
787   ;CHECK-LABEL: stack_fold_mulsd
788   ;CHECK:       mulsd {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 8-byte Folded Reload
789   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
790   %2 = fmul double %a0, %a1
791   ret double %2
794 define <2 x double> @stack_fold_mulsd_int(<2 x double> %a0, <2 x double> %a1) {
795   ;CHECK-LABEL: stack_fold_mulsd_int
796   ;CHECK:       mulsd {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
797   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
798   %2 = call <2 x double> @llvm.x86.sse2.mul.sd(<2 x double> %a0, <2 x double> %a1)
799   ret <2 x double> %2
801 declare <2 x double> @llvm.x86.sse2.mul.sd(<2 x double>, <2 x double>) nounwind readnone
803 define float @stack_fold_mulss(float %a0, float %a1) {
804   ;CHECK-LABEL: stack_fold_mulss
805   ;CHECK:       mulss {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 4-byte Folded Reload
806   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
807   %2 = fmul float %a0, %a1
808   ret float %2
811 define <4 x float> @stack_fold_mulss_int(<4 x float> %a0, <4 x float> %a1) {
812   ;CHECK-LABEL: stack_fold_mulss_int
813   ;CHECK:       mulss {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
814   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
815   %2 = call <4 x float> @llvm.x86.sse.mul.ss(<4 x float> %a0, <4 x float> %a1)
816   ret <4 x float> %2
818 declare <4 x float> @llvm.x86.sse.mul.ss(<4 x float>, <4 x float>) nounwind readnone
820 define <2 x double> @stack_fold_orpd(<2 x double> %a0, <2 x double> %a1) {
821   ;CHECK-LABEL: stack_fold_orpd
822   ;CHECK:       orpd {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
823   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
824   %2 = bitcast <2 x double> %a0 to <2 x i64>
825   %3 = bitcast <2 x double> %a1 to <2 x i64>
826   %4 = or <2 x i64> %2, %3
827   %5 = bitcast <2 x i64> %4 to <2 x double>
828   ; fadd forces execution domain
829   %6 = fadd <2 x double> %5, <double 0x0, double 0x0>
830   ret <2 x double> %6
833 define <4 x float> @stack_fold_orps(<4 x float> %a0, <4 x float> %a1) {
834   ;CHECK-LABEL: stack_fold_orps
835   ;CHECK:       orps {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
836   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
837   %2 = bitcast <4 x float> %a0 to <2 x i64>
838   %3 = bitcast <4 x float> %a1 to <2 x i64>
839   %4 = or <2 x i64> %2, %3
840   %5 = bitcast <2 x i64> %4 to <4 x float>
841   ret <4 x float> %5
844 ; TODO stack_fold_rcpps
846 define <4 x float> @stack_fold_rcpps_int(<4 x float> %a0) {
847   ;CHECK-LABEL: stack_fold_rcpps_int
848   ;CHECK:       rcpps {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
849   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm1},~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
850   %2 = call <4 x float> @llvm.x86.sse.rcp.ps(<4 x float> %a0)
851   ret <4 x float> %2
853 declare <4 x float> @llvm.x86.sse.rcp.ps(<4 x float>) nounwind readnone
855 ; TODO stack_fold_rcpss
856 ; TODO stack_fold_rcpss_int
858 define <2 x double> @stack_fold_roundpd(<2 x double> %a0) {
859   ;CHECK-LABEL: stack_fold_roundpd
860   ;CHECK:       roundpd $7, {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
861   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm1},~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
862   %2 = call <2 x double> @llvm.x86.sse41.round.pd(<2 x double> %a0, i32 7)
863   ret <2 x double> %2
865 declare <2 x double> @llvm.x86.sse41.round.pd(<2 x double>, i32) nounwind readnone
867 define <4 x float> @stack_fold_roundps(<4 x float> %a0) {
868   ;CHECK-LABEL: stack_fold_roundps
869   ;CHECK:       roundps $7, {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
870   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm1},~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
871   %2 = call <4 x float> @llvm.x86.sse41.round.ps(<4 x float> %a0, i32 7)
872   ret <4 x float> %2
874 declare <4 x float> @llvm.x86.sse41.round.ps(<4 x float>, i32) nounwind readnone
876 ; TODO stack_fold_roundsd
877 ; TODO stack_fold_roundsd_int
879 ; TODO stack_fold_roundss
880 ; TODO stack_fold_roundss_int
882 ; TODO stack_fold_rsqrtps
884 define <4 x float> @stack_fold_rsqrtps_int(<4 x float> %a0) {
885   ;CHECK-LABEL: stack_fold_rsqrtps_int
886   ;CHECK:       rsqrtps {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
887   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm1},~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
888   %2 = call <4 x float> @llvm.x86.sse.rsqrt.ps(<4 x float> %a0)
889   ret <4 x float> %2
891 declare <4 x float> @llvm.x86.sse.rsqrt.ps(<4 x float>) nounwind readnone
893 ; TODO stack_fold_rsqrtss
894 ; TODO stack_fold_rsqrtss_int
896 define <2 x double> @stack_fold_shufpd(<2 x double> %a0, <2 x double> %a1) {
897   ;CHECK-LABEL: stack_fold_shufpd
898   ;CHECK:       shufpd $1, {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
899   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
900   %2 = shufflevector <2 x double> %a0, <2 x double> %a1, <2 x i32> <i32 1, i32 2>
901   ret <2 x double> %2
904 define <4 x float> @stack_fold_shufps(<4 x float> %a0, <4 x float> %a1) {
905   ;CHECK-LABEL: stack_fold_shufps
906   ;CHECK:       shufps $-56, {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
907   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
908   %2 = shufflevector <4 x float> %a0, <4 x float> %a1, <4 x i32> <i32 0, i32 2, i32 4, i32 7>
909   ret <4 x float> %2
912 define <2 x double> @stack_fold_sqrtpd(<2 x double> %a0) {
913   ;CHECK-LABEL: stack_fold_sqrtpd
914   ;CHECK:       sqrtpd {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
915   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm1},~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
916   %2 = call <2 x double> @llvm.x86.sse2.sqrt.pd(<2 x double> %a0)
917   ret <2 x double> %2
919 declare <2 x double> @llvm.x86.sse2.sqrt.pd(<2 x double>) nounwind readnone
921 define <4 x float> @stack_fold_sqrtps(<4 x float> %a0) {
922   ;CHECK-LABEL: stack_fold_sqrtps
923   ;CHECK:       sqrtps {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
924   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm1},~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
925   %2 = call <4 x float> @llvm.x86.sse.sqrt.ps(<4 x float> %a0)
926   ret <4 x float> %2
928 declare <4 x float> @llvm.x86.sse.sqrt.ps(<4 x float>) nounwind readnone
930 ; TODO stack_fold_sqrtsd
931 declare double @llvm.sqrt.f64(double) nounwind readnone
933 ; TODO stack_fold_sqrtsd_int
934 declare <2 x double> @llvm.x86.sse2.sqrt.sd(<2 x double>) nounwind readnone
936 ; TODO stack_fold_sqrtss
937 declare float @llvm.sqrt.f32(float) nounwind readnone
939 ; TODO stack_fold_sqrtss_int
940 declare <4 x float> @llvm.x86.sse.sqrt.ss(<4 x float>) nounwind readnone
942 define <2 x double> @stack_fold_subpd(<2 x double> %a0, <2 x double> %a1) {
943   ;CHECK-LABEL: stack_fold_subpd
944   ;CHECK:       subpd {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
945   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
946   %2 = fsub <2 x double> %a0, %a1
947   ret <2 x double> %2
950 define <4 x float> @stack_fold_subps(<4 x float> %a0, <4 x float> %a1) {
951   ;CHECK-LABEL: stack_fold_subps
952   ;CHECK:       subps {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
953   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
954   %2 = fsub <4 x float> %a0, %a1
955   ret <4 x float> %2
958 define double @stack_fold_subsd(double %a0, double %a1) {
959   ;CHECK-LABEL: stack_fold_subsd
960   ;CHECK:       subsd {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 8-byte Folded Reload
961   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
962   %2 = fsub double %a0, %a1
963   ret double %2
966 define <2 x double> @stack_fold_subsd_int(<2 x double> %a0, <2 x double> %a1) {
967   ;CHECK-LABEL: stack_fold_subsd_int
968   ;CHECK:       subsd {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
969   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
970   %2 = call <2 x double> @llvm.x86.sse2.sub.sd(<2 x double> %a0, <2 x double> %a1)
971   ret <2 x double> %2
973 declare <2 x double> @llvm.x86.sse2.sub.sd(<2 x double>, <2 x double>) nounwind readnone
975 define float @stack_fold_subss(float %a0, float %a1) {
976   ;CHECK-LABEL: stack_fold_subss
977   ;CHECK:       subss {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 4-byte Folded Reload
978   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
979   %2 = fsub float %a0, %a1
980   ret float %2
983 define <4 x float> @stack_fold_subss_int(<4 x float> %a0, <4 x float> %a1) {
984   ;CHECK-LABEL: stack_fold_subss_int
985   ;CHECK:       subss {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
986   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
987   %2 = call <4 x float> @llvm.x86.sse.sub.ss(<4 x float> %a0, <4 x float> %a1)
988   ret <4 x float> %2
990 declare <4 x float> @llvm.x86.sse.sub.ss(<4 x float>, <4 x float>) nounwind readnone
992 define i32 @stack_fold_ucomisd(double %a0, double %a1) {
993   ;CHECK-LABEL: stack_fold_ucomisd
994   ;CHECK:       ucomisd {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 8-byte Folded Reload
995   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
996   %2 = fcmp ueq double %a0, %a1
997   %3 = select i1 %2, i32 1, i32 -1
998   ret i32 %3
1001 define i32 @stack_fold_ucomisd_int(<2 x double> %a0, <2 x double> %a1) {
1002   ;CHECK-LABEL: stack_fold_ucomisd_int
1003   ;CHECK:       ucomisd {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
1004   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
1005   %2 = call i32 @llvm.x86.sse2.ucomieq.sd(<2 x double> %a0, <2 x double> %a1)
1006   ret i32 %2
1008 declare i32 @llvm.x86.sse2.ucomieq.sd(<2 x double>, <2 x double>) nounwind readnone
1010 define i32 @stack_fold_ucomiss(float %a0, float %a1) {
1011   ;CHECK-LABEL: stack_fold_ucomiss
1012   ;CHECK:       ucomiss {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 4-byte Folded Reload
1013   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
1014   %2 = fcmp ueq float %a0, %a1
1015   %3 = select i1 %2, i32 1, i32 -1
1016   ret i32 %3
1019 define i32 @stack_fold_ucomiss_int(<4 x float> %a0, <4 x float> %a1) {
1020   ;CHECK-LABEL: stack_fold_ucomiss_int
1021   ;CHECK:       ucomiss {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
1022   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
1023   %2 = call i32 @llvm.x86.sse.ucomieq.ss(<4 x float> %a0, <4 x float> %a1)
1024   ret i32 %2
1026 declare i32 @llvm.x86.sse.ucomieq.ss(<4 x float>, <4 x float>) nounwind readnone
1028 define <2 x double> @stack_fold_unpckhpd(<2 x double> %a0, <2 x double> %a1) {
1029   ;CHECK-LABEL: stack_fold_unpckhpd
1030   ;CHECK:       unpckhpd {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
1031   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
1032   %2 = shufflevector <2 x double> %a0, <2 x double> %a1, <2 x i32> <i32 1, i32 3>
1033   ret <2 x double> %2
1036 define <4 x float> @stack_fold_unpckhps(<4 x float> %a0, <4 x float> %a1) {
1037   ;CHECK-LABEL: stack_fold_unpckhps
1038   ;CHECK:       unpckhps {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
1039   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
1040   %2 = shufflevector <4 x float> %a0, <4 x float> %a1, <4 x i32> <i32 2, i32 6, i32 3, i32 7>
1041   ret <4 x float> %2
1044 define <2 x double> @stack_fold_unpcklpd(<2 x double> %a0, <2 x double> %a1) {
1045   ;CHECK-LABEL: stack_fold_unpcklpd
1046   ;CHECK:       unpcklpd {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
1047   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
1048   %2 = shufflevector <2 x double> %a0, <2 x double> %a1, <2 x i32> <i32 0, i32 2>
1049   ret <2 x double> %2
1052 define <4 x float> @stack_fold_unpcklps(<4 x float> %a0, <4 x float> %a1) {
1053   ;CHECK-LABEL: stack_fold_unpcklps
1054   ;CHECK:       unpcklps {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
1055   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
1056   %2 = shufflevector <4 x float> %a0, <4 x float> %a1, <4 x i32> <i32 0, i32 4, i32 1, i32 5>
1057   ret <4 x float> %2
1060 define <2 x double> @stack_fold_xorpd(<2 x double> %a0, <2 x double> %a1) {
1061   ;CHECK-LABEL: stack_fold_xorpd
1062   ;CHECK:       xorpd {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
1063   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
1064   %2 = bitcast <2 x double> %a0 to <2 x i64>
1065   %3 = bitcast <2 x double> %a1 to <2 x i64>
1066   %4 = xor <2 x i64> %2, %3
1067   %5 = bitcast <2 x i64> %4 to <2 x double>
1068   ; fadd forces execution domain
1069   %6 = fadd <2 x double> %5, <double 0x0, double 0x0>
1070   ret <2 x double> %6
1073 define <4 x float> @stack_fold_xorps(<4 x float> %a0, <4 x float> %a1) {
1074   ;CHECK-LABEL: stack_fold_xorps
1075   ;CHECK:       xorps {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
1076   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{flags}"()
1077   %2 = bitcast <4 x float> %a0 to <2 x i64>
1078   %3 = bitcast <4 x float> %a1 to <2 x i64>
1079   %4 = xor <2 x i64> %2, %3
1080   %5 = bitcast <2 x i64> %4 to <4 x float>
1081   ret <4 x float> %5