[X86][AVX] Added (V)MOVDDUP / (V)MOVSLDUP / (V)MOVSHDUP memory 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 define <2 x double> @stack_fold_movddup(<2 x double> %a0) {
741   ;CHECK-LABEL: stack_fold_movddup
742   ;CHECK:   movddup {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
743   %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}"()
744   %2 = shufflevector <2 x double> %a0, <2 x double> undef, <2 x i32> <i32 0, i32 0>
745   ret <2 x double> %2
747 ; TODO stack_fold_movhpd (load / store)
748 ; TODO stack_fold_movhps (load / store)
750 ; TODO stack_fold_movlpd (load / store)
751 ; TODO stack_fold_movlps (load / store)
753 define <4 x float> @stack_fold_movshdup(<4 x float> %a0) {
754   ;CHECK-LABEL: stack_fold_movshdup
755   ;CHECK:       movshdup {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
756   %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}"()
757   %2 = shufflevector <4 x float> %a0, <4 x float> undef, <4 x i32> <i32 1, i32 1, i32 3, i32 3>
758   ret <4 x float> %2
761 define <4 x float> @stack_fold_movsldup(<4 x float> %a0) {
762   ;CHECK-LABEL: stack_fold_movsldup
763   ;CHECK:       movsldup {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
764   %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}"()
765   %2 = shufflevector <4 x float> %a0, <4 x float> undef, <4 x i32> <i32 0, i32 0, i32 2, i32 2>
766   ret <4 x float> %2
769 define <2 x double> @stack_fold_mulpd(<2 x double> %a0, <2 x double> %a1) {
770   ;CHECK-LABEL: stack_fold_mulpd
771   ;CHECK:       mulpd {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
772   %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}"()
773   %2 = fmul <2 x double> %a0, %a1
774   ret <2 x double> %2
777 define <4 x float> @stack_fold_mulps(<4 x float> %a0, <4 x float> %a1) {
778   ;CHECK-LABEL: stack_fold_mulps
779   ;CHECK:       mulps {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
780   %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}"()
781   %2 = fmul <4 x float> %a0, %a1
782   ret <4 x float> %2
785 define double @stack_fold_mulsd(double %a0, double %a1) {
786   ;CHECK-LABEL: stack_fold_mulsd
787   ;CHECK:       mulsd {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 8-byte Folded Reload
788   %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}"()
789   %2 = fmul double %a0, %a1
790   ret double %2
793 define <2 x double> @stack_fold_mulsd_int(<2 x double> %a0, <2 x double> %a1) {
794   ;CHECK-LABEL: stack_fold_mulsd_int
795   ;CHECK:       mulsd {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
796   %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}"()
797   %2 = call <2 x double> @llvm.x86.sse2.mul.sd(<2 x double> %a0, <2 x double> %a1)
798   ret <2 x double> %2
800 declare <2 x double> @llvm.x86.sse2.mul.sd(<2 x double>, <2 x double>) nounwind readnone
802 define float @stack_fold_mulss(float %a0, float %a1) {
803   ;CHECK-LABEL: stack_fold_mulss
804   ;CHECK:       mulss {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 4-byte Folded Reload
805   %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}"()
806   %2 = fmul float %a0, %a1
807   ret float %2
810 define <4 x float> @stack_fold_mulss_int(<4 x float> %a0, <4 x float> %a1) {
811   ;CHECK-LABEL: stack_fold_mulss_int
812   ;CHECK:       mulss {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
813   %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}"()
814   %2 = call <4 x float> @llvm.x86.sse.mul.ss(<4 x float> %a0, <4 x float> %a1)
815   ret <4 x float> %2
817 declare <4 x float> @llvm.x86.sse.mul.ss(<4 x float>, <4 x float>) nounwind readnone
819 define <2 x double> @stack_fold_orpd(<2 x double> %a0, <2 x double> %a1) {
820   ;CHECK-LABEL: stack_fold_orpd
821   ;CHECK:       orpd {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
822   %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}"()
823   %2 = bitcast <2 x double> %a0 to <2 x i64>
824   %3 = bitcast <2 x double> %a1 to <2 x i64>
825   %4 = or <2 x i64> %2, %3
826   %5 = bitcast <2 x i64> %4 to <2 x double>
827   ; fadd forces execution domain
828   %6 = fadd <2 x double> %5, <double 0x0, double 0x0>
829   ret <2 x double> %6
832 define <4 x float> @stack_fold_orps(<4 x float> %a0, <4 x float> %a1) {
833   ;CHECK-LABEL: stack_fold_orps
834   ;CHECK:       orps {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
835   %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}"()
836   %2 = bitcast <4 x float> %a0 to <2 x i64>
837   %3 = bitcast <4 x float> %a1 to <2 x i64>
838   %4 = or <2 x i64> %2, %3
839   %5 = bitcast <2 x i64> %4 to <4 x float>
840   ret <4 x float> %5
843 ; TODO stack_fold_rcpps
845 define <4 x float> @stack_fold_rcpps_int(<4 x float> %a0) {
846   ;CHECK-LABEL: stack_fold_rcpps_int
847   ;CHECK:       rcpps {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
848   %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}"()
849   %2 = call <4 x float> @llvm.x86.sse.rcp.ps(<4 x float> %a0)
850   ret <4 x float> %2
852 declare <4 x float> @llvm.x86.sse.rcp.ps(<4 x float>) nounwind readnone
854 ; TODO stack_fold_rcpss
855 ; TODO stack_fold_rcpss_int
857 define <2 x double> @stack_fold_roundpd(<2 x double> %a0) {
858   ;CHECK-LABEL: stack_fold_roundpd
859   ;CHECK:       roundpd $7, {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
860   %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}"()
861   %2 = call <2 x double> @llvm.x86.sse41.round.pd(<2 x double> %a0, i32 7)
862   ret <2 x double> %2
864 declare <2 x double> @llvm.x86.sse41.round.pd(<2 x double>, i32) nounwind readnone
866 define <4 x float> @stack_fold_roundps(<4 x float> %a0) {
867   ;CHECK-LABEL: stack_fold_roundps
868   ;CHECK:       roundps $7, {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
869   %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}"()
870   %2 = call <4 x float> @llvm.x86.sse41.round.ps(<4 x float> %a0, i32 7)
871   ret <4 x float> %2
873 declare <4 x float> @llvm.x86.sse41.round.ps(<4 x float>, i32) nounwind readnone
875 ; TODO stack_fold_roundsd
876 ; TODO stack_fold_roundsd_int
878 ; TODO stack_fold_roundss
879 ; TODO stack_fold_roundss_int
881 ; TODO stack_fold_rsqrtps
883 define <4 x float> @stack_fold_rsqrtps_int(<4 x float> %a0) {
884   ;CHECK-LABEL: stack_fold_rsqrtps_int
885   ;CHECK:       rsqrtps {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
886   %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}"()
887   %2 = call <4 x float> @llvm.x86.sse.rsqrt.ps(<4 x float> %a0)
888   ret <4 x float> %2
890 declare <4 x float> @llvm.x86.sse.rsqrt.ps(<4 x float>) nounwind readnone
892 ; TODO stack_fold_rsqrtss
893 ; TODO stack_fold_rsqrtss_int
895 define <2 x double> @stack_fold_shufpd(<2 x double> %a0, <2 x double> %a1) {
896   ;CHECK-LABEL: stack_fold_shufpd
897   ;CHECK:       shufpd $1, {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
898   %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}"()
899   %2 = shufflevector <2 x double> %a0, <2 x double> %a1, <2 x i32> <i32 1, i32 2>
900   ret <2 x double> %2
903 define <4 x float> @stack_fold_shufps(<4 x float> %a0, <4 x float> %a1) {
904   ;CHECK-LABEL: stack_fold_shufps
905   ;CHECK:       shufps $-56, {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
906   %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}"()
907   %2 = shufflevector <4 x float> %a0, <4 x float> %a1, <4 x i32> <i32 0, i32 2, i32 4, i32 7>
908   ret <4 x float> %2
911 define <2 x double> @stack_fold_sqrtpd(<2 x double> %a0) {
912   ;CHECK-LABEL: stack_fold_sqrtpd
913   ;CHECK:       sqrtpd {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
914   %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}"()
915   %2 = call <2 x double> @llvm.x86.sse2.sqrt.pd(<2 x double> %a0)
916   ret <2 x double> %2
918 declare <2 x double> @llvm.x86.sse2.sqrt.pd(<2 x double>) nounwind readnone
920 define <4 x float> @stack_fold_sqrtps(<4 x float> %a0) {
921   ;CHECK-LABEL: stack_fold_sqrtps
922   ;CHECK:       sqrtps {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
923   %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}"()
924   %2 = call <4 x float> @llvm.x86.sse.sqrt.ps(<4 x float> %a0)
925   ret <4 x float> %2
927 declare <4 x float> @llvm.x86.sse.sqrt.ps(<4 x float>) nounwind readnone
929 ; TODO stack_fold_sqrtsd
930 declare double @llvm.sqrt.f64(double) nounwind readnone
932 ; TODO stack_fold_sqrtsd_int
933 declare <2 x double> @llvm.x86.sse2.sqrt.sd(<2 x double>) nounwind readnone
935 ; TODO stack_fold_sqrtss
936 declare float @llvm.sqrt.f32(float) nounwind readnone
938 ; TODO stack_fold_sqrtss_int
939 declare <4 x float> @llvm.x86.sse.sqrt.ss(<4 x float>) nounwind readnone
941 define <2 x double> @stack_fold_subpd(<2 x double> %a0, <2 x double> %a1) {
942   ;CHECK-LABEL: stack_fold_subpd
943   ;CHECK:       subpd {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
944   %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}"()
945   %2 = fsub <2 x double> %a0, %a1
946   ret <2 x double> %2
949 define <4 x float> @stack_fold_subps(<4 x float> %a0, <4 x float> %a1) {
950   ;CHECK-LABEL: stack_fold_subps
951   ;CHECK:       subps {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
952   %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}"()
953   %2 = fsub <4 x float> %a0, %a1
954   ret <4 x float> %2
957 define double @stack_fold_subsd(double %a0, double %a1) {
958   ;CHECK-LABEL: stack_fold_subsd
959   ;CHECK:       subsd {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 8-byte Folded Reload
960   %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}"()
961   %2 = fsub double %a0, %a1
962   ret double %2
965 define <2 x double> @stack_fold_subsd_int(<2 x double> %a0, <2 x double> %a1) {
966   ;CHECK-LABEL: stack_fold_subsd_int
967   ;CHECK:       subsd {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
968   %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}"()
969   %2 = call <2 x double> @llvm.x86.sse2.sub.sd(<2 x double> %a0, <2 x double> %a1)
970   ret <2 x double> %2
972 declare <2 x double> @llvm.x86.sse2.sub.sd(<2 x double>, <2 x double>) nounwind readnone
974 define float @stack_fold_subss(float %a0, float %a1) {
975   ;CHECK-LABEL: stack_fold_subss
976   ;CHECK:       subss {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 4-byte Folded Reload
977   %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}"()
978   %2 = fsub float %a0, %a1
979   ret float %2
982 define <4 x float> @stack_fold_subss_int(<4 x float> %a0, <4 x float> %a1) {
983   ;CHECK-LABEL: stack_fold_subss_int
984   ;CHECK:       subss {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
985   %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}"()
986   %2 = call <4 x float> @llvm.x86.sse.sub.ss(<4 x float> %a0, <4 x float> %a1)
987   ret <4 x float> %2
989 declare <4 x float> @llvm.x86.sse.sub.ss(<4 x float>, <4 x float>) nounwind readnone
991 define i32 @stack_fold_ucomisd(double %a0, double %a1) {
992   ;CHECK-LABEL: stack_fold_ucomisd
993   ;CHECK:       ucomisd {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 8-byte Folded Reload
994   %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}"()
995   %2 = fcmp ueq double %a0, %a1
996   %3 = select i1 %2, i32 1, i32 -1
997   ret i32 %3
1000 define i32 @stack_fold_ucomisd_int(<2 x double> %a0, <2 x double> %a1) {
1001   ;CHECK-LABEL: stack_fold_ucomisd_int
1002   ;CHECK:       ucomisd {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
1003   %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}"()
1004   %2 = call i32 @llvm.x86.sse2.ucomieq.sd(<2 x double> %a0, <2 x double> %a1)
1005   ret i32 %2
1007 declare i32 @llvm.x86.sse2.ucomieq.sd(<2 x double>, <2 x double>) nounwind readnone
1009 define i32 @stack_fold_ucomiss(float %a0, float %a1) {
1010   ;CHECK-LABEL: stack_fold_ucomiss
1011   ;CHECK:       ucomiss {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 4-byte Folded Reload
1012   %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}"()
1013   %2 = fcmp ueq float %a0, %a1
1014   %3 = select i1 %2, i32 1, i32 -1
1015   ret i32 %3
1018 define i32 @stack_fold_ucomiss_int(<4 x float> %a0, <4 x float> %a1) {
1019   ;CHECK-LABEL: stack_fold_ucomiss_int
1020   ;CHECK:       ucomiss {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
1021   %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}"()
1022   %2 = call i32 @llvm.x86.sse.ucomieq.ss(<4 x float> %a0, <4 x float> %a1)
1023   ret i32 %2
1025 declare i32 @llvm.x86.sse.ucomieq.ss(<4 x float>, <4 x float>) nounwind readnone
1027 define <2 x double> @stack_fold_unpckhpd(<2 x double> %a0, <2 x double> %a1) {
1028   ;CHECK-LABEL: stack_fold_unpckhpd
1029   ;CHECK:       unpckhpd {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
1030   %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}"()
1031   %2 = shufflevector <2 x double> %a0, <2 x double> %a1, <2 x i32> <i32 1, i32 3>
1032   ret <2 x double> %2
1035 define <4 x float> @stack_fold_unpckhps(<4 x float> %a0, <4 x float> %a1) {
1036   ;CHECK-LABEL: stack_fold_unpckhps
1037   ;CHECK:       unpckhps {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
1038   %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}"()
1039   %2 = shufflevector <4 x float> %a0, <4 x float> %a1, <4 x i32> <i32 2, i32 6, i32 3, i32 7>
1040   ret <4 x float> %2
1043 define <2 x double> @stack_fold_unpcklpd(<2 x double> %a0, <2 x double> %a1) {
1044   ;CHECK-LABEL: stack_fold_unpcklpd
1045   ;CHECK:       unpcklpd {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
1046   %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}"()
1047   %2 = shufflevector <2 x double> %a0, <2 x double> %a1, <2 x i32> <i32 0, i32 2>
1048   ret <2 x double> %2
1051 define <4 x float> @stack_fold_unpcklps(<4 x float> %a0, <4 x float> %a1) {
1052   ;CHECK-LABEL: stack_fold_unpcklps
1053   ;CHECK:       unpcklps {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
1054   %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}"()
1055   %2 = shufflevector <4 x float> %a0, <4 x float> %a1, <4 x i32> <i32 0, i32 4, i32 1, i32 5>
1056   ret <4 x float> %2
1059 define <2 x double> @stack_fold_xorpd(<2 x double> %a0, <2 x double> %a1) {
1060   ;CHECK-LABEL: stack_fold_xorpd
1061   ;CHECK:       xorpd {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
1062   %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}"()
1063   %2 = bitcast <2 x double> %a0 to <2 x i64>
1064   %3 = bitcast <2 x double> %a1 to <2 x i64>
1065   %4 = xor <2 x i64> %2, %3
1066   %5 = bitcast <2 x i64> %4 to <2 x double>
1067   ; fadd forces execution domain
1068   %6 = fadd <2 x double> %5, <double 0x0, double 0x0>
1069   ret <2 x double> %6
1072 define <4 x float> @stack_fold_xorps(<4 x float> %a0, <4 x float> %a1) {
1073   ;CHECK-LABEL: stack_fold_xorps
1074   ;CHECK:       xorps {{-?[0-9]*}}(%rsp), {{%xmm[0-9][0-9]*}} {{.*#+}} 16-byte Folded Reload
1075   %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}"()
1076   %2 = bitcast <4 x float> %a0 to <2 x i64>
1077   %3 = bitcast <4 x float> %a1 to <2 x i64>
1078   %4 = xor <2 x i64> %2, %3
1079   %5 = bitcast <2 x i64> %4 to <4 x float>
1080   ret <4 x float> %5