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
   2
   3 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
   4 target triple = "x86_64-unknown-unknown"
   5
   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.
  10
  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 }
  18
  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 }
  26
  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 }
  34
  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
  43
  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 }
  51
  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
  60
  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
  69
  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
  78
  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 }
  92
  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
 103 }
 104
 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
 116 }
 117
 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
 127 }
 128
 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
 135 }
 136
 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
 143 }
 144
 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
 151 }
 152 declare <2 x double> @llvm.x86.sse41.blendvpd(<2 x double>, <2 x double>, <2 x double>) nounwind readnone
 153
 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
 160 }
 161 declare <4 x float> @llvm.x86.sse41.blendvps(<4 x float>, <4 x float>, <4 x float>) nounwind readnone
 162
 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
 169 }
 170 declare <2 x double> @llvm.x86.sse2.cmp.pd(<2 x double>, <2 x double>, i8) nounwind readnone
 171
 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
 178 }
 179 declare <4 x float> @llvm.x86.sse.cmp.ps(<4 x float>, <4 x float>, i8) nounwind readnone
 180
 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
 188 }
 189
 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
 196 }
 197 declare <2 x double> @llvm.x86.sse2.cmp.sd(<2 x double>, <2 x double>, i8) nounwind readnone
 198
 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
 206 }
 207
 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
 214 }
 215 declare <4 x float> @llvm.x86.sse.cmp.ss(<4 x float>, <4 x float>, i8) nounwind readnone
 216
 217 ; TODO stack_fold_comisd
 218
 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
 225 }
 226 declare i32 @llvm.x86.sse2.comieq.sd(<2 x double>, <2 x double>) nounwind readnone
 227
 228 ; TODO stack_fold_comiss
 229
 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
 236 }
 237 declare i32 @llvm.x86.sse.comieq.ss(<4 x float>, <4 x float>) nounwind readnone
 238
 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
 245 }
 246 declare <2 x double> @llvm.x86.sse2.cvtdq2pd(<4 x i32>) nounwind readnone
 247
 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
 254 }
 255
 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
 262 }
 263 declare <4 x i32> @llvm.x86.sse2.cvtpd2dq(<2 x double>) nounwind readnone
 264
 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
 271 }
 272
 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
 279 }
 280 declare <4 x i32> @llvm.x86.sse2.cvtps2dq(<4 x float>) nounwind readnone
 281
 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
 288 }
 289 declare <2 x double> @llvm.x86.sse2.cvtps2pd(<4 x float>) nounwind readnone
 290
 291 ; TODO stack_fold_cvtsd2si
 292
 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
 299 }
 300 declare i32 @llvm.x86.sse2.cvtsd2si(<2 x double>) nounwind readnone
 301
 302 ; TODO stack_fold_cvtsd2si64
 303
 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
 310 }
 311 declare i64 @llvm.x86.sse2.cvtsd2si64(<2 x double>) nounwind readnone
 312
 313 ; TODO stack_fold_cvtsd2ss
 314
 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
 321 }
 322 declare <4 x float> @llvm.x86.sse2.cvtsd2ss(<4 x float>, <2 x double>) nounwind readnone
 323
 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
 330 }
 331
 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
 338 }
 339 declare <2 x double> @llvm.x86.sse2.cvtsi2sd(<2 x double>, i32) nounwind readnone
 340
 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
 347 }
 348
 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
 355 }
 356 declare <2 x double> @llvm.x86.sse2.cvtsi642sd(<2 x double>, i64) nounwind readnone
 357
 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
 364 }
 365
 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
 372 }
 373 declare <4 x float> @llvm.x86.sse.cvtsi2ss(<4 x float>, i32) nounwind readnone
 374
 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
 381 }
 382
 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
 389 }
 390 declare <4 x float> @llvm.x86.sse.cvtsi642ss(<4 x float>, i64) nounwind readnone
 391
 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
 398 }
 399
 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
 406 }
 407 declare <2 x double> @llvm.x86.sse2.cvtss2sd(<2 x double>, <4 x float>) nounwind readnone
 408
 409 ; TODO stack_fold_cvtss2si
 410
 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
 417 }
 418 declare i32 @llvm.x86.sse.cvtss2si(<4 x float>) nounwind readnone
 419
 420 ; TODO stack_fold_cvtss2si64
 421
 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
 428 }
 429 declare i64 @llvm.x86.sse.cvtss2si64(<4 x float>) nounwind readnone
 430
 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
 437 }
 438 declare <4 x i32> @llvm.x86.sse2.cvttpd2dq(<2 x double>) nounwind readnone
 439
 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
 446 }
 447
 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
 454 }
 455
 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
 462 }
 463 declare i32 @llvm.x86.sse2.cvttsd2si(<2 x double>) nounwind readnone
 464
 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
 471 }
 472
 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
 479 }
 480 declare i64 @llvm.x86.sse2.cvttsd2si64(<2 x double>) nounwind readnone
 481
 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
 488 }
 489
 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
 496 }
 497 declare i32 @llvm.x86.sse.cvttss2si(<4 x float>) nounwind readnone
 498
 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
 505 }
 506
 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
 513 }
 514 declare i64 @llvm.x86.sse.cvttss2si64(<4 x float>) nounwind readnone
 515
 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
 522 }
 523
 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
 530 }
 531
 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
 538 }
 539
 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
 546 }
 547 declare <2 x double> @llvm.x86.sse2.div.sd(<2 x double>, <2 x double>) nounwind readnone
 548
 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
 555 }
 556
 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
 563 }
 564 declare <4 x float> @llvm.x86.sse.div.ss(<4 x float>, <4 x float>) nounwind readnone
 565
 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
 572 }
 573 declare <2 x double> @llvm.x86.sse41.dppd(<2 x double>, <2 x double>, i8) nounwind readnone
 574
 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
 581 }
 582 declare <4 x float> @llvm.x86.sse41.dpps(<4 x float>, <4 x float>, i8) nounwind readnone
 583
 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
 592 }
 593
 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
 600 }
 601 declare <2 x double> @llvm.x86.sse3.hadd.pd(<2 x double>, <2 x double>) nounwind readnone
 602
 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
 609 }
 610 declare <4 x float> @llvm.x86.sse3.hadd.ps(<4 x float>, <4 x float>) nounwind readnone
 611
 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
 618 }
 619 declare <2 x double> @llvm.x86.sse3.hsub.pd(<2 x double>, <2 x double>) nounwind readnone
 620
 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
 627 }
 628 declare <4 x float> @llvm.x86.sse3.hsub.ps(<4 x float>, <4 x float>) nounwind readnone
 629
 630 ; TODO stack_fold_insertps
 631
 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
 638 }
 639 declare <2 x double> @llvm.x86.sse2.max.pd(<2 x double>, <2 x double>) nounwind readnone
 640
 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
 647 }
 648 declare <4 x float> @llvm.x86.sse.max.ps(<4 x float>, <4 x float>) nounwind readnone
 649
 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
 657 }
 658
 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
 665 }
 666 declare <2 x double> @llvm.x86.sse2.max.sd(<2 x double>, <2 x double>) nounwind readnone
 667
 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
 675 }
 676
 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
 683 }
 684 declare <4 x float> @llvm.x86.sse.max.ss(<4 x float>, <4 x float>) nounwind readnone
 685
 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
 692 }
 693 declare <2 x double> @llvm.x86.sse2.min.pd(<2 x double>, <2 x double>) nounwind readnone
 694
 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
 701 }
 702 declare <4 x float> @llvm.x86.sse.min.ps(<4 x float>, <4 x float>) nounwind readnone
 703
 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
 711 }
 712
 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
 719 }
 720 declare <2 x double> @llvm.x86.sse2.min.sd(<2 x double>, <2 x double>) nounwind readnone
 721
 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
 729 }
 730
 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
 737 }
 738 declare <4 x float> @llvm.x86.sse.min.ss(<4 x float>, <4 x float>) nounwind readnone
 739
 740 ; TODO stack_fold_movd (load / store)
 741 ; TODO stack_fold_movq (load / store)
 742
 743 ; TODO stack_fold_movddup
 744
 745 ; TODO stack_fold_movhpd (load / store)
 746 ; TODO stack_fold_movhps (load / store)
 747
 748 ; TODO stack_fold_movlpd (load / store)
 749 ; TODO stack_fold_movlps (load / store)
 750
 751 ; TODO stack_fold_movsd (load / store)
 752 ; TODO stack_fold_movss (load / store)
 753
 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
 760 }
 761
 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
 768 }
 769
 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
 776 }
 777
 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
 784 }
 785
 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
 792 }
 793
 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
 800 }
 801 declare <2 x double> @llvm.x86.sse2.mul.sd(<2 x double>, <2 x double>) nounwind readnone
 802
 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
 809 }
 810
 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
 817 }
 818 declare <4 x float> @llvm.x86.sse.mul.ss(<4 x float>, <4 x float>) nounwind readnone
 819
 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
 831 }
 832
 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
 842 }
 843
 844 ; TODO stack_fold_rcpps
 845
 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
 852 }
 853 declare <4 x float> @llvm.x86.sse.rcp.ps(<4 x float>) nounwind readnone
 854
 855 ; TODO stack_fold_rcpss
 856 ; TODO stack_fold_rcpss_int
 857
 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
 864 }
 865 declare <2 x double> @llvm.x86.sse41.round.pd(<2 x double>, i32) nounwind readnone
 866
 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
 873 }
 874 declare <4 x float> @llvm.x86.sse41.round.ps(<4 x float>, i32) nounwind readnone
 875
 876 ; TODO stack_fold_roundsd
 877 ; TODO stack_fold_roundsd_int
 878
 879 ; TODO stack_fold_roundss
 880 ; TODO stack_fold_roundss_int
 881
 882 ; TODO stack_fold_rsqrtps
 883
 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
 890 }
 891 declare <4 x float> @llvm.x86.sse.rsqrt.ps(<4 x float>) nounwind readnone
 892
 893 ; TODO stack_fold_rsqrtss
 894 ; TODO stack_fold_rsqrtss_int
 895
 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
 902 }
 903
 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
 910 }
 911
 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
 918 }
 919 declare <2 x double> @llvm.x86.sse2.sqrt.pd(<2 x double>) nounwind readnone
 920
 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
 927 }
 928 declare <4 x float> @llvm.x86.sse.sqrt.ps(<4 x float>) nounwind readnone
 929
 930 ; TODO stack_fold_sqrtsd
 931 declare double @llvm.sqrt.f64(double) nounwind readnone
 932
 933 ; TODO stack_fold_sqrtsd_int
 934 declare <2 x double> @llvm.x86.sse2.sqrt.sd(<2 x double>) nounwind readnone
 935
 936 ; TODO stack_fold_sqrtss
 937 declare float @llvm.sqrt.f32(float) nounwind readnone
 938
 939 ; TODO stack_fold_sqrtss_int
 940 declare <4 x float> @llvm.x86.sse.sqrt.ss(<4 x float>) nounwind readnone
 941
 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
 948 }
 949
 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
 956 }
 957
 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
 964 }
 965
 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
 972 }
 973 declare <2 x double> @llvm.x86.sse2.sub.sd(<2 x double>, <2 x double>) nounwind readnone
 974
 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
 981 }
 982
 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
 989 }
 990 declare <4 x float> @llvm.x86.sse.sub.ss(<4 x float>, <4 x float>) nounwind readnone
 991
 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
 999 }
1000
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
1007 }
1008 declare i32 @llvm.x86.sse2.ucomieq.sd(<2 x double>, <2 x double>) nounwind readnone
1009
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
1017 }
1018
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
1025 }
1026 declare i32 @llvm.x86.sse.ucomieq.ss(<4 x float>, <4 x float>) nounwind readnone
1027
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
1034 }
1035
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
1042 }
1043
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
1050 }
1051
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
1058 }
1059
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
1071 }
1072
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
1082 }