llvm/test/CodeGen/X86/stack-folding-fp-avx512fp16vl.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=+avx512vl,+avx512fp16 < %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 half> @stack_fold_addph(<8 x half> %a0, <8 x half> %a1) {
  13 ; CHECK-LABEL: stack_fold_addph:
  14 ; CHECK:       # %bb.0:
  15 ; CHECK-NEXT:    vmovaps %xmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
  16 ; CHECK-NEXT:    #APP
  17 ; CHECK-NEXT:    nop
  18 ; CHECK-NEXT:    #NO_APP
  19 ; CHECK-NEXT:    vaddph {{[-0-9]+}}(%r{{[sb]}}p), %xmm0, %xmm0 # 16-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 half> %a0, %a1
  23   ret <8 x half> %2
  24 }
  25
  26 define <16 x half> @stack_fold_addph_ymm(<16 x half> %a0, <16 x half> %a1) {
  27 ; CHECK-LABEL: stack_fold_addph_ymm:
  28 ; CHECK:       # %bb.0:
  29 ; CHECK-NEXT:    vmovups %ymm1, {{[-0-9]+}}(%r{{[sb]}}p) # 32-byte Spill
  30 ; CHECK-NEXT:    #APP
  31 ; CHECK-NEXT:    nop
  32 ; CHECK-NEXT:    #NO_APP
  33 ; CHECK-NEXT:    vaddph {{[-0-9]+}}(%r{{[sb]}}p), %ymm0, %ymm0 # 32-byte Folded Reload
  34 ; CHECK-NEXT:    retq
  35   %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}"()
  36   %2 = fadd <16 x half> %a0, %a1
  37   ret <16 x half> %2
  38 }
  39
  40 define i8 @stack_fold_cmpph(<8 x half> %a0, <8 x half> %a1) {
  41 ; CHECK-LABEL: stack_fold_cmpph:
  42 ; CHECK:       # %bb.0:
  43 ; CHECK-NEXT:    vmovaps %xmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
  44 ; CHECK-NEXT:    #APP
  45 ; CHECK-NEXT:    nop
  46 ; CHECK-NEXT:    #NO_APP
  47 ; CHECK-NEXT:    vcmpeqph {{[-0-9]+}}(%r{{[sb]}}p), %xmm0, %k0 # 16-byte Folded Reload
  48 ; CHECK-NEXT:    kmovd %k0, %eax
  49 ; CHECK-NEXT:    # kill: def $al killed $al killed $eax
  50 ; CHECK-NEXT:    retq
  51   %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}"()
  52   %res = call <8 x i1> @llvm.x86.avx512fp16.mask.cmp.ph.128(<8 x half> %a0, <8 x half> %a1, i32 0, <8 x i1> <i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true>)
  53   %2 = bitcast <8 x i1> %res to i8
  54   ret i8 %2
  55 }
  56 declare <8 x i1> @llvm.x86.avx512fp16.mask.cmp.ph.128(<8 x half>, <8 x half>, i32,  <8 x i1>)
  57
  58 define i16 @stack_fold_cmpph_ymm(<16 x half> %a0, <16 x half> %a1) {
  59 ; CHECK-LABEL: stack_fold_cmpph_ymm:
  60 ; CHECK:       # %bb.0:
  61 ; CHECK-NEXT:    vmovups %ymm1, {{[-0-9]+}}(%r{{[sb]}}p) # 32-byte Spill
  62 ; CHECK-NEXT:    #APP
  63 ; CHECK-NEXT:    nop
  64 ; CHECK-NEXT:    #NO_APP
  65 ; CHECK-NEXT:    vcmpeqph {{[-0-9]+}}(%r{{[sb]}}p), %ymm0, %k0 # 32-byte Folded Reload
  66 ; CHECK-NEXT:    kmovd %k0, %eax
  67 ; CHECK-NEXT:    # kill: def $ax killed $ax killed $eax
  68 ; CHECK-NEXT:    vzeroupper
  69 ; CHECK-NEXT:    retq
  70   %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}"()
  71   %res = call <16 x i1> @llvm.x86.avx512fp16.mask.cmp.ph.256(<16 x half> %a0, <16 x half> %a1, i32 0, <16 x i1> <i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true>)
  72   %2 = bitcast <16 x i1> %res to i16
  73   ret i16 %2
  74 }
  75 declare <16 x i1> @llvm.x86.avx512fp16.mask.cmp.ph.256(<16 x half>, <16 x half>, i32, <16 x i1>)
  76
  77 define <8 x half> @stack_fold_divph(<8 x half> %a0, <8 x half> %a1) {
  78 ; CHECK-LABEL: stack_fold_divph:
  79 ; CHECK:       # %bb.0:
  80 ; CHECK-NEXT:    vmovaps %xmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
  81 ; CHECK-NEXT:    #APP
  82 ; CHECK-NEXT:    nop
  83 ; CHECK-NEXT:    #NO_APP
  84 ; CHECK-NEXT:    vdivph {{[-0-9]+}}(%r{{[sb]}}p), %xmm0, %xmm0 # 16-byte Folded Reload
  85 ; CHECK-NEXT:    retq
  86   %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}"()
  87   %2 = fdiv <8 x half> %a0, %a1
  88   ret <8 x half> %2
  89 }
  90
  91 define <16 x half> @stack_fold_divph_ymm(<16 x half> %a0, <16 x half> %a1) {
  92 ; CHECK-LABEL: stack_fold_divph_ymm:
  93 ; CHECK:       # %bb.0:
  94 ; CHECK-NEXT:    vmovups %ymm1, {{[-0-9]+}}(%r{{[sb]}}p) # 32-byte Spill
  95 ; CHECK-NEXT:    #APP
  96 ; CHECK-NEXT:    nop
  97 ; CHECK-NEXT:    #NO_APP
  98 ; CHECK-NEXT:    vdivph {{[-0-9]+}}(%r{{[sb]}}p), %ymm0, %ymm0 # 32-byte Folded Reload
  99 ; CHECK-NEXT:    retq
 100   %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}"()
 101   %2 = fdiv <16 x half> %a0, %a1
 102   ret <16 x half> %2
 103 }
 104
 105 define i8 @stack_fold_fpclassph(<8 x half> %a0) {
 106 ; CHECK-LABEL: stack_fold_fpclassph:
 107 ; CHECK:       # %bb.0:
 108 ; CHECK-NEXT:    vmovaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
 109 ; CHECK-NEXT:    #APP
 110 ; CHECK-NEXT:    nop
 111 ; CHECK-NEXT:    #NO_APP
 112 ; CHECK-NEXT:    vfpclassphx $4, {{[-0-9]+}}(%r{{[sb]}}p), %k0 # 16-byte Folded Reload
 113 ; CHECK-NEXT:    # k0 = isNegativeZero(mem)
 114 ; CHECK-NEXT:    kmovd %k0, %eax
 115 ; CHECK-NEXT:    # kill: def $al killed $al killed $eax
 116 ; CHECK-NEXT:    retq
 117   %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}"()
 118   %2 = call <8 x i1> @llvm.x86.avx512fp16.fpclass.ph.128(<8 x half> %a0, i32 4)
 119   %3 = bitcast <8 x i1> %2 to i8
 120   ret i8 %3
 121 }
 122 declare <8 x i1> @llvm.x86.avx512fp16.fpclass.ph.128(<8 x half>, i32)
 123
 124 define i8 @stack_fold_fpclassph_mask(<8 x half> %a0, ptr %p) {
 125 ; CHECK-LABEL: stack_fold_fpclassph_mask:
 126 ; CHECK:       # %bb.0:
 127 ; CHECK-NEXT:    vmovaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
 128 ; CHECK-NEXT:    #APP
 129 ; CHECK-NEXT:    nop
 130 ; CHECK-NEXT:    #NO_APP
 131 ; CHECK-NEXT:    kmovb (%rdi), %k1
 132 ; CHECK-NEXT:    vfpclassphx $4, {{[-0-9]+}}(%r{{[sb]}}p), %k0 {%k1} # 16-byte Folded Reload
 133 ; CHECK-NEXT:    kmovd %k0, %eax
 134 ; CHECK-NEXT:    # kill: def $al killed $al killed $eax
 135 ; CHECK-NEXT:    retq
 136   %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}"()
 137   %2 = call <8 x i1> @llvm.x86.avx512fp16.fpclass.ph.128(<8 x half> %a0, i32 4)
 138   %mask = load <8 x i1>, ptr %p
 139   %3 = and <8 x i1> %2, %mask
 140   %4 = bitcast <8 x i1> %3 to i8
 141   ret i8 %4
 142 }
 143
 144 define i16 @stack_fold_fpclassph_ymm(<16 x half> %a0) {
 145 ; CHECK-LABEL: stack_fold_fpclassph_ymm:
 146 ; CHECK:       # %bb.0:
 147 ; CHECK-NEXT:    vmovups %ymm0, {{[-0-9]+}}(%r{{[sb]}}p) # 32-byte Spill
 148 ; CHECK-NEXT:    #APP
 149 ; CHECK-NEXT:    nop
 150 ; CHECK-NEXT:    #NO_APP
 151 ; CHECK-NEXT:    vfpclassphy $4, {{[-0-9]+}}(%r{{[sb]}}p), %k0 # 32-byte Folded Reload
 152 ; CHECK-NEXT:    # k0 = isNegativeZero(mem)
 153 ; CHECK-NEXT:    kmovd %k0, %eax
 154 ; CHECK-NEXT:    # kill: def $ax killed $ax killed $eax
 155 ; CHECK-NEXT:    vzeroupper
 156 ; CHECK-NEXT:    retq
 157   %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}"()
 158   %2 = call <16 x i1> @llvm.x86.avx512fp16.fpclass.ph.256(<16 x half> %a0, i32 4)
 159   %3 = bitcast <16 x i1> %2 to i16
 160   ret i16 %3
 161 }
 162 declare <16 x i1> @llvm.x86.avx512fp16.fpclass.ph.256(<16 x half>, i32)
 163
 164 define i16 @stack_fold_fpclassph_mask_ymm(<16 x half> %a0, ptr %p) {
 165 ; CHECK-LABEL: stack_fold_fpclassph_mask_ymm:
 166 ; CHECK:       # %bb.0:
 167 ; CHECK-NEXT:    vmovups %ymm0, {{[-0-9]+}}(%r{{[sb]}}p) # 32-byte Spill
 168 ; CHECK-NEXT:    #APP
 169 ; CHECK-NEXT:    nop
 170 ; CHECK-NEXT:    #NO_APP
 171 ; CHECK-NEXT:    kmovw (%rdi), %k1
 172 ; CHECK-NEXT:    vfpclassphy $4, {{[-0-9]+}}(%r{{[sb]}}p), %k0 {%k1} # 32-byte Folded Reload
 173 ; CHECK-NEXT:    kmovd %k0, %eax
 174 ; CHECK-NEXT:    # kill: def $ax killed $ax killed $eax
 175 ; CHECK-NEXT:    vzeroupper
 176 ; CHECK-NEXT:    retq
 177   %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}"()
 178   %2 = call <16 x i1> @llvm.x86.avx512fp16.fpclass.ph.256(<16 x half> %a0, i32 4)
 179   %mask = load <16 x i1>, ptr %p
 180   %3 = and <16 x i1> %2, %mask
 181   %4 = bitcast <16 x i1> %3 to i16
 182   ret i16 %4
 183 }
 184
 185 define <8 x half> @stack_fold_getexpph(<8 x half> %a0) {
 186 ; CHECK-LABEL: stack_fold_getexpph:
 187 ; CHECK:       # %bb.0:
 188 ; CHECK-NEXT:    vmovaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
 189 ; CHECK-NEXT:    #APP
 190 ; CHECK-NEXT:    nop
 191 ; CHECK-NEXT:    #NO_APP
 192 ; CHECK-NEXT:    vgetexpph {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Folded Reload
 193 ; CHECK-NEXT:    retq
 194   %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}"()
 195   %2 = call <8 x half> @llvm.x86.avx512fp16.mask.getexp.ph.128(<8 x half> %a0, <8 x half> undef, i8 -1)
 196   ret <8 x half> %2
 197 }
 198 declare <8 x half> @llvm.x86.avx512fp16.mask.getexp.ph.128(<8 x half>, <8 x half>, i8)
 199
 200 define <8 x half> @stack_fold_getexpph_mask(<8 x half> %a0, ptr %passthru, i8 %mask) {
 201 ; CHECK-LABEL: stack_fold_getexpph_mask:
 202 ; CHECK:       # %bb.0:
 203 ; CHECK-NEXT:    vmovaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
 204 ; CHECK-NEXT:    kmovd %esi, %k1
 205 ; CHECK-NEXT:    #APP
 206 ; CHECK-NEXT:    nop
 207 ; CHECK-NEXT:    #NO_APP
 208 ; CHECK-NEXT:    vmovaps (%rdi), %xmm1
 209 ; CHECK-NEXT:    vgetexpph {{[-0-9]+}}(%r{{[sb]}}p), %xmm1 {%k1} # 16-byte Folded Reload
 210 ; CHECK-NEXT:    vmovaps %xmm1, %xmm0
 211 ; CHECK-NEXT:    retq
 212   %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}"()
 213   %2 = load <8 x half>, ptr %passthru
 214   %3 = call <8 x half> @llvm.x86.avx512fp16.mask.getexp.ph.128(<8 x half> %a0, <8 x half> %2, i8 %mask)
 215   ret <8 x half> %3
 216 }
 217
 218 define <8 x half> @stack_fold_getexpph_maskz(<8 x half> %a0, ptr %mask) {
 219 ; CHECK-LABEL: stack_fold_getexpph_maskz:
 220 ; CHECK:       # %bb.0:
 221 ; CHECK-NEXT:    vmovaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
 222 ; CHECK-NEXT:    #APP
 223 ; CHECK-NEXT:    nop
 224 ; CHECK-NEXT:    #NO_APP
 225 ; CHECK-NEXT:    kmovb (%rdi), %k1
 226 ; CHECK-NEXT:    vgetexpph {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 {%k1} {z} # 16-byte Folded Reload
 227 ; CHECK-NEXT:    retq
 228   %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}"()
 229   %2 = load i8, ptr %mask
 230   %3 = call <8 x half> @llvm.x86.avx512fp16.mask.getexp.ph.128(<8 x half> %a0, <8 x half> zeroinitializer, i8 %2)
 231   ret <8 x half> %3
 232 }
 233
 234 define <16 x half> @stack_fold_getexpph_ymm(<16 x half> %a0) {
 235 ; CHECK-LABEL: stack_fold_getexpph_ymm:
 236 ; CHECK:       # %bb.0:
 237 ; CHECK-NEXT:    vmovups %ymm0, {{[-0-9]+}}(%r{{[sb]}}p) # 32-byte Spill
 238 ; CHECK-NEXT:    #APP
 239 ; CHECK-NEXT:    nop
 240 ; CHECK-NEXT:    #NO_APP
 241 ; CHECK-NEXT:    vgetexpph {{[-0-9]+}}(%r{{[sb]}}p), %ymm0 # 32-byte Folded Reload
 242 ; CHECK-NEXT:    retq
 243   %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}"()
 244   %2 = call <16 x half> @llvm.x86.avx512fp16.mask.getexp.ph.256(<16 x half> %a0, <16 x half> undef, i16 -1)
 245   ret <16 x half> %2
 246 }
 247 declare <16 x half> @llvm.x86.avx512fp16.mask.getexp.ph.256(<16 x half>, <16 x half>, i16)
 248
 249 define <16 x half> @stack_fold_getexpph_mask_ymm(<16 x half> %a0, ptr %passthru, i16 %mask) {
 250 ; CHECK-LABEL: stack_fold_getexpph_mask_ymm:
 251 ; CHECK:       # %bb.0:
 252 ; CHECK-NEXT:    vmovups %ymm0, {{[-0-9]+}}(%r{{[sb]}}p) # 32-byte Spill
 253 ; CHECK-NEXT:    kmovd %esi, %k1
 254 ; CHECK-NEXT:    #APP
 255 ; CHECK-NEXT:    nop
 256 ; CHECK-NEXT:    #NO_APP
 257 ; CHECK-NEXT:    vmovaps (%rdi), %ymm1
 258 ; CHECK-NEXT:    vgetexpph {{[-0-9]+}}(%r{{[sb]}}p), %ymm1 {%k1} # 32-byte Folded Reload
 259 ; CHECK-NEXT:    vmovaps %ymm1, %ymm0
 260 ; CHECK-NEXT:    retq
 261   %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}"()
 262   %2 = load <16 x half>, ptr %passthru
 263   %3 = call <16 x half> @llvm.x86.avx512fp16.mask.getexp.ph.256(<16 x half> %a0, <16 x half> %2, i16 %mask)
 264   ret <16 x half> %3
 265 }
 266
 267 define <16 x half> @stack_fold_getexpph_maskz_ymm(<16 x half> %a0, ptr %mask) {
 268 ; CHECK-LABEL: stack_fold_getexpph_maskz_ymm:
 269 ; CHECK:       # %bb.0:
 270 ; CHECK-NEXT:    vmovups %ymm0, {{[-0-9]+}}(%r{{[sb]}}p) # 32-byte Spill
 271 ; CHECK-NEXT:    #APP
 272 ; CHECK-NEXT:    nop
 273 ; CHECK-NEXT:    #NO_APP
 274 ; CHECK-NEXT:    kmovw (%rdi), %k1
 275 ; CHECK-NEXT:    vgetexpph {{[-0-9]+}}(%r{{[sb]}}p), %ymm0 {%k1} {z} # 32-byte Folded Reload
 276 ; CHECK-NEXT:    retq
 277   %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}"()
 278   %2 = load i16, ptr %mask
 279   %3 = call <16 x half> @llvm.x86.avx512fp16.mask.getexp.ph.256(<16 x half> %a0, <16 x half> zeroinitializer, i16 %2)
 280   ret <16 x half> %3
 281 }
 282
 283 define <8 x half> @stack_fold_getmantph(<8 x half> %a0) {
 284 ; CHECK-LABEL: stack_fold_getmantph:
 285 ; CHECK:       # %bb.0:
 286 ; CHECK-NEXT:    vmovaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
 287 ; CHECK-NEXT:    #APP
 288 ; CHECK-NEXT:    nop
 289 ; CHECK-NEXT:    #NO_APP
 290 ; CHECK-NEXT:    vgetmantph $8, {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Folded Reload
 291 ; CHECK-NEXT:    retq
 292   %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}"()
 293   %2 = call <8 x half> @llvm.x86.avx512fp16.mask.getmant.ph.128(<8 x half> %a0, i32 8, <8 x half> undef, i8 -1)
 294   ret <8 x half> %2
 295 }
 296 declare <8 x half> @llvm.x86.avx512fp16.mask.getmant.ph.128(<8 x half>, i32, <8 x half>, i8)
 297
 298 define <8 x half> @stack_fold_getmantph_mask(<8 x half> %a0, ptr %passthru, i8 %mask) {
 299 ; CHECK-LABEL: stack_fold_getmantph_mask:
 300 ; CHECK:       # %bb.0:
 301 ; CHECK-NEXT:    vmovaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
 302 ; CHECK-NEXT:    kmovd %esi, %k1
 303 ; CHECK-NEXT:    #APP
 304 ; CHECK-NEXT:    nop
 305 ; CHECK-NEXT:    #NO_APP
 306 ; CHECK-NEXT:    vmovaps (%rdi), %xmm1
 307 ; CHECK-NEXT:    vgetmantph $8, {{[-0-9]+}}(%r{{[sb]}}p), %xmm1 {%k1} # 16-byte Folded Reload
 308 ; CHECK-NEXT:    vmovaps %xmm1, %xmm0
 309 ; CHECK-NEXT:    retq
 310   %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}"()
 311   %2 = load <8 x half>, ptr %passthru
 312   %3 = call <8 x half> @llvm.x86.avx512fp16.mask.getmant.ph.128(<8 x half> %a0, i32 8, <8 x half> %2, i8 %mask)
 313   ret <8 x half> %3
 314 }
 315
 316 define <8 x half> @stack_fold_getmantph_maskz(<8 x half> %a0, ptr %mask) {
 317 ; CHECK-LABEL: stack_fold_getmantph_maskz:
 318 ; CHECK:       # %bb.0:
 319 ; CHECK-NEXT:    vmovaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
 320 ; CHECK-NEXT:    #APP
 321 ; CHECK-NEXT:    nop
 322 ; CHECK-NEXT:    #NO_APP
 323 ; CHECK-NEXT:    kmovb (%rdi), %k1
 324 ; CHECK-NEXT:    vgetmantph $8, {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 {%k1} {z} # 16-byte Folded Reload
 325 ; CHECK-NEXT:    retq
 326   %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}"()
 327   %2 = load i8, ptr %mask
 328   %3 = call <8 x half> @llvm.x86.avx512fp16.mask.getmant.ph.128(<8 x half> %a0, i32 8, <8 x half> zeroinitializer, i8 %2)
 329   ret <8 x half> %3
 330 }
 331
 332 define <16 x half> @stack_fold_getmantph_ymm(<16 x half> %a0) {
 333 ; CHECK-LABEL: stack_fold_getmantph_ymm:
 334 ; CHECK:       # %bb.0:
 335 ; CHECK-NEXT:    vmovups %ymm0, {{[-0-9]+}}(%r{{[sb]}}p) # 32-byte Spill
 336 ; CHECK-NEXT:    #APP
 337 ; CHECK-NEXT:    nop
 338 ; CHECK-NEXT:    #NO_APP
 339 ; CHECK-NEXT:    vgetmantph $8, {{[-0-9]+}}(%r{{[sb]}}p), %ymm0 # 32-byte Folded Reload
 340 ; CHECK-NEXT:    retq
 341   %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}"()
 342   %2 = call <16 x half> @llvm.x86.avx512fp16.mask.getmant.ph.256(<16 x half> %a0, i32 8, <16 x half> undef, i16 -1)
 343   ret <16 x half> %2
 344 }
 345 declare <16 x half> @llvm.x86.avx512fp16.mask.getmant.ph.256(<16 x half>, i32, <16 x half>, i16)
 346
 347 define <16 x half> @stack_fold_getmantph_mask_ymm(<16 x half> %a0, ptr %passthru, i16 %mask) {
 348 ; CHECK-LABEL: stack_fold_getmantph_mask_ymm:
 349 ; CHECK:       # %bb.0:
 350 ; CHECK-NEXT:    vmovups %ymm0, {{[-0-9]+}}(%r{{[sb]}}p) # 32-byte Spill
 351 ; CHECK-NEXT:    kmovd %esi, %k1
 352 ; CHECK-NEXT:    #APP
 353 ; CHECK-NEXT:    nop
 354 ; CHECK-NEXT:    #NO_APP
 355 ; CHECK-NEXT:    vmovaps (%rdi), %ymm1
 356 ; CHECK-NEXT:    vgetmantph $8, {{[-0-9]+}}(%r{{[sb]}}p), %ymm1 {%k1} # 32-byte Folded Reload
 357 ; CHECK-NEXT:    vmovaps %ymm1, %ymm0
 358 ; CHECK-NEXT:    retq
 359   %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}"()
 360   %2 = load <16 x half>, ptr %passthru
 361   %3 = call <16 x half> @llvm.x86.avx512fp16.mask.getmant.ph.256(<16 x half> %a0, i32 8, <16 x half> %2, i16 %mask)
 362   ret <16 x half> %3
 363 }
 364
 365 define <16 x half> @stack_fold_getmantph_maskz_ymm(<16 x half> %a0, ptr %mask) {
 366 ; CHECK-LABEL: stack_fold_getmantph_maskz_ymm:
 367 ; CHECK:       # %bb.0:
 368 ; CHECK-NEXT:    vmovups %ymm0, {{[-0-9]+}}(%r{{[sb]}}p) # 32-byte Spill
 369 ; CHECK-NEXT:    #APP
 370 ; CHECK-NEXT:    nop
 371 ; CHECK-NEXT:    #NO_APP
 372 ; CHECK-NEXT:    kmovw (%rdi), %k1
 373 ; CHECK-NEXT:    vgetmantph $8, {{[-0-9]+}}(%r{{[sb]}}p), %ymm0 {%k1} {z} # 32-byte Folded Reload
 374 ; CHECK-NEXT:    retq
 375   %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}"()
 376   %2 = load i16, ptr %mask
 377   %3 = call <16 x half> @llvm.x86.avx512fp16.mask.getmant.ph.256(<16 x half> %a0, i32 8, <16 x half> zeroinitializer, i16 %2)
 378   ret <16 x half> %3
 379 }
 380
 381 define <8 x half> @stack_fold_maxph(<8 x half> %a0, <8 x half> %a1) #0 {
 382 ; CHECK-LABEL: stack_fold_maxph:
 383 ; CHECK:       # %bb.0:
 384 ; CHECK-NEXT:    vmovaps %xmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
 385 ; CHECK-NEXT:    #APP
 386 ; CHECK-NEXT:    nop
 387 ; CHECK-NEXT:    #NO_APP
 388 ; CHECK-NEXT:    vmaxph {{[-0-9]+}}(%r{{[sb]}}p), %xmm0, %xmm0 # 16-byte Folded Reload
 389 ; CHECK-NEXT:    retq
 390   %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}"()
 391   %2 = call <8 x half> @llvm.x86.avx512fp16.max.ph.128(<8 x half> %a0, <8 x half> %a1)
 392   ret <8 x half> %2
 393 }
 394 declare <8 x half> @llvm.x86.avx512fp16.max.ph.128(<8 x half>, <8 x half>) nounwind readnone
 395
 396 define <8 x half> @stack_fold_maxph_commutable(<8 x half> %a0, <8 x half> %a1) #1 {
 397 ; CHECK-LABEL: stack_fold_maxph_commutable:
 398 ; CHECK:       # %bb.0:
 399 ; CHECK-NEXT:    vmovaps %xmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
 400 ; CHECK-NEXT:    #APP
 401 ; CHECK-NEXT:    nop
 402 ; CHECK-NEXT:    #NO_APP
 403 ; CHECK-NEXT:    vmaxph {{[-0-9]+}}(%r{{[sb]}}p), %xmm0, %xmm0 # 16-byte Folded Reload
 404 ; CHECK-NEXT:    retq
 405   %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}"()
 406   %2 = call <8 x half> @llvm.x86.avx512fp16.max.ph.128(<8 x half> %a0, <8 x half> %a1)
 407   ret <8 x half> %2
 408 }
 409
 410 define <16 x half> @stack_fold_maxph_ymm(<16 x half> %a0, <16 x half> %a1) #0 {
 411 ; CHECK-LABEL: stack_fold_maxph_ymm:
 412 ; CHECK:       # %bb.0:
 413 ; CHECK-NEXT:    vmovups %ymm1, {{[-0-9]+}}(%r{{[sb]}}p) # 32-byte Spill
 414 ; CHECK-NEXT:    #APP
 415 ; CHECK-NEXT:    nop
 416 ; CHECK-NEXT:    #NO_APP
 417 ; CHECK-NEXT:    vmaxph {{[-0-9]+}}(%r{{[sb]}}p), %ymm0, %ymm0 # 32-byte Folded Reload
 418 ; CHECK-NEXT:    retq
 419   %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}"()
 420   %2 = call <16 x half> @llvm.x86.avx512fp16.max.ph.256(<16 x half> %a0, <16 x half> %a1)
 421   ret <16 x half> %2
 422 }
 423 declare <16 x half> @llvm.x86.avx512fp16.max.ph.256(<16 x half>, <16 x half>) nounwind readnone
 424
 425 define <16 x half> @stack_fold_maxph_ymm_commutable(<16 x half> %a0, <16 x half> %a1) #1 {
 426 ; CHECK-LABEL: stack_fold_maxph_ymm_commutable:
 427 ; CHECK:       # %bb.0:
 428 ; CHECK-NEXT:    vmovups %ymm1, {{[-0-9]+}}(%r{{[sb]}}p) # 32-byte Spill
 429 ; CHECK-NEXT:    #APP
 430 ; CHECK-NEXT:    nop
 431 ; CHECK-NEXT:    #NO_APP
 432 ; CHECK-NEXT:    vmaxph {{[-0-9]+}}(%r{{[sb]}}p), %ymm0, %ymm0 # 32-byte Folded Reload
 433 ; CHECK-NEXT:    retq
 434   %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}"()
 435   %2 = call <16 x half> @llvm.x86.avx512fp16.max.ph.256(<16 x half> %a0, <16 x half> %a1)
 436   ret <16 x half> %2
 437 }
 438
 439 define <8 x half> @stack_fold_minph(<8 x half> %a0, <8 x half> %a1) #0 {
 440 ; CHECK-LABEL: stack_fold_minph:
 441 ; CHECK:       # %bb.0:
 442 ; CHECK-NEXT:    vmovaps %xmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
 443 ; CHECK-NEXT:    #APP
 444 ; CHECK-NEXT:    nop
 445 ; CHECK-NEXT:    #NO_APP
 446 ; CHECK-NEXT:    vminph {{[-0-9]+}}(%r{{[sb]}}p), %xmm0, %xmm0 # 16-byte Folded Reload
 447 ; CHECK-NEXT:    retq
 448   %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}"()
 449   %2 = call <8 x half> @llvm.x86.avx512fp16.min.ph.128(<8 x half> %a0, <8 x half> %a1)
 450   ret <8 x half> %2
 451 }
 452 declare <8 x half> @llvm.x86.avx512fp16.min.ph.128(<8 x half>, <8 x half>) nounwind readnone
 453
 454 define <8 x half> @stack_fold_minph_commutable(<8 x half> %a0, <8 x half> %a1) #1 {
 455 ; CHECK-LABEL: stack_fold_minph_commutable:
 456 ; CHECK:       # %bb.0:
 457 ; CHECK-NEXT:    vmovaps %xmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
 458 ; CHECK-NEXT:    #APP
 459 ; CHECK-NEXT:    nop
 460 ; CHECK-NEXT:    #NO_APP
 461 ; CHECK-NEXT:    vminph {{[-0-9]+}}(%r{{[sb]}}p), %xmm0, %xmm0 # 16-byte Folded Reload
 462 ; CHECK-NEXT:    retq
 463   %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}"()
 464   %2 = call <8 x half> @llvm.x86.avx512fp16.min.ph.128(<8 x half> %a0, <8 x half> %a1)
 465   ret <8 x half> %2
 466 }
 467
 468 define <16 x half> @stack_fold_minph_ymm(<16 x half> %a0, <16 x half> %a1) #0 {
 469 ; CHECK-LABEL: stack_fold_minph_ymm:
 470 ; CHECK:       # %bb.0:
 471 ; CHECK-NEXT:    vmovups %ymm1, {{[-0-9]+}}(%r{{[sb]}}p) # 32-byte Spill
 472 ; CHECK-NEXT:    #APP
 473 ; CHECK-NEXT:    nop
 474 ; CHECK-NEXT:    #NO_APP
 475 ; CHECK-NEXT:    vminph {{[-0-9]+}}(%r{{[sb]}}p), %ymm0, %ymm0 # 32-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 = call <16 x half> @llvm.x86.avx512fp16.min.ph.256(<16 x half> %a0, <16 x half> %a1)
 479   ret <16 x half> %2
 480 }
 481 declare <16 x half> @llvm.x86.avx512fp16.min.ph.256(<16 x half>, <16 x half>) nounwind readnone
 482
 483 define <16 x half> @stack_fold_minph_ymm_commutable(<16 x half> %a0, <16 x half> %a1) #1 {
 484 ; CHECK-LABEL: stack_fold_minph_ymm_commutable:
 485 ; CHECK:       # %bb.0:
 486 ; CHECK-NEXT:    vmovups %ymm1, {{[-0-9]+}}(%r{{[sb]}}p) # 32-byte Spill
 487 ; CHECK-NEXT:    #APP
 488 ; CHECK-NEXT:    nop
 489 ; CHECK-NEXT:    #NO_APP
 490 ; CHECK-NEXT:    vminph {{[-0-9]+}}(%r{{[sb]}}p), %ymm0, %ymm0 # 32-byte Folded Reload
 491 ; CHECK-NEXT:    retq
 492   %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}"()
 493   %2 = call <16 x half> @llvm.x86.avx512fp16.min.ph.256(<16 x half> %a0, <16 x half> %a1)
 494   ret <16 x half> %2
 495 }
 496
 497 define <8 x half> @stack_fold_mulph(<8 x half> %a0, <8 x half> %a1) {
 498 ; CHECK-LABEL: stack_fold_mulph:
 499 ; CHECK:       # %bb.0:
 500 ; CHECK-NEXT:    vmovaps %xmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
 501 ; CHECK-NEXT:    #APP
 502 ; CHECK-NEXT:    nop
 503 ; CHECK-NEXT:    #NO_APP
 504 ; CHECK-NEXT:    vmulph {{[-0-9]+}}(%r{{[sb]}}p), %xmm0, %xmm0 # 16-byte Folded Reload
 505 ; CHECK-NEXT:    retq
 506   %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}"()
 507   %2 = fmul <8 x half> %a0, %a1
 508   ret <8 x half> %2
 509 }
 510
 511 define <16 x half> @stack_fold_mulph_ymm(<16 x half> %a0, <16 x half> %a1) {
 512 ; CHECK-LABEL: stack_fold_mulph_ymm:
 513 ; CHECK:       # %bb.0:
 514 ; CHECK-NEXT:    vmovups %ymm1, {{[-0-9]+}}(%r{{[sb]}}p) # 32-byte Spill
 515 ; CHECK-NEXT:    #APP
 516 ; CHECK-NEXT:    nop
 517 ; CHECK-NEXT:    #NO_APP
 518 ; CHECK-NEXT:    vmulph {{[-0-9]+}}(%r{{[sb]}}p), %ymm0, %ymm0 # 32-byte Folded Reload
 519 ; CHECK-NEXT:    retq
 520   %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}"()
 521   %2 = fmul <16 x half> %a0, %a1
 522   ret <16 x half> %2
 523 }
 524
 525 define <8 x half> @stack_fold_rcpph(<8 x half> %a0) {
 526 ; CHECK-LABEL: stack_fold_rcpph:
 527 ; CHECK:       # %bb.0:
 528 ; CHECK-NEXT:    vmovaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
 529 ; CHECK-NEXT:    #APP
 530 ; CHECK-NEXT:    nop
 531 ; CHECK-NEXT:    #NO_APP
 532 ; CHECK-NEXT:    vrcpph {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Folded Reload
 533 ; CHECK-NEXT:    retq
 534   %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}"()
 535   %2 = call <8 x half> @llvm.x86.avx512fp16.mask.rcp.ph.128(<8 x half> %a0, <8 x half> undef, i8 -1)
 536   ret <8 x half> %2
 537 }
 538 declare <8 x half> @llvm.x86.avx512fp16.mask.rcp.ph.128(<8 x half>, <8 x half>, i8)
 539
 540 define <8 x half> @stack_fold_rcpph_mask(<8 x half> %a0, ptr %passthru, i8 %mask) {
 541 ; CHECK-LABEL: stack_fold_rcpph_mask:
 542 ; CHECK:       # %bb.0:
 543 ; CHECK-NEXT:    vmovaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
 544 ; CHECK-NEXT:    kmovd %esi, %k1
 545 ; CHECK-NEXT:    #APP
 546 ; CHECK-NEXT:    nop
 547 ; CHECK-NEXT:    #NO_APP
 548 ; CHECK-NEXT:    vmovaps (%rdi), %xmm1
 549 ; CHECK-NEXT:    vrcpph {{[-0-9]+}}(%r{{[sb]}}p), %xmm1 {%k1} # 16-byte Folded Reload
 550 ; CHECK-NEXT:    vmovaps %xmm1, %xmm0
 551 ; CHECK-NEXT:    retq
 552   %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}"()
 553   %2 = load <8 x half>, ptr %passthru
 554   %3 = call <8 x half> @llvm.x86.avx512fp16.mask.rcp.ph.128(<8 x half> %a0, <8 x half> %2, i8 %mask)
 555   ret <8 x half> %3
 556 }
 557
 558 define <8 x half> @stack_fold_rcpph_maskz(<8 x half> %a0, ptr %mask) {
 559 ; CHECK-LABEL: stack_fold_rcpph_maskz:
 560 ; CHECK:       # %bb.0:
 561 ; CHECK-NEXT:    vmovaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
 562 ; CHECK-NEXT:    #APP
 563 ; CHECK-NEXT:    nop
 564 ; CHECK-NEXT:    #NO_APP
 565 ; CHECK-NEXT:    kmovb (%rdi), %k1
 566 ; CHECK-NEXT:    vrcpph {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 {%k1} {z} # 16-byte Folded Reload
 567 ; CHECK-NEXT:    retq
 568   %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}"()
 569   %2 = load i8, ptr %mask
 570   %3 = call <8 x half> @llvm.x86.avx512fp16.mask.rcp.ph.128(<8 x half> %a0, <8 x half> zeroinitializer, i8 %2)
 571   ret <8 x half> %3
 572 }
 573
 574 define <16 x half> @stack_fold_rcpph_ymm(<16 x half> %a0) {
 575 ; CHECK-LABEL: stack_fold_rcpph_ymm:
 576 ; CHECK:       # %bb.0:
 577 ; CHECK-NEXT:    vmovups %ymm0, {{[-0-9]+}}(%r{{[sb]}}p) # 32-byte Spill
 578 ; CHECK-NEXT:    #APP
 579 ; CHECK-NEXT:    nop
 580 ; CHECK-NEXT:    #NO_APP
 581 ; CHECK-NEXT:    vrcpph {{[-0-9]+}}(%r{{[sb]}}p), %ymm0 # 32-byte Folded Reload
 582 ; CHECK-NEXT:    retq
 583   %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}"()
 584   %2 = call <16 x half> @llvm.x86.avx512fp16.mask.rcp.ph.256(<16 x half> %a0, <16 x half> undef, i16 -1)
 585   ret <16 x half> %2
 586 }
 587 declare <16 x half> @llvm.x86.avx512fp16.mask.rcp.ph.256(<16 x half>, <16 x half>, i16)
 588
 589 define <16 x half> @stack_fold_rcpph_mask_ymm(<16 x half> %a0, ptr %passthru, i16 %mask) {
 590 ; CHECK-LABEL: stack_fold_rcpph_mask_ymm:
 591 ; CHECK:       # %bb.0:
 592 ; CHECK-NEXT:    vmovups %ymm0, {{[-0-9]+}}(%r{{[sb]}}p) # 32-byte Spill
 593 ; CHECK-NEXT:    kmovd %esi, %k1
 594 ; CHECK-NEXT:    #APP
 595 ; CHECK-NEXT:    nop
 596 ; CHECK-NEXT:    #NO_APP
 597 ; CHECK-NEXT:    vmovaps (%rdi), %ymm1
 598 ; CHECK-NEXT:    vrcpph {{[-0-9]+}}(%r{{[sb]}}p), %ymm1 {%k1} # 32-byte Folded Reload
 599 ; CHECK-NEXT:    vmovaps %ymm1, %ymm0
 600 ; CHECK-NEXT:    retq
 601   %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}"()
 602   %2 = load <16 x half>, ptr %passthru
 603   %3 = call <16 x half> @llvm.x86.avx512fp16.mask.rcp.ph.256(<16 x half> %a0, <16 x half> %2, i16 %mask)
 604   ret <16 x half> %3
 605 }
 606
 607 define <16 x half> @stack_fold_rcpph_maskz_ymm(<16 x half> %a0, ptr %mask) {
 608 ; CHECK-LABEL: stack_fold_rcpph_maskz_ymm:
 609 ; CHECK:       # %bb.0:
 610 ; CHECK-NEXT:    vmovups %ymm0, {{[-0-9]+}}(%r{{[sb]}}p) # 32-byte Spill
 611 ; CHECK-NEXT:    #APP
 612 ; CHECK-NEXT:    nop
 613 ; CHECK-NEXT:    #NO_APP
 614 ; CHECK-NEXT:    kmovw (%rdi), %k1
 615 ; CHECK-NEXT:    vrcpph {{[-0-9]+}}(%r{{[sb]}}p), %ymm0 {%k1} {z} # 32-byte Folded Reload
 616 ; CHECK-NEXT:    retq
 617   %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}"()
 618   %2 = load i16, ptr %mask
 619   %3 = call <16 x half> @llvm.x86.avx512fp16.mask.rcp.ph.256(<16 x half> %a0, <16 x half> zeroinitializer, i16 %2)
 620   ret <16 x half> %3
 621 }
 622
 623 define <8 x half> @stack_fold_reduceph(<8 x half> %a0) {
 624 ; CHECK-LABEL: stack_fold_reduceph:
 625 ; CHECK:       # %bb.0:
 626 ; CHECK-NEXT:    vmovaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
 627 ; CHECK-NEXT:    #APP
 628 ; CHECK-NEXT:    nop
 629 ; CHECK-NEXT:    #NO_APP
 630 ; CHECK-NEXT:    vreduceph $8, {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Folded Reload
 631 ; CHECK-NEXT:    retq
 632   %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}"()
 633   %2 = call <8 x half> @llvm.x86.avx512fp16.mask.reduce.ph.128(<8 x half> %a0, i32 8, <8 x half> undef, i8 -1)
 634   ret <8 x half> %2
 635 }
 636 declare <8 x half> @llvm.x86.avx512fp16.mask.reduce.ph.128(<8 x half>, i32, <8 x half>, i8)
 637
 638 define <8 x half> @stack_fold_reduceph_mask(<8 x half> %a0, ptr %passthru, i8 %mask) {
 639 ; CHECK-LABEL: stack_fold_reduceph_mask:
 640 ; CHECK:       # %bb.0:
 641 ; CHECK-NEXT:    vmovaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
 642 ; CHECK-NEXT:    kmovd %esi, %k1
 643 ; CHECK-NEXT:    #APP
 644 ; CHECK-NEXT:    nop
 645 ; CHECK-NEXT:    #NO_APP
 646 ; CHECK-NEXT:    vmovaps (%rdi), %xmm1
 647 ; CHECK-NEXT:    vreduceph $8, {{[-0-9]+}}(%r{{[sb]}}p), %xmm1 {%k1} # 16-byte Folded Reload
 648 ; CHECK-NEXT:    vmovaps %xmm1, %xmm0
 649 ; CHECK-NEXT:    retq
 650   %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}"()
 651   %2 = load <8 x half>, ptr %passthru
 652   %3 = call <8 x half> @llvm.x86.avx512fp16.mask.reduce.ph.128(<8 x half> %a0, i32 8, <8 x half> %2, i8 %mask)
 653   ret <8 x half> %3
 654 }
 655
 656 define <8 x half> @stack_fold_reduceph_maskz(<8 x half> %a0, ptr %mask) {
 657 ; CHECK-LABEL: stack_fold_reduceph_maskz:
 658 ; CHECK:       # %bb.0:
 659 ; CHECK-NEXT:    vmovaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
 660 ; CHECK-NEXT:    #APP
 661 ; CHECK-NEXT:    nop
 662 ; CHECK-NEXT:    #NO_APP
 663 ; CHECK-NEXT:    kmovb (%rdi), %k1
 664 ; CHECK-NEXT:    vreduceph $8, {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 {%k1} {z} # 16-byte Folded Reload
 665 ; CHECK-NEXT:    retq
 666   %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}"()
 667   %2 = load i8, ptr %mask
 668   %3 = call <8 x half> @llvm.x86.avx512fp16.mask.reduce.ph.128(<8 x half> %a0, i32 8, <8 x half> zeroinitializer, i8 %2)
 669   ret <8 x half> %3
 670 }
 671
 672 define <16 x half> @stack_fold_reduceph_ymm(<16 x half> %a0) {
 673 ; CHECK-LABEL: stack_fold_reduceph_ymm:
 674 ; CHECK:       # %bb.0:
 675 ; CHECK-NEXT:    vmovups %ymm0, {{[-0-9]+}}(%r{{[sb]}}p) # 32-byte Spill
 676 ; CHECK-NEXT:    #APP
 677 ; CHECK-NEXT:    nop
 678 ; CHECK-NEXT:    #NO_APP
 679 ; CHECK-NEXT:    vreduceph $8, {{[-0-9]+}}(%r{{[sb]}}p), %ymm0 # 32-byte Folded Reload
 680 ; CHECK-NEXT:    retq
 681   %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}"()
 682   %2 = call <16 x half> @llvm.x86.avx512fp16.mask.reduce.ph.256(<16 x half> %a0, i32 8, <16 x half> undef, i16 -1)
 683   ret <16 x half> %2
 684 }
 685 declare <16 x half> @llvm.x86.avx512fp16.mask.reduce.ph.256(<16 x half>, i32, <16 x half>, i16)
 686
 687 define <16 x half> @stack_fold_reduceph_mask_ymm(<16 x half> %a0, ptr %passthru, i16 %mask) {
 688 ; CHECK-LABEL: stack_fold_reduceph_mask_ymm:
 689 ; CHECK:       # %bb.0:
 690 ; CHECK-NEXT:    vmovups %ymm0, {{[-0-9]+}}(%r{{[sb]}}p) # 32-byte Spill
 691 ; CHECK-NEXT:    kmovd %esi, %k1
 692 ; CHECK-NEXT:    #APP
 693 ; CHECK-NEXT:    nop
 694 ; CHECK-NEXT:    #NO_APP
 695 ; CHECK-NEXT:    vmovaps (%rdi), %ymm1
 696 ; CHECK-NEXT:    vreduceph $8, {{[-0-9]+}}(%r{{[sb]}}p), %ymm1 {%k1} # 32-byte Folded Reload
 697 ; CHECK-NEXT:    vmovaps %ymm1, %ymm0
 698 ; CHECK-NEXT:    retq
 699   %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}"()
 700   %2 = load <16 x half>, ptr %passthru
 701   %3 = call <16 x half> @llvm.x86.avx512fp16.mask.reduce.ph.256(<16 x half> %a0, i32 8, <16 x half> %2, i16 %mask)
 702   ret <16 x half> %3
 703 }
 704
 705 define <16 x half> @stack_fold_reduceph_maskz_ymm(<16 x half> %a0, ptr %mask) {
 706 ; CHECK-LABEL: stack_fold_reduceph_maskz_ymm:
 707 ; CHECK:       # %bb.0:
 708 ; CHECK-NEXT:    vmovups %ymm0, {{[-0-9]+}}(%r{{[sb]}}p) # 32-byte Spill
 709 ; CHECK-NEXT:    #APP
 710 ; CHECK-NEXT:    nop
 711 ; CHECK-NEXT:    #NO_APP
 712 ; CHECK-NEXT:    kmovw (%rdi), %k1
 713 ; CHECK-NEXT:    vreduceph $8, {{[-0-9]+}}(%r{{[sb]}}p), %ymm0 {%k1} {z} # 32-byte Folded Reload
 714 ; CHECK-NEXT:    retq
 715   %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}"()
 716   %2 = load i16, ptr %mask
 717   %3 = call <16 x half> @llvm.x86.avx512fp16.mask.reduce.ph.256(<16 x half> %a0, i32 8, <16 x half> zeroinitializer, i16 %2)
 718   ret <16 x half> %3
 719 }
 720
 721 define <8 x half> @stack_fold_rndscaleph(<8 x half> %a0) {
 722 ; CHECK-LABEL: stack_fold_rndscaleph:
 723 ; CHECK:       # %bb.0:
 724 ; CHECK-NEXT:    vmovaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
 725 ; CHECK-NEXT:    #APP
 726 ; CHECK-NEXT:    nop
 727 ; CHECK-NEXT:    #NO_APP
 728 ; CHECK-NEXT:    vrndscaleph $8, {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Folded Reload
 729 ; CHECK-NEXT:    retq
 730   %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}"()
 731   %2 = call <8 x half> @llvm.x86.avx512fp16.mask.rndscale.ph.128(<8 x half> %a0, i32 8, <8 x half> undef, i8 -1)
 732   ret <8 x half> %2
 733 }
 734 declare <8 x half> @llvm.x86.avx512fp16.mask.rndscale.ph.128(<8 x half>, i32, <8 x half>, i8)
 735
 736 define <8 x half> @stack_fold_rndscaleph_mask(<8 x half> %a0, ptr %passthru, i8 %mask) {
 737 ; CHECK-LABEL: stack_fold_rndscaleph_mask:
 738 ; CHECK:       # %bb.0:
 739 ; CHECK-NEXT:    vmovaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
 740 ; CHECK-NEXT:    kmovd %esi, %k1
 741 ; CHECK-NEXT:    #APP
 742 ; CHECK-NEXT:    nop
 743 ; CHECK-NEXT:    #NO_APP
 744 ; CHECK-NEXT:    vmovaps (%rdi), %xmm1
 745 ; CHECK-NEXT:    vrndscaleph $8, {{[-0-9]+}}(%r{{[sb]}}p), %xmm1 {%k1} # 16-byte Folded Reload
 746 ; CHECK-NEXT:    vmovaps %xmm1, %xmm0
 747 ; CHECK-NEXT:    retq
 748   %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}"()
 749   %2 = load <8 x half>, ptr %passthru
 750   %3 = call <8 x half> @llvm.x86.avx512fp16.mask.rndscale.ph.128(<8 x half> %a0, i32 8, <8 x half> %2, i8 %mask)
 751   ret <8 x half> %3
 752 }
 753
 754 define <8 x half> @stack_fold_rndscaleph_maskz(<8 x half> %a0, ptr %mask) {
 755 ; CHECK-LABEL: stack_fold_rndscaleph_maskz:
 756 ; CHECK:       # %bb.0:
 757 ; CHECK-NEXT:    vmovaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
 758 ; CHECK-NEXT:    #APP
 759 ; CHECK-NEXT:    nop
 760 ; CHECK-NEXT:    #NO_APP
 761 ; CHECK-NEXT:    kmovb (%rdi), %k1
 762 ; CHECK-NEXT:    vrndscaleph $8, {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 {%k1} {z} # 16-byte Folded Reload
 763 ; CHECK-NEXT:    retq
 764   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm1},~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
 765   %2 = load i8, ptr %mask
 766   %3 = call <8 x half> @llvm.x86.avx512fp16.mask.rndscale.ph.128(<8 x half> %a0, i32 8, <8 x half> zeroinitializer, i8 %2)
 767   ret <8 x half> %3
 768 }
 769
 770 define <16 x half> @stack_fold_rndscaleph_ymm(<16 x half> %a0) {
 771 ; CHECK-LABEL: stack_fold_rndscaleph_ymm:
 772 ; CHECK:       # %bb.0:
 773 ; CHECK-NEXT:    vmovups %ymm0, {{[-0-9]+}}(%r{{[sb]}}p) # 32-byte Spill
 774 ; CHECK-NEXT:    #APP
 775 ; CHECK-NEXT:    nop
 776 ; CHECK-NEXT:    #NO_APP
 777 ; CHECK-NEXT:    vrndscaleph $8, {{[-0-9]+}}(%r{{[sb]}}p), %ymm0 # 32-byte Folded Reload
 778 ; CHECK-NEXT:    retq
 779   %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}"()
 780   %2 = call <16 x half> @llvm.x86.avx512fp16.mask.rndscale.ph.256(<16 x half> %a0, i32 8, <16 x half> undef, i16 -1)
 781   ret <16 x half> %2
 782 }
 783 declare <16 x half> @llvm.x86.avx512fp16.mask.rndscale.ph.256(<16 x half>, i32, <16 x half>, i16)
 784
 785 define <16 x half> @stack_fold_rndscaleph_mask_ymm(<16 x half> %a0, ptr %passthru, i16 %mask) {
 786 ; CHECK-LABEL: stack_fold_rndscaleph_mask_ymm:
 787 ; CHECK:       # %bb.0:
 788 ; CHECK-NEXT:    vmovups %ymm0, {{[-0-9]+}}(%r{{[sb]}}p) # 32-byte Spill
 789 ; CHECK-NEXT:    kmovd %esi, %k1
 790 ; CHECK-NEXT:    #APP
 791 ; CHECK-NEXT:    nop
 792 ; CHECK-NEXT:    #NO_APP
 793 ; CHECK-NEXT:    vmovaps (%rdi), %ymm1
 794 ; CHECK-NEXT:    vrndscaleph $8, {{[-0-9]+}}(%r{{[sb]}}p), %ymm1 {%k1} # 32-byte Folded Reload
 795 ; CHECK-NEXT:    vmovaps %ymm1, %ymm0
 796 ; CHECK-NEXT:    retq
 797   %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}"()
 798   %2 = load <16 x half>, ptr %passthru
 799   %3 = call <16 x half> @llvm.x86.avx512fp16.mask.rndscale.ph.256(<16 x half> %a0, i32 8, <16 x half> %2, i16 %mask)
 800   ret <16 x half> %3
 801 }
 802
 803 define <16 x half> @stack_fold_rndscaleph_maskz_ymm(<16 x half> %a0, ptr %mask) {
 804 ; CHECK-LABEL: stack_fold_rndscaleph_maskz_ymm:
 805 ; CHECK:       # %bb.0:
 806 ; CHECK-NEXT:    vmovups %ymm0, {{[-0-9]+}}(%r{{[sb]}}p) # 32-byte Spill
 807 ; CHECK-NEXT:    #APP
 808 ; CHECK-NEXT:    nop
 809 ; CHECK-NEXT:    #NO_APP
 810 ; CHECK-NEXT:    kmovw (%rdi), %k1
 811 ; CHECK-NEXT:    vrndscaleph $8, {{[-0-9]+}}(%r{{[sb]}}p), %ymm0 {%k1} {z} # 32-byte Folded Reload
 812 ; CHECK-NEXT:    retq
 813   %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}"()
 814   %2 = load i16, ptr %mask
 815   %3 = call <16 x half> @llvm.x86.avx512fp16.mask.rndscale.ph.256(<16 x half> %a0, i32 8, <16 x half> zeroinitializer, i16 %2)
 816   ret <16 x half> %3
 817 }
 818
 819 define <8 x half> @stack_fold_rsqrtph(<8 x half> %a0) {
 820 ; CHECK-LABEL: stack_fold_rsqrtph:
 821 ; CHECK:       # %bb.0:
 822 ; CHECK-NEXT:    vmovaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
 823 ; CHECK-NEXT:    #APP
 824 ; CHECK-NEXT:    nop
 825 ; CHECK-NEXT:    #NO_APP
 826 ; CHECK-NEXT:    vrsqrtph {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Folded Reload
 827 ; CHECK-NEXT:    retq
 828   %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}"()
 829   %2 = call <8 x half> @llvm.x86.avx512fp16.mask.rsqrt.ph.128(<8 x half> %a0, <8 x half> undef, i8 -1)
 830   ret <8 x half> %2
 831 }
 832 declare <8 x half> @llvm.x86.avx512fp16.mask.rsqrt.ph.128(<8 x half>, <8 x half>, i8)
 833
 834 define <8 x half> @stack_fold_rsqrtph_mask(<8 x half> %a0, ptr %passthru, i8 %mask) {
 835 ; CHECK-LABEL: stack_fold_rsqrtph_mask:
 836 ; CHECK:       # %bb.0:
 837 ; CHECK-NEXT:    vmovaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
 838 ; CHECK-NEXT:    kmovd %esi, %k1
 839 ; CHECK-NEXT:    #APP
 840 ; CHECK-NEXT:    nop
 841 ; CHECK-NEXT:    #NO_APP
 842 ; CHECK-NEXT:    vmovaps (%rdi), %xmm1
 843 ; CHECK-NEXT:    vrsqrtph {{[-0-9]+}}(%r{{[sb]}}p), %xmm1 {%k1} # 16-byte Folded Reload
 844 ; CHECK-NEXT:    vmovaps %xmm1, %xmm0
 845 ; CHECK-NEXT:    retq
 846   %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}"()
 847   %2 = load <8 x half>, ptr %passthru
 848   %3 = call <8 x half> @llvm.x86.avx512fp16.mask.rsqrt.ph.128(<8 x half> %a0, <8 x half> %2, i8 %mask)
 849   ret <8 x half> %3
 850 }
 851
 852 define <8 x half> @stack_fold_rsqrtph_maskz(<8 x half> %a0, ptr %mask) {
 853 ; CHECK-LABEL: stack_fold_rsqrtph_maskz:
 854 ; CHECK:       # %bb.0:
 855 ; CHECK-NEXT:    vmovaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
 856 ; CHECK-NEXT:    #APP
 857 ; CHECK-NEXT:    nop
 858 ; CHECK-NEXT:    #NO_APP
 859 ; CHECK-NEXT:    kmovb (%rdi), %k1
 860 ; CHECK-NEXT:    vrsqrtph {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 {%k1} {z} # 16-byte Folded Reload
 861 ; CHECK-NEXT:    retq
 862   %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}"()
 863   %2 = load i8, ptr %mask
 864   %3 = call <8 x half> @llvm.x86.avx512fp16.mask.rsqrt.ph.128(<8 x half> %a0, <8 x half> zeroinitializer, i8 %2)
 865   ret <8 x half> %3
 866 }
 867
 868 define <16 x half> @stack_fold_rsqrtph_ymm(<16 x half> %a0) {
 869 ; CHECK-LABEL: stack_fold_rsqrtph_ymm:
 870 ; CHECK:       # %bb.0:
 871 ; CHECK-NEXT:    vmovups %ymm0, {{[-0-9]+}}(%r{{[sb]}}p) # 32-byte Spill
 872 ; CHECK-NEXT:    #APP
 873 ; CHECK-NEXT:    nop
 874 ; CHECK-NEXT:    #NO_APP
 875 ; CHECK-NEXT:    vrsqrtph {{[-0-9]+}}(%r{{[sb]}}p), %ymm0 # 32-byte Folded Reload
 876 ; CHECK-NEXT:    retq
 877   %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}"()
 878   %2 = call <16 x half> @llvm.x86.avx512fp16.mask.rsqrt.ph.256(<16 x half> %a0, <16 x half> undef, i16 -1)
 879   ret <16 x half> %2
 880 }
 881 declare <16 x half> @llvm.x86.avx512fp16.mask.rsqrt.ph.256(<16 x half>, <16 x half>, i16)
 882
 883 define <16 x half> @stack_fold_rsqrtph_mask_ymm(<16 x half> %a0, ptr %passthru, i16 %mask) {
 884 ; CHECK-LABEL: stack_fold_rsqrtph_mask_ymm:
 885 ; CHECK:       # %bb.0:
 886 ; CHECK-NEXT:    vmovups %ymm0, {{[-0-9]+}}(%r{{[sb]}}p) # 32-byte Spill
 887 ; CHECK-NEXT:    kmovd %esi, %k1
 888 ; CHECK-NEXT:    #APP
 889 ; CHECK-NEXT:    nop
 890 ; CHECK-NEXT:    #NO_APP
 891 ; CHECK-NEXT:    vmovaps (%rdi), %ymm1
 892 ; CHECK-NEXT:    vrsqrtph {{[-0-9]+}}(%r{{[sb]}}p), %ymm1 {%k1} # 32-byte Folded Reload
 893 ; CHECK-NEXT:    vmovaps %ymm1, %ymm0
 894 ; CHECK-NEXT:    retq
 895   %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}"()
 896   %2 = load <16 x half>, ptr %passthru
 897   %3 = call <16 x half> @llvm.x86.avx512fp16.mask.rsqrt.ph.256(<16 x half> %a0, <16 x half> %2, i16 %mask)
 898   ret <16 x half> %3
 899 }
 900
 901 define <16 x half> @stack_fold_rsqrtph_maskz_ymm(<16 x half> %a0, ptr %mask) {
 902 ; CHECK-LABEL: stack_fold_rsqrtph_maskz_ymm:
 903 ; CHECK:       # %bb.0:
 904 ; CHECK-NEXT:    vmovups %ymm0, {{[-0-9]+}}(%r{{[sb]}}p) # 32-byte Spill
 905 ; CHECK-NEXT:    #APP
 906 ; CHECK-NEXT:    nop
 907 ; CHECK-NEXT:    #NO_APP
 908 ; CHECK-NEXT:    kmovw (%rdi), %k1
 909 ; CHECK-NEXT:    vrsqrtph {{[-0-9]+}}(%r{{[sb]}}p), %ymm0 {%k1} {z} # 32-byte Folded Reload
 910 ; CHECK-NEXT:    retq
 911   %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}"()
 912   %2 = load i16, ptr %mask
 913   %3 = call <16 x half> @llvm.x86.avx512fp16.mask.rsqrt.ph.256(<16 x half> %a0, <16 x half> zeroinitializer, i16 %2)
 914   ret <16 x half> %3
 915 }
 916
 917 define <8 x half> @stack_fold_sqrtph(<8 x half> %a0) {
 918 ; CHECK-LABEL: stack_fold_sqrtph:
 919 ; CHECK:       # %bb.0:
 920 ; CHECK-NEXT:    vmovaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
 921 ; CHECK-NEXT:    #APP
 922 ; CHECK-NEXT:    nop
 923 ; CHECK-NEXT:    #NO_APP
 924 ; CHECK-NEXT:    vsqrtph {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 # 16-byte Folded Reload
 925 ; CHECK-NEXT:    retq
 926   %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}"()
 927   %2 = call <8 x half> @llvm.sqrt.v8f16(<8 x half> %a0)
 928   ret <8 x half> %2
 929 }
 930 declare <8 x half> @llvm.sqrt.v8f16(<8 x half>)
 931
 932 define <8 x half> @stack_fold_sqrtph_mask(<8 x half> %a0, ptr %passthru, i8 %mask) {
 933 ; CHECK-LABEL: stack_fold_sqrtph_mask:
 934 ; CHECK:       # %bb.0:
 935 ; CHECK-NEXT:    vmovaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
 936 ; CHECK-NEXT:    #APP
 937 ; CHECK-NEXT:    nop
 938 ; CHECK-NEXT:    #NO_APP
 939 ; CHECK-NEXT:    vmovaps (%rdi), %xmm1
 940 ; CHECK-NEXT:    kmovd %esi, %k1
 941 ; CHECK-NEXT:    vsqrtph {{[-0-9]+}}(%r{{[sb]}}p), %xmm1 {%k1} # 16-byte Folded Reload
 942 ; CHECK-NEXT:    vmovaps %xmm1, %xmm0
 943 ; CHECK-NEXT:    retq
 944   %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}"()
 945   %2 = load <8 x half>, ptr %passthru
 946   %3 = call <8 x half> @llvm.sqrt.v8f16(<8 x half> %a0)
 947   %4 = bitcast i8 %mask to <8 x i1>
 948   %5 = select <8 x i1> %4, <8 x half> %3, <8 x half> %2
 949   ret <8 x half> %5
 950 }
 951
 952 define <8 x half> @stack_fold_sqrtph_maskz(<8 x half> %a0, ptr %mask) {
 953 ; CHECK-LABEL: stack_fold_sqrtph_maskz:
 954 ; CHECK:       # %bb.0:
 955 ; CHECK-NEXT:    vmovaps %xmm0, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
 956 ; CHECK-NEXT:    #APP
 957 ; CHECK-NEXT:    nop
 958 ; CHECK-NEXT:    #NO_APP
 959 ; CHECK-NEXT:    kmovb (%rdi), %k1
 960 ; CHECK-NEXT:    vsqrtph {{[-0-9]+}}(%r{{[sb]}}p), %xmm0 {%k1} {z} # 16-byte Folded Reload
 961 ; CHECK-NEXT:    retq
 962   %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}"()
 963   %2 = load i8, ptr %mask
 964   %3 = call <8 x half> @llvm.sqrt.v8f16(<8 x half> %a0)
 965   %4 = bitcast i8 %2 to <8 x i1>
 966   %5 = select <8 x i1> %4, <8 x half> %3, <8 x half> zeroinitializer
 967   ret <8 x half> %5
 968 }
 969
 970 define <16 x half> @stack_fold_sqrtph_ymm(<16 x half> %a0) {
 971 ; CHECK-LABEL: stack_fold_sqrtph_ymm:
 972 ; CHECK:       # %bb.0:
 973 ; CHECK-NEXT:    vmovups %ymm0, {{[-0-9]+}}(%r{{[sb]}}p) # 32-byte Spill
 974 ; CHECK-NEXT:    #APP
 975 ; CHECK-NEXT:    nop
 976 ; CHECK-NEXT:    #NO_APP
 977 ; CHECK-NEXT:    vsqrtph {{[-0-9]+}}(%r{{[sb]}}p), %ymm0 # 32-byte Folded Reload
 978 ; CHECK-NEXT:    retq
 979   %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}"()
 980   %2 = call <16 x half> @llvm.sqrt.v16f16(<16 x half> %a0)
 981   ret <16 x half> %2
 982 }
 983 declare <16 x half> @llvm.sqrt.v16f16(<16 x half>)
 984
 985 define <16 x half> @stack_fold_sqrtph_mask_ymm(<16 x half> %a0, ptr %passthru, i16 %mask) {
 986 ; CHECK-LABEL: stack_fold_sqrtph_mask_ymm:
 987 ; CHECK:       # %bb.0:
 988 ; CHECK-NEXT:    vmovups %ymm0, {{[-0-9]+}}(%r{{[sb]}}p) # 32-byte Spill
 989 ; CHECK-NEXT:    #APP
 990 ; CHECK-NEXT:    nop
 991 ; CHECK-NEXT:    #NO_APP
 992 ; CHECK-NEXT:    vmovaps (%rdi), %ymm1
 993 ; CHECK-NEXT:    kmovd %esi, %k1
 994 ; CHECK-NEXT:    vsqrtph {{[-0-9]+}}(%r{{[sb]}}p), %ymm1 {%k1} # 32-byte Folded Reload
 995 ; CHECK-NEXT:    vmovaps %ymm1, %ymm0
 996 ; CHECK-NEXT:    retq
 997   %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}"()
 998   %2 = load <16 x half>, ptr %passthru
 999   %3 = call <16 x half> @llvm.sqrt.v16f16(<16 x half> %a0)
1000   %4 = bitcast i16 %mask to <16 x i1>
1001   %5 = select <16 x i1> %4, <16 x half> %3, <16 x half> %2
1002   ret <16 x half> %5
1003 }
1004
1005 define <16 x half> @stack_fold_sqrtph_maskz_ymm(<16 x half> %a0, ptr %mask) {
1006 ; CHECK-LABEL: stack_fold_sqrtph_maskz_ymm:
1007 ; CHECK:       # %bb.0:
1008 ; CHECK-NEXT:    vmovups %ymm0, {{[-0-9]+}}(%r{{[sb]}}p) # 32-byte Spill
1009 ; CHECK-NEXT:    #APP
1010 ; CHECK-NEXT:    nop
1011 ; CHECK-NEXT:    #NO_APP
1012 ; CHECK-NEXT:    kmovw (%rdi), %k1
1013 ; CHECK-NEXT:    vsqrtph {{[-0-9]+}}(%r{{[sb]}}p), %ymm0 {%k1} {z} # 32-byte Folded Reload
1014 ; CHECK-NEXT:    retq
1015   %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}"()
1016   %2 = load i16, ptr %mask
1017   %3 = call <16 x half> @llvm.sqrt.v16f16(<16 x half> %a0)
1018   %4 = bitcast i16 %2 to <16 x i1>
1019   %5 = select <16 x i1> %4, <16 x half> %3, <16 x half> zeroinitializer
1020   ret <16 x half> %5
1021 }
1022
1023 define <8 x half> @stack_fold_subph(<8 x half> %a0, <8 x half> %a1) {
1024 ; CHECK-LABEL: stack_fold_subph:
1025 ; CHECK:       # %bb.0:
1026 ; CHECK-NEXT:    vmovaps %xmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
1027 ; CHECK-NEXT:    #APP
1028 ; CHECK-NEXT:    nop
1029 ; CHECK-NEXT:    #NO_APP
1030 ; CHECK-NEXT:    vsubph {{[-0-9]+}}(%r{{[sb]}}p), %xmm0, %xmm0 # 16-byte Folded Reload
1031 ; CHECK-NEXT:    retq
1032   %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}"()
1033   %2 = fsub <8 x half> %a0, %a1
1034   ret <8 x half> %2
1035 }
1036
1037 define <16 x half> @stack_fold_subph_ymm(<16 x half> %a0, <16 x half> %a1) {
1038 ; CHECK-LABEL: stack_fold_subph_ymm:
1039 ; CHECK:       # %bb.0:
1040 ; CHECK-NEXT:    vmovups %ymm1, {{[-0-9]+}}(%r{{[sb]}}p) # 32-byte Spill
1041 ; CHECK-NEXT:    #APP
1042 ; CHECK-NEXT:    nop
1043 ; CHECK-NEXT:    #NO_APP
1044 ; CHECK-NEXT:    vsubph {{[-0-9]+}}(%r{{[sb]}}p), %ymm0, %ymm0 # 32-byte Folded Reload
1045 ; CHECK-NEXT:    retq
1046   %1 = tail call <2 x i64> asm sideeffect "nop", "=x,~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{flags}"()
1047   %2 = fsub <16 x half> %a0, %a1
1048   ret <16 x half> %2
1049 }
1050
1051 define <4 x float> @stack_fold_fmulc(<4 x float> %a0, <4 x float> %a1) {
1052 ; CHECK-LABEL: stack_fold_fmulc:
1053 ; CHECK:       # %bb.0:
1054 ; CHECK-NEXT:    vmovaps %xmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
1055 ; CHECK-NEXT:    #APP
1056 ; CHECK-NEXT:    nop
1057 ; CHECK-NEXT:    #NO_APP
1058 ; CHECK-NEXT:    vfmulcph {{[-0-9]+}}(%r{{[sb]}}p), %xmm0, %xmm2 # 16-byte Folded Reload
1059 ; CHECK-NEXT:    vmovaps %xmm2, %xmm0
1060 ; CHECK-NEXT:    retq
1061   %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}"()
1062   %2 = call <4 x float> @llvm.x86.avx512fp16.mask.vfmul.cph.128(<4 x float> %a0, <4 x float> %a1, <4 x float> undef, i8 -1)
1063   ret <4 x float> %2
1064 }
1065 declare <4 x float> @llvm.x86.avx512fp16.mask.vfmul.cph.128(<4 x float>, <4 x float>, <4 x float>, i8)
1066
1067 define <4 x float> @stack_fold_fmulc_mask(<4 x float> %a0, <4 x float> %a1, ptr %passthru, i8 %mask) {
1068 ; CHECK-LABEL: stack_fold_fmulc_mask:
1069 ; CHECK:       # %bb.0:
1070 ; CHECK-NEXT:    vmovaps %xmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
1071 ; CHECK-NEXT:    kmovd %esi, %k1
1072 ; CHECK-NEXT:    #APP
1073 ; CHECK-NEXT:    nop
1074 ; CHECK-NEXT:    #NO_APP
1075 ; CHECK-NEXT:    vmovaps (%rdi), %xmm2
1076 ; CHECK-NEXT:    vfmulcph {{[-0-9]+}}(%r{{[sb]}}p), %xmm0, %xmm2 {%k1} # 16-byte Folded Reload
1077 ; CHECK-NEXT:    vmovaps %xmm2, %xmm0
1078 ; CHECK-NEXT:    retq
1079   %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}"()
1080   %2 = load <4 x float>, ptr %passthru
1081   %3 = call <4 x float> @llvm.x86.avx512fp16.mask.vfmul.cph.128(<4 x float> %a0, <4 x float> %a1, <4 x float> %2, i8 %mask)
1082   ret <4 x float> %3
1083 }
1084
1085 define <4 x float> @stack_fold_fmulc_maskz(<4 x float> %a0, <4 x float> %a1, ptr %mask) {
1086 ; CHECK-LABEL: stack_fold_fmulc_maskz:
1087 ; CHECK:       # %bb.0:
1088 ; CHECK-NEXT:    vmovaps %xmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
1089 ; CHECK-NEXT:    #APP
1090 ; CHECK-NEXT:    nop
1091 ; CHECK-NEXT:    #NO_APP
1092 ; CHECK-NEXT:    kmovb (%rdi), %k1
1093 ; CHECK-NEXT:    vfmulcph {{[-0-9]+}}(%r{{[sb]}}p), %xmm0, %xmm2 {%k1} {z} # 16-byte Folded Reload
1094 ; CHECK-NEXT:    vmovaps %xmm2, %xmm0
1095 ; CHECK-NEXT:    retq
1096   %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}"()
1097   %2 = load i8, ptr %mask
1098   %3 = call <4 x float> @llvm.x86.avx512fp16.mask.vfmul.cph.128(<4 x float> %a0, <4 x float> %a1, <4 x float> zeroinitializer, i8 %2)
1099   ret <4 x float> %3
1100 }
1101
1102 define <4 x float> @stack_fold_fcmulc(<4 x float> %a0, <4 x float> %a1) {
1103 ; CHECK-LABEL: stack_fold_fcmulc:
1104 ; CHECK:       # %bb.0:
1105 ; CHECK-NEXT:    vmovaps %xmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
1106 ; CHECK-NEXT:    #APP
1107 ; CHECK-NEXT:    nop
1108 ; CHECK-NEXT:    #NO_APP
1109 ; CHECK-NEXT:    vfcmulcph {{[-0-9]+}}(%r{{[sb]}}p), %xmm0, %xmm2 # 16-byte Folded Reload
1110 ; CHECK-NEXT:    vmovaps %xmm2, %xmm0
1111 ; CHECK-NEXT:    retq
1112   %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}"()
1113   %2 = call <4 x float> @llvm.x86.avx512fp16.mask.vfcmul.cph.128(<4 x float> %a0, <4 x float> %a1, <4 x float> undef, i8 -1)
1114   ret <4 x float> %2
1115 }
1116 declare <4 x float> @llvm.x86.avx512fp16.mask.vfcmul.cph.128(<4 x float>, <4 x float>, <4 x float>, i8)
1117
1118 define <4 x float> @stack_fold_fcmulc_mask(<4 x float> %a0, <4 x float> %a1, ptr %passthru, i8 %mask) {
1119 ; CHECK-LABEL: stack_fold_fcmulc_mask:
1120 ; CHECK:       # %bb.0:
1121 ; CHECK-NEXT:    vmovaps %xmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
1122 ; CHECK-NEXT:    kmovd %esi, %k1
1123 ; CHECK-NEXT:    #APP
1124 ; CHECK-NEXT:    nop
1125 ; CHECK-NEXT:    #NO_APP
1126 ; CHECK-NEXT:    vmovaps (%rdi), %xmm2
1127 ; CHECK-NEXT:    vfcmulcph {{[-0-9]+}}(%r{{[sb]}}p), %xmm0, %xmm2 {%k1} # 16-byte Folded Reload
1128 ; CHECK-NEXT:    vmovaps %xmm2, %xmm0
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 = load <4 x float>, ptr %passthru
1132   %3 = call <4 x float> @llvm.x86.avx512fp16.mask.vfcmul.cph.128(<4 x float> %a0, <4 x float> %a1, <4 x float> %2, i8 %mask)
1133   ret <4 x float> %3
1134 }
1135
1136 define <4 x float> @stack_fold_fcmulc_maskz(<4 x float> %a0, <4 x float> %a1, ptr %mask) {
1137 ; CHECK-LABEL: stack_fold_fcmulc_maskz:
1138 ; CHECK:       # %bb.0:
1139 ; CHECK-NEXT:    vmovaps %xmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
1140 ; CHECK-NEXT:    #APP
1141 ; CHECK-NEXT:    nop
1142 ; CHECK-NEXT:    #NO_APP
1143 ; CHECK-NEXT:    kmovb (%rdi), %k1
1144 ; CHECK-NEXT:    vfcmulcph {{[-0-9]+}}(%r{{[sb]}}p), %xmm0, %xmm2 {%k1} {z} # 16-byte Folded Reload
1145 ; CHECK-NEXT:    vmovaps %xmm2, %xmm0
1146 ; CHECK-NEXT:    retq
1147   %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}"()
1148   %2 = load i8, ptr %mask
1149   %3 = call <4 x float> @llvm.x86.avx512fp16.mask.vfcmul.cph.128(<4 x float> %a0, <4 x float> %a1, <4 x float> zeroinitializer, i8 %2)
1150   ret <4 x float> %3
1151 }
1152
1153 define <4 x float> @stack_fold_fmaddc(<4 x float> %a0, <4 x float> %a1, <4 x float> %a2) {
1154 ; CHECK-LABEL: stack_fold_fmaddc:
1155 ; CHECK:       # %bb.0:
1156 ; CHECK-NEXT:    vmovaps %xmm2, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
1157 ; CHECK-NEXT:    #APP
1158 ; CHECK-NEXT:    nop
1159 ; CHECK-NEXT:    #NO_APP
1160 ; CHECK-NEXT:    vfmaddcph {{[-0-9]+}}(%r{{[sb]}}p), %xmm1, %xmm0 # 16-byte Folded Reload
1161 ; CHECK-NEXT:    retq
1162   %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}"()
1163   %2 = call <4 x float> @llvm.x86.avx512fp16.mask.vfmadd.cph.128(<4 x float> %a1, <4 x float> %a2, <4 x float> %a0, i8 -1)
1164   ret <4 x float> %2
1165 }
1166 declare <4 x float> @llvm.x86.avx512fp16.mask.vfmadd.cph.128(<4 x float>, <4 x float>, <4 x float>, i8)
1167
1168 define <4 x float> @stack_fold_fmaddc_mask(ptr %p, <4 x float> %a1, <4 x float> %a2, i8 %mask) {
1169 ; CHECK-LABEL: stack_fold_fmaddc_mask:
1170 ; CHECK:       # %bb.0:
1171 ; CHECK-NEXT:    vmovaps %xmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
1172 ; CHECK-NEXT:    kmovd %esi, %k1
1173 ; CHECK-NEXT:    #APP
1174 ; CHECK-NEXT:    nop
1175 ; CHECK-NEXT:    #NO_APP
1176 ; CHECK-NEXT:    vmovaps (%rdi), %xmm2
1177 ; CHECK-NEXT:    vfmaddcph {{[-0-9]+}}(%r{{[sb]}}p), %xmm0, %xmm2 {%k1} # 16-byte Folded Reload
1178 ; CHECK-NEXT:    vmovaps %xmm2, %xmm0
1179 ; CHECK-NEXT:    retq
1180   %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}"()
1181   %a0 = load <4 x float>, ptr %p
1182   %2 = call <4 x float> @llvm.x86.avx512fp16.mask.vfmadd.cph.128(<4 x float> %a1, <4 x float> %a2, <4 x float> %a0, i8 %mask)
1183   ret <4 x float> %2
1184 }
1185
1186 define <4 x float> @stack_fold_fmaddc_maskz(<4 x float> %a0, <4 x float> %a1, <4 x float> %a2, ptr %mask) {
1187 ; CHECK-LABEL: stack_fold_fmaddc_maskz:
1188 ; CHECK:       # %bb.0:
1189 ; CHECK-NEXT:    vmovaps %xmm2, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
1190 ; CHECK-NEXT:    #APP
1191 ; CHECK-NEXT:    nop
1192 ; CHECK-NEXT:    #NO_APP
1193 ; CHECK-NEXT:    kmovb (%rdi), %k1
1194 ; CHECK-NEXT:    vxorps %xmm0, %xmm0, %xmm0
1195 ; CHECK-NEXT:    vfmaddcph {{[-0-9]+}}(%r{{[sb]}}p), %xmm1, %xmm0 {%k1} {z} # 16-byte Folded Reload
1196 ; CHECK-NEXT:    retq
1197   %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}"()
1198   %2 = load i8, ptr %mask
1199   %3 = call <4 x float> @llvm.x86.avx512fp16.mask.vfmadd.cph.128(<4 x float> %a1, <4 x float> %a2, <4 x float> zeroinitializer, i8 %2)
1200   ret <4 x float> %3
1201 }
1202 declare <4 x float> @llvm.x86.avx512fp16.maskz.vfmadd.cph.128(<4 x float>, <4 x float>, <4 x float>, i8)
1203
1204 define <4 x float> @stack_fold_fcmaddc(<4 x float> %a0, <4 x float> %a1, <4 x float> %a2) {
1205 ; CHECK-LABEL: stack_fold_fcmaddc:
1206 ; CHECK:       # %bb.0:
1207 ; CHECK-NEXT:    vmovaps %xmm2, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
1208 ; CHECK-NEXT:    #APP
1209 ; CHECK-NEXT:    nop
1210 ; CHECK-NEXT:    #NO_APP
1211 ; CHECK-NEXT:    vfcmaddcph {{[-0-9]+}}(%r{{[sb]}}p), %xmm1, %xmm0 # 16-byte Folded Reload
1212 ; CHECK-NEXT:    retq
1213   %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}"()
1214   %2 = call <4 x float> @llvm.x86.avx512fp16.mask.vfcmadd.cph.128(<4 x float> %a1, <4 x float> %a2, <4 x float> %a0, i8 -1)
1215   ret <4 x float> %2
1216 }
1217 declare <4 x float> @llvm.x86.avx512fp16.mask.vfcmadd.cph.128(<4 x float>, <4 x float>, <4 x float>, i8)
1218
1219 define <4 x float> @stack_fold_fcmaddc_mask(ptr %p, <4 x float> %a1, <4 x float> %a2, i8 %mask) {
1220 ; CHECK-LABEL: stack_fold_fcmaddc_mask:
1221 ; CHECK:       # %bb.0:
1222 ; CHECK-NEXT:    vmovaps %xmm1, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
1223 ; CHECK-NEXT:    kmovd %esi, %k1
1224 ; CHECK-NEXT:    #APP
1225 ; CHECK-NEXT:    nop
1226 ; CHECK-NEXT:    #NO_APP
1227 ; CHECK-NEXT:    vmovaps (%rdi), %xmm2
1228 ; CHECK-NEXT:    vfcmaddcph {{[-0-9]+}}(%r{{[sb]}}p), %xmm0, %xmm2 {%k1} # 16-byte Folded Reload
1229 ; CHECK-NEXT:    vmovaps %xmm2, %xmm0
1230 ; CHECK-NEXT:    retq
1231   %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}"()
1232   %a0 = load <4 x float>, ptr %p
1233   %2 = call <4 x float> @llvm.x86.avx512fp16.mask.vfcmadd.cph.128(<4 x float> %a1, <4 x float> %a2, <4 x float> %a0, i8 %mask)
1234   ret <4 x float> %2
1235 }
1236
1237 define <4 x float> @stack_fold_fcmaddc_maskz(<4 x float> %a0, <4 x float> %a1, <4 x float> %a2, ptr %mask) {
1238 ; CHECK-LABEL: stack_fold_fcmaddc_maskz:
1239 ; CHECK:       # %bb.0:
1240 ; CHECK-NEXT:    vmovaps %xmm2, {{[-0-9]+}}(%r{{[sb]}}p) # 16-byte Spill
1241 ; CHECK-NEXT:    #APP
1242 ; CHECK-NEXT:    nop
1243 ; CHECK-NEXT:    #NO_APP
1244 ; CHECK-NEXT:    kmovb (%rdi), %k1
1245 ; CHECK-NEXT:    vxorps %xmm0, %xmm0, %xmm0
1246 ; CHECK-NEXT:    vfcmaddcph {{[-0-9]+}}(%r{{[sb]}}p), %xmm1, %xmm0 {%k1} {z} # 16-byte Folded Reload
1247 ; CHECK-NEXT:    retq
1248   %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}"()
1249   %2 = load i8, ptr %mask
1250   %3 = call <4 x float> @llvm.x86.avx512fp16.mask.vfcmadd.cph.128(<4 x float> %a1, <4 x float> %a2, <4 x float> zeroinitializer, i8 %2)
1251   ret <4 x float> %3
1252 }
1253 declare <4 x float> @llvm.x86.avx512fp16.maskz.vfcmadd.cph.128(<4 x float>, <4 x float>, <4 x float>, i8)
1254
1255 define <8 x float> @stack_fold_fmulc_ymm(<8 x float> %a0, <8 x float> %a1) {
1256 ; CHECK-LABEL: stack_fold_fmulc_ymm:
1257 ; CHECK:       # %bb.0:
1258 ; CHECK-NEXT:    vmovups %ymm1, {{[-0-9]+}}(%r{{[sb]}}p) # 32-byte Spill
1259 ; CHECK-NEXT:    #APP
1260 ; CHECK-NEXT:    nop
1261 ; CHECK-NEXT:    #NO_APP
1262 ; CHECK-NEXT:    vfmulcph {{[-0-9]+}}(%r{{[sb]}}p), %ymm0, %ymm2 # 32-byte Folded Reload
1263 ; CHECK-NEXT:    vmovaps %ymm2, %ymm0
1264 ; CHECK-NEXT:    retq
1265   %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}"()
1266   %2 = call <8 x float> @llvm.x86.avx512fp16.mask.vfmul.cph.256(<8 x float> %a0, <8 x float> %a1, <8 x float> undef, i8 -1)
1267   ret <8 x float> %2
1268 }
1269 declare <8 x float> @llvm.x86.avx512fp16.mask.vfmul.cph.256(<8 x float>, <8 x float>, <8 x float>, i8)
1270
1271 define <8 x float> @stack_fold_fmulc_mask_ymm(<8 x float> %a0, <8 x float> %a1, ptr %passthru, i8 %mask) {
1272 ; CHECK-LABEL: stack_fold_fmulc_mask_ymm:
1273 ; CHECK:       # %bb.0:
1274 ; CHECK-NEXT:    vmovups %ymm1, {{[-0-9]+}}(%r{{[sb]}}p) # 32-byte Spill
1275 ; CHECK-NEXT:    kmovd %esi, %k1
1276 ; CHECK-NEXT:    #APP
1277 ; CHECK-NEXT:    nop
1278 ; CHECK-NEXT:    #NO_APP
1279 ; CHECK-NEXT:    vmovaps (%rdi), %ymm2
1280 ; CHECK-NEXT:    vfmulcph {{[-0-9]+}}(%r{{[sb]}}p), %ymm0, %ymm2 {%k1} # 32-byte Folded Reload
1281 ; CHECK-NEXT:    vmovaps %ymm2, %ymm0
1282 ; CHECK-NEXT:    retq
1283   %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}"()
1284   %2 = load <8 x float>, ptr %passthru
1285   %3 = call <8 x float> @llvm.x86.avx512fp16.mask.vfmul.cph.256(<8 x float> %a0, <8 x float> %a1, <8 x float> %2, i8 %mask)
1286   ret <8 x float> %3
1287 }
1288
1289 define <8 x float> @stack_fold_fmulc_maskz_ymm(<8 x float> %a0, <8 x float> %a1, ptr %mask) {
1290 ; CHECK-LABEL: stack_fold_fmulc_maskz_ymm:
1291 ; CHECK:       # %bb.0:
1292 ; CHECK-NEXT:    vmovups %ymm1, {{[-0-9]+}}(%r{{[sb]}}p) # 32-byte Spill
1293 ; CHECK-NEXT:    #APP
1294 ; CHECK-NEXT:    nop
1295 ; CHECK-NEXT:    #NO_APP
1296 ; CHECK-NEXT:    kmovb (%rdi), %k1
1297 ; CHECK-NEXT:    vfmulcph {{[-0-9]+}}(%r{{[sb]}}p), %ymm0, %ymm2 {%k1} {z} # 32-byte Folded Reload
1298 ; CHECK-NEXT:    vmovaps %ymm2, %ymm0
1299 ; CHECK-NEXT:    retq
1300   %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}"()
1301   %2 = load i8, ptr %mask
1302   %3 = call <8 x float> @llvm.x86.avx512fp16.mask.vfmul.cph.256(<8 x float> %a0, <8 x float> %a1, <8 x float> zeroinitializer, i8 %2)
1303   ret <8 x float> %3
1304 }
1305
1306 define <8 x float> @stack_fold_fcmulc_ymm(<8 x float> %a0, <8 x float> %a1) {
1307 ; CHECK-LABEL: stack_fold_fcmulc_ymm:
1308 ; CHECK:       # %bb.0:
1309 ; CHECK-NEXT:    vmovups %ymm1, {{[-0-9]+}}(%r{{[sb]}}p) # 32-byte Spill
1310 ; CHECK-NEXT:    #APP
1311 ; CHECK-NEXT:    nop
1312 ; CHECK-NEXT:    #NO_APP
1313 ; CHECK-NEXT:    vfcmulcph {{[-0-9]+}}(%r{{[sb]}}p), %ymm0, %ymm2 # 32-byte Folded Reload
1314 ; CHECK-NEXT:    vmovaps %ymm2, %ymm0
1315 ; CHECK-NEXT:    retq
1316   %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}"()
1317   %2 = call <8 x float> @llvm.x86.avx512fp16.mask.vfcmul.cph.256(<8 x float> %a0, <8 x float> %a1, <8 x float> undef, i8 -1)
1318   ret <8 x float> %2
1319 }
1320 declare <8 x float> @llvm.x86.avx512fp16.mask.vfcmul.cph.256(<8 x float>, <8 x float>, <8 x float>, i8)
1321
1322 define <8 x float> @stack_fold_fcmulc_mask_ymm(<8 x float> %a0, <8 x float> %a1, ptr %passthru, i8 %mask) {
1323 ; CHECK-LABEL: stack_fold_fcmulc_mask_ymm:
1324 ; CHECK:       # %bb.0:
1325 ; CHECK-NEXT:    vmovups %ymm1, {{[-0-9]+}}(%r{{[sb]}}p) # 32-byte Spill
1326 ; CHECK-NEXT:    kmovd %esi, %k1
1327 ; CHECK-NEXT:    #APP
1328 ; CHECK-NEXT:    nop
1329 ; CHECK-NEXT:    #NO_APP
1330 ; CHECK-NEXT:    vmovaps (%rdi), %ymm2
1331 ; CHECK-NEXT:    vfcmulcph {{[-0-9]+}}(%r{{[sb]}}p), %ymm0, %ymm2 {%k1} # 32-byte Folded Reload
1332 ; CHECK-NEXT:    vmovaps %ymm2, %ymm0
1333 ; CHECK-NEXT:    retq
1334   %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}"()
1335   %2 = load <8 x float>, ptr %passthru
1336   %3 = call <8 x float> @llvm.x86.avx512fp16.mask.vfcmul.cph.256(<8 x float> %a0, <8 x float> %a1, <8 x float> %2, i8 %mask)
1337   ret <8 x float> %3
1338 }
1339
1340 define <8 x float> @stack_fold_fcmulc_maskz_ymm(<8 x float> %a0, <8 x float> %a1, ptr %mask) {
1341 ; CHECK-LABEL: stack_fold_fcmulc_maskz_ymm:
1342 ; CHECK:       # %bb.0:
1343 ; CHECK-NEXT:    vmovups %ymm1, {{[-0-9]+}}(%r{{[sb]}}p) # 32-byte Spill
1344 ; CHECK-NEXT:    #APP
1345 ; CHECK-NEXT:    nop
1346 ; CHECK-NEXT:    #NO_APP
1347 ; CHECK-NEXT:    kmovb (%rdi), %k1
1348 ; CHECK-NEXT:    vfcmulcph {{[-0-9]+}}(%r{{[sb]}}p), %ymm0, %ymm2 {%k1} {z} # 32-byte Folded Reload
1349 ; CHECK-NEXT:    vmovaps %ymm2, %ymm0
1350 ; CHECK-NEXT:    retq
1351   %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}"()
1352   %2 = load i8, ptr %mask
1353   %3 = call <8 x float> @llvm.x86.avx512fp16.mask.vfcmul.cph.256(<8 x float> %a0, <8 x float> %a1, <8 x float> zeroinitializer, i8 %2)
1354   ret <8 x float> %3
1355 }
1356
1357 define <8 x float> @stack_fold_fmaddc_ymm(<8 x float> %a0, <8 x float> %a1, <8 x float> %a2) {
1358 ; CHECK-LABEL: stack_fold_fmaddc_ymm:
1359 ; CHECK:       # %bb.0:
1360 ; CHECK-NEXT:    vmovups %ymm2, {{[-0-9]+}}(%r{{[sb]}}p) # 32-byte Spill
1361 ; CHECK-NEXT:    #APP
1362 ; CHECK-NEXT:    nop
1363 ; CHECK-NEXT:    #NO_APP
1364 ; CHECK-NEXT:    vfmaddcph {{[-0-9]+}}(%r{{[sb]}}p), %ymm1, %ymm0 # 32-byte Folded Reload
1365 ; CHECK-NEXT:    retq
1366   %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}"()
1367   %2 = call <8 x float> @llvm.x86.avx512fp16.mask.vfmadd.cph.256(<8 x float> %a1, <8 x float> %a2, <8 x float> %a0, i8 -1)
1368   ret <8 x float> %2
1369 }
1370 declare <8 x float> @llvm.x86.avx512fp16.mask.vfmadd.cph.256(<8 x float>, <8 x float>, <8 x float>, i8)
1371
1372 define <8 x float> @stack_fold_fmaddc_mask_ymm(ptr %p, <8 x float> %a1, <8 x float> %a2, i8 %mask) {
1373 ; CHECK-LABEL: stack_fold_fmaddc_mask_ymm:
1374 ; CHECK:       # %bb.0:
1375 ; CHECK-NEXT:    vmovups %ymm1, {{[-0-9]+}}(%r{{[sb]}}p) # 32-byte Spill
1376 ; CHECK-NEXT:    kmovd %esi, %k1
1377 ; CHECK-NEXT:    #APP
1378 ; CHECK-NEXT:    nop
1379 ; CHECK-NEXT:    #NO_APP
1380 ; CHECK-NEXT:    vmovaps (%rdi), %ymm2
1381 ; CHECK-NEXT:    vfmaddcph {{[-0-9]+}}(%r{{[sb]}}p), %ymm0, %ymm2 {%k1} # 32-byte Folded Reload
1382 ; CHECK-NEXT:    vmovaps %ymm2, %ymm0
1383 ; CHECK-NEXT:    retq
1384   %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}"()
1385   %a0 = load <8 x float>, ptr %p
1386   %2 = call <8 x float> @llvm.x86.avx512fp16.mask.vfmadd.cph.256(<8 x float> %a1, <8 x float> %a2, <8 x float> %a0, i8 %mask)
1387   ret <8 x float> %2
1388 }
1389
1390 define <8 x float> @stack_fold_fmaddc_maskz_ymm(<8 x float> %a0, <8 x float> %a1, <8 x float> %a2, ptr %mask) {
1391 ; CHECK-LABEL: stack_fold_fmaddc_maskz_ymm:
1392 ; CHECK:       # %bb.0:
1393 ; CHECK-NEXT:    vmovups %ymm2, {{[-0-9]+}}(%r{{[sb]}}p) # 32-byte Spill
1394 ; CHECK-NEXT:    #APP
1395 ; CHECK-NEXT:    nop
1396 ; CHECK-NEXT:    #NO_APP
1397 ; CHECK-NEXT:    kmovb (%rdi), %k1
1398 ; CHECK-NEXT:    vxorps %xmm0, %xmm0, %xmm0
1399 ; CHECK-NEXT:    vfmaddcph {{[-0-9]+}}(%r{{[sb]}}p), %ymm1, %ymm0 {%k1} {z} # 32-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 = load i8, ptr %mask
1403   %3 = call <8 x float> @llvm.x86.avx512fp16.mask.vfmadd.cph.256(<8 x float> %a1, <8 x float> %a2, <8 x float> zeroinitializer, i8 %2)
1404   ret <8 x float> %3
1405 }
1406 declare <8 x float> @llvm.x86.avx512fp16.maskz.vfmadd.cph.256(<8 x float>, <8 x float>, <8 x float>, i8)
1407
1408 define <8 x float> @stack_fold_fcmaddc_ymm(<8 x float> %a0, <8 x float> %a1, <8 x float> %a2) {
1409 ; CHECK-LABEL: stack_fold_fcmaddc_ymm:
1410 ; CHECK:       # %bb.0:
1411 ; CHECK-NEXT:    vmovups %ymm2, {{[-0-9]+}}(%r{{[sb]}}p) # 32-byte Spill
1412 ; CHECK-NEXT:    #APP
1413 ; CHECK-NEXT:    nop
1414 ; CHECK-NEXT:    #NO_APP
1415 ; CHECK-NEXT:    vfcmaddcph {{[-0-9]+}}(%r{{[sb]}}p), %ymm1, %ymm0 # 32-byte Folded Reload
1416 ; CHECK-NEXT:    retq
1417   %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}"()
1418   %2 = call <8 x float> @llvm.x86.avx512fp16.mask.vfcmadd.cph.256(<8 x float> %a1, <8 x float> %a2, <8 x float> %a0, i8 -1)
1419   ret <8 x float> %2
1420 }
1421 declare <8 x float> @llvm.x86.avx512fp16.mask.vfcmadd.cph.256(<8 x float>, <8 x float>, <8 x float>, i8)
1422
1423 define <8 x float> @stack_fold_fcmaddc_mask_ymm(ptr %p, <8 x float> %a1, <8 x float> %a2, i8 %mask) {
1424 ; CHECK-LABEL: stack_fold_fcmaddc_mask_ymm:
1425 ; CHECK:       # %bb.0:
1426 ; CHECK-NEXT:    vmovups %ymm1, {{[-0-9]+}}(%r{{[sb]}}p) # 32-byte Spill
1427 ; CHECK-NEXT:    kmovd %esi, %k1
1428 ; CHECK-NEXT:    #APP
1429 ; CHECK-NEXT:    nop
1430 ; CHECK-NEXT:    #NO_APP
1431 ; CHECK-NEXT:    vmovaps (%rdi), %ymm2
1432 ; CHECK-NEXT:    vfcmaddcph {{[-0-9]+}}(%r{{[sb]}}p), %ymm0, %ymm2 {%k1} # 32-byte Folded Reload
1433 ; CHECK-NEXT:    vmovaps %ymm2, %ymm0
1434 ; CHECK-NEXT:    retq
1435   %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}"()
1436   %a0 = load <8 x float>, ptr %p
1437   %2 = call <8 x float> @llvm.x86.avx512fp16.mask.vfcmadd.cph.256(<8 x float> %a1, <8 x float> %a2, <8 x float> %a0, i8 %mask)
1438   ret <8 x float> %2
1439 }
1440
1441 define <8 x float> @stack_fold_fcmaddc_maskz_ymm(<8 x float> %a0, <8 x float> %a1, <8 x float> %a2, ptr %mask) {
1442 ; CHECK-LABEL: stack_fold_fcmaddc_maskz_ymm:
1443 ; CHECK:       # %bb.0:
1444 ; CHECK-NEXT:    vmovups %ymm2, {{[-0-9]+}}(%r{{[sb]}}p) # 32-byte Spill
1445 ; CHECK-NEXT:    #APP
1446 ; CHECK-NEXT:    nop
1447 ; CHECK-NEXT:    #NO_APP
1448 ; CHECK-NEXT:    kmovb (%rdi), %k1
1449 ; CHECK-NEXT:    vxorps %xmm0, %xmm0, %xmm0
1450 ; CHECK-NEXT:    vfcmaddcph {{[-0-9]+}}(%r{{[sb]}}p), %ymm1, %ymm0 {%k1} {z} # 32-byte Folded Reload
1451 ; CHECK-NEXT:    retq
1452   %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}"()
1453   %2 = load i8, ptr %mask
1454   %3 = call <8 x float> @llvm.x86.avx512fp16.mask.vfcmadd.cph.256(<8 x float> %a1, <8 x float> %a2, <8 x float> zeroinitializer, i8 %2)
1455   ret <8 x float> %3
1456 }
1457 declare <8 x float> @llvm.x86.avx512fp16.maskz.vfcmadd.cph.256(<8 x float>, <8 x float>, <8 x float>, i8)
1458
1459 attributes #0 = { "unsafe-fp-math"="false" }
1460 attributes #1 = { "unsafe-fp-math"="true" }