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 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
 746 }
 747 ; TODO stack_fold_movhpd (load / store)
 748 ; TODO stack_fold_movhps (load / store)
 749
 750 ; TODO stack_fold_movlpd (load / store)
 751 ; TODO stack_fold_movlps (load / store)
 752
 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
 759 }
 760
 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
 767 }
 768
 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
 775 }
 776
 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
 783 }
 784
 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
 791 }
 792
 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
 799 }
 800 declare <2 x double> @llvm.x86.sse2.mul.sd(<2 x double>, <2 x double>) nounwind readnone
 801
 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
 808 }
 809
 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
 816 }
 817 declare <4 x float> @llvm.x86.sse.mul.ss(<4 x float>, <4 x float>) nounwind readnone
 818
 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
 830 }
 831
 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
 841 }
 842
 843 ; TODO stack_fold_rcpps
 844
 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
 851 }
 852 declare <4 x float> @llvm.x86.sse.rcp.ps(<4 x float>) nounwind readnone
 853
 854 ; TODO stack_fold_rcpss
 855 ; TODO stack_fold_rcpss_int
 856
 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
 863 }
 864 declare <2 x double> @llvm.x86.sse41.round.pd(<2 x double>, i32) nounwind readnone
 865
 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
 872 }
 873 declare <4 x float> @llvm.x86.sse41.round.ps(<4 x float>, i32) nounwind readnone
 874
 875 ; TODO stack_fold_roundsd
 876 ; TODO stack_fold_roundsd_int
 877
 878 ; TODO stack_fold_roundss
 879 ; TODO stack_fold_roundss_int
 880
 881 ; TODO stack_fold_rsqrtps
 882
 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
 889 }
 890 declare <4 x float> @llvm.x86.sse.rsqrt.ps(<4 x float>) nounwind readnone
 891
 892 ; TODO stack_fold_rsqrtss
 893 ; TODO stack_fold_rsqrtss_int
 894
 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
 901 }
 902
 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 $200, {{-?[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
 909 }
 910
 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
 917 }
 918 declare <2 x double> @llvm.x86.sse2.sqrt.pd(<2 x double>) nounwind readnone
 919
 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
 926 }
 927 declare <4 x float> @llvm.x86.sse.sqrt.ps(<4 x float>) nounwind readnone
 928
 929 ; TODO stack_fold_sqrtsd
 930 declare double @llvm.sqrt.f64(double) nounwind readnone
 931
 932 ; TODO stack_fold_sqrtsd_int
 933 declare <2 x double> @llvm.x86.sse2.sqrt.sd(<2 x double>) nounwind readnone
 934
 935 ; TODO stack_fold_sqrtss
 936 declare float @llvm.sqrt.f32(float) nounwind readnone
 937
 938 ; TODO stack_fold_sqrtss_int
 939 declare <4 x float> @llvm.x86.sse.sqrt.ss(<4 x float>) nounwind readnone
 940
 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
 947 }
 948
 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
 955 }
 956
 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
 963 }
 964
 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
 971 }
 972 declare <2 x double> @llvm.x86.sse2.sub.sd(<2 x double>, <2 x double>) nounwind readnone
 973
 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
 980 }
 981
 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
 988 }
 989 declare <4 x float> @llvm.x86.sse.sub.ss(<4 x float>, <4 x float>) nounwind readnone
 990
 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
 998 }
 999
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
1006 }
1007 declare i32 @llvm.x86.sse2.ucomieq.sd(<2 x double>, <2 x double>) nounwind readnone
1008
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
1016 }
1017
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
1024 }
1025 declare i32 @llvm.x86.sse.ucomieq.ss(<4 x float>, <4 x float>) nounwind readnone
1026
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
1033 }
1034
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
1041 }
1042
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
1049 }
1050
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
1057 }
1058
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
1070 }
1071
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
1081 }