test/CodeGen/X86/stack-folding-fp-avx512.ll

   1 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
   2 ; RUN: llc -O3 -disable-peephole -mtriple=x86_64-unknown-unknown -mattr=+avx512f,+avx512dq < %s | FileCheck %s
   3
   4 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
   5 target triple = "x86_64-unknown-unknown"
   6
   7 ; Stack reload folding tests.
   8 ;
   9 ; By including a nop call with sideeffects we can force a partial register spill of the
  10 ; relevant registers and check that the reload is correctly folded into the instruction.
  11
  12 define <8 x double> @stack_fold_addpd_zmm(<8 x double> %a0, <8 x double> %a1) {
  13 ; CHECK-LABEL: stack_fold_addpd_zmm:
  14 ; CHECK:       # %bb.0:
  15 ; CHECK-NEXT:    vmovups %zmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
  16 ; CHECK-NEXT:    #APP
  17 ; CHECK-NEXT:    nop
  18 ; CHECK-NEXT:    #NO_APP
  19 ; CHECK-NEXT:    vaddpd {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %zmm0 # 64-byte Folded Reload
  20 ; CHECK-NEXT:    retq
  21   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
  22   %2 = fadd <8 x double> %a0, %a1
  23   ret <8 x double> %2
  24 }
  25
  26 define <8 x double> @stack_fold_addpd_zmm_k(<8 x double> %a0, <8 x double> %a1, i8 %mask, <8 x double>* %passthru) {
  27 ; CHECK-LABEL: stack_fold_addpd_zmm_k:
  28 ; CHECK:       # %bb.0:
  29 ; CHECK-NEXT:    vmovups %zmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
  30 ; CHECK-NEXT:    #APP
  31 ; CHECK-NEXT:    nop
  32 ; CHECK-NEXT:    #NO_APP
  33 ; CHECK-NEXT:    kmovw %edi, %k1
  34 ; CHECK-NEXT:    vmovapd (%rsi), %zmm2
  35 ; CHECK-NEXT:    vaddpd {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %zmm2 {%k1} # 64-byte Folded Reload
  36 ; CHECK-NEXT:    vmovapd %zmm2, %zmm0
  37 ; CHECK-NEXT:    retq
  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},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
  39   %2 = fadd <8 x double> %a0, %a1
  40   %3 = bitcast i8 %mask to <8 x i1>
  41   %4 = load <8 x double>, <8 x double>* %passthru
  42   %5 = select <8 x i1> %3, <8 x double> %2, <8 x double> %4
  43   ret <8 x double> %5
  44 }
  45
  46 define <8 x double> @stack_fold_addpd_zmm_k_commuted(<8 x double> %a0, <8 x double> %a1, i8 %mask, <8 x double>* %passthru) {
  47 ; CHECK-LABEL: stack_fold_addpd_zmm_k_commuted:
  48 ; CHECK:       # %bb.0:
  49 ; CHECK-NEXT:    vmovups %zmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
  50 ; CHECK-NEXT:    #APP
  51 ; CHECK-NEXT:    nop
  52 ; CHECK-NEXT:    #NO_APP
  53 ; CHECK-NEXT:    kmovw %edi, %k1
  54 ; CHECK-NEXT:    vmovapd (%rsi), %zmm2
  55 ; CHECK-NEXT:    vaddpd {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %zmm2 {%k1} # 64-byte Folded Reload
  56 ; CHECK-NEXT:    vmovapd %zmm2, %zmm0
  57 ; CHECK-NEXT:    retq
  58   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
  59   %2 = fadd <8 x double> %a1, %a0
  60   %3 = bitcast i8 %mask to <8 x i1>
  61   %4 = load <8 x double>, <8 x double>* %passthru
  62   %5 = select <8 x i1> %3, <8 x double> %2, <8 x double> %4
  63   ret <8 x double> %5
  64 }
  65
  66 define <8 x double> @stack_fold_addpd_zmm_kz(<8 x double> %a0, <8 x double> %a1, i8 %mask) {
  67 ; CHECK-LABEL: stack_fold_addpd_zmm_kz:
  68 ; CHECK:       # %bb.0:
  69 ; CHECK-NEXT:    vmovups %zmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
  70 ; CHECK-NEXT:    #APP
  71 ; CHECK-NEXT:    nop
  72 ; CHECK-NEXT:    #NO_APP
  73 ; CHECK-NEXT:    kmovw %edi, %k1
  74 ; CHECK-NEXT:    vaddpd {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %zmm0 {%k1} {z} # 64-byte Folded Reload
  75 ; CHECK-NEXT:    retq
  76   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
  77   %2 = fadd <8 x double> %a1, %a0
  78   %3 = bitcast i8 %mask to <8 x i1>
  79   %4 = select <8 x i1> %3, <8 x double> %2, <8 x double> zeroinitializer
  80   ret <8 x double> %4
  81 }
  82
  83 define <16 x float> @stack_fold_addps_zmm(<16 x float> %a0, <16 x float> %a1) {
  84 ; CHECK-LABEL: stack_fold_addps_zmm:
  85 ; CHECK:       # %bb.0:
  86 ; CHECK-NEXT:    vmovups %zmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
  87 ; CHECK-NEXT:    #APP
  88 ; CHECK-NEXT:    nop
  89 ; CHECK-NEXT:    #NO_APP
  90 ; CHECK-NEXT:    vaddps {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %zmm0 # 64-byte Folded Reload
  91 ; CHECK-NEXT:    retq
  92   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
  93   %2 = fadd <16 x float> %a0, %a1
  94   ret <16 x float> %2
  95 }
  96
  97 define <16 x float> @stack_fold_addps_zmm_k(<16 x float> %a0, <16 x float> %a1, i16 %mask, <16 x float>* %passthru) {
  98 ; CHECK-LABEL: stack_fold_addps_zmm_k:
  99 ; CHECK:       # %bb.0:
 100 ; CHECK-NEXT:    vmovups %zmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
 101 ; CHECK-NEXT:    #APP
 102 ; CHECK-NEXT:    nop
 103 ; CHECK-NEXT:    #NO_APP
 104 ; CHECK-NEXT:    kmovw %edi, %k1
 105 ; CHECK-NEXT:    vmovaps (%rsi), %zmm2
 106 ; CHECK-NEXT:    vaddps {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %zmm2 {%k1} # 64-byte Folded Reload
 107 ; CHECK-NEXT:    vmovaps %zmm2, %zmm0
 108 ; CHECK-NEXT:    retq
 109   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
 110   %2 = fadd <16 x float> %a0, %a1
 111   %3 = bitcast i16 %mask to <16 x i1>
 112   %4 = load <16 x float>, <16 x float>* %passthru
 113   %5 = select <16 x i1> %3, <16 x float> %2, <16 x float> %4
 114   ret <16 x float> %5
 115 }
 116
 117 define <16 x float> @stack_fold_addps_zmm_k_commuted(<16 x float> %a0, <16 x float> %a1, i16 %mask, <16 x float>* %passthru) {
 118 ; CHECK-LABEL: stack_fold_addps_zmm_k_commuted:
 119 ; CHECK:       # %bb.0:
 120 ; CHECK-NEXT:    vmovups %zmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
 121 ; CHECK-NEXT:    #APP
 122 ; CHECK-NEXT:    nop
 123 ; CHECK-NEXT:    #NO_APP
 124 ; CHECK-NEXT:    kmovw %edi, %k1
 125 ; CHECK-NEXT:    vmovaps (%rsi), %zmm2
 126 ; CHECK-NEXT:    vaddps {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %zmm2 {%k1} # 64-byte Folded Reload
 127 ; CHECK-NEXT:    vmovaps %zmm2, %zmm0
 128 ; CHECK-NEXT:    retq
 129   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
 130   %2 = fadd <16 x float> %a1, %a0
 131   %3 = bitcast i16 %mask to <16 x i1>
 132   %4 = load <16 x float>, <16 x float>* %passthru
 133   %5 = select <16 x i1> %3, <16 x float> %2, <16 x float> %4
 134   ret <16 x float> %5
 135 }
 136
 137 define <16 x float> @stack_fold_addps_zmm_kz(<16 x float> %a0, <16 x float> %a1, i16 %mask) {
 138 ; CHECK-LABEL: stack_fold_addps_zmm_kz:
 139 ; CHECK:       # %bb.0:
 140 ; CHECK-NEXT:    vmovups %zmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
 141 ; CHECK-NEXT:    #APP
 142 ; CHECK-NEXT:    nop
 143 ; CHECK-NEXT:    #NO_APP
 144 ; CHECK-NEXT:    kmovw %edi, %k1
 145 ; CHECK-NEXT:    vaddps {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %zmm0 {%k1} {z} # 64-byte Folded Reload
 146 ; CHECK-NEXT:    retq
 147   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
 148   %2 = fadd <16 x float> %a1, %a0
 149   %3 = bitcast i16 %mask to <16 x i1>
 150   %4 = select <16 x i1> %3, <16 x float> %2, <16 x float> zeroinitializer
 151   ret <16 x float> %4
 152 }
 153
 154 define double @stack_fold_addsd(double %a0, double %a1) {
 155 ; CHECK-LABEL: stack_fold_addsd:
 156 ; CHECK:       # %bb.0:
 157 ; CHECK-NEXT:    vmovsd %xmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 8-byte Spill
 158 ; CHECK-NEXT:    #APP
 159 ; CHECK-NEXT:    nop
 160 ; CHECK-NEXT:    #NO_APP
 161 ; CHECK-NEXT:    vaddsd {{[-0-9]+}}(%r{{[sb]}}p), %xmm0, %xmm0 # 8-byte Folded Reload
 162 ; CHECK-NEXT:    retq
 163   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
 164   %2 = fadd double %a0, %a1
 165   ret double %2
 166 }
 167
 168 define <2 x double> @stack_fold_addsd_int(<2 x double> %a0, <2 x double> %a1) {
 169 ; CHECK-LABEL: stack_fold_addsd_int:
 170 ; CHECK:       # %bb.0:
 171 ; CHECK-NEXT:    vmovaps %xmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
 172 ; CHECK-NEXT:    #APP
 173 ; CHECK-NEXT:    nop
 174 ; CHECK-NEXT:    #NO_APP
 175 ; CHECK-NEXT:    vaddsd {{[-0-9]+}}(%r{{[sb]}}p), %xmm0, %xmm0 # 16-byte Folded Reload
 176 ; CHECK-NEXT:    retq
 177   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
 178   %2 = extractelement <2 x double> %a0, i32 0
 179   %3 = extractelement <2 x double> %a1, i32 0
 180   %4 = fadd double %2, %3
 181   %5 = insertelement <2 x double> %a0, double %4, i32 0
 182   ret <2 x double> %5
 183 }
 184
 185 define float @stack_fold_addss(float %a0, float %a1) {
 186 ; CHECK-LABEL: stack_fold_addss:
 187 ; CHECK:       # %bb.0:
 188 ; CHECK-NEXT:    vmovss %xmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 4-byte Spill
 189 ; CHECK-NEXT:    #APP
 190 ; CHECK-NEXT:    nop
 191 ; CHECK-NEXT:    #NO_APP
 192 ; CHECK-NEXT:    vaddss {{[-0-9]+}}(%r{{[sb]}}p), %xmm0, %xmm0 # 4-byte Folded Reload
 193 ; CHECK-NEXT:    retq
 194   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
 195   %2 = fadd float %a0, %a1
 196   ret float %2
 197 }
 198
 199 define <4 x float> @stack_fold_addss_int(<4 x float> %a0, <4 x float> %a1) {
 200 ; CHECK-LABEL: stack_fold_addss_int:
 201 ; CHECK:       # %bb.0:
 202 ; CHECK-NEXT:    vmovaps %xmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
 203 ; CHECK-NEXT:    #APP
 204 ; CHECK-NEXT:    nop
 205 ; CHECK-NEXT:    #NO_APP
 206 ; CHECK-NEXT:    vaddss {{[-0-9]+}}(%r{{[sb]}}p), %xmm0, %xmm0 # 16-byte Folded Reload
 207 ; CHECK-NEXT:    retq
 208   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
 209   %2 = extractelement <4 x float> %a0, i32 0
 210   %3 = extractelement <4 x float> %a1, i32 0
 211   %4 = fadd float %2, %3
 212   %5 = insertelement <4 x float> %a0, float %4, i32 0
 213   ret <4 x float> %5
 214 }
 215
 216 define <8 x double> @stack_fold_andnpd_zmm(<8 x double> %a0, <8 x double> %a1) {
 217 ; CHECK-LABEL: stack_fold_andnpd_zmm:
 218 ; CHECK:       # %bb.0:
 219 ; CHECK-NEXT:    vmovups %zmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
 220 ; CHECK-NEXT:    #APP
 221 ; CHECK-NEXT:    nop
 222 ; CHECK-NEXT:    #NO_APP
 223 ; CHECK-NEXT:    vandnpd {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %zmm0 # 64-byte Folded Reload
 224 ; CHECK-NEXT:    vxorpd %xmm1, %xmm1, %xmm1
 225 ; CHECK-NEXT:    vaddpd %zmm1, %zmm0, %zmm0
 226 ; CHECK-NEXT:    retq
 227   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
 228   %2 = bitcast <8 x double> %a0 to <8 x i64>
 229   %3 = bitcast <8 x double> %a1 to <8 x i64>
 230   %4 = xor <8 x i64> %2, <i64 -1, i64 -1, i64 -1, i64 -1, i64 -1, i64 -1, i64 -1, i64 -1>
 231   %5 = and <8 x i64> %4, %3
 232   %6 = bitcast <8 x i64> %5 to <8 x double>
 233   ; fadd forces execution domain
 234   %7 = fadd <8 x double> %6, <double 0x0, double 0x0, double 0x0, double 0x0, double 0x0, double 0x0, double 0x0, double 0x0>
 235   ret <8 x double> %7
 236 }
 237
 238 define <16 x float> @stack_fold_andnps_zmm(<16 x float> %a0, <16 x float> %a1) {
 239 ; CHECK-LABEL: stack_fold_andnps_zmm:
 240 ; CHECK:       # %bb.0:
 241 ; CHECK-NEXT:    vmovups %zmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
 242 ; CHECK-NEXT:    #APP
 243 ; CHECK-NEXT:    nop
 244 ; CHECK-NEXT:    #NO_APP
 245 ; CHECK-NEXT:    vandnps {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %zmm0 # 64-byte Folded Reload
 246 ; CHECK-NEXT:    vxorps %xmm1, %xmm1, %xmm1
 247 ; CHECK-NEXT:    vaddps %zmm1, %zmm0, %zmm0
 248 ; CHECK-NEXT:    retq
 249   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
 250   %2 = bitcast <16 x float> %a0 to <16 x i32>
 251   %3 = bitcast <16 x float> %a1 to <16 x i32>
 252   %4 = xor <16 x i32> %2, <i32 -1, i32 -1, i32 -1, i32 -1, i32 -1, i32 -1, i32 -1, i32 -1, i32 -1, i32 -1, i32 -1, i32 -1, i32 -1, i32 -1, i32 -1, i32 -1>
 253   %5 = and <16 x i32> %4, %3
 254   %6 = bitcast <16 x i32> %5 to <16 x float>
 255   ; fadd forces execution domain
 256   %7 = fadd <16 x float> %6, <float 0x0, float 0x0, float 0x0, float 0x0, float 0x0, float 0x0, float 0x0, float 0x0, float 0x0, float 0x0, float 0x0, float 0x0, float 0x0, float 0x0, float 0x0, float 0x0>
 257   ret <16 x float> %7
 258 }
 259
 260 define <8 x double> @stack_fold_andpd_zmm(<8 x double> %a0, <8 x double> %a1) {
 261 ; CHECK-LABEL: stack_fold_andpd_zmm:
 262 ; CHECK:       # %bb.0:
 263 ; CHECK-NEXT:    vmovups %zmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
 264 ; CHECK-NEXT:    #APP
 265 ; CHECK-NEXT:    nop
 266 ; CHECK-NEXT:    #NO_APP
 267 ; CHECK-NEXT:    vandpd {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %zmm0 # 64-byte Folded Reload
 268 ; CHECK-NEXT:    vxorpd %xmm1, %xmm1, %xmm1
 269 ; CHECK-NEXT:    vaddpd %zmm1, %zmm0, %zmm0
 270 ; CHECK-NEXT:    retq
 271   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
 272   %2 = bitcast <8 x double> %a0 to <8 x i64>
 273   %3 = bitcast <8 x double> %a1 to <8 x i64>
 274   %4 = and <8 x i64> %2, %3
 275   %5 = bitcast <8 x i64> %4 to <8 x double>
 276   ; fadd forces execution domain
 277   %6 = fadd <8 x double> %5, <double 0x0, double 0x0, double 0x0, double 0x0, double 0x0, double 0x0, double 0x0, double 0x0>
 278   ret <8 x double> %6
 279 }
 280
 281 define <16 x float> @stack_fold_andps_zmm(<16 x float> %a0, <16 x float> %a1) {
 282 ; CHECK-LABEL: stack_fold_andps_zmm:
 283 ; CHECK:       # %bb.0:
 284 ; CHECK-NEXT:    vmovups %zmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
 285 ; CHECK-NEXT:    #APP
 286 ; CHECK-NEXT:    nop
 287 ; CHECK-NEXT:    #NO_APP
 288 ; CHECK-NEXT:    vandps {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %zmm0 # 64-byte Folded Reload
 289 ; CHECK-NEXT:    vxorps %xmm1, %xmm1, %xmm1
 290 ; CHECK-NEXT:    vaddps %zmm1, %zmm0, %zmm0
 291 ; CHECK-NEXT:    retq
 292   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
 293   %2 = bitcast <16 x float> %a0 to <16 x i32>
 294   %3 = bitcast <16 x float> %a1 to <16 x i32>
 295   %4 = and <16 x i32> %2, %3
 296   %5 = bitcast <16 x i32> %4 to <16 x float>
 297   ; fadd forces execution domain
 298   %6 = fadd <16 x float> %5, <float 0x0, float 0x0, float 0x0, float 0x0, float 0x0, float 0x0, float 0x0, float 0x0, float 0x0, float 0x0, float 0x0, float 0x0, float 0x0, float 0x0, float 0x0, float 0x0>
 299   ret <16 x float> %6
 300 }
 301
 302 define i8 @stack_fold_cmppd(<8 x double> %a0, <8 x double> %a1) {
 303 ; CHECK-LABEL: stack_fold_cmppd:
 304 ; CHECK:       # %bb.0:
 305 ; CHECK-NEXT:    vmovups %zmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
 306 ; CHECK-NEXT:    #APP
 307 ; CHECK-NEXT:    nop
 308 ; CHECK-NEXT:    #NO_APP
 309 ; CHECK-NEXT:    vcmpeqpd {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %k0 # 64-byte Folded Reload
 310 ; CHECK-NEXT:    kmovw %k0, %eax
 311 ; CHECK-NEXT:    # kill: def $al killed $al killed $eax
 312 ; CHECK-NEXT:    vzeroupper
 313 ; CHECK-NEXT:    retq
 314   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
 315   %res = call <8 x i1> @llvm.x86.avx512.cmp.pd.512(<8 x double> %a0, <8 x double> %a1, i32 0, i32 4)
 316   %2 = bitcast <8 x i1> %res to i8
 317   ret i8 %2
 318 }
 319 declare <8 x i1> @llvm.x86.avx512.cmp.pd.512(<8 x double>, <8 x double>, i32, i32)
 320
 321 define <8 x double> @stack_fold_cmppd_mask(<8 x double> %a0, <8 x double> %a1, <8 x double>* %a2, i8 %mask, <8 x double> %b0, <8 x double> %b1) {
 322 ; CHECK-LABEL: stack_fold_cmppd_mask:
 323 ; CHECK:       # %bb.0:
 324 ; CHECK-NEXT:    subq $184, %rsp
 325 ; CHECK-NEXT:    .cfi_def_cfa_offset 192
 326 ; CHECK-NEXT:    vmovups %zmm3, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
 327 ; CHECK-NEXT:    vmovups %zmm2, (%rsp) # 64-byte Spill
 328 ; CHECK-NEXT:    vmovups %zmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
 329 ; CHECK-NEXT:    vmovups %zmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
 330 ; CHECK-NEXT:    #APP
 331 ; CHECK-NEXT:    nop
 332 ; CHECK-NEXT:    #NO_APP
 333 ; CHECK-NEXT:    vmovupd {{[-0-9]+}}(%r{{[sb]}}p), %zmm0 # 64-byte Reload
 334 ; CHECK-NEXT:    vaddpd (%rdi), %zmm0, %zmm0
 335 ; CHECK-NEXT:    kmovw %esi, %k1
 336 ; CHECK-NEXT:    vcmpeqpd {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %k1 {%k1} # 64-byte Folded Reload
 337 ; CHECK-NEXT:    vmovupd {{[-0-9]+}}(%r{{[sb]}}p), %zmm0 # 64-byte Reload
 338 ; CHECK-NEXT:    vblendmpd (%rsp), %zmm0, %zmm0 {%k1} # 64-byte Folded Reload
 339 ; CHECK-NEXT:    addq $184, %rsp
 340 ; CHECK-NEXT:    .cfi_def_cfa_offset 8
 341 ; CHECK-NEXT:    retq
 342   %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},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
 343   ; load and fadd are here to keep the operations below the side effecting block and to avoid folding the wrong load
 344   %2 = load <8 x double>, <8 x double>* %a2
 345   %3 = fadd <8 x double> %a1, %2
 346   %4 = bitcast i8 %mask to <8 x i1>
 347   %5 = call <8 x i1> @llvm.x86.avx512.cmp.pd.512(<8 x double> %3, <8 x double> %a0, i32 0, i32 4)
 348   %6 = and <8 x i1> %4, %5
 349   %7 = select <8 x i1> %6, <8 x double> %b0, <8 x double> %b1
 350   ret <8 x double> %7
 351 }
 352
 353 define <8 x double> @stack_fold_cmppd_mask_commuted(<8 x double> %a0, <8 x double> %a1, <8 x double>* %a2, i8 %mask, <8 x double> %b0, <8 x double> %b1) {
 354 ; CHECK-LABEL: stack_fold_cmppd_mask_commuted:
 355 ; CHECK:       # %bb.0:
 356 ; CHECK-NEXT:    subq $184, %rsp
 357 ; CHECK-NEXT:    .cfi_def_cfa_offset 192
 358 ; CHECK-NEXT:    vmovups %zmm3, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
 359 ; CHECK-NEXT:    vmovups %zmm2, (%rsp) # 64-byte Spill
 360 ; CHECK-NEXT:    vmovups %zmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
 361 ; CHECK-NEXT:    vmovups %zmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
 362 ; CHECK-NEXT:    #APP
 363 ; CHECK-NEXT:    nop
 364 ; CHECK-NEXT:    #NO_APP
 365 ; CHECK-NEXT:    vmovupd {{[-0-9]+}}(%r{{[sb]}}p), %zmm0 # 64-byte Reload
 366 ; CHECK-NEXT:    vaddpd (%rdi), %zmm0, %zmm0
 367 ; CHECK-NEXT:    kmovw %esi, %k1
 368 ; CHECK-NEXT:    vcmpeqpd {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %k1 {%k1} # 64-byte Folded Reload
 369 ; CHECK-NEXT:    vmovupd {{[-0-9]+}}(%r{{[sb]}}p), %zmm0 # 64-byte Reload
 370 ; CHECK-NEXT:    vblendmpd (%rsp), %zmm0, %zmm0 {%k1} # 64-byte Folded Reload
 371 ; CHECK-NEXT:    addq $184, %rsp
 372 ; CHECK-NEXT:    .cfi_def_cfa_offset 8
 373 ; CHECK-NEXT:    retq
 374   %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},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
 375   ; load and fadd are here to keep the operations below the side effecting block and to avoid folding the wrong load
 376   %2 = load <8 x double>, <8 x double>* %a2
 377   %3 = fadd <8 x double> %a1, %2
 378   %4 = bitcast i8 %mask to <8 x i1>
 379   %5 = call <8 x i1> @llvm.x86.avx512.cmp.pd.512(<8 x double> %a0, <8 x double> %3, i32 0, i32 4)
 380   %6 = and <8 x i1> %4, %5
 381   %7 = select <8 x i1> %6, <8 x double> %b0, <8 x double> %b1
 382   ret <8 x double> %7
 383 }
 384
 385 define i16 @stack_fold_cmpps(<16 x float> %a0, <16 x float> %a1) {
 386 ; CHECK-LABEL: stack_fold_cmpps:
 387 ; CHECK:       # %bb.0:
 388 ; CHECK-NEXT:    vmovups %zmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
 389 ; CHECK-NEXT:    #APP
 390 ; CHECK-NEXT:    nop
 391 ; CHECK-NEXT:    #NO_APP
 392 ; CHECK-NEXT:    vcmpeqps {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %k0 # 64-byte Folded Reload
 393 ; CHECK-NEXT:    kmovw %k0, %eax
 394 ; CHECK-NEXT:    # kill: def $ax killed $ax killed $eax
 395 ; CHECK-NEXT:    vzeroupper
 396 ; CHECK-NEXT:    retq
 397   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
 398   %res = call <16 x i1> @llvm.x86.avx512.cmp.ps.512(<16 x float> %a0, <16 x float> %a1, i32 0, i32 4)
 399   %2 = bitcast <16 x i1> %res to i16
 400   ret i16 %2
 401 }
 402 declare <16 x i1> @llvm.x86.avx512.cmp.ps.512(<16 x float>, <16 x float>, i32, i32)
 403
 404 define <16 x float> @stack_fold_cmpps_mask(<16 x float> %a0, <16 x float> %a1, <16 x float>* %a2, i16 %mask, <16 x float> %b0, <16 x float> %b1) {
 405 ; CHECK-LABEL: stack_fold_cmpps_mask:
 406 ; CHECK:       # %bb.0:
 407 ; CHECK-NEXT:    subq $184, %rsp
 408 ; CHECK-NEXT:    .cfi_def_cfa_offset 192
 409 ; CHECK-NEXT:    vmovups %zmm3, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
 410 ; CHECK-NEXT:    vmovups %zmm2, (%rsp) # 64-byte Spill
 411 ; CHECK-NEXT:    vmovups %zmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
 412 ; CHECK-NEXT:    vmovups %zmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
 413 ; CHECK-NEXT:    #APP
 414 ; CHECK-NEXT:    nop
 415 ; CHECK-NEXT:    #NO_APP
 416 ; CHECK-NEXT:    vmovups {{[-0-9]+}}(%r{{[sb]}}p), %zmm0 # 64-byte Reload
 417 ; CHECK-NEXT:    vaddps (%rdi), %zmm0, %zmm0
 418 ; CHECK-NEXT:    kmovw %esi, %k1
 419 ; CHECK-NEXT:    vcmpeqps {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %k1 {%k1} # 64-byte Folded Reload
 420 ; CHECK-NEXT:    vmovups {{[-0-9]+}}(%r{{[sb]}}p), %zmm0 # 64-byte Reload
 421 ; CHECK-NEXT:    vblendmps (%rsp), %zmm0, %zmm0 {%k1} # 64-byte Folded Reload
 422 ; CHECK-NEXT:    addq $184, %rsp
 423 ; CHECK-NEXT:    .cfi_def_cfa_offset 8
 424 ; CHECK-NEXT:    retq
 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},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
 426   ; load and fadd are here to keep the operations below the side effecting block and to avoid folding the wrong load
 427   %2 = load <16 x float>, <16 x float>* %a2
 428   %3 = fadd <16 x float> %a1, %2
 429   %4 = bitcast i16 %mask to <16 x i1>
 430   %5 = call <16 x i1> @llvm.x86.avx512.cmp.ps.512(<16 x float> %3, <16 x float> %a0, i32 0, i32 4)
 431   %6 = and <16 x i1> %4, %5
 432   %7 = select <16 x i1> %6, <16 x float> %b0, <16 x float> %b1
 433   ret <16 x float> %7
 434 }
 435
 436 define <16 x float> @stack_fold_cmpps_mask_commuted(<16 x float> %a0, <16 x float> %a1, <16 x float>* %a2, i16 %mask, <16 x float> %b0, <16 x float> %b1) {
 437 ; CHECK-LABEL: stack_fold_cmpps_mask_commuted:
 438 ; CHECK:       # %bb.0:
 439 ; CHECK-NEXT:    subq $184, %rsp
 440 ; CHECK-NEXT:    .cfi_def_cfa_offset 192
 441 ; CHECK-NEXT:    vmovups %zmm3, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
 442 ; CHECK-NEXT:    vmovups %zmm2, (%rsp) # 64-byte Spill
 443 ; CHECK-NEXT:    vmovups %zmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
 444 ; CHECK-NEXT:    vmovups %zmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
 445 ; CHECK-NEXT:    #APP
 446 ; CHECK-NEXT:    nop
 447 ; CHECK-NEXT:    #NO_APP
 448 ; CHECK-NEXT:    vmovups {{[-0-9]+}}(%r{{[sb]}}p), %zmm0 # 64-byte Reload
 449 ; CHECK-NEXT:    vaddps (%rdi), %zmm0, %zmm0
 450 ; CHECK-NEXT:    kmovw %esi, %k1
 451 ; CHECK-NEXT:    vcmpeqps {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %k1 {%k1} # 64-byte Folded Reload
 452 ; CHECK-NEXT:    vmovups {{[-0-9]+}}(%r{{[sb]}}p), %zmm0 # 64-byte Reload
 453 ; CHECK-NEXT:    vblendmps (%rsp), %zmm0, %zmm0 {%k1} # 64-byte Folded Reload
 454 ; CHECK-NEXT:    addq $184, %rsp
 455 ; CHECK-NEXT:    .cfi_def_cfa_offset 8
 456 ; CHECK-NEXT:    retq
 457   %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},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
 458   ; load and fadd are here to keep the operations below the side effecting block and to avoid folding the wrong load
 459   %2 = load <16 x float>, <16 x float>* %a2
 460   %3 = fadd <16 x float> %a1, %2
 461   %4 = bitcast i16 %mask to <16 x i1>
 462   %5 = call <16 x i1> @llvm.x86.avx512.cmp.ps.512(<16 x float> %a0, <16 x float> %3, i32 0, i32 4)
 463   %6 = and <16 x i1> %4, %5
 464   %7 = select <16 x i1> %6, <16 x float> %b0, <16 x float> %b1
 465   ret <16 x float> %7
 466 }
 467
 468 define <2 x double> @stack_fold_divsd_int(<2 x double> %a0, <2 x double> %a1) {
 469 ; CHECK-LABEL: stack_fold_divsd_int:
 470 ; CHECK:       # %bb.0:
 471 ; CHECK-NEXT:    vmovaps %xmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
 472 ; CHECK-NEXT:    #APP
 473 ; CHECK-NEXT:    nop
 474 ; CHECK-NEXT:    #NO_APP
 475 ; CHECK-NEXT:    vdivsd {{[-0-9]+}}(%r{{[sb]}}p), %xmm0, %xmm0 # 16-byte Folded Reload
 476 ; CHECK-NEXT:    retq
 477   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
 478   %2 = extractelement <2 x double> %a0, i32 0
 479   %3 = extractelement <2 x double> %a1, i32 0
 480   %4 = fdiv double %2, %3
 481   %5 = insertelement <2 x double> %a0, double %4, i32 0
 482   ret <2 x double> %5
 483 }
 484
 485 define float @stack_fold_divss(float %a0, float %a1) {
 486 ; CHECK-LABEL: stack_fold_divss:
 487 ; CHECK:       # %bb.0:
 488 ; CHECK-NEXT:    vmovss %xmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 4-byte Spill
 489 ; CHECK-NEXT:    #APP
 490 ; CHECK-NEXT:    nop
 491 ; CHECK-NEXT:    #NO_APP
 492 ; CHECK-NEXT:    vdivss {{[-0-9]+}}(%r{{[sb]}}p), %xmm0, %xmm0 # 4-byte Folded Reload
 493 ; CHECK-NEXT:    retq
 494   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
 495   %2 = fdiv float %a0, %a1
 496   ret float %2
 497 }
 498
 499 define <4 x float> @stack_fold_divss_int(<4 x float> %a0, <4 x float> %a1) {
 500 ; CHECK-LABEL: stack_fold_divss_int:
 501 ; CHECK:       # %bb.0:
 502 ; CHECK-NEXT:    vmovaps %xmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
 503 ; CHECK-NEXT:    #APP
 504 ; CHECK-NEXT:    nop
 505 ; CHECK-NEXT:    #NO_APP
 506 ; CHECK-NEXT:    vdivss {{[-0-9]+}}(%r{{[sb]}}p), %xmm0, %xmm0 # 16-byte Folded Reload
 507 ; CHECK-NEXT:    retq
 508   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
 509   %2 = extractelement <4 x float> %a0, i32 0
 510   %3 = extractelement <4 x float> %a1, i32 0
 511   %4 = fdiv float %2, %3
 512   %5 = insertelement <4 x float> %a0, float %4, i32 0
 513   ret <4 x float> %5
 514 }
 515
 516 define <8 x double> @stack_fold_cvtdq2pd(<8 x i32> %a0) {
 517 ; CHECK-LABEL: stack_fold_cvtdq2pd:
 518 ; CHECK:       # %bb.0:
 519 ; CHECK-NEXT:    vmovups %ymm0, {{[-0-9]+}}(%r{{[sb]}}p) # 32-byte Spill
 520 ; CHECK-NEXT:    #APP
 521 ; CHECK-NEXT:    nop
 522 ; CHECK-NEXT:    #NO_APP
 523 ; CHECK-NEXT:    vcvtdq2pd {{[-0-9]+}}(%r{{[sb]}}p), %zmm0 # 32-byte Folded Reload
 524 ; CHECK-NEXT:    retq
 525   %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},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
 526   %2 = sitofp <8 x i32> %a0 to <8 x double>
 527   ret <8 x double> %2
 528 }
 529
 530 define <8 x double> @stack_fold_cvtudq2pd(<8 x i32> %a0) {
 531 ; CHECK-LABEL: stack_fold_cvtudq2pd:
 532 ; CHECK:       # %bb.0:
 533 ; CHECK-NEXT:    vmovups %ymm0, {{[-0-9]+}}(%r{{[sb]}}p) # 32-byte Spill
 534 ; CHECK-NEXT:    #APP
 535 ; CHECK-NEXT:    nop
 536 ; CHECK-NEXT:    #NO_APP
 537 ; CHECK-NEXT:    vcvtudq2pd {{[-0-9]+}}(%r{{[sb]}}p), %zmm0 # 32-byte Folded Reload
 538 ; CHECK-NEXT:    retq
 539   %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},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
 540   %2 = uitofp <8 x i32> %a0 to <8 x double>
 541   ret <8 x double> %2
 542 }
 543
 544 define <8 x float> @stack_fold_cvtpd2ps(<8 x double> %a0) {
 545 ; CHECK-LABEL: stack_fold_cvtpd2ps:
 546 ; CHECK:       # %bb.0:
 547 ; CHECK-NEXT:    vmovups %zmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
 548 ; CHECK-NEXT:    #APP
 549 ; CHECK-NEXT:    nop
 550 ; CHECK-NEXT:    #NO_APP
 551 ; CHECK-NEXT:    vcvtpd2ps {{[-0-9]+}}(%r{{[sb]}}p), %ymm0 # 64-byte Folded Reload
 552 ; CHECK-NEXT:    retq
 553   %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},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
 554   %2 = fptrunc <8 x double> %a0 to <8 x float>
 555   ret <8 x float> %2
 556 }
 557
 558 define <16 x float> @stack_fold_cvtph2ps(<16 x i16> %a0) {
 559 ; CHECK-LABEL: stack_fold_cvtph2ps:
 560 ; CHECK:       # %bb.0:
 561 ; CHECK-NEXT:    vmovups %ymm0, {{[-0-9]+}}(%r{{[sb]}}p) # 32-byte Spill
 562 ; CHECK-NEXT:    #APP
 563 ; CHECK-NEXT:    nop
 564 ; CHECK-NEXT:    #NO_APP
 565 ; CHECK-NEXT:    vcvtph2ps {{[-0-9]+}}(%r{{[sb]}}p), %zmm0 # 32-byte Folded Reload
 566 ; CHECK-NEXT:    retq
 567   %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},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
 568   %2 = call <16 x float> @llvm.x86.avx512.mask.vcvtph2ps.512(<16 x i16> %a0, <16 x float> undef, i16 -1, i32 4)
 569   ret <16 x float> %2
 570 }
 571 declare <16 x float> @llvm.x86.avx512.mask.vcvtph2ps.512(<16 x i16>, <16 x float>, i16, i32) nounwind readonly
 572
 573 define <16 x i16> @stack_fold_cvtps2ph(<16 x float> %a0) {
 574 ; CHECK-LABEL: stack_fold_cvtps2ph:
 575 ; CHECK:       # %bb.0:
 576 ; CHECK-NEXT:    vcvtps2ph $0, %zmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 32-byte Folded Spill
 577 ; CHECK-NEXT:    #APP
 578 ; CHECK-NEXT:    nop
 579 ; CHECK-NEXT:    #NO_APP
 580 ; CHECK-NEXT:    vmovups {{[-0-9]+}}(%r{{[sb]}}p), %ymm0 # 32-byte Reload
 581 ; CHECK-NEXT:    retq
 582   %1 = call <16 x i16> @llvm.x86.avx512.mask.vcvtps2ph.512(<16 x float> %a0, i32 0, <16 x i16> undef, i16 -1)
 583   %2 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm1},~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
 584   ret <16 x i16> %1
 585 }
 586 declare <16 x i16> @llvm.x86.avx512.mask.vcvtps2ph.512(<16 x float>, i32, <16 x i16>, i16) nounwind readonly
 587
 588 define <4 x float> @stack_fold_insertps(<4 x float> %a0, <4 x float> %a1) {
 589 ; CHECK-LABEL: stack_fold_insertps:
 590 ; CHECK:       # %bb.0:
 591 ; CHECK-NEXT:    vmovaps %xmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
 592 ; CHECK-NEXT:    #APP
 593 ; CHECK-NEXT:    nop
 594 ; CHECK-NEXT:    #NO_APP
 595 ; CHECK-NEXT:    vinsertps $17, {{[-0-9]+}}(%r{{[sb]}}p), %xmm0, %xmm0 # 16-byte Folded Reload
 596 ; CHECK-NEXT:    # xmm0 = zero,mem[0],xmm0[2,3]
 597 ; CHECK-NEXT:    retq
 598   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
 599   %2 = call <4 x float> @llvm.x86.sse41.insertps(<4 x float> %a0, <4 x float> %a1, i8 209)
 600   ret <4 x float> %2
 601 }
 602 declare <4 x float> @llvm.x86.sse41.insertps(<4 x float>, <4 x float>, i8) nounwind readnone
 603
 604 define <8 x double> @stack_fold_maxpd_zmm(<8 x double> %a0, <8 x double> %a1) #0 {
 605 ; CHECK-LABEL: stack_fold_maxpd_zmm:
 606 ; CHECK:       # %bb.0:
 607 ; CHECK-NEXT:    vmovups %zmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
 608 ; CHECK-NEXT:    #APP
 609 ; CHECK-NEXT:    nop
 610 ; CHECK-NEXT:    #NO_APP
 611 ; CHECK-NEXT:    vmaxpd {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %zmm0 # 64-byte Folded Reload
 612 ; CHECK-NEXT:    retq
 613   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
 614   %2 = call <8 x double> @llvm.x86.avx512.max.pd.512(<8 x double> %a0, <8 x double> %a1, i32 4)
 615   ret <8 x double> %2
 616 }
 617 declare <8 x double> @llvm.x86.avx512.max.pd.512(<8 x double>, <8 x double>, i32) nounwind readnone
 618
 619 define <8 x double> @stack_fold_maxpd_zmm_commutable(<8 x double> %a0, <8 x double> %a1) #1 {
 620 ; CHECK-LABEL: stack_fold_maxpd_zmm_commutable:
 621 ; CHECK:       # %bb.0:
 622 ; CHECK-NEXT:    vmovups %zmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
 623 ; CHECK-NEXT:    #APP
 624 ; CHECK-NEXT:    nop
 625 ; CHECK-NEXT:    #NO_APP
 626 ; CHECK-NEXT:    vmaxpd {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %zmm0 # 64-byte Folded Reload
 627 ; CHECK-NEXT:    retq
 628   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
 629   %2 = call <8 x double> @llvm.x86.avx512.max.pd.512(<8 x double> %a0, <8 x double> %a1, i32 4)
 630   ret <8 x double> %2
 631 }
 632
 633 define <8 x double> @stack_fold_maxpd_zmm_commutable_k(<8 x double> %a0, <8 x double> %a1, i8 %mask, <8 x double>* %passthru) #1 {
 634 ; CHECK-LABEL: stack_fold_maxpd_zmm_commutable_k:
 635 ; CHECK:       # %bb.0:
 636 ; CHECK-NEXT:    vmovups %zmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
 637 ; CHECK-NEXT:    #APP
 638 ; CHECK-NEXT:    nop
 639 ; CHECK-NEXT:    #NO_APP
 640 ; CHECK-NEXT:    kmovw %edi, %k1
 641 ; CHECK-NEXT:    vmovapd (%rsi), %zmm2
 642 ; CHECK-NEXT:    vmaxpd {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %zmm2 {%k1} # 64-byte Folded Reload
 643 ; CHECK-NEXT:    vmovapd %zmm2, %zmm0
 644 ; CHECK-NEXT:    retq
 645   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
 646   %2 = call <8 x double> @llvm.x86.avx512.max.pd.512(<8 x double> %a0, <8 x double> %a1, i32 4)
 647   %3 = bitcast i8 %mask to <8 x i1>
 648   %4 = load <8 x double>, <8 x double>* %passthru
 649   %5 = select <8 x i1> %3, <8 x double> %2, <8 x double> %4
 650   ret <8 x double> %5
 651 }
 652
 653 define <8 x double> @stack_fold_maxpd_zmm_commutable_k_commuted(<8 x double> %a0, <8 x double> %a1, i8 %mask, <8 x double>* %passthru) #1 {
 654 ; CHECK-LABEL: stack_fold_maxpd_zmm_commutable_k_commuted:
 655 ; CHECK:       # %bb.0:
 656 ; CHECK-NEXT:    vmovups %zmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
 657 ; CHECK-NEXT:    #APP
 658 ; CHECK-NEXT:    nop
 659 ; CHECK-NEXT:    #NO_APP
 660 ; CHECK-NEXT:    kmovw %edi, %k1
 661 ; CHECK-NEXT:    vmovapd (%rsi), %zmm2
 662 ; CHECK-NEXT:    vmaxpd {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %zmm2 {%k1} # 64-byte Folded Reload
 663 ; CHECK-NEXT:    vmovapd %zmm2, %zmm0
 664 ; CHECK-NEXT:    retq
 665   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
 666   %2 = call <8 x double> @llvm.x86.avx512.max.pd.512(<8 x double> %a1, <8 x double> %a0, i32 4)
 667   %3 = bitcast i8 %mask to <8 x i1>
 668   %4 = load <8 x double>, <8 x double>* %passthru
 669   %5 = select <8 x i1> %3, <8 x double> %2, <8 x double> %4
 670   ret <8 x double> %5
 671 }
 672
 673 define <8 x double> @stack_fold_maxpd_zmm_commutable_kz(<8 x double> %a0, <8 x double> %a1, i8 %mask) #1 {
 674 ; CHECK-LABEL: stack_fold_maxpd_zmm_commutable_kz:
 675 ; CHECK:       # %bb.0:
 676 ; CHECK-NEXT:    vmovups %zmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
 677 ; CHECK-NEXT:    #APP
 678 ; CHECK-NEXT:    nop
 679 ; CHECK-NEXT:    #NO_APP
 680 ; CHECK-NEXT:    kmovw %edi, %k1
 681 ; CHECK-NEXT:    vmaxpd {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %zmm0 {%k1} {z} # 64-byte Folded Reload
 682 ; CHECK-NEXT:    retq
 683   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
 684   %2 = call <8 x double> @llvm.x86.avx512.max.pd.512(<8 x double> %a1, <8 x double> %a0, i32 4)
 685   %3 = bitcast i8 %mask to <8 x i1>
 686   %4 = select <8 x i1> %3, <8 x double> %2, <8 x double> zeroinitializer
 687   ret <8 x double> %4
 688 }
 689
 690 define <16 x float> @stack_fold_maxps_zmm(<16 x float> %a0, <16 x float> %a1) #0 {
 691 ; CHECK-LABEL: stack_fold_maxps_zmm:
 692 ; CHECK:       # %bb.0:
 693 ; CHECK-NEXT:    vmovups %zmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
 694 ; CHECK-NEXT:    #APP
 695 ; CHECK-NEXT:    nop
 696 ; CHECK-NEXT:    #NO_APP
 697 ; CHECK-NEXT:    vmaxps {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %zmm0 # 64-byte Folded Reload
 698 ; CHECK-NEXT:    retq
 699   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
 700   %2 = call <16 x float> @llvm.x86.avx512.max.ps.512(<16 x float> %a0, <16 x float> %a1, i32 4)
 701   ret <16 x float> %2
 702 }
 703 declare <16 x float> @llvm.x86.avx512.max.ps.512(<16 x float>, <16 x float>, i32) nounwind readnone
 704
 705 define <16 x float> @stack_fold_maxps_zmm_commutable(<16 x float> %a0, <16 x float> %a1) #1 {
 706 ; CHECK-LABEL: stack_fold_maxps_zmm_commutable:
 707 ; CHECK:       # %bb.0:
 708 ; CHECK-NEXT:    vmovups %zmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
 709 ; CHECK-NEXT:    #APP
 710 ; CHECK-NEXT:    nop
 711 ; CHECK-NEXT:    #NO_APP
 712 ; CHECK-NEXT:    vmaxps {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %zmm0 # 64-byte Folded Reload
 713 ; CHECK-NEXT:    retq
 714   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
 715   %2 = call <16 x float> @llvm.x86.avx512.max.ps.512(<16 x float> %a0, <16 x float> %a1, i32 4)
 716   ret <16 x float> %2
 717 }
 718
 719 define <16 x float> @stack_fold_maxps_zmm_commutable_k(<16 x float> %a0, <16 x float> %a1, i16 %mask, <16 x float>* %passthru) #1 {
 720 ; CHECK-LABEL: stack_fold_maxps_zmm_commutable_k:
 721 ; CHECK:       # %bb.0:
 722 ; CHECK-NEXT:    vmovups %zmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
 723 ; CHECK-NEXT:    #APP
 724 ; CHECK-NEXT:    nop
 725 ; CHECK-NEXT:    #NO_APP
 726 ; CHECK-NEXT:    kmovw %edi, %k1
 727 ; CHECK-NEXT:    vmovaps (%rsi), %zmm2
 728 ; CHECK-NEXT:    vmaxps {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %zmm2 {%k1} # 64-byte Folded Reload
 729 ; CHECK-NEXT:    vmovaps %zmm2, %zmm0
 730 ; CHECK-NEXT:    retq
 731   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
 732   %2 = call <16 x float> @llvm.x86.avx512.max.ps.512(<16 x float> %a0, <16 x float> %a1, i32 4)
 733   %3 = bitcast i16 %mask to <16 x i1>
 734   %4 = load <16 x float>, <16 x float>* %passthru
 735   %5 = select <16 x i1> %3, <16 x float> %2, <16 x float> %4
 736   ret <16 x float> %5
 737 }
 738
 739 define <16 x float> @stack_fold_maxps_zmm_commutable_k_commuted(<16 x float> %a0, <16 x float> %a1, i16 %mask, <16 x float>* %passthru) #1 {
 740 ; CHECK-LABEL: stack_fold_maxps_zmm_commutable_k_commuted:
 741 ; CHECK:       # %bb.0:
 742 ; CHECK-NEXT:    vmovups %zmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
 743 ; CHECK-NEXT:    #APP
 744 ; CHECK-NEXT:    nop
 745 ; CHECK-NEXT:    #NO_APP
 746 ; CHECK-NEXT:    kmovw %edi, %k1
 747 ; CHECK-NEXT:    vmovaps (%rsi), %zmm2
 748 ; CHECK-NEXT:    vmaxps {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %zmm2 {%k1} # 64-byte Folded Reload
 749 ; CHECK-NEXT:    vmovaps %zmm2, %zmm0
 750 ; CHECK-NEXT:    retq
 751   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
 752   %2 = call <16 x float> @llvm.x86.avx512.max.ps.512(<16 x float> %a1, <16 x float> %a0, i32 4)
 753   %3 = bitcast i16 %mask to <16 x i1>
 754   %4 = load <16 x float>, <16 x float>* %passthru
 755   %5 = select <16 x i1> %3, <16 x float> %2, <16 x float> %4
 756   ret <16 x float> %5
 757 }
 758
 759 define <16 x float> @stack_fold_maxps_zmm_commutable_kz(<16 x float> %a0, <16 x float> %a1, i16 %mask) #1 {
 760 ; CHECK-LABEL: stack_fold_maxps_zmm_commutable_kz:
 761 ; CHECK:       # %bb.0:
 762 ; CHECK-NEXT:    vmovups %zmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
 763 ; CHECK-NEXT:    #APP
 764 ; CHECK-NEXT:    nop
 765 ; CHECK-NEXT:    #NO_APP
 766 ; CHECK-NEXT:    kmovw %edi, %k1
 767 ; CHECK-NEXT:    vmaxps {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %zmm0 {%k1} {z} # 64-byte Folded Reload
 768 ; CHECK-NEXT:    retq
 769   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
 770   %2 = call <16 x float> @llvm.x86.avx512.max.ps.512(<16 x float> %a1, <16 x float> %a0, i32 4)
 771   %3 = bitcast i16 %mask to <16 x i1>
 772   %4 = select <16 x i1> %3, <16 x float> %2, <16 x float> zeroinitializer
 773   ret <16 x float> %4
 774 }
 775
 776 define <8 x double> @stack_fold_minpd_zmm(<8 x double> %a0, <8 x double> %a1) #0 {
 777 ; CHECK-LABEL: stack_fold_minpd_zmm:
 778 ; CHECK:       # %bb.0:
 779 ; CHECK-NEXT:    vmovups %zmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
 780 ; CHECK-NEXT:    #APP
 781 ; CHECK-NEXT:    nop
 782 ; CHECK-NEXT:    #NO_APP
 783 ; CHECK-NEXT:    vminpd {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %zmm0 # 64-byte Folded Reload
 784 ; CHECK-NEXT:    retq
 785   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
 786   %2 = call <8 x double> @llvm.x86.avx512.min.pd.512(<8 x double> %a0, <8 x double> %a1, i32 4)
 787   ret <8 x double> %2
 788 }
 789 declare <8 x double> @llvm.x86.avx512.min.pd.512(<8 x double>, <8 x double>, i32) nounwind readnone
 790
 791 define <8 x double> @stack_fold_minpd_zmm_commutable(<8 x double> %a0, <8 x double> %a1) #1 {
 792 ; CHECK-LABEL: stack_fold_minpd_zmm_commutable:
 793 ; CHECK:       # %bb.0:
 794 ; CHECK-NEXT:    vmovups %zmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
 795 ; CHECK-NEXT:    #APP
 796 ; CHECK-NEXT:    nop
 797 ; CHECK-NEXT:    #NO_APP
 798 ; CHECK-NEXT:    vminpd {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %zmm0 # 64-byte Folded Reload
 799 ; CHECK-NEXT:    retq
 800   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
 801   %2 = call <8 x double> @llvm.x86.avx512.min.pd.512(<8 x double> %a0, <8 x double> %a1, i32 4)
 802   ret <8 x double> %2
 803 }
 804
 805 define <8 x double> @stack_fold_minpd_zmm_commutable_k(<8 x double> %a0, <8 x double> %a1, i8 %mask, <8 x double>* %passthru) #1 {
 806 ; CHECK-LABEL: stack_fold_minpd_zmm_commutable_k:
 807 ; CHECK:       # %bb.0:
 808 ; CHECK-NEXT:    vmovups %zmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
 809 ; CHECK-NEXT:    #APP
 810 ; CHECK-NEXT:    nop
 811 ; CHECK-NEXT:    #NO_APP
 812 ; CHECK-NEXT:    kmovw %edi, %k1
 813 ; CHECK-NEXT:    vmovapd (%rsi), %zmm2
 814 ; CHECK-NEXT:    vminpd {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %zmm2 {%k1} # 64-byte Folded Reload
 815 ; CHECK-NEXT:    vmovapd %zmm2, %zmm0
 816 ; CHECK-NEXT:    retq
 817   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
 818   %2 = call <8 x double> @llvm.x86.avx512.min.pd.512(<8 x double> %a0, <8 x double> %a1, i32 4)
 819   %3 = bitcast i8 %mask to <8 x i1>
 820   %4 = load <8 x double>, <8 x double>* %passthru
 821   %5 = select <8 x i1> %3, <8 x double> %2, <8 x double> %4
 822   ret <8 x double> %5
 823 }
 824
 825 define <8 x double> @stack_fold_minpd_zmm_commutable_k_commuted(<8 x double> %a0, <8 x double> %a1, i8 %mask, <8 x double>* %passthru) #1 {
 826 ; CHECK-LABEL: stack_fold_minpd_zmm_commutable_k_commuted:
 827 ; CHECK:       # %bb.0:
 828 ; CHECK-NEXT:    vmovups %zmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
 829 ; CHECK-NEXT:    #APP
 830 ; CHECK-NEXT:    nop
 831 ; CHECK-NEXT:    #NO_APP
 832 ; CHECK-NEXT:    kmovw %edi, %k1
 833 ; CHECK-NEXT:    vmovapd (%rsi), %zmm2
 834 ; CHECK-NEXT:    vminpd {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %zmm2 {%k1} # 64-byte Folded Reload
 835 ; CHECK-NEXT:    vmovapd %zmm2, %zmm0
 836 ; CHECK-NEXT:    retq
 837   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
 838   %2 = call <8 x double> @llvm.x86.avx512.min.pd.512(<8 x double> %a1, <8 x double> %a0, i32 4)
 839   %3 = bitcast i8 %mask to <8 x i1>
 840   %4 = load <8 x double>, <8 x double>* %passthru
 841   %5 = select <8 x i1> %3, <8 x double> %2, <8 x double> %4
 842   ret <8 x double> %5
 843 }
 844
 845 define <8 x double> @stack_fold_minpd_zmm_commutable_kz(<8 x double> %a0, <8 x double> %a1, i8 %mask) #1 {
 846 ; CHECK-LABEL: stack_fold_minpd_zmm_commutable_kz:
 847 ; CHECK:       # %bb.0:
 848 ; CHECK-NEXT:    vmovups %zmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
 849 ; CHECK-NEXT:    #APP
 850 ; CHECK-NEXT:    nop
 851 ; CHECK-NEXT:    #NO_APP
 852 ; CHECK-NEXT:    kmovw %edi, %k1
 853 ; CHECK-NEXT:    vminpd {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %zmm0 {%k1} {z} # 64-byte Folded Reload
 854 ; CHECK-NEXT:    retq
 855   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
 856   %2 = call <8 x double> @llvm.x86.avx512.min.pd.512(<8 x double> %a1, <8 x double> %a0, i32 4)
 857   %3 = bitcast i8 %mask to <8 x i1>
 858   %4 = select <8 x i1> %3, <8 x double> %2, <8 x double> zeroinitializer
 859   ret <8 x double> %4
 860 }
 861
 862 define <16 x float> @stack_fold_minps_zmm(<16 x float> %a0, <16 x float> %a1) #0 {
 863 ; CHECK-LABEL: stack_fold_minps_zmm:
 864 ; CHECK:       # %bb.0:
 865 ; CHECK-NEXT:    vmovups %zmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
 866 ; CHECK-NEXT:    #APP
 867 ; CHECK-NEXT:    nop
 868 ; CHECK-NEXT:    #NO_APP
 869 ; CHECK-NEXT:    vminps {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %zmm0 # 64-byte Folded Reload
 870 ; CHECK-NEXT:    retq
 871   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
 872   %2 = call <16 x float> @llvm.x86.avx512.min.ps.512(<16 x float> %a0, <16 x float> %a1, i32 4)
 873   ret <16 x float> %2
 874 }
 875 declare <16 x float> @llvm.x86.avx512.min.ps.512(<16 x float>, <16 x float>, i32) nounwind readnone
 876
 877 define <16 x float> @stack_fold_minps_zmm_commutable(<16 x float> %a0, <16 x float> %a1) #1 {
 878 ; CHECK-LABEL: stack_fold_minps_zmm_commutable:
 879 ; CHECK:       # %bb.0:
 880 ; CHECK-NEXT:    vmovups %zmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
 881 ; CHECK-NEXT:    #APP
 882 ; CHECK-NEXT:    nop
 883 ; CHECK-NEXT:    #NO_APP
 884 ; CHECK-NEXT:    vminps {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %zmm0 # 64-byte Folded Reload
 885 ; CHECK-NEXT:    retq
 886   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
 887   %2 = call <16 x float> @llvm.x86.avx512.min.ps.512(<16 x float> %a0, <16 x float> %a1, i32 4)
 888   ret <16 x float> %2
 889 }
 890
 891 define <16 x float> @stack_fold_minps_zmm_commutable_k(<16 x float> %a0, <16 x float> %a1, i16 %mask, <16 x float>* %passthru) #1 {
 892 ; CHECK-LABEL: stack_fold_minps_zmm_commutable_k:
 893 ; CHECK:       # %bb.0:
 894 ; CHECK-NEXT:    vmovups %zmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
 895 ; CHECK-NEXT:    #APP
 896 ; CHECK-NEXT:    nop
 897 ; CHECK-NEXT:    #NO_APP
 898 ; CHECK-NEXT:    kmovw %edi, %k1
 899 ; CHECK-NEXT:    vmovaps (%rsi), %zmm2
 900 ; CHECK-NEXT:    vminps {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %zmm2 {%k1} # 64-byte Folded Reload
 901 ; CHECK-NEXT:    vmovaps %zmm2, %zmm0
 902 ; CHECK-NEXT:    retq
 903   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
 904   %2 = call <16 x float> @llvm.x86.avx512.min.ps.512(<16 x float> %a0, <16 x float> %a1, i32 4)
 905   %3 = bitcast i16 %mask to <16 x i1>
 906   %4 = load <16 x float>, <16 x float>* %passthru
 907   %5 = select <16 x i1> %3, <16 x float> %2, <16 x float> %4
 908   ret <16 x float> %5
 909 }
 910
 911 define <16 x float> @stack_fold_minps_zmm_commutable_k_commuted(<16 x float> %a0, <16 x float> %a1, i16 %mask, <16 x float>* %passthru) #1 {
 912 ; CHECK-LABEL: stack_fold_minps_zmm_commutable_k_commuted:
 913 ; CHECK:       # %bb.0:
 914 ; CHECK-NEXT:    vmovups %zmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
 915 ; CHECK-NEXT:    #APP
 916 ; CHECK-NEXT:    nop
 917 ; CHECK-NEXT:    #NO_APP
 918 ; CHECK-NEXT:    kmovw %edi, %k1
 919 ; CHECK-NEXT:    vmovaps (%rsi), %zmm2
 920 ; CHECK-NEXT:    vminps {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %zmm2 {%k1} # 64-byte Folded Reload
 921 ; CHECK-NEXT:    vmovaps %zmm2, %zmm0
 922 ; CHECK-NEXT:    retq
 923   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
 924   %2 = call <16 x float> @llvm.x86.avx512.min.ps.512(<16 x float> %a1, <16 x float> %a0, i32 4)
 925   %3 = bitcast i16 %mask to <16 x i1>
 926   %4 = load <16 x float>, <16 x float>* %passthru
 927   %5 = select <16 x i1> %3, <16 x float> %2, <16 x float> %4
 928   ret <16 x float> %5
 929 }
 930
 931 define <16 x float> @stack_fold_minps_zmm_commutable_kz(<16 x float> %a0, <16 x float> %a1, i16 %mask) #1 {
 932 ; CHECK-LABEL: stack_fold_minps_zmm_commutable_kz:
 933 ; CHECK:       # %bb.0:
 934 ; CHECK-NEXT:    vmovups %zmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
 935 ; CHECK-NEXT:    #APP
 936 ; CHECK-NEXT:    nop
 937 ; CHECK-NEXT:    #NO_APP
 938 ; CHECK-NEXT:    kmovw %edi, %k1
 939 ; CHECK-NEXT:    vminps {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %zmm0 {%k1} {z} # 64-byte Folded Reload
 940 ; CHECK-NEXT:    retq
 941   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
 942   %2 = call <16 x float> @llvm.x86.avx512.min.ps.512(<16 x float> %a1, <16 x float> %a0, i32 4)
 943   %3 = bitcast i16 %mask to <16 x i1>
 944   %4 = select <16 x i1> %3, <16 x float> %2, <16 x float> zeroinitializer
 945   ret <16 x float> %4
 946 }
 947
 948 define <8 x double> @stack_fold_mulpd_zmm(<8 x double> %a0, <8 x double> %a1) {
 949 ; CHECK-LABEL: stack_fold_mulpd_zmm:
 950 ; CHECK:       # %bb.0:
 951 ; CHECK-NEXT:    vmovups %zmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
 952 ; CHECK-NEXT:    #APP
 953 ; CHECK-NEXT:    nop
 954 ; CHECK-NEXT:    #NO_APP
 955 ; CHECK-NEXT:    vmulpd {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %zmm0 # 64-byte Folded Reload
 956 ; CHECK-NEXT:    retq
 957   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
 958   %2 = fmul <8 x double> %a0, %a1
 959   ret <8 x double> %2
 960 }
 961
 962 define <8 x double> @stack_fold_mulpd_zmm_k(<8 x double> %a0, <8 x double> %a1, i8 %mask, <8 x double>* %passthru) {
 963 ; CHECK-LABEL: stack_fold_mulpd_zmm_k:
 964 ; CHECK:       # %bb.0:
 965 ; CHECK-NEXT:    vmovups %zmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
 966 ; CHECK-NEXT:    #APP
 967 ; CHECK-NEXT:    nop
 968 ; CHECK-NEXT:    #NO_APP
 969 ; CHECK-NEXT:    kmovw %edi, %k1
 970 ; CHECK-NEXT:    vmovapd (%rsi), %zmm2
 971 ; CHECK-NEXT:    vmulpd {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %zmm2 {%k1} # 64-byte Folded Reload
 972 ; CHECK-NEXT:    vmovapd %zmm2, %zmm0
 973 ; CHECK-NEXT:    retq
 974   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
 975   %2 = fmul <8 x double> %a0, %a1
 976   %3 = bitcast i8 %mask to <8 x i1>
 977   %4 = load <8 x double>, <8 x double>* %passthru
 978   %5 = select <8 x i1> %3, <8 x double> %2, <8 x double> %4
 979   ret <8 x double> %5
 980 }
 981
 982 define <8 x double> @stack_fold_mulpd_zmm_k_commuted(<8 x double> %a0, <8 x double> %a1, i8 %mask, <8 x double>* %passthru) {
 983 ; CHECK-LABEL: stack_fold_mulpd_zmm_k_commuted:
 984 ; CHECK:       # %bb.0:
 985 ; CHECK-NEXT:    vmovups %zmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
 986 ; CHECK-NEXT:    #APP
 987 ; CHECK-NEXT:    nop
 988 ; CHECK-NEXT:    #NO_APP
 989 ; CHECK-NEXT:    kmovw %edi, %k1
 990 ; CHECK-NEXT:    vmovapd (%rsi), %zmm2
 991 ; CHECK-NEXT:    vmulpd {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %zmm2 {%k1} # 64-byte Folded Reload
 992 ; CHECK-NEXT:    vmovapd %zmm2, %zmm0
 993 ; CHECK-NEXT:    retq
 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},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
 995   %2 = fmul <8 x double> %a1, %a0
 996   %3 = bitcast i8 %mask to <8 x i1>
 997   %4 = load <8 x double>, <8 x double>* %passthru
 998   %5 = select <8 x i1> %3, <8 x double> %2, <8 x double> %4
 999   ret <8 x double> %5
1000 }
1001
1002 define <8 x double> @stack_fold_mulpd_zmm_kz(<8 x double> %a0, <8 x double> %a1, i8 %mask) {
1003 ; CHECK-LABEL: stack_fold_mulpd_zmm_kz:
1004 ; CHECK:       # %bb.0:
1005 ; CHECK-NEXT:    vmovups %zmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
1006 ; CHECK-NEXT:    #APP
1007 ; CHECK-NEXT:    nop
1008 ; CHECK-NEXT:    #NO_APP
1009 ; CHECK-NEXT:    kmovw %edi, %k1
1010 ; CHECK-NEXT:    vmulpd {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %zmm0 {%k1} {z} # 64-byte Folded Reload
1011 ; CHECK-NEXT:    retq
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},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
1013   %2 = fmul <8 x double> %a1, %a0
1014   %3 = bitcast i8 %mask to <8 x i1>
1015   %4 = select <8 x i1> %3, <8 x double> %2, <8 x double> zeroinitializer
1016   ret <8 x double> %4
1017 }
1018
1019 define <16 x float> @stack_fold_mulps_zmm(<16 x float> %a0, <16 x float> %a1) {
1020 ; CHECK-LABEL: stack_fold_mulps_zmm:
1021 ; CHECK:       # %bb.0:
1022 ; CHECK-NEXT:    vmovups %zmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
1023 ; CHECK-NEXT:    #APP
1024 ; CHECK-NEXT:    nop
1025 ; CHECK-NEXT:    #NO_APP
1026 ; CHECK-NEXT:    vmulps {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %zmm0 # 64-byte Folded Reload
1027 ; CHECK-NEXT:    retq
1028   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
1029   %2 = fmul <16 x float> %a0, %a1
1030   ret <16 x float> %2
1031 }
1032
1033 define <16 x float> @stack_fold_mulps_zmm_k(<16 x float> %a0, <16 x float> %a1, i16 %mask, <16 x float>* %passthru) {
1034 ; CHECK-LABEL: stack_fold_mulps_zmm_k:
1035 ; CHECK:       # %bb.0:
1036 ; CHECK-NEXT:    vmovups %zmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
1037 ; CHECK-NEXT:    #APP
1038 ; CHECK-NEXT:    nop
1039 ; CHECK-NEXT:    #NO_APP
1040 ; CHECK-NEXT:    kmovw %edi, %k1
1041 ; CHECK-NEXT:    vmovaps (%rsi), %zmm2
1042 ; CHECK-NEXT:    vmulps {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %zmm2 {%k1} # 64-byte Folded Reload
1043 ; CHECK-NEXT:    vmovaps %zmm2, %zmm0
1044 ; CHECK-NEXT:    retq
1045   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
1046   %2 = fmul <16 x float> %a0, %a1
1047   %3 = bitcast i16 %mask to <16 x i1>
1048   %4 = load <16 x float>, <16 x float>* %passthru
1049   %5 = select <16 x i1> %3, <16 x float> %2, <16 x float> %4
1050   ret <16 x float> %5
1051 }
1052
1053 define <16 x float> @stack_fold_mulps_zmm_k_commuted(<16 x float> %a0, <16 x float> %a1, i16 %mask, <16 x float>* %passthru) {
1054 ; CHECK-LABEL: stack_fold_mulps_zmm_k_commuted:
1055 ; CHECK:       # %bb.0:
1056 ; CHECK-NEXT:    vmovups %zmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
1057 ; CHECK-NEXT:    #APP
1058 ; CHECK-NEXT:    nop
1059 ; CHECK-NEXT:    #NO_APP
1060 ; CHECK-NEXT:    kmovw %edi, %k1
1061 ; CHECK-NEXT:    vmovaps (%rsi), %zmm2
1062 ; CHECK-NEXT:    vmulps {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %zmm2 {%k1} # 64-byte Folded Reload
1063 ; CHECK-NEXT:    vmovaps %zmm2, %zmm0
1064 ; CHECK-NEXT:    retq
1065   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
1066   %2 = fmul <16 x float> %a1, %a0
1067   %3 = bitcast i16 %mask to <16 x i1>
1068   %4 = load <16 x float>, <16 x float>* %passthru
1069   %5 = select <16 x i1> %3, <16 x float> %2, <16 x float> %4
1070   ret <16 x float> %5
1071 }
1072
1073 define <16 x float> @stack_fold_mulps_zmm_kz(<16 x float> %a0, <16 x float> %a1, i16 %mask) {
1074 ; CHECK-LABEL: stack_fold_mulps_zmm_kz:
1075 ; CHECK:       # %bb.0:
1076 ; CHECK-NEXT:    vmovups %zmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
1077 ; CHECK-NEXT:    #APP
1078 ; CHECK-NEXT:    nop
1079 ; CHECK-NEXT:    #NO_APP
1080 ; CHECK-NEXT:    kmovw %edi, %k1
1081 ; CHECK-NEXT:    vmulps {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %zmm0 {%k1} {z} # 64-byte Folded Reload
1082 ; CHECK-NEXT:    retq
1083   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
1084   %2 = fmul <16 x float> %a1, %a0
1085   %3 = bitcast i16 %mask to <16 x i1>
1086   %4 = select <16 x i1> %3, <16 x float> %2, <16 x float> zeroinitializer
1087   ret <16 x float> %4
1088 }
1089
1090 define double @stack_fold_mulsd(double %a0, double %a1) {
1091 ; CHECK-LABEL: stack_fold_mulsd:
1092 ; CHECK:       # %bb.0:
1093 ; CHECK-NEXT:    vmovsd %xmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 8-byte Spill
1094 ; CHECK-NEXT:    #APP
1095 ; CHECK-NEXT:    nop
1096 ; CHECK-NEXT:    #NO_APP
1097 ; CHECK-NEXT:    vmulsd {{[-0-9]+}}(%r{{[sb]}}p), %xmm0, %xmm0 # 8-byte Folded Reload
1098 ; CHECK-NEXT:    retq
1099   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
1100   %2 = fmul double %a0, %a1
1101   ret double %2
1102 }
1103
1104 define <2 x double> @stack_fold_mulsd_int(<2 x double> %a0, <2 x double> %a1) {
1105 ; CHECK-LABEL: stack_fold_mulsd_int:
1106 ; CHECK:       # %bb.0:
1107 ; CHECK-NEXT:    vmovaps %xmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
1108 ; CHECK-NEXT:    #APP
1109 ; CHECK-NEXT:    nop
1110 ; CHECK-NEXT:    #NO_APP
1111 ; CHECK-NEXT:    vmulsd {{[-0-9]+}}(%r{{[sb]}}p), %xmm0, %xmm0 # 16-byte Folded Reload
1112 ; CHECK-NEXT:    retq
1113   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
1114   %2 = extractelement <2 x double> %a0, i32 0
1115   %3 = extractelement <2 x double> %a1, i32 0
1116   %4 = fmul double %2, %3
1117   %5 = insertelement <2 x double> %a0, double %4, i32 0
1118   ret <2 x double> %5
1119 }
1120
1121 define float @stack_fold_mulss(float %a0, float %a1) {
1122 ; CHECK-LABEL: stack_fold_mulss:
1123 ; CHECK:       # %bb.0:
1124 ; CHECK-NEXT:    vmovss %xmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 4-byte Spill
1125 ; CHECK-NEXT:    #APP
1126 ; CHECK-NEXT:    nop
1127 ; CHECK-NEXT:    #NO_APP
1128 ; CHECK-NEXT:    vmulss {{[-0-9]+}}(%r{{[sb]}}p), %xmm0, %xmm0 # 4-byte Folded Reload
1129 ; CHECK-NEXT:    retq
1130   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
1131   %2 = fmul float %a0, %a1
1132   ret float %2
1133 }
1134
1135 define <4 x float> @stack_fold_mulss_int(<4 x float> %a0, <4 x float> %a1) {
1136 ; CHECK-LABEL: stack_fold_mulss_int:
1137 ; CHECK:       # %bb.0:
1138 ; CHECK-NEXT:    vmovaps %xmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
1139 ; CHECK-NEXT:    #APP
1140 ; CHECK-NEXT:    nop
1141 ; CHECK-NEXT:    #NO_APP
1142 ; CHECK-NEXT:    vmulss {{[-0-9]+}}(%r{{[sb]}}p), %xmm0, %xmm0 # 16-byte Folded Reload
1143 ; CHECK-NEXT:    retq
1144   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
1145   %2 = extractelement <4 x float> %a0, i32 0
1146   %3 = extractelement <4 x float> %a1, i32 0
1147   %4 = fmul float %2, %3
1148   %5 = insertelement <4 x float> %a0, float %4, i32 0
1149   ret <4 x float> %5
1150 }
1151
1152 define <8 x double> @stack_fold_orpd_zmm(<8 x double> %a0, <8 x double> %a1) #0 {
1153 ; CHECK-LABEL: stack_fold_orpd_zmm:
1154 ; CHECK:       # %bb.0:
1155 ; CHECK-NEXT:    vmovups %zmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
1156 ; CHECK-NEXT:    #APP
1157 ; CHECK-NEXT:    nop
1158 ; CHECK-NEXT:    #NO_APP
1159 ; CHECK-NEXT:    vorpd {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %zmm0 # 64-byte Folded Reload
1160 ; CHECK-NEXT:    vxorpd %xmm1, %xmm1, %xmm1
1161 ; CHECK-NEXT:    vaddpd %zmm1, %zmm0, %zmm0
1162 ; CHECK-NEXT:    retq
1163   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
1164   %2 = bitcast <8 x double> %a0 to <8 x i64>
1165   %3 = bitcast <8 x double> %a1 to <8 x i64>
1166   %4 = or <8 x i64> %2, %3
1167   %5 = bitcast <8 x i64> %4 to <8 x double>
1168   ; fadd forces execution domain
1169   %6 = fadd <8 x double> %5, <double 0x0, double 0x0, double 0x0, double 0x0, double 0x0, double 0x0, double 0x0, double 0x0>
1170   ret <8 x double> %6
1171 }
1172
1173 define <16 x float> @stack_fold_orps_zmm(<16 x float> %a0, <16 x float> %a1) #0 {
1174 ; CHECK-LABEL: stack_fold_orps_zmm:
1175 ; CHECK:       # %bb.0:
1176 ; CHECK-NEXT:    vmovups %zmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
1177 ; CHECK-NEXT:    #APP
1178 ; CHECK-NEXT:    nop
1179 ; CHECK-NEXT:    #NO_APP
1180 ; CHECK-NEXT:    vorps {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %zmm0 # 64-byte Folded Reload
1181 ; CHECK-NEXT:    vxorps %xmm1, %xmm1, %xmm1
1182 ; CHECK-NEXT:    vaddps %zmm1, %zmm0, %zmm0
1183 ; CHECK-NEXT:    retq
1184   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
1185   %2 = bitcast <16 x float> %a0 to <16 x i32>
1186   %3 = bitcast <16 x float> %a1 to <16 x i32>
1187   %4 = or <16 x i32> %2, %3
1188   %5 = bitcast <16 x i32> %4 to <16 x float>
1189   ; fadd forces execution domain
1190   %6 = fadd <16 x float> %5, <float 0x0, float 0x0, float 0x0, float 0x0, float 0x0, float 0x0, float 0x0, float 0x0, float 0x0, float 0x0, float 0x0, float 0x0, float 0x0, float 0x0, float 0x0, float 0x0>
1191   ret <16 x float> %6
1192 }
1193
1194 define <8 x double> @stack_fold_shuff64x2(<8 x double> %a, <8 x double> %b) {
1195 ; CHECK-LABEL: stack_fold_shuff64x2:
1196 ; CHECK:       # %bb.0:
1197 ; CHECK-NEXT:    subq $56, %rsp
1198 ; CHECK-NEXT:    .cfi_def_cfa_offset 64
1199 ; CHECK-NEXT:    vmovups %zmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
1200 ; CHECK-NEXT:    vmovups %zmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
1201 ; CHECK-NEXT:    #APP
1202 ; CHECK-NEXT:    nop
1203 ; CHECK-NEXT:    #NO_APP
1204 ; CHECK-NEXT:    vmovupd {{[-0-9]+}}(%r{{[sb]}}p), %zmm0 # 64-byte Reload
1205 ; CHECK-NEXT:    vshuff64x2 $24, {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %zmm0 # 64-byte Folded Reload
1206 ; CHECK-NEXT:    # zmm0 = zmm0[0,1,4,5],mem[2,3,0,1]
1207 ; CHECK-NEXT:    addq $56, %rsp
1208 ; CHECK-NEXT:    .cfi_def_cfa_offset 8
1209 ; CHECK-NEXT:    retq
1210   %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},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
1211   %2 = shufflevector <8 x double> %a, <8 x double> %b, <8 x i32> <i32 0, i32 1, i32 4, i32 5, i32 10, i32 11, i32 8, i32 9>
1212   ret <8 x double> %2
1213 }
1214
1215 define <8 x double> @stack_fold_shuff64x2_mask(<8 x double> %a, <8 x double> %b, i8 %mask, <8 x double>* %passthru) {
1216 ; CHECK-LABEL: stack_fold_shuff64x2_mask:
1217 ; CHECK:       # %bb.0:
1218 ; CHECK-NEXT:    subq $56, %rsp
1219 ; CHECK-NEXT:    .cfi_def_cfa_offset 64
1220 ; CHECK-NEXT:    vmovups %zmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
1221 ; CHECK-NEXT:    vmovups %zmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
1222 ; CHECK-NEXT:    #APP
1223 ; CHECK-NEXT:    nop
1224 ; CHECK-NEXT:    #NO_APP
1225 ; CHECK-NEXT:    kmovw %edi, %k1
1226 ; CHECK-NEXT:    vmovapd (%rsi), %zmm1
1227 ; CHECK-NEXT:    vmovupd {{[-0-9]+}}(%r{{[sb]}}p), %zmm0 # 64-byte Reload
1228 ; CHECK-NEXT:    vshuff64x2 $24, {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %zmm1 {%k1} # 64-byte Folded Reload
1229 ; CHECK-NEXT:    # zmm1 {%k1} = zmm0[0,1,4,5],mem[2,3,0,1]
1230 ; CHECK-NEXT:    vmovapd %zmm1, %zmm0
1231 ; CHECK-NEXT:    addq $56, %rsp
1232 ; CHECK-NEXT:    .cfi_def_cfa_offset 8
1233 ; CHECK-NEXT:    retq
1234   %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},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
1235   %2 = shufflevector <8 x double> %a, <8 x double> %b, <8 x i32> <i32 0, i32 1, i32 4, i32 5, i32 10, i32 11, i32 8, i32 9>
1236   %3 = bitcast i8 %mask to <8 x i1>
1237   ; load needed to keep the operation from being scheduled above the asm block
1238   %4 = load <8 x double>, <8 x double>* %passthru
1239   %5 = select <8 x i1> %3, <8 x double> %2, <8 x double> %4
1240   ret <8 x double> %5
1241 }
1242
1243 define <8 x double> @stack_fold_shuff64x2_maskz(<8 x double> %a, <8 x double> %b, i8 %mask, <8 x double>* %passthru) {
1244 ; CHECK-LABEL: stack_fold_shuff64x2_maskz:
1245 ; CHECK:       # %bb.0:
1246 ; CHECK-NEXT:    subq $56, %rsp
1247 ; CHECK-NEXT:    .cfi_def_cfa_offset 64
1248 ; CHECK-NEXT:    vmovups %zmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
1249 ; CHECK-NEXT:    vmovups %zmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
1250 ; CHECK-NEXT:    #APP
1251 ; CHECK-NEXT:    nop
1252 ; CHECK-NEXT:    #NO_APP
1253 ; CHECK-NEXT:    kmovw %edi, %k1
1254 ; CHECK-NEXT:    vmovupd {{[-0-9]+}}(%r{{[sb]}}p), %zmm0 # 64-byte Reload
1255 ; CHECK-NEXT:    vshuff64x2 $24, {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %zmm0 {%k1} {z} # 64-byte Folded Reload
1256 ; CHECK-NEXT:    # zmm0 {%k1} {z} = zmm0[0,1,4,5],mem[2,3,0,1]
1257 ; CHECK-NEXT:    addq $56, %rsp
1258 ; CHECK-NEXT:    .cfi_def_cfa_offset 8
1259 ; CHECK-NEXT:    retq
1260   %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},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
1261   %2 = shufflevector <8 x double> %a, <8 x double> %b, <8 x i32> <i32 0, i32 1, i32 4, i32 5, i32 10, i32 11, i32 8, i32 9>
1262   %3 = bitcast i8 %mask to <8 x i1>
1263   %4 = select <8 x i1> %3, <8 x double> %2, <8 x double> zeroinitializer
1264   ret <8 x double> %4
1265 }
1266
1267 define <16 x float> @stack_fold_shuff32x4_mask(<16 x float> %a, <16 x float> %b, i16 %mask, <16 x float>* %passthru) {
1268 ; CHECK-LABEL: stack_fold_shuff32x4_mask:
1269 ; CHECK:       # %bb.0:
1270 ; CHECK-NEXT:    subq $56, %rsp
1271 ; CHECK-NEXT:    .cfi_def_cfa_offset 64
1272 ; CHECK-NEXT:    vmovups %zmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
1273 ; CHECK-NEXT:    vmovups %zmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
1274 ; CHECK-NEXT:    #APP
1275 ; CHECK-NEXT:    nop
1276 ; CHECK-NEXT:    #NO_APP
1277 ; CHECK-NEXT:    kmovw %edi, %k1
1278 ; CHECK-NEXT:    vmovaps (%rsi), %zmm1
1279 ; CHECK-NEXT:    vmovups {{[-0-9]+}}(%r{{[sb]}}p), %zmm0 # 64-byte Reload
1280 ; CHECK-NEXT:    vshuff32x4 $20, {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %zmm1 {%k1} # 64-byte Folded Reload
1281 ; CHECK-NEXT:    # zmm1 {%k1} = zmm0[0,1,2,3,4,5,6,7],mem[4,5,6,7,0,1,2,3]
1282 ; CHECK-NEXT:    vmovaps %zmm1, %zmm0
1283 ; CHECK-NEXT:    addq $56, %rsp
1284 ; CHECK-NEXT:    .cfi_def_cfa_offset 8
1285 ; CHECK-NEXT:    retq
1286   %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},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
1287   %2 = shufflevector <16 x float> %a, <16 x float> %b, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 20, i32 21, i32 22, i32 23, i32 16, i32 17, i32 18, i32 19>
1288   %3 = bitcast i16 %mask to <16 x i1>
1289   ; load needed to keep the operation from being scheduled above the asm block
1290   %4 = load <16 x float>, <16 x float>* %passthru
1291   %5 = select <16 x i1> %3, <16 x float> %2, <16 x float> %4
1292   ret <16 x float> %5
1293 }
1294
1295 define <16 x float> @stack_fold_shuff32x4_maskz(<16 x float> %a, <16 x float> %b, i16 %mask) {
1296 ; CHECK-LABEL: stack_fold_shuff32x4_maskz:
1297 ; CHECK:       # %bb.0:
1298 ; CHECK-NEXT:    subq $56, %rsp
1299 ; CHECK-NEXT:    .cfi_def_cfa_offset 64
1300 ; CHECK-NEXT:    vmovups %zmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
1301 ; CHECK-NEXT:    vmovups %zmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
1302 ; CHECK-NEXT:    #APP
1303 ; CHECK-NEXT:    nop
1304 ; CHECK-NEXT:    #NO_APP
1305 ; CHECK-NEXT:    kmovw %edi, %k1
1306 ; CHECK-NEXT:    vmovups {{[-0-9]+}}(%r{{[sb]}}p), %zmm0 # 64-byte Reload
1307 ; CHECK-NEXT:    vshuff32x4 $20, {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %zmm0 {%k1} {z} # 64-byte Folded Reload
1308 ; CHECK-NEXT:    # zmm0 {%k1} {z} = zmm0[0,1,2,3,4,5,6,7],mem[4,5,6,7,0,1,2,3]
1309 ; CHECK-NEXT:    addq $56, %rsp
1310 ; CHECK-NEXT:    .cfi_def_cfa_offset 8
1311 ; CHECK-NEXT:    retq
1312   %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},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
1313   %2 = shufflevector <16 x float> %a, <16 x float> %b, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 20, i32 21, i32 22, i32 23, i32 16, i32 17, i32 18, i32 19>
1314   %3 = bitcast i16 %mask to <16 x i1>
1315   %4 = select <16 x i1> %3, <16 x float> %2, <16 x float> zeroinitializer
1316   ret <16 x float> %4
1317 }
1318
1319 define <8 x double> @stack_fold_subpd_zmm(<8 x double> %a0, <8 x double> %a1) {
1320 ; CHECK-LABEL: stack_fold_subpd_zmm:
1321 ; CHECK:       # %bb.0:
1322 ; CHECK-NEXT:    vmovups %zmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
1323 ; CHECK-NEXT:    #APP
1324 ; CHECK-NEXT:    nop
1325 ; CHECK-NEXT:    #NO_APP
1326 ; CHECK-NEXT:    vsubpd {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %zmm0 # 64-byte Folded Reload
1327 ; CHECK-NEXT:    retq
1328   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
1329   %2 = fsub <8 x double> %a0, %a1
1330   ret <8 x double> %2
1331 }
1332
1333 define <16 x float> @stack_fold_subps_zmm(<16 x float> %a0, <16 x float> %a1) {
1334 ; CHECK-LABEL: stack_fold_subps_zmm:
1335 ; CHECK:       # %bb.0:
1336 ; CHECK-NEXT:    vmovups %zmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
1337 ; CHECK-NEXT:    #APP
1338 ; CHECK-NEXT:    nop
1339 ; CHECK-NEXT:    #NO_APP
1340 ; CHECK-NEXT:    vsubps {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %zmm0 # 64-byte Folded Reload
1341 ; CHECK-NEXT:    retq
1342   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
1343   %2 = fsub <16 x float> %a0, %a1
1344   ret <16 x float> %2
1345 }
1346
1347 define double @stack_fold_subsd(double %a0, double %a1) {
1348 ; CHECK-LABEL: stack_fold_subsd:
1349 ; CHECK:       # %bb.0:
1350 ; CHECK-NEXT:    vmovsd %xmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 8-byte Spill
1351 ; CHECK-NEXT:    #APP
1352 ; CHECK-NEXT:    nop
1353 ; CHECK-NEXT:    #NO_APP
1354 ; CHECK-NEXT:    vsubsd {{[-0-9]+}}(%r{{[sb]}}p), %xmm0, %xmm0 # 8-byte Folded Reload
1355 ; CHECK-NEXT:    retq
1356   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
1357   %2 = fsub double %a0, %a1
1358   ret double %2
1359 }
1360
1361 define <2 x double> @stack_fold_subsd_int(<2 x double> %a0, <2 x double> %a1) {
1362 ; CHECK-LABEL: stack_fold_subsd_int:
1363 ; CHECK:       # %bb.0:
1364 ; CHECK-NEXT:    vmovaps %xmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
1365 ; CHECK-NEXT:    #APP
1366 ; CHECK-NEXT:    nop
1367 ; CHECK-NEXT:    #NO_APP
1368 ; CHECK-NEXT:    vsubsd {{[-0-9]+}}(%r{{[sb]}}p), %xmm0, %xmm0 # 16-byte Folded Reload
1369 ; CHECK-NEXT:    retq
1370   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
1371   %2 = extractelement <2 x double> %a0, i32 0
1372   %3 = extractelement <2 x double> %a1, i32 0
1373   %4 = fsub double %2, %3
1374   %5 = insertelement <2 x double> %a0, double %4, i32 0
1375   ret <2 x double> %5
1376 }
1377
1378 define float @stack_fold_subss(float %a0, float %a1) {
1379 ; CHECK-LABEL: stack_fold_subss:
1380 ; CHECK:       # %bb.0:
1381 ; CHECK-NEXT:    vmovss %xmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 4-byte Spill
1382 ; CHECK-NEXT:    #APP
1383 ; CHECK-NEXT:    nop
1384 ; CHECK-NEXT:    #NO_APP
1385 ; CHECK-NEXT:    vsubss {{[-0-9]+}}(%r{{[sb]}}p), %xmm0, %xmm0 # 4-byte Folded Reload
1386 ; CHECK-NEXT:    retq
1387   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
1388   %2 = fsub float %a0, %a1
1389   ret float %2
1390 }
1391
1392 define <4 x float> @stack_fold_subss_int(<4 x float> %a0, <4 x float> %a1) {
1393 ; CHECK-LABEL: stack_fold_subss_int:
1394 ; CHECK:       # %bb.0:
1395 ; CHECK-NEXT:    vmovaps %xmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
1396 ; CHECK-NEXT:    #APP
1397 ; CHECK-NEXT:    nop
1398 ; CHECK-NEXT:    #NO_APP
1399 ; CHECK-NEXT:    vsubss {{[-0-9]+}}(%r{{[sb]}}p), %xmm0, %xmm0 # 16-byte Folded Reload
1400 ; CHECK-NEXT:    retq
1401   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
1402   %2 = extractelement <4 x float> %a0, i32 0
1403   %3 = extractelement <4 x float> %a1, i32 0
1404   %4 = fsub float %2, %3
1405   %5 = insertelement <4 x float> %a0, float %4, i32 0
1406   ret <4 x float> %5
1407 }
1408
1409 define <8 x double> @stack_fold_xorpd_zmm(<8 x double> %a0, <8 x double> %a1) #0 {
1410 ; CHECK-LABEL: stack_fold_xorpd_zmm:
1411 ; CHECK:       # %bb.0:
1412 ; CHECK-NEXT:    vmovups %zmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
1413 ; CHECK-NEXT:    #APP
1414 ; CHECK-NEXT:    nop
1415 ; CHECK-NEXT:    #NO_APP
1416 ; CHECK-NEXT:    vxorpd {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %zmm0 # 64-byte Folded Reload
1417 ; CHECK-NEXT:    vxorpd %xmm1, %xmm1, %xmm1
1418 ; CHECK-NEXT:    vaddpd %zmm1, %zmm0, %zmm0
1419 ; CHECK-NEXT:    retq
1420   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
1421   %2 = bitcast <8 x double> %a0 to <8 x i64>
1422   %3 = bitcast <8 x double> %a1 to <8 x i64>
1423   %4 = xor <8 x i64> %2, %3
1424   %5 = bitcast <8 x i64> %4 to <8 x double>
1425   ; fadd forces execution domain
1426   %6 = fadd <8 x double> %5, <double 0x0, double 0x0, double 0x0, double 0x0, double 0x0, double 0x0, double 0x0, double 0x0>
1427   ret <8 x double> %6
1428 }
1429
1430 define <16 x float> @stack_fold_xorps_zmm(<16 x float> %a0, <16 x float> %a1) #0 {
1431 ; CHECK-LABEL: stack_fold_xorps_zmm:
1432 ; CHECK:       # %bb.0:
1433 ; CHECK-NEXT:    vmovups %zmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
1434 ; CHECK-NEXT:    #APP
1435 ; CHECK-NEXT:    nop
1436 ; CHECK-NEXT:    #NO_APP
1437 ; CHECK-NEXT:    vxorps {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %zmm0 # 64-byte Folded Reload
1438 ; CHECK-NEXT:    vxorps %xmm1, %xmm1, %xmm1
1439 ; CHECK-NEXT:    vaddps %zmm1, %zmm0, %zmm0
1440 ; CHECK-NEXT:    retq
1441   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
1442   %2 = bitcast <16 x float> %a0 to <16 x i32>
1443   %3 = bitcast <16 x float> %a1 to <16 x i32>
1444   %4 = xor <16 x i32> %2, %3
1445   %5 = bitcast <16 x i32> %4 to <16 x float>
1446   ; fadd forces execution domain
1447   %6 = fadd <16 x float> %5, <float 0x0, float 0x0, float 0x0, float 0x0, float 0x0, float 0x0, float 0x0, float 0x0, float 0x0, float 0x0, float 0x0, float 0x0, float 0x0, float 0x0, float 0x0, float 0x0>
1448   ret <16 x float> %6
1449 }
1450
1451 define i32 @stack_fold_extractps(<4 x float> %a0) {
1452 ; CHECK-LABEL: stack_fold_extractps:
1453 ; CHECK:       # %bb.0:
1454 ; CHECK-NEXT:    pushq %rbp
1455 ; CHECK-NEXT:    .cfi_def_cfa_offset 16
1456 ; CHECK-NEXT:    pushq %r15
1457 ; CHECK-NEXT:    .cfi_def_cfa_offset 24
1458 ; CHECK-NEXT:    pushq %r14
1459 ; CHECK-NEXT:    .cfi_def_cfa_offset 32
1460 ; CHECK-NEXT:    pushq %r13
1461 ; CHECK-NEXT:    .cfi_def_cfa_offset 40
1462 ; CHECK-NEXT:    pushq %r12
1463 ; CHECK-NEXT:    .cfi_def_cfa_offset 48
1464 ; CHECK-NEXT:    pushq %rbx
1465 ; CHECK-NEXT:    .cfi_def_cfa_offset 56
1466 ; CHECK-NEXT:    .cfi_offset %rbx, -56
1467 ; CHECK-NEXT:    .cfi_offset %r12, -48
1468 ; CHECK-NEXT:    .cfi_offset %r13, -40
1469 ; CHECK-NEXT:    .cfi_offset %r14, -32
1470 ; CHECK-NEXT:    .cfi_offset %r15, -24
1471 ; CHECK-NEXT:    .cfi_offset %rbp, -16
1472 ; CHECK-NEXT:    vextractps $1, %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 4-byte Folded Spill
1473 ; CHECK-NEXT:    #APP
1474 ; CHECK-NEXT:    nop
1475 ; CHECK-NEXT:    #NO_APP
1476 ; CHECK-NEXT:    movl {{[-0-9]+}}(%r{{[sb]}}p), %eax # 4-byte Reload
1477 ; CHECK-NEXT:    popq %rbx
1478 ; CHECK-NEXT:    .cfi_def_cfa_offset 48
1479 ; CHECK-NEXT:    popq %r12
1480 ; CHECK-NEXT:    .cfi_def_cfa_offset 40
1481 ; CHECK-NEXT:    popq %r13
1482 ; CHECK-NEXT:    .cfi_def_cfa_offset 32
1483 ; CHECK-NEXT:    popq %r14
1484 ; CHECK-NEXT:    .cfi_def_cfa_offset 24
1485 ; CHECK-NEXT:    popq %r15
1486 ; CHECK-NEXT:    .cfi_def_cfa_offset 16
1487 ; CHECK-NEXT:    popq %rbp
1488 ; CHECK-NEXT:    .cfi_def_cfa_offset 8
1489 ; CHECK-NEXT:    retq
1490   %1 = extractelement <4 x float> %a0, i32 1
1491   %2 = bitcast float %1 to i32
1492   %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}"()
1493   ret i32 %2
1494 }
1495
1496 define <4 x float> @stack_fold_extracti32x4(<16 x float> %a0) {
1497 ; CHECK-LABEL: stack_fold_extracti32x4:
1498 ; CHECK:       # %bb.0:
1499 ; CHECK-NEXT:    vextractf32x4 $3, %zmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Folded Spill
1500 ; CHECK-NEXT:    #APP
1501 ; CHECK-NEXT:    nop
1502 ; CHECK-NEXT:    #NO_APP
1503 ; CHECK-NEXT:    vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
1504 ; CHECK-NEXT:    vzeroupper
1505 ; CHECK-NEXT:    retq
1506   %1 = shufflevector <16 x float> %a0, <16 x float> undef, <4 x i32> <i32 12, i32 13, i32 14, i32 15>
1507   %2 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm1},~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
1508   ret <4 x float> %1
1509 }
1510
1511 define <2 x double> @stack_fold_extractf64x2(<8 x double> %a0) {
1512 ; CHECK-LABEL: stack_fold_extractf64x2:
1513 ; CHECK:       # %bb.0:
1514 ; CHECK-NEXT:    vextractf32x4 $3, %zmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Folded Spill
1515 ; CHECK-NEXT:    #APP
1516 ; CHECK-NEXT:    nop
1517 ; CHECK-NEXT:    #NO_APP
1518 ; CHECK-NEXT:    vmovaps {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Reload
1519 ; CHECK-NEXT:    vzeroupper
1520 ; CHECK-NEXT:    retq
1521   %1 = shufflevector <8 x double> %a0, <8 x double> undef, <2 x i32> <i32 6, i32 7>
1522   %2 = tail call <2 x double> asm sideeffect "nop", "=x,~{xmm1},~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
1523   ret <2 x double> %1
1524 }
1525
1526 define <8 x float> @stack_fold_extracti32x8(<16 x float> %a0) {
1527 ; CHECK-LABEL: stack_fold_extracti32x8:
1528 ; CHECK:       # %bb.0:
1529 ; CHECK-NEXT:    vextractf64x4 $1, %zmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 32-byte Folded Spill
1530 ; CHECK-NEXT:    #APP
1531 ; CHECK-NEXT:    nop
1532 ; CHECK-NEXT:    #NO_APP
1533 ; CHECK-NEXT:    vmovups {{[-0-9]+}}(%r{{[sb]}}p), %ymm0 # 32-byte Reload
1534 ; CHECK-NEXT:    retq
1535   %1 = shufflevector <16 x float> %a0, <16 x float> undef, <8 x i32> <i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15>
1536   %2 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm1},~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
1537   ret <8 x float> %1
1538 }
1539
1540 define <4 x double> @stack_fold_extractf64x4(<8 x double> %a0) {
1541 ; CHECK-LABEL: stack_fold_extractf64x4:
1542 ; CHECK:       # %bb.0:
1543 ; CHECK-NEXT:    vextractf64x4 $1, %zmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 32-byte Folded Spill
1544 ; CHECK-NEXT:    #APP
1545 ; CHECK-NEXT:    nop
1546 ; CHECK-NEXT:    #NO_APP
1547 ; CHECK-NEXT:    vmovups {{[-0-9]+}}(%r{{[sb]}}p), %ymm0 # 32-byte Reload
1548 ; CHECK-NEXT:    retq
1549   %1 = shufflevector <8 x double> %a0, <8 x double> undef, <4 x i32> <i32 4, i32 5, i32 6, i32 7>
1550   %2 = tail call <2 x double> asm sideeffect "nop", "=x,~{xmm1},~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
1551   ret <4 x double> %1
1552 }
1553
1554 define <16 x float> @stack_fold_insertf32x8(<8 x float> %a0, <8 x float> %a1) {
1555 ; CHECK-LABEL: stack_fold_insertf32x8:
1556 ; CHECK:       # %bb.0:
1557 ; CHECK-NEXT:    vmovups %ymm1, {{[-0-9]+}}(%r{{[sb]}}p) # 32-byte Spill
1558 ; CHECK-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
1559 ; CHECK-NEXT:    #APP
1560 ; CHECK-NEXT:    nop
1561 ; CHECK-NEXT:    #NO_APP
1562 ; CHECK-NEXT:    vinsertf64x4 $1, {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %zmm0 # 32-byte Folded Reload
1563 ; CHECK-NEXT:    retq
1564   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
1565   %2 = shufflevector <8 x float> %a0, <8 x float> %a1, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15>
1566   ret <16 x float> %2
1567 }
1568
1569 define <8 x double> @stack_fold_insertf64x4(<4 x double> %a0, <4 x double> %a1) {
1570 ; CHECK-LABEL: stack_fold_insertf64x4:
1571 ; CHECK:       # %bb.0:
1572 ; CHECK-NEXT:    vmovups %ymm1, {{[-0-9]+}}(%r{{[sb]}}p) # 32-byte Spill
1573 ; CHECK-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
1574 ; CHECK-NEXT:    #APP
1575 ; CHECK-NEXT:    nop
1576 ; CHECK-NEXT:    #NO_APP
1577 ; CHECK-NEXT:    vinsertf64x4 $1, {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %zmm0 # 32-byte Folded Reload
1578 ; CHECK-NEXT:    retq
1579   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
1580   %2 = shufflevector <4 x double> %a0, <4 x double> %a1, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
1581   ret <8 x double> %2
1582 }
1583
1584 define <8 x double> @stack_fold_insertf64x4_mask(<8 x double>* %passthru, <4 x double> %a0, <4 x double> %a1, i8 %mask) {
1585 ; CHECK-LABEL: stack_fold_insertf64x4_mask:
1586 ; CHECK:       # %bb.0:
1587 ; CHECK-NEXT:    vmovups %ymm1, {{[-0-9]+}}(%r{{[sb]}}p) # 32-byte Spill
1588 ; CHECK-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
1589 ; CHECK-NEXT:    #APP
1590 ; CHECK-NEXT:    nop
1591 ; CHECK-NEXT:    #NO_APP
1592 ; CHECK-NEXT:    kmovw %esi, %k1
1593 ; CHECK-NEXT:    vmovapd (%rdi), %zmm2
1594 ; CHECK-NEXT:    vinsertf64x4 $1, {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %zmm2 {%k1} # 32-byte Folded Reload
1595 ; CHECK-NEXT:    vmovapd %zmm2, %zmm0
1596 ; CHECK-NEXT:    retq
1597   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
1598   %2 = shufflevector <4 x double> %a0, <4 x double> %a1, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
1599   %3 = bitcast i8 %mask to <8 x i1>
1600   %4 = load <8 x double>, <8 x double>* %passthru
1601   %5 = select <8 x i1> %3, <8 x double> %2, <8 x double> %4
1602   ret <8 x double> %5
1603 }
1604
1605 define <8 x double> @stack_fold_insertf64x4_maskz(<4 x double> %a0, <4 x double> %a1, i8 %mask) {
1606 ; CHECK-LABEL: stack_fold_insertf64x4_maskz:
1607 ; CHECK:       # %bb.0:
1608 ; CHECK-NEXT:    vmovups %ymm1, {{[-0-9]+}}(%r{{[sb]}}p) # 32-byte Spill
1609 ; CHECK-NEXT:    # kill: def $ymm0 killed $ymm0 def $zmm0
1610 ; CHECK-NEXT:    #APP
1611 ; CHECK-NEXT:    nop
1612 ; CHECK-NEXT:    #NO_APP
1613 ; CHECK-NEXT:    kmovw %edi, %k1
1614 ; CHECK-NEXT:    vinsertf64x4 $1, {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %zmm0 {%k1} {z} # 32-byte Folded Reload
1615 ; CHECK-NEXT:    retq
1616   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
1617   %2 = shufflevector <4 x double> %a0, <4 x double> %a1, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
1618   %3 = bitcast i8 %mask to <8 x i1>
1619   %4 = select <8 x i1> %3, <8 x double> %2, <8 x double> zeroinitializer
1620   ret <8 x double> %4
1621 }
1622
1623 define <16 x float> @stack_fold_vpermt2ps(<16 x float> %x0, <16 x i32> %x1, <16 x float> %x2) {
1624 ; CHECK-LABEL: stack_fold_vpermt2ps:
1625 ; CHECK:       # %bb.0:
1626 ; CHECK-NEXT:    vmovups %zmm2, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
1627 ; CHECK-NEXT:    #APP
1628 ; CHECK-NEXT:    nop
1629 ; CHECK-NEXT:    #NO_APP
1630 ; CHECK-NEXT:    vpermt2ps {{[-0-9]+}}(%r{{[sb]}}p), %zmm1, %zmm0 # 64-byte Folded Reload
1631 ; CHECK-NEXT:    retq
1632   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
1633   %2 = call <16 x float> @llvm.x86.avx512.vpermi2var.ps.512(<16 x float> %x0, <16 x i32> %x1, <16 x float> %x2)
1634   ret <16 x float> %2
1635 }
1636 declare <16 x float> @llvm.x86.avx512.vpermi2var.ps.512(<16 x float>, <16 x i32>, <16 x float>)
1637
1638 define <16 x float> @stack_fold_vpermi2ps(<16 x i32> %x0, <16 x float> %x1, <16 x float> %x2) {
1639 ; CHECK-LABEL: stack_fold_vpermi2ps:
1640 ; CHECK:       # %bb.0:
1641 ; CHECK-NEXT:    vmovups %zmm2, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
1642 ; CHECK-NEXT:    #APP
1643 ; CHECK-NEXT:    nop
1644 ; CHECK-NEXT:    #NO_APP
1645 ; CHECK-NEXT:    vpermi2ps {{[-0-9]+}}(%r{{[sb]}}p), %zmm1, %zmm0 # 64-byte Folded Reload
1646 ; CHECK-NEXT:    retq
1647   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
1648   %2 = call <16 x float> @llvm.x86.avx512.vpermi2var.ps.512(<16 x float> %x1, <16 x i32> %x0, <16 x float> %x2)
1649   ret <16 x float> %2
1650 }
1651
1652 define <16 x float> @stack_fold_vpermi2ps_mask(<16 x float> %x0, <16 x i32>* %x1, <16 x float> %x2, i16 %mask) {
1653 ; CHECK-LABEL: stack_fold_vpermi2ps_mask:
1654 ; CHECK:       # %bb.0:
1655 ; CHECK-NEXT:    vmovups %zmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
1656 ; CHECK-NEXT:    #APP
1657 ; CHECK-NEXT:    nop
1658 ; CHECK-NEXT:    #NO_APP
1659 ; CHECK-NEXT:    vmovaps (%rdi), %zmm2
1660 ; CHECK-NEXT:    kmovw %esi, %k1
1661 ; CHECK-NEXT:    vpermi2ps {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %zmm2 {%k1} # 64-byte Folded Reload
1662 ; CHECK-NEXT:    vmovaps %zmm2, %zmm0
1663 ; CHECK-NEXT:    retq
1664   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
1665   %x1b = load <16 x i32>, <16 x i32>* %x1
1666   %2 = call <16 x float> @llvm.x86.avx512.vpermi2var.ps.512(<16 x float> %x0, <16 x i32> %x1b, <16 x float> %x2)
1667   %3 = bitcast <16 x i32> %x1b to <16 x float>
1668   %4 = bitcast i16 %mask to <16 x i1>
1669   %5 = select <16 x i1> %4, <16 x float> %2, <16 x float> %3
1670   ret <16 x float> %5
1671 }
1672
1673 define <16 x float> @stack_fold_vpermt2ps_mask(<16 x i32>* %x0, <16 x float> %x1, <16 x float> %x2, i16 %mask) {
1674 ; CHECK-LABEL: stack_fold_vpermt2ps_mask:
1675 ; CHECK:       # %bb.0:
1676 ; CHECK-NEXT:    vmovups %zmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
1677 ; CHECK-NEXT:    #APP
1678 ; CHECK-NEXT:    nop
1679 ; CHECK-NEXT:    #NO_APP
1680 ; CHECK-NEXT:    vmovaps (%rdi), %zmm1
1681 ; CHECK-NEXT:    kmovw %esi, %k1
1682 ; CHECK-NEXT:    vpermt2ps {{[-0-9]+}}(%r{{[sb]}}p), %zmm1, %zmm0 {%k1} # 64-byte Folded Reload
1683 ; CHECK-NEXT:    retq
1684   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
1685   %x0b = load <16 x i32>, <16 x i32>* %x0
1686   %2 = call <16 x float> @llvm.x86.avx512.vpermi2var.ps.512(<16 x float> %x1, <16 x i32> %x0b, <16 x float> %x2)
1687   %3 = bitcast i16 %mask to <16 x i1>
1688   %4 = select <16 x i1> %3, <16 x float> %2, <16 x float> %x1
1689   ret <16 x float> %4
1690 }
1691
1692 define <16 x float> @stack_fold_vpermt2ps_maskz(<16 x i32>* %x0, <16 x float> %x1, <16 x float> %x2, i16 %mask) {
1693 ; CHECK-LABEL: stack_fold_vpermt2ps_maskz:
1694 ; CHECK:       # %bb.0:
1695 ; CHECK-NEXT:    vmovups %zmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
1696 ; CHECK-NEXT:    #APP
1697 ; CHECK-NEXT:    nop
1698 ; CHECK-NEXT:    #NO_APP
1699 ; CHECK-NEXT:    vmovaps (%rdi), %zmm1
1700 ; CHECK-NEXT:    kmovw %esi, %k1
1701 ; CHECK-NEXT:    vpermt2ps {{[-0-9]+}}(%r{{[sb]}}p), %zmm1, %zmm0 {%k1} {z} # 64-byte Folded Reload
1702 ; CHECK-NEXT:    retq
1703   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
1704   %x0b = load <16 x i32>, <16 x i32>* %x0
1705   %2 = call <16 x float> @llvm.x86.avx512.vpermi2var.ps.512(<16 x float> %x1, <16 x i32> %x0b, <16 x float> %x2)
1706   %3 = bitcast i16 %mask to <16 x i1>
1707   %4 = select <16 x i1> %3, <16 x float> %2, <16 x float> zeroinitializer
1708   ret <16 x float> %4
1709 }
1710
1711 define <8 x double> @stack_fold_vpermt2pd(<8 x double> %x0, <8 x i64> %x1, <8 x double> %x2) {
1712 ; CHECK-LABEL: stack_fold_vpermt2pd:
1713 ; CHECK:       # %bb.0:
1714 ; CHECK-NEXT:    vmovups %zmm2, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
1715 ; CHECK-NEXT:    #APP
1716 ; CHECK-NEXT:    nop
1717 ; CHECK-NEXT:    #NO_APP
1718 ; CHECK-NEXT:    vpermt2pd {{[-0-9]+}}(%r{{[sb]}}p), %zmm1, %zmm0 # 64-byte Folded Reload
1719 ; CHECK-NEXT:    retq
1720   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
1721   %2 = call <8 x double> @llvm.x86.avx512.vpermi2var.pd.512(<8 x double> %x0, <8 x i64> %x1, <8 x double> %x2)
1722   %3 = bitcast <8 x i64> %x1 to <8 x double>
1723   ret <8 x double> %2
1724 }
1725 declare <8 x double> @llvm.x86.avx512.vpermi2var.pd.512(<8 x double>, <8 x i64>, <8 x double>)
1726
1727 define <8 x double> @stack_fold_vpermi2pd(<8 x i64> %x0, <8 x double> %x1, <8 x double> %x2) {
1728 ; CHECK-LABEL: stack_fold_vpermi2pd:
1729 ; CHECK:       # %bb.0:
1730 ; CHECK-NEXT:    vmovups %zmm2, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
1731 ; CHECK-NEXT:    #APP
1732 ; CHECK-NEXT:    nop
1733 ; CHECK-NEXT:    #NO_APP
1734 ; CHECK-NEXT:    vpermi2pd {{[-0-9]+}}(%r{{[sb]}}p), %zmm1, %zmm0 # 64-byte Folded Reload
1735 ; CHECK-NEXT:    retq
1736   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
1737   %2 = call <8 x double> @llvm.x86.avx512.vpermi2var.pd.512(<8 x double> %x1, <8 x i64> %x0, <8 x double> %x2)
1738   ret <8 x double> %2
1739 }
1740
1741 define <8 x double> @stack_fold_permpd(<8 x double> %a0) {
1742 ; CHECK-LABEL: stack_fold_permpd:
1743 ; CHECK:       # %bb.0:
1744 ; CHECK-NEXT:    vmovups %zmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
1745 ; CHECK-NEXT:    #APP
1746 ; CHECK-NEXT:    nop
1747 ; CHECK-NEXT:    #NO_APP
1748 ; CHECK-NEXT:    vpermpd $235, {{[-0-9]+}}(%r{{[sb]}}p), %zmm0 # 64-byte Folded Reload
1749 ; CHECK-NEXT:    # zmm0 = mem[3,2,2,3,7,6,6,7]
1750 ; CHECK-NEXT:    vxorpd %xmm1, %xmm1, %xmm1
1751 ; CHECK-NEXT:    vaddpd %zmm1, %zmm0, %zmm0
1752 ; CHECK-NEXT:    retq
1753   %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},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
1754   %2 = shufflevector <8 x double> %a0, <8 x double> undef, <8 x i32> <i32 3, i32 2, i32 2, i32 3, i32 7, i32 6, i32 6, i32 7>
1755   ; fadd forces execution domain
1756   %3 = fadd <8 x double> %2, <double 0x0, double 0x0, double 0x0, double 0x0, double 0x0, double 0x0, double 0x0, double 0x0>
1757   ret <8 x double> %3
1758 }
1759
1760 define <8 x double> @stack_fold_permpd_mask(<8 x double>* %passthru, <8 x double> %a0, i8 %mask) {
1761 ; CHECK-LABEL: stack_fold_permpd_mask:
1762 ; CHECK:       # %bb.0:
1763 ; CHECK-NEXT:    vmovups %zmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
1764 ; CHECK-NEXT:    #APP
1765 ; CHECK-NEXT:    nop
1766 ; CHECK-NEXT:    #NO_APP
1767 ; CHECK-NEXT:    kmovw %esi, %k1
1768 ; CHECK-NEXT:    vmovapd (%rdi), %zmm0
1769 ; CHECK-NEXT:    vpermpd $235, {{[-0-9]+}}(%r{{[sb]}}p), %zmm0 {%k1} # 64-byte Folded Reload
1770 ; CHECK-NEXT:    # zmm0 {%k1} = mem[3,2,2,3,7,6,6,7]
1771 ; CHECK-NEXT:    vxorpd %xmm1, %xmm1, %xmm1
1772 ; CHECK-NEXT:    vaddpd %zmm1, %zmm0, %zmm0
1773 ; CHECK-NEXT:    retq
1774   %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},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
1775   %2 = shufflevector <8 x double> %a0, <8 x double> undef, <8 x i32> <i32 3, i32 2, i32 2, i32 3, i32 7, i32 6, i32 6, i32 7>
1776   %3 = bitcast i8 %mask to <8 x i1>
1777   ; load needed to keep the operation from being scheduled above the asm block
1778   %4 = load <8 x double>, <8 x double>* %passthru
1779   %5 = select <8 x i1> %3, <8 x double> %2, <8 x double> %4
1780   ; fadd forces execution domain
1781   %6 = fadd <8 x double> %5, <double 0x0, double 0x0, double 0x0, double 0x0, double 0x0, double 0x0, double 0x0, double 0x0>
1782   ret <8 x double> %6
1783 }
1784
1785 define <8 x double> @stack_fold_permpd_maskz(<8 x double> %a0, i8 %mask) {
1786 ; CHECK-LABEL: stack_fold_permpd_maskz:
1787 ; CHECK:       # %bb.0:
1788 ; CHECK-NEXT:    vmovups %zmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
1789 ; CHECK-NEXT:    #APP
1790 ; CHECK-NEXT:    nop
1791 ; CHECK-NEXT:    #NO_APP
1792 ; CHECK-NEXT:    kmovw %edi, %k1
1793 ; CHECK-NEXT:    vpermpd $235, {{[-0-9]+}}(%r{{[sb]}}p), %zmm0 {%k1} {z} # 64-byte Folded Reload
1794 ; CHECK-NEXT:    # zmm0 {%k1} {z} = mem[3,2,2,3,7,6,6,7]
1795 ; CHECK-NEXT:    retq
1796   %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},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
1797   %2 = shufflevector <8 x double> %a0, <8 x double> undef, <8 x i32> <i32 3, i32 2, i32 2, i32 3, i32 7, i32 6, i32 6, i32 7>
1798   %3 = bitcast i8 %mask to <8 x i1>
1799   %4 = select <8 x i1> %3, <8 x double> %2, <8 x double> zeroinitializer
1800   ret <8 x double> %4
1801 }
1802
1803 define <8 x double> @stack_fold_permpdvar(<8 x i64> %a0, <8 x double> %a1) {
1804 ; CHECK-LABEL: stack_fold_permpdvar:
1805 ; CHECK:       # %bb.0:
1806 ; CHECK-NEXT:    vmovups %zmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
1807 ; CHECK-NEXT:    #APP
1808 ; CHECK-NEXT:    nop
1809 ; CHECK-NEXT:    #NO_APP
1810 ; CHECK-NEXT:    vpermpd {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %zmm0 # 64-byte Folded Reload
1811 ; CHECK-NEXT:    vxorpd %xmm1, %xmm1, %xmm1
1812 ; CHECK-NEXT:    vaddpd %zmm1, %zmm0, %zmm0
1813 ; CHECK-NEXT:    retq
1814   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
1815   %2 = call <8 x double> @llvm.x86.avx512.permvar.df.512(<8 x double> %a1, <8 x i64> %a0)
1816   ; fadd forces execution domain
1817   %3 = fadd <8 x double> %2, zeroinitializer
1818   ret <8 x double> %3
1819 }
1820 declare <8 x double> @llvm.x86.avx512.permvar.df.512(<8 x double>, <8 x i64>) nounwind readonly
1821
1822 define <16 x float> @stack_fold_permps(<16 x i32> %a0, <16 x float> %a1) {
1823 ; CHECK-LABEL: stack_fold_permps:
1824 ; CHECK:       # %bb.0:
1825 ; CHECK-NEXT:    vmovups %zmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
1826 ; CHECK-NEXT:    #APP
1827 ; CHECK-NEXT:    nop
1828 ; CHECK-NEXT:    #NO_APP
1829 ; CHECK-NEXT:    vpermps {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %zmm0 # 64-byte Folded Reload
1830 ; CHECK-NEXT:    retq
1831   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
1832   %2 = call <16 x float> @llvm.x86.avx512.permvar.sf.512(<16 x float> %a1, <16 x i32> %a0)
1833   ret <16 x float> %2
1834 }
1835 declare <16 x float> @llvm.x86.avx512.permvar.sf.512(<16 x float>, <16 x i32>) nounwind readonly
1836
1837 define <8 x double> @stack_fold_permilpd_zmm(<8 x double> %a0) {
1838 ; CHECK-LABEL: stack_fold_permilpd_zmm:
1839 ; CHECK:       # %bb.0:
1840 ; CHECK-NEXT:    vmovups %zmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
1841 ; CHECK-NEXT:    #APP
1842 ; CHECK-NEXT:    nop
1843 ; CHECK-NEXT:    #NO_APP
1844 ; CHECK-NEXT:    vpermilpd $85, {{[-0-9]+}}(%r{{[sb]}}p), %zmm0 # 64-byte Folded Reload
1845 ; CHECK-NEXT:    # zmm0 = mem[1,0,3,2,5,4,7,6]
1846 ; CHECK-NEXT:    retq
1847   %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},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
1848   %2 = shufflevector <8 x double> %a0, <8 x double> undef, <8 x i32> <i32 1, i32 0, i32 3, i32 2, i32 5, i32 4, i32 7, i32 6>
1849   ret <8 x double> %2
1850 }
1851
1852 define <8 x double> @stack_fold_permilpd_zmm_mask(<8 x double>* %passthru, <8 x double> %a0, i8 %mask) {
1853 ; CHECK-LABEL: stack_fold_permilpd_zmm_mask:
1854 ; CHECK:       # %bb.0:
1855 ; CHECK-NEXT:    vmovups %zmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
1856 ; CHECK-NEXT:    #APP
1857 ; CHECK-NEXT:    nop
1858 ; CHECK-NEXT:    #NO_APP
1859 ; CHECK-NEXT:    kmovw %esi, %k1
1860 ; CHECK-NEXT:    vmovapd (%rdi), %zmm1
1861 ; CHECK-NEXT:    vpermilpd $85, {{[-0-9]+}}(%r{{[sb]}}p), %zmm1 {%k1} # 64-byte Folded Reload
1862 ; CHECK-NEXT:    # zmm1 {%k1} = mem[1,0,3,2,5,4,7,6]
1863 ; CHECK-NEXT:    vmovapd %zmm1, %zmm0
1864 ; CHECK-NEXT:    retq
1865   %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},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
1866   %2 = shufflevector <8 x double> %a0, <8 x double> undef, <8 x i32> <i32 1, i32 0, i32 3, i32 2, i32 5, i32 4, i32 7, i32 6>
1867   %3 = bitcast i8 %mask to <8 x i1>
1868   ; load needed to keep the operation from being scheduled above the asm block
1869   %4 = load <8 x double>, <8 x double>* %passthru
1870   %5 = select <8 x i1> %3, <8 x double> %2, <8 x double> %4
1871   ret <8 x double> %5
1872 }
1873
1874 define <8 x double> @stack_fold_permilpd_zmm_maskz(<8 x double> %a0, i8 %mask) {
1875 ; CHECK-LABEL: stack_fold_permilpd_zmm_maskz:
1876 ; CHECK:       # %bb.0:
1877 ; CHECK-NEXT:    vmovups %zmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
1878 ; CHECK-NEXT:    #APP
1879 ; CHECK-NEXT:    nop
1880 ; CHECK-NEXT:    #NO_APP
1881 ; CHECK-NEXT:    kmovw %edi, %k1
1882 ; CHECK-NEXT:    vpermilpd $85, {{[-0-9]+}}(%r{{[sb]}}p), %zmm0 {%k1} {z} # 64-byte Folded Reload
1883 ; CHECK-NEXT:    # zmm0 {%k1} {z} = mem[1,0,3,2,5,4,7,6]
1884 ; CHECK-NEXT:    retq
1885   %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},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
1886   %2 = shufflevector <8 x double> %a0, <8 x double> undef, <8 x i32> <i32 1, i32 0, i32 3, i32 2, i32 5, i32 4, i32 7, i32 6>
1887   %3 = bitcast i8 %mask to <8 x i1>
1888   %4 = select <8 x i1> %3, <8 x double> %2, <8 x double> zeroinitializer
1889   ret <8 x double> %4
1890 }
1891
1892 define <8 x double> @stack_fold_permilpdvar_zmm(<8 x double> %a0, <8 x i64> %a1) {
1893 ; CHECK-LABEL: stack_fold_permilpdvar_zmm:
1894 ; CHECK:       # %bb.0:
1895 ; CHECK-NEXT:    vmovups %zmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
1896 ; CHECK-NEXT:    #APP
1897 ; CHECK-NEXT:    nop
1898 ; CHECK-NEXT:    #NO_APP
1899 ; CHECK-NEXT:    vpermilpd {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %zmm0 # 64-byte Folded Reload
1900 ; CHECK-NEXT:    retq
1901   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
1902   %2 = call <8 x double> @llvm.x86.avx512.vpermilvar.pd.512(<8 x double> %a0, <8 x i64> %a1)
1903   ret <8 x double> %2
1904 }
1905 declare <8 x double> @llvm.x86.avx512.vpermilvar.pd.512(<8 x double>, <8 x i64>) nounwind readnone
1906
1907 define <8 x double> @stack_fold_permilpdvar_zmm_mask(<8 x double>* %passthru, <8 x double> %a0, <8 x i64> %a1, i8 %mask) {
1908 ; CHECK-LABEL: stack_fold_permilpdvar_zmm_mask:
1909 ; CHECK:       # %bb.0:
1910 ; CHECK-NEXT:    vmovups %zmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
1911 ; CHECK-NEXT:    #APP
1912 ; CHECK-NEXT:    nop
1913 ; CHECK-NEXT:    #NO_APP
1914 ; CHECK-NEXT:    kmovw %esi, %k1
1915 ; CHECK-NEXT:    vmovapd (%rdi), %zmm2
1916 ; CHECK-NEXT:    vpermilpd {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %zmm2 {%k1} # 64-byte Folded Reload
1917 ; CHECK-NEXT:    vmovapd %zmm2, %zmm0
1918 ; CHECK-NEXT:    retq
1919   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
1920   %2 = call <8 x double> @llvm.x86.avx512.vpermilvar.pd.512(<8 x double> %a0, <8 x i64> %a1)
1921   %3 = bitcast i8 %mask to <8 x i1>
1922   ; load needed to keep the operation from being scheduled above the asm block
1923   %4 = load <8 x double>, <8 x double>* %passthru
1924   %5 = select <8 x i1> %3, <8 x double> %2, <8 x double> %4
1925   ret <8 x double> %5
1926 }
1927
1928 define <8 x double> @stack_fold_permilpdvar_zmm_maskz(<8 x double> %a0, <8 x i64> %a1, i8 %mask) {
1929 ; CHECK-LABEL: stack_fold_permilpdvar_zmm_maskz:
1930 ; CHECK:       # %bb.0:
1931 ; CHECK-NEXT:    vmovups %zmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
1932 ; CHECK-NEXT:    #APP
1933 ; CHECK-NEXT:    nop
1934 ; CHECK-NEXT:    #NO_APP
1935 ; CHECK-NEXT:    kmovw %edi, %k1
1936 ; CHECK-NEXT:    vpermilpd {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %zmm0 {%k1} {z} # 64-byte Folded Reload
1937 ; CHECK-NEXT:    retq
1938   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
1939   %2 = call <8 x double> @llvm.x86.avx512.vpermilvar.pd.512(<8 x double> %a0, <8 x i64> %a1)
1940   %3 = bitcast i8 %mask to <8 x i1>
1941   %4 = select <8 x i1> %3, <8 x double> %2, <8 x double> zeroinitializer
1942   ret <8 x double> %4
1943 }
1944
1945 define <16 x float> @stack_fold_permilps_zmm(<16 x float> %a0) {
1946 ; CHECK-LABEL: stack_fold_permilps_zmm:
1947 ; CHECK:       # %bb.0:
1948 ; CHECK-NEXT:    vmovups %zmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
1949 ; CHECK-NEXT:    #APP
1950 ; CHECK-NEXT:    nop
1951 ; CHECK-NEXT:    #NO_APP
1952 ; CHECK-NEXT:    vpermilps $27, {{[-0-9]+}}(%r{{[sb]}}p), %zmm0 # 64-byte Folded Reload
1953 ; CHECK-NEXT:    # zmm0 = mem[3,2,1,0,7,6,5,4,11,10,9,8,15,14,13,12]
1954 ; CHECK-NEXT:    retq
1955   %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},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
1956   %2 = shufflevector <16 x float> %a0, <16 x float> undef, <16 x i32> <i32 3, i32 2, i32 1, i32 0, i32 7, i32 6, i32 5, i32 4, i32 11, i32 10, i32 9, i32 8, i32 15, i32 14, i32 13, i32 12>
1957   ret <16 x float> %2
1958 }
1959
1960 define <16 x float> @stack_fold_permilps_zmm_mask(<16 x float>* %passthru, <16 x float> %a0, i16 %mask) {
1961 ; CHECK-LABEL: stack_fold_permilps_zmm_mask:
1962 ; CHECK:       # %bb.0:
1963 ; CHECK-NEXT:    vmovups %zmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
1964 ; CHECK-NEXT:    #APP
1965 ; CHECK-NEXT:    nop
1966 ; CHECK-NEXT:    #NO_APP
1967 ; CHECK-NEXT:    kmovw %esi, %k1
1968 ; CHECK-NEXT:    vmovaps (%rdi), %zmm1
1969 ; CHECK-NEXT:    vpermilps $27, {{[-0-9]+}}(%r{{[sb]}}p), %zmm1 {%k1} # 64-byte Folded Reload
1970 ; CHECK-NEXT:    # zmm1 {%k1} = mem[3,2,1,0,7,6,5,4,11,10,9,8,15,14,13,12]
1971 ; CHECK-NEXT:    vmovaps %zmm1, %zmm0
1972 ; CHECK-NEXT:    retq
1973   %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},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
1974   %2 = shufflevector <16 x float> %a0, <16 x float> undef, <16 x i32> <i32 3, i32 2, i32 1, i32 0, i32 7, i32 6, i32 5, i32 4, i32 11, i32 10, i32 9, i32 8, i32 15, i32 14, i32 13, i32 12>
1975   %3 = bitcast i16 %mask to <16 x i1>
1976   ; load needed to keep the operation from being scheduled above the asm block
1977   %4 = load <16 x float>, <16 x float>* %passthru
1978   %5 = select <16 x i1> %3, <16 x float> %2, <16 x float> %4
1979   ret <16 x float> %5
1980 }
1981
1982 define <16 x float> @stack_fold_permilps_zmm_maskz(<16 x float> %a0, i16 %mask) {
1983 ; CHECK-LABEL: stack_fold_permilps_zmm_maskz:
1984 ; CHECK:       # %bb.0:
1985 ; CHECK-NEXT:    vmovups %zmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
1986 ; CHECK-NEXT:    #APP
1987 ; CHECK-NEXT:    nop
1988 ; CHECK-NEXT:    #NO_APP
1989 ; CHECK-NEXT:    kmovw %edi, %k1
1990 ; CHECK-NEXT:    vpermilps $27, {{[-0-9]+}}(%r{{[sb]}}p), %zmm0 {%k1} {z} # 64-byte Folded Reload
1991 ; CHECK-NEXT:    # zmm0 {%k1} {z} = mem[3,2,1,0,7,6,5,4,11,10,9,8,15,14,13,12]
1992 ; CHECK-NEXT:    retq
1993   %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},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
1994   %2 = shufflevector <16 x float> %a0, <16 x float> undef, <16 x i32> <i32 3, i32 2, i32 1, i32 0, i32 7, i32 6, i32 5, i32 4, i32 11, i32 10, i32 9, i32 8, i32 15, i32 14, i32 13, i32 12>
1995   %3 = bitcast i16 %mask to <16 x i1>
1996   %4 = select <16 x i1> %3, <16 x float> %2, <16 x float> zeroinitializer
1997   ret <16 x float> %4
1998 }
1999
2000 define <16 x float> @stack_fold_permilpsvar_zmm(<16 x float> %a0, <16 x i32> %a1) {
2001 ; CHECK-LABEL: stack_fold_permilpsvar_zmm:
2002 ; CHECK:       # %bb.0:
2003 ; CHECK-NEXT:    vmovups %zmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
2004 ; CHECK-NEXT:    #APP
2005 ; CHECK-NEXT:    nop
2006 ; CHECK-NEXT:    #NO_APP
2007 ; CHECK-NEXT:    vpermilps {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %zmm0 # 64-byte Folded Reload
2008 ; CHECK-NEXT:    retq
2009   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
2010   %2 = call <16 x float> @llvm.x86.avx512.vpermilvar.ps.512(<16 x float> %a0, <16 x i32> %a1)
2011   ret <16 x float> %2
2012 }
2013 declare <16 x float> @llvm.x86.avx512.vpermilvar.ps.512(<16 x float>, <16 x i32>) nounwind readnone
2014
2015 define <16 x float> @stack_fold_permilpsvar_zmm_mask(<16 x float>* %passthru, <16 x float> %a0, <16 x i32> %a1, i16 %mask) {
2016 ; CHECK-LABEL: stack_fold_permilpsvar_zmm_mask:
2017 ; CHECK:       # %bb.0:
2018 ; CHECK-NEXT:    vmovups %zmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
2019 ; CHECK-NEXT:    #APP
2020 ; CHECK-NEXT:    nop
2021 ; CHECK-NEXT:    #NO_APP
2022 ; CHECK-NEXT:    kmovw %esi, %k1
2023 ; CHECK-NEXT:    vmovaps (%rdi), %zmm2
2024 ; CHECK-NEXT:    vpermilps {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %zmm2 {%k1} # 64-byte Folded Reload
2025 ; CHECK-NEXT:    vmovaps %zmm2, %zmm0
2026 ; CHECK-NEXT:    retq
2027   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
2028   %2 = call <16 x float> @llvm.x86.avx512.vpermilvar.ps.512(<16 x float> %a0, <16 x i32> %a1)
2029   %3 = bitcast i16 %mask to <16 x i1>
2030   ; load needed to keep the operation from being scheduled above the asm block
2031   %4 = load <16 x float>, <16 x float>* %passthru
2032   %5 = select <16 x i1> %3, <16 x float> %2, <16 x float> %4
2033   ret <16 x float> %5
2034 }
2035
2036 define <16 x float> @stack_fold_permilpsvar_zmm_maskz(<16 x float> %a0, <16 x i32> %a1, i16 %mask) {
2037 ; CHECK-LABEL: stack_fold_permilpsvar_zmm_maskz:
2038 ; CHECK:       # %bb.0:
2039 ; CHECK-NEXT:    vmovups %zmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 64-byte Spill
2040 ; CHECK-NEXT:    #APP
2041 ; CHECK-NEXT:    nop
2042 ; CHECK-NEXT:    #NO_APP
2043 ; CHECK-NEXT:    kmovw %edi, %k1
2044 ; CHECK-NEXT:    vpermilps {{[-0-9]+}}(%r{{[sb]}}p), %zmm0, %zmm0 {%k1} {z} # 64-byte Folded Reload
2045 ; CHECK-NEXT:    retq
2046   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
2047   %2 = call <16 x float> @llvm.x86.avx512.vpermilvar.ps.512(<16 x float> %a0, <16 x i32> %a1)
2048   %3 = bitcast i16 %mask to <16 x i1>
2049   %4 = select <16 x i1> %3, <16 x float> %2, <16 x float> zeroinitializer
2050   ret <16 x float> %4
2051 }
2052
2053 attributes #0 = { "unsafe-fp-math"="false" }
2054 attributes #1 = { "unsafe-fp-math"="true" }