test/CodeGen/X86/avx512vl-intrinsics.ll

   1 ; RUN: llc < %s -mtriple=x86_64-apple-darwin -mcpu=knl -mattr=+avx512vl --show-mc-encoding| FileCheck %s
   2
   3 ; 256-bit
   4
   5 define i8 @test_pcmpeq_d_256(<8 x i32> %a, <8 x i32> %b) {
   6 ; CHECK-LABEL: test_pcmpeq_d_256
   7 ; CHECK: vpcmpeqd %ymm1, %ymm0, %k0 ##
   8   %res = call i8 @llvm.x86.avx512.mask.pcmpeq.d.256(<8 x i32> %a, <8 x i32> %b, i8 -1)
   9   ret i8 %res
  10 }
  11
  12 define i8 @test_mask_pcmpeq_d_256(<8 x i32> %a, <8 x i32> %b, i8 %mask) {
  13 ; CHECK-LABEL: test_mask_pcmpeq_d_256
  14 ; CHECK: vpcmpeqd %ymm1, %ymm0, %k0 {%k1} ##
  15   %res = call i8 @llvm.x86.avx512.mask.pcmpeq.d.256(<8 x i32> %a, <8 x i32> %b, i8 %mask)
  16   ret i8 %res
  17 }
  18
  19 declare i8 @llvm.x86.avx512.mask.pcmpeq.d.256(<8 x i32>, <8 x i32>, i8)
  20
  21 define i8 @test_pcmpeq_q_256(<4 x i64> %a, <4 x i64> %b) {
  22 ; CHECK-LABEL: test_pcmpeq_q_256
  23 ; CHECK: vpcmpeqq %ymm1, %ymm0, %k0 ##
  24   %res = call i8 @llvm.x86.avx512.mask.pcmpeq.q.256(<4 x i64> %a, <4 x i64> %b, i8 -1)
  25   ret i8 %res
  26 }
  27
  28 define i8 @test_mask_pcmpeq_q_256(<4 x i64> %a, <4 x i64> %b, i8 %mask) {
  29 ; CHECK-LABEL: test_mask_pcmpeq_q_256
  30 ; CHECK: vpcmpeqq %ymm1, %ymm0, %k0 {%k1} ##
  31   %res = call i8 @llvm.x86.avx512.mask.pcmpeq.q.256(<4 x i64> %a, <4 x i64> %b, i8 %mask)
  32   ret i8 %res
  33 }
  34
  35 declare i8 @llvm.x86.avx512.mask.pcmpeq.q.256(<4 x i64>, <4 x i64>, i8)
  36
  37 define i8 @test_pcmpgt_d_256(<8 x i32> %a, <8 x i32> %b) {
  38 ; CHECK-LABEL: test_pcmpgt_d_256
  39 ; CHECK: vpcmpgtd %ymm1, %ymm0, %k0 ##
  40   %res = call i8 @llvm.x86.avx512.mask.pcmpgt.d.256(<8 x i32> %a, <8 x i32> %b, i8 -1)
  41   ret i8 %res
  42 }
  43
  44 define i8 @test_mask_pcmpgt_d_256(<8 x i32> %a, <8 x i32> %b, i8 %mask) {
  45 ; CHECK-LABEL: test_mask_pcmpgt_d_256
  46 ; CHECK: vpcmpgtd %ymm1, %ymm0, %k0 {%k1} ##
  47   %res = call i8 @llvm.x86.avx512.mask.pcmpgt.d.256(<8 x i32> %a, <8 x i32> %b, i8 %mask)
  48   ret i8 %res
  49 }
  50
  51 declare i8 @llvm.x86.avx512.mask.pcmpgt.d.256(<8 x i32>, <8 x i32>, i8)
  52
  53 define i8 @test_pcmpgt_q_256(<4 x i64> %a, <4 x i64> %b) {
  54 ; CHECK-LABEL: test_pcmpgt_q_256
  55 ; CHECK: vpcmpgtq %ymm1, %ymm0, %k0 ##
  56   %res = call i8 @llvm.x86.avx512.mask.pcmpgt.q.256(<4 x i64> %a, <4 x i64> %b, i8 -1)
  57   ret i8 %res
  58 }
  59
  60 define i8 @test_mask_pcmpgt_q_256(<4 x i64> %a, <4 x i64> %b, i8 %mask) {
  61 ; CHECK-LABEL: test_mask_pcmpgt_q_256
  62 ; CHECK: vpcmpgtq %ymm1, %ymm0, %k0 {%k1} ##
  63   %res = call i8 @llvm.x86.avx512.mask.pcmpgt.q.256(<4 x i64> %a, <4 x i64> %b, i8 %mask)
  64   ret i8 %res
  65 }
  66
  67 declare i8 @llvm.x86.avx512.mask.pcmpgt.q.256(<4 x i64>, <4 x i64>, i8)
  68
  69 define <8 x i8> @test_cmp_d_256(<8 x i32> %a0, <8 x i32> %a1) {
  70 ; CHECK-LABEL: test_cmp_d_256
  71 ; CHECK: vpcmpeqd %ymm1, %ymm0, %k0 ##
  72   %res0 = call i8 @llvm.x86.avx512.mask.cmp.d.256(<8 x i32> %a0, <8 x i32> %a1, i32 0, i8 -1)
  73   %vec0 = insertelement <8 x i8> undef, i8 %res0, i32 0
  74 ; CHECK: vpcmpltd %ymm1, %ymm0, %k0 ##
  75   %res1 = call i8 @llvm.x86.avx512.mask.cmp.d.256(<8 x i32> %a0, <8 x i32> %a1, i32 1, i8 -1)
  76   %vec1 = insertelement <8 x i8> %vec0, i8 %res1, i32 1
  77 ; CHECK: vpcmpled %ymm1, %ymm0, %k0 ##
  78   %res2 = call i8 @llvm.x86.avx512.mask.cmp.d.256(<8 x i32> %a0, <8 x i32> %a1, i32 2, i8 -1)
  79   %vec2 = insertelement <8 x i8> %vec1, i8 %res2, i32 2
  80 ; CHECK: vpcmpunordd %ymm1, %ymm0, %k0 ##
  81   %res3 = call i8 @llvm.x86.avx512.mask.cmp.d.256(<8 x i32> %a0, <8 x i32> %a1, i32 3, i8 -1)
  82   %vec3 = insertelement <8 x i8> %vec2, i8 %res3, i32 3
  83 ; CHECK: vpcmpneqd %ymm1, %ymm0, %k0 ##
  84   %res4 = call i8 @llvm.x86.avx512.mask.cmp.d.256(<8 x i32> %a0, <8 x i32> %a1, i32 4, i8 -1)
  85   %vec4 = insertelement <8 x i8> %vec3, i8 %res4, i32 4
  86 ; CHECK: vpcmpnltd %ymm1, %ymm0, %k0 ##
  87   %res5 = call i8 @llvm.x86.avx512.mask.cmp.d.256(<8 x i32> %a0, <8 x i32> %a1, i32 5, i8 -1)
  88   %vec5 = insertelement <8 x i8> %vec4, i8 %res5, i32 5
  89 ; CHECK: vpcmpnled %ymm1, %ymm0, %k0 ##
  90   %res6 = call i8 @llvm.x86.avx512.mask.cmp.d.256(<8 x i32> %a0, <8 x i32> %a1, i32 6, i8 -1)
  91   %vec6 = insertelement <8 x i8> %vec5, i8 %res6, i32 6
  92 ; CHECK: vpcmpordd %ymm1, %ymm0, %k0 ##
  93   %res7 = call i8 @llvm.x86.avx512.mask.cmp.d.256(<8 x i32> %a0, <8 x i32> %a1, i32 7, i8 -1)
  94   %vec7 = insertelement <8 x i8> %vec6, i8 %res7, i32 7
  95   ret <8 x i8> %vec7
  96 }
  97
  98 define <8 x i8> @test_mask_cmp_d_256(<8 x i32> %a0, <8 x i32> %a1, i8 %mask) {
  99 ; CHECK-LABEL: test_mask_cmp_d_256
 100 ; CHECK: vpcmpeqd %ymm1, %ymm0, %k0 {%k1} ##
 101   %res0 = call i8 @llvm.x86.avx512.mask.cmp.d.256(<8 x i32> %a0, <8 x i32> %a1, i32 0, i8 %mask)
 102   %vec0 = insertelement <8 x i8> undef, i8 %res0, i32 0
 103 ; CHECK: vpcmpltd %ymm1, %ymm0, %k0 {%k1} ##
 104   %res1 = call i8 @llvm.x86.avx512.mask.cmp.d.256(<8 x i32> %a0, <8 x i32> %a1, i32 1, i8 %mask)
 105   %vec1 = insertelement <8 x i8> %vec0, i8 %res1, i32 1
 106 ; CHECK: vpcmpled %ymm1, %ymm0, %k0 {%k1} ##
 107   %res2 = call i8 @llvm.x86.avx512.mask.cmp.d.256(<8 x i32> %a0, <8 x i32> %a1, i32 2, i8 %mask)
 108   %vec2 = insertelement <8 x i8> %vec1, i8 %res2, i32 2
 109 ; CHECK: vpcmpunordd %ymm1, %ymm0, %k0 {%k1} ##
 110   %res3 = call i8 @llvm.x86.avx512.mask.cmp.d.256(<8 x i32> %a0, <8 x i32> %a1, i32 3, i8 %mask)
 111   %vec3 = insertelement <8 x i8> %vec2, i8 %res3, i32 3
 112 ; CHECK: vpcmpneqd %ymm1, %ymm0, %k0 {%k1} ##
 113   %res4 = call i8 @llvm.x86.avx512.mask.cmp.d.256(<8 x i32> %a0, <8 x i32> %a1, i32 4, i8 %mask)
 114   %vec4 = insertelement <8 x i8> %vec3, i8 %res4, i32 4
 115 ; CHECK: vpcmpnltd %ymm1, %ymm0, %k0 {%k1} ##
 116   %res5 = call i8 @llvm.x86.avx512.mask.cmp.d.256(<8 x i32> %a0, <8 x i32> %a1, i32 5, i8 %mask)
 117   %vec5 = insertelement <8 x i8> %vec4, i8 %res5, i32 5
 118 ; CHECK: vpcmpnled %ymm1, %ymm0, %k0 {%k1} ##
 119   %res6 = call i8 @llvm.x86.avx512.mask.cmp.d.256(<8 x i32> %a0, <8 x i32> %a1, i32 6, i8 %mask)
 120   %vec6 = insertelement <8 x i8> %vec5, i8 %res6, i32 6
 121 ; CHECK: vpcmpordd %ymm1, %ymm0, %k0 {%k1} ##
 122   %res7 = call i8 @llvm.x86.avx512.mask.cmp.d.256(<8 x i32> %a0, <8 x i32> %a1, i32 7, i8 %mask)
 123   %vec7 = insertelement <8 x i8> %vec6, i8 %res7, i32 7
 124   ret <8 x i8> %vec7
 125 }
 126
 127 declare i8 @llvm.x86.avx512.mask.cmp.d.256(<8 x i32>, <8 x i32>, i32, i8) nounwind readnone
 128
 129 define <8 x i8> @test_ucmp_d_256(<8 x i32> %a0, <8 x i32> %a1) {
 130 ; CHECK-LABEL: test_ucmp_d_256
 131 ; CHECK: vpcmpequd %ymm1, %ymm0, %k0 ##
 132   %res0 = call i8 @llvm.x86.avx512.mask.ucmp.d.256(<8 x i32> %a0, <8 x i32> %a1, i32 0, i8 -1)
 133   %vec0 = insertelement <8 x i8> undef, i8 %res0, i32 0
 134 ; CHECK: vpcmpltud %ymm1, %ymm0, %k0 ##
 135   %res1 = call i8 @llvm.x86.avx512.mask.ucmp.d.256(<8 x i32> %a0, <8 x i32> %a1, i32 1, i8 -1)
 136   %vec1 = insertelement <8 x i8> %vec0, i8 %res1, i32 1
 137 ; CHECK: vpcmpleud %ymm1, %ymm0, %k0 ##
 138   %res2 = call i8 @llvm.x86.avx512.mask.ucmp.d.256(<8 x i32> %a0, <8 x i32> %a1, i32 2, i8 -1)
 139   %vec2 = insertelement <8 x i8> %vec1, i8 %res2, i32 2
 140 ; CHECK: vpcmpunordud %ymm1, %ymm0, %k0 ##
 141   %res3 = call i8 @llvm.x86.avx512.mask.ucmp.d.256(<8 x i32> %a0, <8 x i32> %a1, i32 3, i8 -1)
 142   %vec3 = insertelement <8 x i8> %vec2, i8 %res3, i32 3
 143 ; CHECK: vpcmpnequd %ymm1, %ymm0, %k0 ##
 144   %res4 = call i8 @llvm.x86.avx512.mask.ucmp.d.256(<8 x i32> %a0, <8 x i32> %a1, i32 4, i8 -1)
 145   %vec4 = insertelement <8 x i8> %vec3, i8 %res4, i32 4
 146 ; CHECK: vpcmpnltud %ymm1, %ymm0, %k0 ##
 147   %res5 = call i8 @llvm.x86.avx512.mask.ucmp.d.256(<8 x i32> %a0, <8 x i32> %a1, i32 5, i8 -1)
 148   %vec5 = insertelement <8 x i8> %vec4, i8 %res5, i32 5
 149 ; CHECK: vpcmpnleud %ymm1, %ymm0, %k0 ##
 150   %res6 = call i8 @llvm.x86.avx512.mask.ucmp.d.256(<8 x i32> %a0, <8 x i32> %a1, i32 6, i8 -1)
 151   %vec6 = insertelement <8 x i8> %vec5, i8 %res6, i32 6
 152 ; CHECK: vpcmpordud %ymm1, %ymm0, %k0 ##
 153   %res7 = call i8 @llvm.x86.avx512.mask.ucmp.d.256(<8 x i32> %a0, <8 x i32> %a1, i32 7, i8 -1)
 154   %vec7 = insertelement <8 x i8> %vec6, i8 %res7, i32 7
 155   ret <8 x i8> %vec7
 156 }
 157
 158 define <8 x i8> @test_mask_ucmp_d_256(<8 x i32> %a0, <8 x i32> %a1, i8 %mask) {
 159 ; CHECK-LABEL: test_mask_ucmp_d_256
 160 ; CHECK: vpcmpequd %ymm1, %ymm0, %k0 {%k1} ##
 161   %res0 = call i8 @llvm.x86.avx512.mask.ucmp.d.256(<8 x i32> %a0, <8 x i32> %a1, i32 0, i8 %mask)
 162   %vec0 = insertelement <8 x i8> undef, i8 %res0, i32 0
 163 ; CHECK: vpcmpltud %ymm1, %ymm0, %k0 {%k1} ##
 164   %res1 = call i8 @llvm.x86.avx512.mask.ucmp.d.256(<8 x i32> %a0, <8 x i32> %a1, i32 1, i8 %mask)
 165   %vec1 = insertelement <8 x i8> %vec0, i8 %res1, i32 1
 166 ; CHECK: vpcmpleud %ymm1, %ymm0, %k0 {%k1} ##
 167   %res2 = call i8 @llvm.x86.avx512.mask.ucmp.d.256(<8 x i32> %a0, <8 x i32> %a1, i32 2, i8 %mask)
 168   %vec2 = insertelement <8 x i8> %vec1, i8 %res2, i32 2
 169 ; CHECK: vpcmpunordud %ymm1, %ymm0, %k0 {%k1} ##
 170   %res3 = call i8 @llvm.x86.avx512.mask.ucmp.d.256(<8 x i32> %a0, <8 x i32> %a1, i32 3, i8 %mask)
 171   %vec3 = insertelement <8 x i8> %vec2, i8 %res3, i32 3
 172 ; CHECK: vpcmpnequd %ymm1, %ymm0, %k0 {%k1} ##
 173   %res4 = call i8 @llvm.x86.avx512.mask.ucmp.d.256(<8 x i32> %a0, <8 x i32> %a1, i32 4, i8 %mask)
 174   %vec4 = insertelement <8 x i8> %vec3, i8 %res4, i32 4
 175 ; CHECK: vpcmpnltud %ymm1, %ymm0, %k0 {%k1} ##
 176   %res5 = call i8 @llvm.x86.avx512.mask.ucmp.d.256(<8 x i32> %a0, <8 x i32> %a1, i32 5, i8 %mask)
 177   %vec5 = insertelement <8 x i8> %vec4, i8 %res5, i32 5
 178 ; CHECK: vpcmpnleud %ymm1, %ymm0, %k0 {%k1} ##
 179   %res6 = call i8 @llvm.x86.avx512.mask.ucmp.d.256(<8 x i32> %a0, <8 x i32> %a1, i32 6, i8 %mask)
 180   %vec6 = insertelement <8 x i8> %vec5, i8 %res6, i32 6
 181 ; CHECK: vpcmpordud %ymm1, %ymm0, %k0 {%k1} ##
 182   %res7 = call i8 @llvm.x86.avx512.mask.ucmp.d.256(<8 x i32> %a0, <8 x i32> %a1, i32 7, i8 %mask)
 183   %vec7 = insertelement <8 x i8> %vec6, i8 %res7, i32 7
 184   ret <8 x i8> %vec7
 185 }
 186
 187 declare i8 @llvm.x86.avx512.mask.ucmp.d.256(<8 x i32>, <8 x i32>, i32, i8) nounwind readnone
 188
 189 define <8 x i8> @test_cmp_q_256(<4 x i64> %a0, <4 x i64> %a1) {
 190 ; CHECK-LABEL: test_cmp_q_256
 191 ; CHECK: vpcmpeqq %ymm1, %ymm0, %k0 ##
 192   %res0 = call i8 @llvm.x86.avx512.mask.cmp.q.256(<4 x i64> %a0, <4 x i64> %a1, i32 0, i8 -1)
 193   %vec0 = insertelement <8 x i8> undef, i8 %res0, i32 0
 194 ; CHECK: vpcmpltq %ymm1, %ymm0, %k0 ##
 195   %res1 = call i8 @llvm.x86.avx512.mask.cmp.q.256(<4 x i64> %a0, <4 x i64> %a1, i32 1, i8 -1)
 196   %vec1 = insertelement <8 x i8> %vec0, i8 %res1, i32 1
 197 ; CHECK: vpcmpleq %ymm1, %ymm0, %k0 ##
 198   %res2 = call i8 @llvm.x86.avx512.mask.cmp.q.256(<4 x i64> %a0, <4 x i64> %a1, i32 2, i8 -1)
 199   %vec2 = insertelement <8 x i8> %vec1, i8 %res2, i32 2
 200 ; CHECK: vpcmpunordq %ymm1, %ymm0, %k0 ##
 201   %res3 = call i8 @llvm.x86.avx512.mask.cmp.q.256(<4 x i64> %a0, <4 x i64> %a1, i32 3, i8 -1)
 202   %vec3 = insertelement <8 x i8> %vec2, i8 %res3, i32 3
 203 ; CHECK: vpcmpneqq %ymm1, %ymm0, %k0 ##
 204   %res4 = call i8 @llvm.x86.avx512.mask.cmp.q.256(<4 x i64> %a0, <4 x i64> %a1, i32 4, i8 -1)
 205   %vec4 = insertelement <8 x i8> %vec3, i8 %res4, i32 4
 206 ; CHECK: vpcmpnltq %ymm1, %ymm0, %k0 ##
 207   %res5 = call i8 @llvm.x86.avx512.mask.cmp.q.256(<4 x i64> %a0, <4 x i64> %a1, i32 5, i8 -1)
 208   %vec5 = insertelement <8 x i8> %vec4, i8 %res5, i32 5
 209 ; CHECK: vpcmpnleq %ymm1, %ymm0, %k0 ##
 210   %res6 = call i8 @llvm.x86.avx512.mask.cmp.q.256(<4 x i64> %a0, <4 x i64> %a1, i32 6, i8 -1)
 211   %vec6 = insertelement <8 x i8> %vec5, i8 %res6, i32 6
 212 ; CHECK: vpcmpordq %ymm1, %ymm0, %k0 ##
 213   %res7 = call i8 @llvm.x86.avx512.mask.cmp.q.256(<4 x i64> %a0, <4 x i64> %a1, i32 7, i8 -1)
 214   %vec7 = insertelement <8 x i8> %vec6, i8 %res7, i32 7
 215   ret <8 x i8> %vec7
 216 }
 217
 218 define <8 x i8> @test_mask_cmp_q_256(<4 x i64> %a0, <4 x i64> %a1, i8 %mask) {
 219 ; CHECK-LABEL: test_mask_cmp_q_256
 220 ; CHECK: vpcmpeqq %ymm1, %ymm0, %k0 {%k1} ##
 221   %res0 = call i8 @llvm.x86.avx512.mask.cmp.q.256(<4 x i64> %a0, <4 x i64> %a1, i32 0, i8 %mask)
 222   %vec0 = insertelement <8 x i8> undef, i8 %res0, i32 0
 223 ; CHECK: vpcmpltq %ymm1, %ymm0, %k0 {%k1} ##
 224   %res1 = call i8 @llvm.x86.avx512.mask.cmp.q.256(<4 x i64> %a0, <4 x i64> %a1, i32 1, i8 %mask)
 225   %vec1 = insertelement <8 x i8> %vec0, i8 %res1, i32 1
 226 ; CHECK: vpcmpleq %ymm1, %ymm0, %k0 {%k1} ##
 227   %res2 = call i8 @llvm.x86.avx512.mask.cmp.q.256(<4 x i64> %a0, <4 x i64> %a1, i32 2, i8 %mask)
 228   %vec2 = insertelement <8 x i8> %vec1, i8 %res2, i32 2
 229 ; CHECK: vpcmpunordq %ymm1, %ymm0, %k0 {%k1} ##
 230   %res3 = call i8 @llvm.x86.avx512.mask.cmp.q.256(<4 x i64> %a0, <4 x i64> %a1, i32 3, i8 %mask)
 231   %vec3 = insertelement <8 x i8> %vec2, i8 %res3, i32 3
 232 ; CHECK: vpcmpneqq %ymm1, %ymm0, %k0 {%k1} ##
 233   %res4 = call i8 @llvm.x86.avx512.mask.cmp.q.256(<4 x i64> %a0, <4 x i64> %a1, i32 4, i8 %mask)
 234   %vec4 = insertelement <8 x i8> %vec3, i8 %res4, i32 4
 235 ; CHECK: vpcmpnltq %ymm1, %ymm0, %k0 {%k1} ##
 236   %res5 = call i8 @llvm.x86.avx512.mask.cmp.q.256(<4 x i64> %a0, <4 x i64> %a1, i32 5, i8 %mask)
 237   %vec5 = insertelement <8 x i8> %vec4, i8 %res5, i32 5
 238 ; CHECK: vpcmpnleq %ymm1, %ymm0, %k0 {%k1} ##
 239   %res6 = call i8 @llvm.x86.avx512.mask.cmp.q.256(<4 x i64> %a0, <4 x i64> %a1, i32 6, i8 %mask)
 240   %vec6 = insertelement <8 x i8> %vec5, i8 %res6, i32 6
 241 ; CHECK: vpcmpordq %ymm1, %ymm0, %k0 {%k1} ##
 242   %res7 = call i8 @llvm.x86.avx512.mask.cmp.q.256(<4 x i64> %a0, <4 x i64> %a1, i32 7, i8 %mask)
 243   %vec7 = insertelement <8 x i8> %vec6, i8 %res7, i32 7
 244   ret <8 x i8> %vec7
 245 }
 246
 247 declare i8 @llvm.x86.avx512.mask.cmp.q.256(<4 x i64>, <4 x i64>, i32, i8) nounwind readnone
 248
 249 define <8 x i8> @test_ucmp_q_256(<4 x i64> %a0, <4 x i64> %a1) {
 250 ; CHECK-LABEL: test_ucmp_q_256
 251 ; CHECK: vpcmpequq %ymm1, %ymm0, %k0 ##
 252   %res0 = call i8 @llvm.x86.avx512.mask.ucmp.q.256(<4 x i64> %a0, <4 x i64> %a1, i32 0, i8 -1)
 253   %vec0 = insertelement <8 x i8> undef, i8 %res0, i32 0
 254 ; CHECK: vpcmpltuq %ymm1, %ymm0, %k0 ##
 255   %res1 = call i8 @llvm.x86.avx512.mask.ucmp.q.256(<4 x i64> %a0, <4 x i64> %a1, i32 1, i8 -1)
 256   %vec1 = insertelement <8 x i8> %vec0, i8 %res1, i32 1
 257 ; CHECK: vpcmpleuq %ymm1, %ymm0, %k0 ##
 258   %res2 = call i8 @llvm.x86.avx512.mask.ucmp.q.256(<4 x i64> %a0, <4 x i64> %a1, i32 2, i8 -1)
 259   %vec2 = insertelement <8 x i8> %vec1, i8 %res2, i32 2
 260 ; CHECK: vpcmpunorduq %ymm1, %ymm0, %k0 ##
 261   %res3 = call i8 @llvm.x86.avx512.mask.ucmp.q.256(<4 x i64> %a0, <4 x i64> %a1, i32 3, i8 -1)
 262   %vec3 = insertelement <8 x i8> %vec2, i8 %res3, i32 3
 263 ; CHECK: vpcmpnequq %ymm1, %ymm0, %k0 ##
 264   %res4 = call i8 @llvm.x86.avx512.mask.ucmp.q.256(<4 x i64> %a0, <4 x i64> %a1, i32 4, i8 -1)
 265   %vec4 = insertelement <8 x i8> %vec3, i8 %res4, i32 4
 266 ; CHECK: vpcmpnltuq %ymm1, %ymm0, %k0 ##
 267   %res5 = call i8 @llvm.x86.avx512.mask.ucmp.q.256(<4 x i64> %a0, <4 x i64> %a1, i32 5, i8 -1)
 268   %vec5 = insertelement <8 x i8> %vec4, i8 %res5, i32 5
 269 ; CHECK: vpcmpnleuq %ymm1, %ymm0, %k0 ##
 270   %res6 = call i8 @llvm.x86.avx512.mask.ucmp.q.256(<4 x i64> %a0, <4 x i64> %a1, i32 6, i8 -1)
 271   %vec6 = insertelement <8 x i8> %vec5, i8 %res6, i32 6
 272 ; CHECK: vpcmporduq %ymm1, %ymm0, %k0 ##
 273   %res7 = call i8 @llvm.x86.avx512.mask.ucmp.q.256(<4 x i64> %a0, <4 x i64> %a1, i32 7, i8 -1)
 274   %vec7 = insertelement <8 x i8> %vec6, i8 %res7, i32 7
 275   ret <8 x i8> %vec7
 276 }
 277
 278 define <8 x i8> @test_mask_ucmp_q_256(<4 x i64> %a0, <4 x i64> %a1, i8 %mask) {
 279 ; CHECK-LABEL: test_mask_ucmp_q_256
 280 ; CHECK: vpcmpequq %ymm1, %ymm0, %k0 {%k1} ##
 281   %res0 = call i8 @llvm.x86.avx512.mask.ucmp.q.256(<4 x i64> %a0, <4 x i64> %a1, i32 0, i8 %mask)
 282   %vec0 = insertelement <8 x i8> undef, i8 %res0, i32 0
 283 ; CHECK: vpcmpltuq %ymm1, %ymm0, %k0 {%k1} ##
 284   %res1 = call i8 @llvm.x86.avx512.mask.ucmp.q.256(<4 x i64> %a0, <4 x i64> %a1, i32 1, i8 %mask)
 285   %vec1 = insertelement <8 x i8> %vec0, i8 %res1, i32 1
 286 ; CHECK: vpcmpleuq %ymm1, %ymm0, %k0 {%k1} ##
 287   %res2 = call i8 @llvm.x86.avx512.mask.ucmp.q.256(<4 x i64> %a0, <4 x i64> %a1, i32 2, i8 %mask)
 288   %vec2 = insertelement <8 x i8> %vec1, i8 %res2, i32 2
 289 ; CHECK: vpcmpunorduq %ymm1, %ymm0, %k0 {%k1} ##
 290   %res3 = call i8 @llvm.x86.avx512.mask.ucmp.q.256(<4 x i64> %a0, <4 x i64> %a1, i32 3, i8 %mask)
 291   %vec3 = insertelement <8 x i8> %vec2, i8 %res3, i32 3
 292 ; CHECK: vpcmpnequq %ymm1, %ymm0, %k0 {%k1} ##
 293   %res4 = call i8 @llvm.x86.avx512.mask.ucmp.q.256(<4 x i64> %a0, <4 x i64> %a1, i32 4, i8 %mask)
 294   %vec4 = insertelement <8 x i8> %vec3, i8 %res4, i32 4
 295 ; CHECK: vpcmpnltuq %ymm1, %ymm0, %k0 {%k1} ##
 296   %res5 = call i8 @llvm.x86.avx512.mask.ucmp.q.256(<4 x i64> %a0, <4 x i64> %a1, i32 5, i8 %mask)
 297   %vec5 = insertelement <8 x i8> %vec4, i8 %res5, i32 5
 298 ; CHECK: vpcmpnleuq %ymm1, %ymm0, %k0 {%k1} ##
 299   %res6 = call i8 @llvm.x86.avx512.mask.ucmp.q.256(<4 x i64> %a0, <4 x i64> %a1, i32 6, i8 %mask)
 300   %vec6 = insertelement <8 x i8> %vec5, i8 %res6, i32 6
 301 ; CHECK: vpcmporduq %ymm1, %ymm0, %k0 {%k1} ##
 302   %res7 = call i8 @llvm.x86.avx512.mask.ucmp.q.256(<4 x i64> %a0, <4 x i64> %a1, i32 7, i8 %mask)
 303   %vec7 = insertelement <8 x i8> %vec6, i8 %res7, i32 7
 304   ret <8 x i8> %vec7
 305 }
 306
 307 declare i8 @llvm.x86.avx512.mask.ucmp.q.256(<4 x i64>, <4 x i64>, i32, i8) nounwind readnone
 308
 309 ; 128-bit
 310
 311 define i8 @test_pcmpeq_d_128(<4 x i32> %a, <4 x i32> %b) {
 312 ; CHECK-LABEL: test_pcmpeq_d_128
 313 ; CHECK: vpcmpeqd %xmm1, %xmm0, %k0 ##
 314   %res = call i8 @llvm.x86.avx512.mask.pcmpeq.d.128(<4 x i32> %a, <4 x i32> %b, i8 -1)
 315   ret i8 %res
 316 }
 317
 318 define i8 @test_mask_pcmpeq_d_128(<4 x i32> %a, <4 x i32> %b, i8 %mask) {
 319 ; CHECK-LABEL: test_mask_pcmpeq_d_128
 320 ; CHECK: vpcmpeqd %xmm1, %xmm0, %k0 {%k1} ##
 321   %res = call i8 @llvm.x86.avx512.mask.pcmpeq.d.128(<4 x i32> %a, <4 x i32> %b, i8 %mask)
 322   ret i8 %res
 323 }
 324
 325 declare i8 @llvm.x86.avx512.mask.pcmpeq.d.128(<4 x i32>, <4 x i32>, i8)
 326
 327 define i8 @test_pcmpeq_q_128(<2 x i64> %a, <2 x i64> %b) {
 328 ; CHECK-LABEL: test_pcmpeq_q_128
 329 ; CHECK: vpcmpeqq %xmm1, %xmm0, %k0 ##
 330   %res = call i8 @llvm.x86.avx512.mask.pcmpeq.q.128(<2 x i64> %a, <2 x i64> %b, i8 -1)
 331   ret i8 %res
 332 }
 333
 334 define i8 @test_mask_pcmpeq_q_128(<2 x i64> %a, <2 x i64> %b, i8 %mask) {
 335 ; CHECK-LABEL: test_mask_pcmpeq_q_128
 336 ; CHECK: vpcmpeqq %xmm1, %xmm0, %k0 {%k1} ##
 337   %res = call i8 @llvm.x86.avx512.mask.pcmpeq.q.128(<2 x i64> %a, <2 x i64> %b, i8 %mask)
 338   ret i8 %res
 339 }
 340
 341 declare i8 @llvm.x86.avx512.mask.pcmpeq.q.128(<2 x i64>, <2 x i64>, i8)
 342
 343 define i8 @test_pcmpgt_d_128(<4 x i32> %a, <4 x i32> %b) {
 344 ; CHECK-LABEL: test_pcmpgt_d_128
 345 ; CHECK: vpcmpgtd %xmm1, %xmm0, %k0 ##
 346   %res = call i8 @llvm.x86.avx512.mask.pcmpgt.d.128(<4 x i32> %a, <4 x i32> %b, i8 -1)
 347   ret i8 %res
 348 }
 349
 350 define i8 @test_mask_pcmpgt_d_128(<4 x i32> %a, <4 x i32> %b, i8 %mask) {
 351 ; CHECK-LABEL: test_mask_pcmpgt_d_128
 352 ; CHECK: vpcmpgtd %xmm1, %xmm0, %k0 {%k1} ##
 353   %res = call i8 @llvm.x86.avx512.mask.pcmpgt.d.128(<4 x i32> %a, <4 x i32> %b, i8 %mask)
 354   ret i8 %res
 355 }
 356
 357 declare i8 @llvm.x86.avx512.mask.pcmpgt.d.128(<4 x i32>, <4 x i32>, i8)
 358
 359 define i8 @test_pcmpgt_q_128(<2 x i64> %a, <2 x i64> %b) {
 360 ; CHECK-LABEL: test_pcmpgt_q_128
 361 ; CHECK: vpcmpgtq %xmm1, %xmm0, %k0 ##
 362   %res = call i8 @llvm.x86.avx512.mask.pcmpgt.q.128(<2 x i64> %a, <2 x i64> %b, i8 -1)
 363   ret i8 %res
 364 }
 365
 366 define i8 @test_mask_pcmpgt_q_128(<2 x i64> %a, <2 x i64> %b, i8 %mask) {
 367 ; CHECK-LABEL: test_mask_pcmpgt_q_128
 368 ; CHECK: vpcmpgtq %xmm1, %xmm0, %k0 {%k1} ##
 369   %res = call i8 @llvm.x86.avx512.mask.pcmpgt.q.128(<2 x i64> %a, <2 x i64> %b, i8 %mask)
 370   ret i8 %res
 371 }
 372
 373 declare i8 @llvm.x86.avx512.mask.pcmpgt.q.128(<2 x i64>, <2 x i64>, i8)
 374
 375 define <8 x i8> @test_cmp_d_128(<4 x i32> %a0, <4 x i32> %a1) {
 376 ; CHECK-LABEL: test_cmp_d_128
 377 ; CHECK: vpcmpeqd %xmm1, %xmm0, %k0 ##
 378   %res0 = call i8 @llvm.x86.avx512.mask.cmp.d.128(<4 x i32> %a0, <4 x i32> %a1, i32 0, i8 -1)
 379   %vec0 = insertelement <8 x i8> undef, i8 %res0, i32 0
 380 ; CHECK: vpcmpltd %xmm1, %xmm0, %k0 ##
 381   %res1 = call i8 @llvm.x86.avx512.mask.cmp.d.128(<4 x i32> %a0, <4 x i32> %a1, i32 1, i8 -1)
 382   %vec1 = insertelement <8 x i8> %vec0, i8 %res1, i32 1
 383 ; CHECK: vpcmpled %xmm1, %xmm0, %k0 ##
 384   %res2 = call i8 @llvm.x86.avx512.mask.cmp.d.128(<4 x i32> %a0, <4 x i32> %a1, i32 2, i8 -1)
 385   %vec2 = insertelement <8 x i8> %vec1, i8 %res2, i32 2
 386 ; CHECK: vpcmpunordd %xmm1, %xmm0, %k0 ##
 387   %res3 = call i8 @llvm.x86.avx512.mask.cmp.d.128(<4 x i32> %a0, <4 x i32> %a1, i32 3, i8 -1)
 388   %vec3 = insertelement <8 x i8> %vec2, i8 %res3, i32 3
 389 ; CHECK: vpcmpneqd %xmm1, %xmm0, %k0 ##
 390   %res4 = call i8 @llvm.x86.avx512.mask.cmp.d.128(<4 x i32> %a0, <4 x i32> %a1, i32 4, i8 -1)
 391   %vec4 = insertelement <8 x i8> %vec3, i8 %res4, i32 4
 392 ; CHECK: vpcmpnltd %xmm1, %xmm0, %k0 ##
 393   %res5 = call i8 @llvm.x86.avx512.mask.cmp.d.128(<4 x i32> %a0, <4 x i32> %a1, i32 5, i8 -1)
 394   %vec5 = insertelement <8 x i8> %vec4, i8 %res5, i32 5
 395 ; CHECK: vpcmpnled %xmm1, %xmm0, %k0 ##
 396   %res6 = call i8 @llvm.x86.avx512.mask.cmp.d.128(<4 x i32> %a0, <4 x i32> %a1, i32 6, i8 -1)
 397   %vec6 = insertelement <8 x i8> %vec5, i8 %res6, i32 6
 398 ; CHECK: vpcmpordd %xmm1, %xmm0, %k0 ##
 399   %res7 = call i8 @llvm.x86.avx512.mask.cmp.d.128(<4 x i32> %a0, <4 x i32> %a1, i32 7, i8 -1)
 400   %vec7 = insertelement <8 x i8> %vec6, i8 %res7, i32 7
 401   ret <8 x i8> %vec7
 402 }
 403
 404 define <8 x i8> @test_mask_cmp_d_128(<4 x i32> %a0, <4 x i32> %a1, i8 %mask) {
 405 ; CHECK-LABEL: test_mask_cmp_d_128
 406 ; CHECK: vpcmpeqd %xmm1, %xmm0, %k0 {%k1} ##
 407   %res0 = call i8 @llvm.x86.avx512.mask.cmp.d.128(<4 x i32> %a0, <4 x i32> %a1, i32 0, i8 %mask)
 408   %vec0 = insertelement <8 x i8> undef, i8 %res0, i32 0
 409 ; CHECK: vpcmpltd %xmm1, %xmm0, %k0 {%k1} ##
 410   %res1 = call i8 @llvm.x86.avx512.mask.cmp.d.128(<4 x i32> %a0, <4 x i32> %a1, i32 1, i8 %mask)
 411   %vec1 = insertelement <8 x i8> %vec0, i8 %res1, i32 1
 412 ; CHECK: vpcmpled %xmm1, %xmm0, %k0 {%k1} ##
 413   %res2 = call i8 @llvm.x86.avx512.mask.cmp.d.128(<4 x i32> %a0, <4 x i32> %a1, i32 2, i8 %mask)
 414   %vec2 = insertelement <8 x i8> %vec1, i8 %res2, i32 2
 415 ; CHECK: vpcmpunordd %xmm1, %xmm0, %k0 {%k1} ##
 416   %res3 = call i8 @llvm.x86.avx512.mask.cmp.d.128(<4 x i32> %a0, <4 x i32> %a1, i32 3, i8 %mask)
 417   %vec3 = insertelement <8 x i8> %vec2, i8 %res3, i32 3
 418 ; CHECK: vpcmpneqd %xmm1, %xmm0, %k0 {%k1} ##
 419   %res4 = call i8 @llvm.x86.avx512.mask.cmp.d.128(<4 x i32> %a0, <4 x i32> %a1, i32 4, i8 %mask)
 420   %vec4 = insertelement <8 x i8> %vec3, i8 %res4, i32 4
 421 ; CHECK: vpcmpnltd %xmm1, %xmm0, %k0 {%k1} ##
 422   %res5 = call i8 @llvm.x86.avx512.mask.cmp.d.128(<4 x i32> %a0, <4 x i32> %a1, i32 5, i8 %mask)
 423   %vec5 = insertelement <8 x i8> %vec4, i8 %res5, i32 5
 424 ; CHECK: vpcmpnled %xmm1, %xmm0, %k0 {%k1} ##
 425   %res6 = call i8 @llvm.x86.avx512.mask.cmp.d.128(<4 x i32> %a0, <4 x i32> %a1, i32 6, i8 %mask)
 426   %vec6 = insertelement <8 x i8> %vec5, i8 %res6, i32 6
 427 ; CHECK: vpcmpordd %xmm1, %xmm0, %k0 {%k1} ##
 428   %res7 = call i8 @llvm.x86.avx512.mask.cmp.d.128(<4 x i32> %a0, <4 x i32> %a1, i32 7, i8 %mask)
 429   %vec7 = insertelement <8 x i8> %vec6, i8 %res7, i32 7
 430   ret <8 x i8> %vec7
 431 }
 432
 433 declare i8 @llvm.x86.avx512.mask.cmp.d.128(<4 x i32>, <4 x i32>, i32, i8) nounwind readnone
 434
 435 define <8 x i8> @test_ucmp_d_128(<4 x i32> %a0, <4 x i32> %a1) {
 436 ; CHECK-LABEL: test_ucmp_d_128
 437 ; CHECK: vpcmpequd %xmm1, %xmm0, %k0 ##
 438   %res0 = call i8 @llvm.x86.avx512.mask.ucmp.d.128(<4 x i32> %a0, <4 x i32> %a1, i32 0, i8 -1)
 439   %vec0 = insertelement <8 x i8> undef, i8 %res0, i32 0
 440 ; CHECK: vpcmpltud %xmm1, %xmm0, %k0 ##
 441   %res1 = call i8 @llvm.x86.avx512.mask.ucmp.d.128(<4 x i32> %a0, <4 x i32> %a1, i32 1, i8 -1)
 442   %vec1 = insertelement <8 x i8> %vec0, i8 %res1, i32 1
 443 ; CHECK: vpcmpleud %xmm1, %xmm0, %k0 ##
 444   %res2 = call i8 @llvm.x86.avx512.mask.ucmp.d.128(<4 x i32> %a0, <4 x i32> %a1, i32 2, i8 -1)
 445   %vec2 = insertelement <8 x i8> %vec1, i8 %res2, i32 2
 446 ; CHECK: vpcmpunordud %xmm1, %xmm0, %k0 ##
 447   %res3 = call i8 @llvm.x86.avx512.mask.ucmp.d.128(<4 x i32> %a0, <4 x i32> %a1, i32 3, i8 -1)
 448   %vec3 = insertelement <8 x i8> %vec2, i8 %res3, i32 3
 449 ; CHECK: vpcmpnequd %xmm1, %xmm0, %k0 ##
 450   %res4 = call i8 @llvm.x86.avx512.mask.ucmp.d.128(<4 x i32> %a0, <4 x i32> %a1, i32 4, i8 -1)
 451   %vec4 = insertelement <8 x i8> %vec3, i8 %res4, i32 4
 452 ; CHECK: vpcmpnltud %xmm1, %xmm0, %k0 ##
 453   %res5 = call i8 @llvm.x86.avx512.mask.ucmp.d.128(<4 x i32> %a0, <4 x i32> %a1, i32 5, i8 -1)
 454   %vec5 = insertelement <8 x i8> %vec4, i8 %res5, i32 5
 455 ; CHECK: vpcmpnleud %xmm1, %xmm0, %k0 ##
 456   %res6 = call i8 @llvm.x86.avx512.mask.ucmp.d.128(<4 x i32> %a0, <4 x i32> %a1, i32 6, i8 -1)
 457   %vec6 = insertelement <8 x i8> %vec5, i8 %res6, i32 6
 458 ; CHECK: vpcmpordud %xmm1, %xmm0, %k0 ##
 459   %res7 = call i8 @llvm.x86.avx512.mask.ucmp.d.128(<4 x i32> %a0, <4 x i32> %a1, i32 7, i8 -1)
 460   %vec7 = insertelement <8 x i8> %vec6, i8 %res7, i32 7
 461   ret <8 x i8> %vec7
 462 }
 463
 464 define <8 x i8> @test_mask_ucmp_d_128(<4 x i32> %a0, <4 x i32> %a1, i8 %mask) {
 465 ; CHECK-LABEL: test_mask_ucmp_d_128
 466 ; CHECK: vpcmpequd %xmm1, %xmm0, %k0 {%k1} ##
 467   %res0 = call i8 @llvm.x86.avx512.mask.ucmp.d.128(<4 x i32> %a0, <4 x i32> %a1, i32 0, i8 %mask)
 468   %vec0 = insertelement <8 x i8> undef, i8 %res0, i32 0
 469 ; CHECK: vpcmpltud %xmm1, %xmm0, %k0 {%k1} ##
 470   %res1 = call i8 @llvm.x86.avx512.mask.ucmp.d.128(<4 x i32> %a0, <4 x i32> %a1, i32 1, i8 %mask)
 471   %vec1 = insertelement <8 x i8> %vec0, i8 %res1, i32 1
 472 ; CHECK: vpcmpleud %xmm1, %xmm0, %k0 {%k1} ##
 473   %res2 = call i8 @llvm.x86.avx512.mask.ucmp.d.128(<4 x i32> %a0, <4 x i32> %a1, i32 2, i8 %mask)
 474   %vec2 = insertelement <8 x i8> %vec1, i8 %res2, i32 2
 475 ; CHECK: vpcmpunordud %xmm1, %xmm0, %k0 {%k1} ##
 476   %res3 = call i8 @llvm.x86.avx512.mask.ucmp.d.128(<4 x i32> %a0, <4 x i32> %a1, i32 3, i8 %mask)
 477   %vec3 = insertelement <8 x i8> %vec2, i8 %res3, i32 3
 478 ; CHECK: vpcmpnequd %xmm1, %xmm0, %k0 {%k1} ##
 479   %res4 = call i8 @llvm.x86.avx512.mask.ucmp.d.128(<4 x i32> %a0, <4 x i32> %a1, i32 4, i8 %mask)
 480   %vec4 = insertelement <8 x i8> %vec3, i8 %res4, i32 4
 481 ; CHECK: vpcmpnltud %xmm1, %xmm0, %k0 {%k1} ##
 482   %res5 = call i8 @llvm.x86.avx512.mask.ucmp.d.128(<4 x i32> %a0, <4 x i32> %a1, i32 5, i8 %mask)
 483   %vec5 = insertelement <8 x i8> %vec4, i8 %res5, i32 5
 484 ; CHECK: vpcmpnleud %xmm1, %xmm0, %k0 {%k1} ##
 485   %res6 = call i8 @llvm.x86.avx512.mask.ucmp.d.128(<4 x i32> %a0, <4 x i32> %a1, i32 6, i8 %mask)
 486   %vec6 = insertelement <8 x i8> %vec5, i8 %res6, i32 6
 487 ; CHECK: vpcmpordud %xmm1, %xmm0, %k0 {%k1} ##
 488   %res7 = call i8 @llvm.x86.avx512.mask.ucmp.d.128(<4 x i32> %a0, <4 x i32> %a1, i32 7, i8 %mask)
 489   %vec7 = insertelement <8 x i8> %vec6, i8 %res7, i32 7
 490   ret <8 x i8> %vec7
 491 }
 492
 493 declare i8 @llvm.x86.avx512.mask.ucmp.d.128(<4 x i32>, <4 x i32>, i32, i8) nounwind readnone
 494
 495 define <8 x i8> @test_cmp_q_128(<2 x i64> %a0, <2 x i64> %a1) {
 496 ; CHECK-LABEL: test_cmp_q_128
 497 ; CHECK: vpcmpeqq %xmm1, %xmm0, %k0 ##
 498   %res0 = call i8 @llvm.x86.avx512.mask.cmp.q.128(<2 x i64> %a0, <2 x i64> %a1, i32 0, i8 -1)
 499   %vec0 = insertelement <8 x i8> undef, i8 %res0, i32 0
 500 ; CHECK: vpcmpltq %xmm1, %xmm0, %k0 ##
 501   %res1 = call i8 @llvm.x86.avx512.mask.cmp.q.128(<2 x i64> %a0, <2 x i64> %a1, i32 1, i8 -1)
 502   %vec1 = insertelement <8 x i8> %vec0, i8 %res1, i32 1
 503 ; CHECK: vpcmpleq %xmm1, %xmm0, %k0 ##
 504   %res2 = call i8 @llvm.x86.avx512.mask.cmp.q.128(<2 x i64> %a0, <2 x i64> %a1, i32 2, i8 -1)
 505   %vec2 = insertelement <8 x i8> %vec1, i8 %res2, i32 2
 506 ; CHECK: vpcmpunordq %xmm1, %xmm0, %k0 ##
 507   %res3 = call i8 @llvm.x86.avx512.mask.cmp.q.128(<2 x i64> %a0, <2 x i64> %a1, i32 3, i8 -1)
 508   %vec3 = insertelement <8 x i8> %vec2, i8 %res3, i32 3
 509 ; CHECK: vpcmpneqq %xmm1, %xmm0, %k0 ##
 510   %res4 = call i8 @llvm.x86.avx512.mask.cmp.q.128(<2 x i64> %a0, <2 x i64> %a1, i32 4, i8 -1)
 511   %vec4 = insertelement <8 x i8> %vec3, i8 %res4, i32 4
 512 ; CHECK: vpcmpnltq %xmm1, %xmm0, %k0 ##
 513   %res5 = call i8 @llvm.x86.avx512.mask.cmp.q.128(<2 x i64> %a0, <2 x i64> %a1, i32 5, i8 -1)
 514   %vec5 = insertelement <8 x i8> %vec4, i8 %res5, i32 5
 515 ; CHECK: vpcmpnleq %xmm1, %xmm0, %k0 ##
 516   %res6 = call i8 @llvm.x86.avx512.mask.cmp.q.128(<2 x i64> %a0, <2 x i64> %a1, i32 6, i8 -1)
 517   %vec6 = insertelement <8 x i8> %vec5, i8 %res6, i32 6
 518 ; CHECK: vpcmpordq %xmm1, %xmm0, %k0 ##
 519   %res7 = call i8 @llvm.x86.avx512.mask.cmp.q.128(<2 x i64> %a0, <2 x i64> %a1, i32 7, i8 -1)
 520   %vec7 = insertelement <8 x i8> %vec6, i8 %res7, i32 7
 521   ret <8 x i8> %vec7
 522 }
 523
 524 define <8 x i8> @test_mask_cmp_q_128(<2 x i64> %a0, <2 x i64> %a1, i8 %mask) {
 525 ; CHECK-LABEL: test_mask_cmp_q_128
 526 ; CHECK: vpcmpeqq %xmm1, %xmm0, %k0 {%k1} ##
 527   %res0 = call i8 @llvm.x86.avx512.mask.cmp.q.128(<2 x i64> %a0, <2 x i64> %a1, i32 0, i8 %mask)
 528   %vec0 = insertelement <8 x i8> undef, i8 %res0, i32 0
 529 ; CHECK: vpcmpltq %xmm1, %xmm0, %k0 {%k1} ##
 530   %res1 = call i8 @llvm.x86.avx512.mask.cmp.q.128(<2 x i64> %a0, <2 x i64> %a1, i32 1, i8 %mask)
 531   %vec1 = insertelement <8 x i8> %vec0, i8 %res1, i32 1
 532 ; CHECK: vpcmpleq %xmm1, %xmm0, %k0 {%k1} ##
 533   %res2 = call i8 @llvm.x86.avx512.mask.cmp.q.128(<2 x i64> %a0, <2 x i64> %a1, i32 2, i8 %mask)
 534   %vec2 = insertelement <8 x i8> %vec1, i8 %res2, i32 2
 535 ; CHECK: vpcmpunordq %xmm1, %xmm0, %k0 {%k1} ##
 536   %res3 = call i8 @llvm.x86.avx512.mask.cmp.q.128(<2 x i64> %a0, <2 x i64> %a1, i32 3, i8 %mask)
 537   %vec3 = insertelement <8 x i8> %vec2, i8 %res3, i32 3
 538 ; CHECK: vpcmpneqq %xmm1, %xmm0, %k0 {%k1} ##
 539   %res4 = call i8 @llvm.x86.avx512.mask.cmp.q.128(<2 x i64> %a0, <2 x i64> %a1, i32 4, i8 %mask)
 540   %vec4 = insertelement <8 x i8> %vec3, i8 %res4, i32 4
 541 ; CHECK: vpcmpnltq %xmm1, %xmm0, %k0 {%k1} ##
 542   %res5 = call i8 @llvm.x86.avx512.mask.cmp.q.128(<2 x i64> %a0, <2 x i64> %a1, i32 5, i8 %mask)
 543   %vec5 = insertelement <8 x i8> %vec4, i8 %res5, i32 5
 544 ; CHECK: vpcmpnleq %xmm1, %xmm0, %k0 {%k1} ##
 545   %res6 = call i8 @llvm.x86.avx512.mask.cmp.q.128(<2 x i64> %a0, <2 x i64> %a1, i32 6, i8 %mask)
 546   %vec6 = insertelement <8 x i8> %vec5, i8 %res6, i32 6
 547 ; CHECK: vpcmpordq %xmm1, %xmm0, %k0 {%k1} ##
 548   %res7 = call i8 @llvm.x86.avx512.mask.cmp.q.128(<2 x i64> %a0, <2 x i64> %a1, i32 7, i8 %mask)
 549   %vec7 = insertelement <8 x i8> %vec6, i8 %res7, i32 7
 550   ret <8 x i8> %vec7
 551 }
 552
 553 declare i8 @llvm.x86.avx512.mask.cmp.q.128(<2 x i64>, <2 x i64>, i32, i8) nounwind readnone
 554
 555 define <8 x i8> @test_ucmp_q_128(<2 x i64> %a0, <2 x i64> %a1) {
 556 ; CHECK-LABEL: test_ucmp_q_128
 557 ; CHECK: vpcmpequq %xmm1, %xmm0, %k0 ##
 558   %res0 = call i8 @llvm.x86.avx512.mask.ucmp.q.128(<2 x i64> %a0, <2 x i64> %a1, i32 0, i8 -1)
 559   %vec0 = insertelement <8 x i8> undef, i8 %res0, i32 0
 560 ; CHECK: vpcmpltuq %xmm1, %xmm0, %k0 ##
 561   %res1 = call i8 @llvm.x86.avx512.mask.ucmp.q.128(<2 x i64> %a0, <2 x i64> %a1, i32 1, i8 -1)
 562   %vec1 = insertelement <8 x i8> %vec0, i8 %res1, i32 1
 563 ; CHECK: vpcmpleuq %xmm1, %xmm0, %k0 ##
 564   %res2 = call i8 @llvm.x86.avx512.mask.ucmp.q.128(<2 x i64> %a0, <2 x i64> %a1, i32 2, i8 -1)
 565   %vec2 = insertelement <8 x i8> %vec1, i8 %res2, i32 2
 566 ; CHECK: vpcmpunorduq %xmm1, %xmm0, %k0 ##
 567   %res3 = call i8 @llvm.x86.avx512.mask.ucmp.q.128(<2 x i64> %a0, <2 x i64> %a1, i32 3, i8 -1)
 568   %vec3 = insertelement <8 x i8> %vec2, i8 %res3, i32 3
 569 ; CHECK: vpcmpnequq %xmm1, %xmm0, %k0 ##
 570   %res4 = call i8 @llvm.x86.avx512.mask.ucmp.q.128(<2 x i64> %a0, <2 x i64> %a1, i32 4, i8 -1)
 571   %vec4 = insertelement <8 x i8> %vec3, i8 %res4, i32 4
 572 ; CHECK: vpcmpnltuq %xmm1, %xmm0, %k0 ##
 573   %res5 = call i8 @llvm.x86.avx512.mask.ucmp.q.128(<2 x i64> %a0, <2 x i64> %a1, i32 5, i8 -1)
 574   %vec5 = insertelement <8 x i8> %vec4, i8 %res5, i32 5
 575 ; CHECK: vpcmpnleuq %xmm1, %xmm0, %k0 ##
 576   %res6 = call i8 @llvm.x86.avx512.mask.ucmp.q.128(<2 x i64> %a0, <2 x i64> %a1, i32 6, i8 -1)
 577   %vec6 = insertelement <8 x i8> %vec5, i8 %res6, i32 6
 578 ; CHECK: vpcmporduq %xmm1, %xmm0, %k0 ##
 579   %res7 = call i8 @llvm.x86.avx512.mask.ucmp.q.128(<2 x i64> %a0, <2 x i64> %a1, i32 7, i8 -1)
 580   %vec7 = insertelement <8 x i8> %vec6, i8 %res7, i32 7
 581   ret <8 x i8> %vec7
 582 }
 583
 584 define <8 x i8> @test_mask_ucmp_q_128(<2 x i64> %a0, <2 x i64> %a1, i8 %mask) {
 585 ; CHECK-LABEL: test_mask_ucmp_q_128
 586 ; CHECK: vpcmpequq %xmm1, %xmm0, %k0 {%k1} ##
 587   %res0 = call i8 @llvm.x86.avx512.mask.ucmp.q.128(<2 x i64> %a0, <2 x i64> %a1, i32 0, i8 %mask)
 588   %vec0 = insertelement <8 x i8> undef, i8 %res0, i32 0
 589 ; CHECK: vpcmpltuq %xmm1, %xmm0, %k0 {%k1} ##
 590   %res1 = call i8 @llvm.x86.avx512.mask.ucmp.q.128(<2 x i64> %a0, <2 x i64> %a1, i32 1, i8 %mask)
 591   %vec1 = insertelement <8 x i8> %vec0, i8 %res1, i32 1
 592 ; CHECK: vpcmpleuq %xmm1, %xmm0, %k0 {%k1} ##
 593   %res2 = call i8 @llvm.x86.avx512.mask.ucmp.q.128(<2 x i64> %a0, <2 x i64> %a1, i32 2, i8 %mask)
 594   %vec2 = insertelement <8 x i8> %vec1, i8 %res2, i32 2
 595 ; CHECK: vpcmpunorduq %xmm1, %xmm0, %k0 {%k1} ##
 596   %res3 = call i8 @llvm.x86.avx512.mask.ucmp.q.128(<2 x i64> %a0, <2 x i64> %a1, i32 3, i8 %mask)
 597   %vec3 = insertelement <8 x i8> %vec2, i8 %res3, i32 3
 598 ; CHECK: vpcmpnequq %xmm1, %xmm0, %k0 {%k1} ##
 599   %res4 = call i8 @llvm.x86.avx512.mask.ucmp.q.128(<2 x i64> %a0, <2 x i64> %a1, i32 4, i8 %mask)
 600   %vec4 = insertelement <8 x i8> %vec3, i8 %res4, i32 4
 601 ; CHECK: vpcmpnltuq %xmm1, %xmm0, %k0 {%k1} ##
 602   %res5 = call i8 @llvm.x86.avx512.mask.ucmp.q.128(<2 x i64> %a0, <2 x i64> %a1, i32 5, i8 %mask)
 603   %vec5 = insertelement <8 x i8> %vec4, i8 %res5, i32 5
 604 ; CHECK: vpcmpnleuq %xmm1, %xmm0, %k0 {%k1} ##
 605   %res6 = call i8 @llvm.x86.avx512.mask.ucmp.q.128(<2 x i64> %a0, <2 x i64> %a1, i32 6, i8 %mask)
 606   %vec6 = insertelement <8 x i8> %vec5, i8 %res6, i32 6
 607 ; CHECK: vpcmporduq %xmm1, %xmm0, %k0 {%k1} ##
 608   %res7 = call i8 @llvm.x86.avx512.mask.ucmp.q.128(<2 x i64> %a0, <2 x i64> %a1, i32 7, i8 %mask)
 609   %vec7 = insertelement <8 x i8> %vec6, i8 %res7, i32 7
 610   ret <8 x i8> %vec7
 611 }
 612
 613 declare i8 @llvm.x86.avx512.mask.ucmp.q.128(<2 x i64>, <2 x i64>, i32, i8) nounwind readnone
 614
 615 ; CHECK-LABEL: compr1
 616 ; CHECK: vcompresspd %zmm0
 617 define void @compr1(i8* %addr, <8 x double> %data, i8 %mask) {
 618   call void @llvm.x86.avx512.mask.compress.store.pd.512(i8* %addr, <8 x double> %data, i8 %mask)
 619   ret void
 620 }
 621
 622 declare void @llvm.x86.avx512.mask.compress.store.pd.512(i8* %addr, <8 x double> %data, i8 %mask)
 623
 624 ; CHECK-LABEL: compr2
 625 ; CHECK: vcompresspd %ymm0
 626 define void @compr2(i8* %addr, <4 x double> %data, i8 %mask) {
 627   call void @llvm.x86.avx512.mask.compress.store.pd.256(i8* %addr, <4 x double> %data, i8 %mask)
 628   ret void
 629 }
 630
 631 declare void @llvm.x86.avx512.mask.compress.store.pd.256(i8* %addr, <4 x double> %data, i8 %mask)
 632
 633 ; CHECK-LABEL: compr3
 634 ; CHECK: vcompressps %xmm0
 635 define void @compr3(i8* %addr, <4 x float> %data, i8 %mask) {
 636   call void @llvm.x86.avx512.mask.compress.store.ps.128(i8* %addr, <4 x float> %data, i8 %mask)
 637   ret void
 638 }
 639
 640 declare void @llvm.x86.avx512.mask.compress.store.ps.128(i8* %addr, <4 x float> %data, i8 %mask)
 641
 642 ; CHECK-LABEL: compr4
 643 ; CHECK: vcompresspd %zmm0, %zmm0 {%k1} {z} ## encoding: [0x62,0xf2,0xfd,0xc9,0x8a,0xc0]
 644 define <8 x double> @compr4(i8* %addr, <8 x double> %data, i8 %mask) {
 645   %res = call <8 x double> @llvm.x86.avx512.mask.compress.pd.512(<8 x double> %data, <8 x double> zeroinitializer, i8 %mask)
 646   ret <8 x double> %res
 647 }
 648
 649 declare <8 x double> @llvm.x86.avx512.mask.compress.pd.512(<8 x double> %data, <8 x double> %src0, i8 %mask)
 650
 651 ; CHECK-LABEL: compr5
 652 ; CHECK: vcompresspd %ymm0, %ymm1 {%k1}  ## encoding: [0x62,0xf2,0xfd,0x29,0x8a,0xc1]
 653 define <4 x double> @compr5(<4 x double> %data, <4 x double> %src0, i8 %mask) {
 654   %res = call <4 x double> @llvm.x86.avx512.mask.compress.pd.256( <4 x double> %data, <4 x double> %src0, i8 %mask)
 655   ret <4 x double> %res
 656 }
 657
 658 declare <4 x double> @llvm.x86.avx512.mask.compress.pd.256(<4 x double> %data, <4 x double> %src0, i8 %mask)
 659
 660 ; CHECK-LABEL: compr6
 661 ; CHECK: vcompressps %xmm0
 662 define <4 x float> @compr6(<4 x float> %data, i8 %mask) {
 663   %res = call <4 x float> @llvm.x86.avx512.mask.compress.ps.128(<4 x float> %data, <4 x float>zeroinitializer, i8 %mask)
 664   ret <4 x float> %res
 665 }
 666
 667 declare <4 x float> @llvm.x86.avx512.mask.compress.ps.128(<4 x float> %data, <4 x float> %src0, i8 %mask)
 668
 669 ; CHECK-LABEL: compr7
 670 ; CHECK-NOT: vcompress
 671 ; CHECK: vmovupd
 672 define void @compr7(i8* %addr, <8 x double> %data) {
 673   call void @llvm.x86.avx512.mask.compress.store.pd.512(i8* %addr, <8 x double> %data, i8 -1)
 674   ret void
 675 }
 676
 677 ; CHECK-LABEL: compr8
 678 ; CHECK-NOT: vcompressps %xmm0
 679 define <4 x float> @compr8(<4 x float> %data) {
 680   %res = call <4 x float> @llvm.x86.avx512.mask.compress.ps.128(<4 x float> %data, <4 x float>zeroinitializer, i8 -1)
 681   ret <4 x float> %res
 682 }
 683
 684 ; CHECK-LABEL: compr9
 685 ; CHECK: vpcompressq %zmm0, (%rdi) {%k1}  ## encoding: [0x62,0xf2,0xfd,0x49,0x8b,0x07]
 686 define void @compr9(i8* %addr, <8 x i64> %data, i8 %mask) {
 687   call void @llvm.x86.avx512.mask.compress.store.q.512(i8* %addr, <8 x i64> %data, i8 %mask)
 688   ret void
 689 }
 690
 691 declare void @llvm.x86.avx512.mask.compress.store.q.512(i8* %addr, <8 x i64> %data, i8 %mask)
 692
 693 ; CHECK-LABEL: compr10
 694 ; CHECK: vpcompressd %xmm0, %xmm0 {%k1} {z} ## encoding: [0x62,0xf2,0x7d,0x89,0x8b,0xc0]
 695 define <4 x i32> @compr10(<4 x i32> %data, i8 %mask) {
 696   %res = call <4 x i32> @llvm.x86.avx512.mask.compress.d.128(<4 x i32> %data, <4 x i32>zeroinitializer, i8 %mask)
 697   ret <4 x i32> %res
 698 }
 699
 700 declare <4 x i32> @llvm.x86.avx512.mask.compress.d.128(<4 x i32> %data, <4 x i32> %src0, i8 %mask)
 701
 702 ; Expand
 703
 704 ; CHECK-LABEL: expand1
 705 ; CHECK: vexpandpd (%rdi), %zmm0 {%k1}  ## encoding: [0x62,0xf2,0xfd,0x49,0x88,0x07]
 706 define <8 x double> @expand1(i8* %addr, <8 x double> %data, i8 %mask) {
 707   %res = call <8 x double> @llvm.x86.avx512.mask.expand.load.pd.512(i8* %addr, <8 x double> %data, i8 %mask)
 708   ret <8 x double> %res
 709 }
 710
 711 declare <8 x double> @llvm.x86.avx512.mask.expand.load.pd.512(i8* %addr, <8 x double> %data, i8 %mask)
 712
 713 ; CHECK-LABEL: expand2
 714 ; CHECK: vexpandpd (%rdi), %ymm0 {%k1} ## encoding: [0x62,0xf2,0xfd,0x29,0x88,0x07]
 715 define <4 x double> @expand2(i8* %addr, <4 x double> %data, i8 %mask) {
 716   %res = call <4 x double> @llvm.x86.avx512.mask.expand.load.pd.256(i8* %addr, <4 x double> %data, i8 %mask)
 717   ret <4 x double> %res
 718 }
 719
 720 declare <4 x double> @llvm.x86.avx512.mask.expand.load.pd.256(i8* %addr, <4 x double> %data, i8 %mask)
 721
 722 ; CHECK-LABEL: expand3
 723 ; CHECK: vexpandps (%rdi), %xmm0 {%k1} ## encoding: [0x62,0xf2,0x7d,0x09,0x88,0x07]
 724 define <4 x float> @expand3(i8* %addr, <4 x float> %data, i8 %mask) {
 725   %res = call <4 x float> @llvm.x86.avx512.mask.expand.load.ps.128(i8* %addr, <4 x float> %data, i8 %mask)
 726   ret <4 x float> %res
 727 }
 728
 729 declare <4 x float> @llvm.x86.avx512.mask.expand.load.ps.128(i8* %addr, <4 x float> %data, i8 %mask)
 730
 731 ; CHECK-LABEL: expand4
 732 ; CHECK: vexpandpd %zmm0, %zmm0 {%k1} {z} ## encoding: [0x62,0xf2,0xfd,0xc9,0x88,0xc0]
 733 define <8 x double> @expand4(i8* %addr, <8 x double> %data, i8 %mask) {
 734   %res = call <8 x double> @llvm.x86.avx512.mask.expand.pd.512(<8 x double> %data, <8 x double> zeroinitializer, i8 %mask)
 735   ret <8 x double> %res
 736 }
 737
 738 declare <8 x double> @llvm.x86.avx512.mask.expand.pd.512(<8 x double> %data, <8 x double> %src0, i8 %mask)
 739
 740 ; CHECK-LABEL: expand5
 741 ; CHECK: vexpandpd %ymm0, %ymm1 {%k1}  ## encoding: [0x62,0xf2,0xfd,0x29,0x88,0xc8]
 742 define <4 x double> @expand5(<4 x double> %data, <4 x double> %src0, i8 %mask) {
 743   %res = call <4 x double> @llvm.x86.avx512.mask.expand.pd.256( <4 x double> %data, <4 x double> %src0, i8 %mask)
 744   ret <4 x double> %res
 745 }
 746
 747 declare <4 x double> @llvm.x86.avx512.mask.expand.pd.256(<4 x double> %data, <4 x double> %src0, i8 %mask)
 748
 749 ; CHECK-LABEL: expand6
 750 ; CHECK: vexpandps %xmm0
 751 define <4 x float> @expand6(<4 x float> %data, i8 %mask) {
 752   %res = call <4 x float> @llvm.x86.avx512.mask.expand.ps.128(<4 x float> %data, <4 x float>zeroinitializer, i8 %mask)
 753   ret <4 x float> %res
 754 }
 755
 756 declare <4 x float> @llvm.x86.avx512.mask.expand.ps.128(<4 x float> %data, <4 x float> %src0, i8 %mask)
 757
 758 ; CHECK-LABEL: expand7
 759 ; CHECK-NOT: vexpand
 760 ; CHECK: vmovupd
 761 define <8 x double> @expand7(i8* %addr, <8 x double> %data) {
 762   %res = call <8 x double> @llvm.x86.avx512.mask.expand.load.pd.512(i8* %addr, <8 x double> %data, i8 -1)
 763   ret <8 x double> %res
 764 }
 765
 766 ; CHECK-LABEL: expand8
 767 ; CHECK-NOT: vexpandps %xmm0
 768 define <4 x float> @expand8(<4 x float> %data) {
 769   %res = call <4 x float> @llvm.x86.avx512.mask.expand.ps.128(<4 x float> %data, <4 x float>zeroinitializer, i8 -1)
 770   ret <4 x float> %res
 771 }
 772
 773 ; CHECK-LABEL: expand9
 774 ; CHECK: vpexpandq (%rdi), %zmm0 {%k1} ## encoding: [0x62,0xf2,0xfd,0x49,0x89,0x07]
 775 define <8 x i64> @expand9(i8* %addr, <8 x i64> %data, i8 %mask) {
 776   %res = call <8 x i64> @llvm.x86.avx512.mask.expand.load.q.512(i8* %addr, <8 x i64> %data, i8 %mask)
 777   ret <8 x i64> %res
 778 }
 779
 780 declare <8 x i64> @llvm.x86.avx512.mask.expand.load.q.512(i8* %addr, <8 x i64> %data, i8 %mask)
 781
 782 ; CHECK-LABEL: expand10
 783 ; CHECK: vpexpandd %xmm0, %xmm0 {%k1} {z} ## encoding: [0x62,0xf2,0x7d,0x89,0x89,0xc0]
 784 define <4 x i32> @expand10(<4 x i32> %data, i8 %mask) {
 785   %res = call <4 x i32> @llvm.x86.avx512.mask.expand.d.128(<4 x i32> %data, <4 x i32>zeroinitializer, i8 %mask)
 786   ret <4 x i32> %res
 787 }
 788
 789 declare <4 x i32> @llvm.x86.avx512.mask.expand.d.128(<4 x i32> %data, <4 x i32> %src0, i8 %mask)
 790
 791 define <8 x float> @test_x86_mask_blend_ps_256(i8 %a0, <8 x float> %a1, <8 x float> %a2) {
 792   ; CHECK: vblendmps %ymm1, %ymm0
 793   %res = call <8 x float> @llvm.x86.avx512.mask.blend.ps.256(<8 x float> %a1, <8 x float> %a2, i8 %a0) ; <<8 x float>> [#uses=1]
 794   ret <8 x float> %res
 795 }
 796
 797 declare <8 x float> @llvm.x86.avx512.mask.blend.ps.256(<8 x float>, <8 x float>, i8) nounwind readonly
 798
 799 define <4 x double> @test_x86_mask_blend_pd_256(i8 %a0, <4 x double> %a1, <4 x double> %a2) {
 800   ; CHECK: vblendmpd %ymm1, %ymm0
 801   %res = call <4 x double> @llvm.x86.avx512.mask.blend.pd.256(<4 x double> %a1, <4 x double> %a2, i8 %a0) ; <<4 x double>> [#uses=1]
 802   ret <4 x double> %res
 803 }
 804
 805 define <4 x double> @test_x86_mask_blend_pd_256_memop(<4 x double> %a, <4 x double>* %ptr, i8 %mask) {
 806   ; CHECK-LABEL: test_x86_mask_blend_pd_256_memop
 807   ; CHECK: vblendmpd (%
 808   %b = load <4 x double>, <4 x double>* %ptr
 809   %res = call <4 x double> @llvm.x86.avx512.mask.blend.pd.256(<4 x double> %a, <4 x double> %b, i8 %mask) ; <<4 x double>> [#uses=1]
 810   ret <4 x double> %res
 811 }
 812 declare <4 x double> @llvm.x86.avx512.mask.blend.pd.256(<4 x double>, <4 x double>, i8) nounwind readonly
 813
 814 ; CHECK-LABEL: test_x86_mask_blend_d_256
 815 ; CHECK: vpblendmd
 816 define <8 x i32> @test_x86_mask_blend_d_256(i8 %a0, <8 x i32> %a1, <8 x i32> %a2) {
 817   %res = call <8 x i32> @llvm.x86.avx512.mask.blend.d.256(<8 x i32> %a1, <8 x i32> %a2, i8 %a0) ; <<8 x i32>> [#uses=1]
 818   ret <8 x i32> %res
 819 }
 820 declare <8 x i32> @llvm.x86.avx512.mask.blend.d.256(<8 x i32>, <8 x i32>, i8) nounwind readonly
 821
 822 define <4 x i64> @test_x86_mask_blend_q_256(i8 %a0, <4 x i64> %a1, <4 x i64> %a2) {
 823   ; CHECK: vpblendmq
 824   %res = call <4 x i64> @llvm.x86.avx512.mask.blend.q.256(<4 x i64> %a1, <4 x i64> %a2, i8 %a0) ; <<4 x i64>> [#uses=1]
 825   ret <4 x i64> %res
 826 }
 827 declare <4 x i64> @llvm.x86.avx512.mask.blend.q.256(<4 x i64>, <4 x i64>, i8) nounwind readonly
 828
 829 define <4 x float> @test_x86_mask_blend_ps_128(i8 %a0, <4 x float> %a1, <4 x float> %a2) {
 830   ; CHECK: vblendmps %xmm1, %xmm0
 831   %res = call <4 x float> @llvm.x86.avx512.mask.blend.ps.128(<4 x float> %a1, <4 x float> %a2, i8 %a0) ; <<4 x float>> [#uses=1]
 832   ret <4 x float> %res
 833 }
 834
 835 declare <4 x float> @llvm.x86.avx512.mask.blend.ps.128(<4 x float>, <4 x float>, i8) nounwind readonly
 836
 837 define <2 x double> @test_x86_mask_blend_pd_128(i8 %a0, <2 x double> %a1, <2 x double> %a2) {
 838   ; CHECK: vblendmpd %xmm1, %xmm0
 839   %res = call <2 x double> @llvm.x86.avx512.mask.blend.pd.128(<2 x double> %a1, <2 x double> %a2, i8 %a0) ; <<2 x double>> [#uses=1]
 840   ret <2 x double> %res
 841 }
 842
 843 define <2 x double> @test_x86_mask_blend_pd_128_memop(<2 x double> %a, <2 x double>* %ptr, i8 %mask) {
 844   ; CHECK-LABEL: test_x86_mask_blend_pd_128_memop
 845   ; CHECK: vblendmpd (%
 846   %b = load <2 x double>, <2 x double>* %ptr
 847   %res = call <2 x double> @llvm.x86.avx512.mask.blend.pd.128(<2 x double> %a, <2 x double> %b, i8 %mask) ; <<2 x double>> [#uses=1]
 848   ret <2 x double> %res
 849 }
 850 declare <2 x double> @llvm.x86.avx512.mask.blend.pd.128(<2 x double>, <2 x double>, i8) nounwind readonly
 851
 852 define <4 x i32> @test_x86_mask_blend_d_128(i8 %a0, <4 x i32> %a1, <4 x i32> %a2) {
 853   ; CHECK: vpblendmd
 854   %res = call <4 x i32> @llvm.x86.avx512.mask.blend.d.128(<4 x i32> %a1, <4 x i32> %a2, i8 %a0) ; <<4 x i32>> [#uses=1]
 855   ret <4 x i32> %res
 856 }
 857 declare <4 x i32> @llvm.x86.avx512.mask.blend.d.128(<4 x i32>, <4 x i32>, i8) nounwind readonly
 858
 859 define <2 x i64> @test_x86_mask_blend_q_128(i8 %a0, <2 x i64> %a1, <2 x i64> %a2) {
 860   ; CHECK: vpblendmq
 861   %res = call <2 x i64> @llvm.x86.avx512.mask.blend.q.128(<2 x i64> %a1, <2 x i64> %a2, i8 %a0) ; <<2 x i64>> [#uses=1]
 862   ret <2 x i64> %res
 863 }
 864 declare <2 x i64> @llvm.x86.avx512.mask.blend.q.128(<2 x i64>, <2 x i64>, i8) nounwind readonly
 865
 866
 867 define < 2 x i64> @test_mask_mul_epi32_rr_128(< 4 x i32> %a, < 4 x i32> %b) {
 868   ;CHECK-LABEL: test_mask_mul_epi32_rr_128
 869   ;CHECK: vpmuldq %xmm1, %xmm0, %xmm0     ## encoding: [0x62,0xf2,0xfd,0x08,0x28,0xc1]
 870   %res = call < 2 x i64> @llvm.x86.avx512.mask.pmul.dq.128(< 4 x i32> %a, < 4 x i32> %b, < 2 x i64> zeroinitializer, i8 -1)
 871   ret < 2 x i64> %res
 872 }
 873
 874 define < 2 x i64> @test_mask_mul_epi32_rrk_128(< 4 x i32> %a, < 4 x i32> %b, < 2 x i64> %passThru, i8 %mask) {
 875   ;CHECK-LABEL: test_mask_mul_epi32_rrk_128
 876   ;CHECK: vpmuldq %xmm1, %xmm0, %xmm2 {%k1} ## encoding: [0x62,0xf2,0xfd,0x09,0x28,0xd1]
 877   %res = call < 2 x i64> @llvm.x86.avx512.mask.pmul.dq.128(< 4 x i32> %a, < 4 x i32> %b, < 2 x i64> %passThru, i8 %mask)
 878   ret < 2 x i64> %res
 879 }
 880
 881 define < 2 x i64> @test_mask_mul_epi32_rrkz_128(< 4 x i32> %a, < 4 x i32> %b, i8 %mask) {
 882   ;CHECK-LABEL: test_mask_mul_epi32_rrkz_128
 883   ;CHECK: vpmuldq %xmm1, %xmm0, %xmm0 {%k1} {z} ## encoding: [0x62,0xf2,0xfd,0x89,0x28,0xc1]
 884   %res = call < 2 x i64> @llvm.x86.avx512.mask.pmul.dq.128(< 4 x i32> %a, < 4 x i32> %b, < 2 x i64> zeroinitializer, i8 %mask)
 885   ret < 2 x i64> %res
 886 }
 887
 888 define < 2 x i64> @test_mask_mul_epi32_rm_128(< 4 x i32> %a, < 4 x i32>* %ptr_b) {
 889   ;CHECK-LABEL: test_mask_mul_epi32_rm_128
 890   ;CHECK: vpmuldq (%rdi), %xmm0, %xmm0    ## encoding: [0x62,0xf2,0xfd,0x08,0x28,0x07]
 891   %b = load < 4 x i32>, < 4 x i32>* %ptr_b
 892   %res = call < 2 x i64> @llvm.x86.avx512.mask.pmul.dq.128(< 4 x i32> %a, < 4 x i32> %b, < 2 x i64> zeroinitializer, i8 -1)
 893   ret < 2 x i64> %res
 894 }
 895
 896 define < 2 x i64> @test_mask_mul_epi32_rmk_128(< 4 x i32> %a, < 4 x i32>* %ptr_b, < 2 x i64> %passThru, i8 %mask) {
 897   ;CHECK-LABEL: test_mask_mul_epi32_rmk_128
 898   ;CHECK: vpmuldq (%rdi), %xmm0, %xmm1 {%k1} ## encoding: [0x62,0xf2,0xfd,0x09,0x28,0x0f]
 899   %b = load < 4 x i32>, < 4 x i32>* %ptr_b
 900   %res = call < 2 x i64> @llvm.x86.avx512.mask.pmul.dq.128(< 4 x i32> %a, < 4 x i32> %b, < 2 x i64> %passThru, i8 %mask)
 901   ret < 2 x i64> %res
 902 }
 903
 904 define < 2 x i64> @test_mask_mul_epi32_rmkz_128(< 4 x i32> %a, < 4 x i32>* %ptr_b, i8 %mask) {
 905   ;CHECK-LABEL: test_mask_mul_epi32_rmkz_128
 906   ;CHECK: vpmuldq (%rdi), %xmm0, %xmm0 {%k1} {z} ## encoding: [0x62,0xf2,0xfd,0x89,0x28,0x07]
 907   %b = load < 4 x i32>, < 4 x i32>* %ptr_b
 908   %res = call < 2 x i64> @llvm.x86.avx512.mask.pmul.dq.128(< 4 x i32> %a, < 4 x i32> %b, < 2 x i64> zeroinitializer, i8 %mask)
 909   ret < 2 x i64> %res
 910 }
 911
 912 define < 2 x i64> @test_mask_mul_epi32_rmb_128(< 4 x i32> %a, i64* %ptr_b) {
 913   ;CHECK-LABEL: test_mask_mul_epi32_rmb_128
 914   ;CHECK: vpmuldq (%rdi){1to2}, %xmm0, %xmm0  ## encoding: [0x62,0xf2,0xfd,0x18,0x28,0x07]
 915   %q = load i64, i64* %ptr_b
 916   %vecinit.i = insertelement < 2 x i64> undef, i64 %q, i32 0
 917   %b64 = shufflevector < 2 x i64> %vecinit.i, < 2 x i64> undef, <2 x i32> zeroinitializer
 918   %b = bitcast < 2 x i64> %b64 to < 4 x i32>
 919   %res = call < 2 x i64> @llvm.x86.avx512.mask.pmul.dq.128(< 4 x i32> %a, < 4 x i32> %b, < 2 x i64> zeroinitializer, i8 -1)
 920   ret < 2 x i64> %res
 921 }
 922
 923 define < 2 x i64> @test_mask_mul_epi32_rmbk_128(< 4 x i32> %a, i64* %ptr_b, < 2 x i64> %passThru, i8 %mask) {
 924   ;CHECK-LABEL: test_mask_mul_epi32_rmbk_128
 925   ;CHECK: vpmuldq (%rdi){1to2}, %xmm0, %xmm1 {%k1} ## encoding: [0x62,0xf2,0xfd,0x19,0x28,0x0f]
 926   %q = load i64, i64* %ptr_b
 927   %vecinit.i = insertelement < 2 x i64> undef, i64 %q, i32 0
 928   %b64 = shufflevector < 2 x i64> %vecinit.i, < 2 x i64> undef, <2 x i32> zeroinitializer
 929   %b = bitcast < 2 x i64> %b64 to < 4 x i32>
 930   %res = call < 2 x i64> @llvm.x86.avx512.mask.pmul.dq.128(< 4 x i32> %a, < 4 x i32> %b, < 2 x i64> %passThru, i8 %mask)
 931   ret < 2 x i64> %res
 932 }
 933
 934 define < 2 x i64> @test_mask_mul_epi32_rmbkz_128(< 4 x i32> %a, i64* %ptr_b, i8 %mask) {
 935   ;CHECK-LABEL: test_mask_mul_epi32_rmbkz_128
 936   ;CHECK: vpmuldq (%rdi){1to2}, %xmm0, %xmm0 {%k1} {z} ## encoding: [0x62,0xf2,0xfd,0x99,0x28,0x07]
 937   %q = load i64, i64* %ptr_b
 938   %vecinit.i = insertelement < 2 x i64> undef, i64 %q, i32 0
 939   %b64 = shufflevector < 2 x i64> %vecinit.i, < 2 x i64> undef, < 2 x i32> zeroinitializer
 940   %b = bitcast < 2 x i64> %b64 to < 4 x i32>
 941   %res = call < 2 x i64> @llvm.x86.avx512.mask.pmul.dq.128(< 4 x i32> %a, < 4 x i32> %b, < 2 x i64> zeroinitializer, i8 %mask)
 942   ret < 2 x i64> %res
 943 }
 944
 945 declare < 2 x i64> @llvm.x86.avx512.mask.pmul.dq.128(< 4 x i32>, < 4 x i32>, < 2 x i64>, i8)
 946
 947 define < 4 x i64> @test_mask_mul_epi32_rr_256(< 8 x i32> %a, < 8 x i32> %b) {
 948   ;CHECK-LABEL: test_mask_mul_epi32_rr_256
 949   ;CHECK: vpmuldq %ymm1, %ymm0, %ymm0     ## encoding: [0x62,0xf2,0xfd,0x28,0x28,0xc1]
 950   %res = call < 4 x i64> @llvm.x86.avx512.mask.pmul.dq.256(< 8 x i32> %a, < 8 x i32> %b, < 4 x i64> zeroinitializer, i8 -1)
 951   ret < 4 x i64> %res
 952 }
 953
 954 define < 4 x i64> @test_mask_mul_epi32_rrk_256(< 8 x i32> %a, < 8 x i32> %b, < 4 x i64> %passThru, i8 %mask) {
 955   ;CHECK-LABEL: test_mask_mul_epi32_rrk_256
 956   ;CHECK: vpmuldq %ymm1, %ymm0, %ymm2 {%k1} ## encoding: [0x62,0xf2,0xfd,0x29,0x28,0xd1]
 957   %res = call < 4 x i64> @llvm.x86.avx512.mask.pmul.dq.256(< 8 x i32> %a, < 8 x i32> %b, < 4 x i64> %passThru, i8 %mask)
 958   ret < 4 x i64> %res
 959 }
 960
 961 define < 4 x i64> @test_mask_mul_epi32_rrkz_256(< 8 x i32> %a, < 8 x i32> %b, i8 %mask) {
 962   ;CHECK-LABEL: test_mask_mul_epi32_rrkz_256
 963   ;CHECK: vpmuldq %ymm1, %ymm0, %ymm0 {%k1} {z} ## encoding: [0x62,0xf2,0xfd,0xa9,0x28,0xc1]
 964   %res = call < 4 x i64> @llvm.x86.avx512.mask.pmul.dq.256(< 8 x i32> %a, < 8 x i32> %b, < 4 x i64> zeroinitializer, i8 %mask)
 965   ret < 4 x i64> %res
 966 }
 967
 968 define < 4 x i64> @test_mask_mul_epi32_rm_256(< 8 x i32> %a, < 8 x i32>* %ptr_b) {
 969   ;CHECK-LABEL: test_mask_mul_epi32_rm_256
 970   ;CHECK: vpmuldq (%rdi), %ymm0, %ymm0    ## encoding: [0x62,0xf2,0xfd,0x28,0x28,0x07]
 971   %b = load < 8 x i32>, < 8 x i32>* %ptr_b
 972   %res = call < 4 x i64> @llvm.x86.avx512.mask.pmul.dq.256(< 8 x i32> %a, < 8 x i32> %b, < 4 x i64> zeroinitializer, i8 -1)
 973   ret < 4 x i64> %res
 974 }
 975
 976 define < 4 x i64> @test_mask_mul_epi32_rmk_256(< 8 x i32> %a, < 8 x i32>* %ptr_b, < 4 x i64> %passThru, i8 %mask) {
 977   ;CHECK-LABEL: test_mask_mul_epi32_rmk_256
 978   ;CHECK: vpmuldq (%rdi), %ymm0, %ymm1 {%k1} ## encoding: [0x62,0xf2,0xfd,0x29,0x28,0x0f]
 979   %b = load < 8 x i32>, < 8 x i32>* %ptr_b
 980   %res = call < 4 x i64> @llvm.x86.avx512.mask.pmul.dq.256(< 8 x i32> %a, < 8 x i32> %b, < 4 x i64> %passThru, i8 %mask)
 981   ret < 4 x i64> %res
 982 }
 983
 984 define < 4 x i64> @test_mask_mul_epi32_rmkz_256(< 8 x i32> %a, < 8 x i32>* %ptr_b, i8 %mask) {
 985   ;CHECK-LABEL: test_mask_mul_epi32_rmkz_256
 986   ;CHECK: vpmuldq (%rdi), %ymm0, %ymm0 {%k1} {z} ## encoding: [0x62,0xf2,0xfd,0xa9,0x28,0x07]
 987   %b = load < 8 x i32>, < 8 x i32>* %ptr_b
 988   %res = call < 4 x i64> @llvm.x86.avx512.mask.pmul.dq.256(< 8 x i32> %a, < 8 x i32> %b, < 4 x i64> zeroinitializer, i8 %mask)
 989   ret < 4 x i64> %res
 990 }
 991
 992 define < 4 x i64> @test_mask_mul_epi32_rmb_256(< 8 x i32> %a, i64* %ptr_b) {
 993   ;CHECK-LABEL: test_mask_mul_epi32_rmb_256
 994   ;CHECK: vpmuldq (%rdi){1to4}, %ymm0, %ymm0  ## encoding: [0x62,0xf2,0xfd,0x38,0x28,0x07]
 995   %q = load i64, i64* %ptr_b
 996   %vecinit.i = insertelement < 4 x i64> undef, i64 %q, i32 0
 997   %b64 = shufflevector < 4 x i64> %vecinit.i, < 4 x i64> undef, < 4 x i32> zeroinitializer
 998   %b = bitcast < 4 x i64> %b64 to < 8 x i32>
 999   %res = call < 4 x i64> @llvm.x86.avx512.mask.pmul.dq.256(< 8 x i32> %a, < 8 x i32> %b, < 4 x i64> zeroinitializer, i8 -1)
1000   ret < 4 x i64> %res
1001 }
1002
1003 define < 4 x i64> @test_mask_mul_epi32_rmbk_256(< 8 x i32> %a, i64* %ptr_b, < 4 x i64> %passThru, i8 %mask) {
1004   ;CHECK-LABEL: test_mask_mul_epi32_rmbk_256
1005   ;CHECK: vpmuldq (%rdi){1to4}, %ymm0, %ymm1 {%k1} ## encoding: [0x62,0xf2,0xfd,0x39,0x28,0x0f]
1006   %q = load i64, i64* %ptr_b
1007   %vecinit.i = insertelement < 4 x i64> undef, i64 %q, i32 0
1008   %b64 = shufflevector < 4 x i64> %vecinit.i, < 4 x i64> undef, < 4 x i32> zeroinitializer
1009   %b = bitcast < 4 x i64> %b64 to < 8 x i32>
1010   %res = call < 4 x i64> @llvm.x86.avx512.mask.pmul.dq.256(< 8 x i32> %a, < 8 x i32> %b, < 4 x i64> %passThru, i8 %mask)
1011   ret < 4 x i64> %res
1012 }
1013
1014 define < 4 x i64> @test_mask_mul_epi32_rmbkz_256(< 8 x i32> %a, i64* %ptr_b, i8 %mask) {
1015   ;CHECK-LABEL: test_mask_mul_epi32_rmbkz_256
1016   ;CHECK: vpmuldq (%rdi){1to4}, %ymm0, %ymm0 {%k1} {z} ## encoding: [0x62,0xf2,0xfd,0xb9,0x28,0x07]
1017   %q = load i64, i64* %ptr_b
1018   %vecinit.i = insertelement < 4 x i64> undef, i64 %q, i32 0
1019   %b64 = shufflevector < 4 x i64> %vecinit.i, < 4 x i64> undef, < 4 x i32> zeroinitializer
1020   %b = bitcast < 4 x i64> %b64 to < 8 x i32>
1021   %res = call < 4 x i64> @llvm.x86.avx512.mask.pmul.dq.256(< 8 x i32> %a, < 8 x i32> %b, < 4 x i64> zeroinitializer, i8 %mask)
1022   ret < 4 x i64> %res
1023 }
1024
1025 declare < 4 x i64> @llvm.x86.avx512.mask.pmul.dq.256(< 8 x i32>, < 8 x i32>, < 4 x i64>, i8)
1026
1027 define < 2 x i64> @test_mask_mul_epu32_rr_128(< 4 x i32> %a, < 4 x i32> %b) {
1028   ;CHECK-LABEL: test_mask_mul_epu32_rr_128
1029   ;CHECK: vpmuludq %xmm1, %xmm0, %xmm0 ## encoding: [0xc5,0xf9,0xf4,0xc1]
1030   %res = call < 2 x i64> @llvm.x86.avx512.mask.pmulu.dq.128(< 4 x i32> %a, < 4 x i32> %b, < 2 x i64> zeroinitializer, i8 -1)
1031   ret < 2 x i64> %res
1032 }
1033
1034 define < 2 x i64> @test_mask_mul_epu32_rrk_128(< 4 x i32> %a, < 4 x i32> %b, < 2 x i64> %passThru, i8 %mask) {
1035   ;CHECK-LABEL: test_mask_mul_epu32_rrk_128
1036   ;CHECK: vpmuludq %xmm1, %xmm0, %xmm2 {%k1} ## encoding: [0x62,0xf1,0xfd,0x09,0xf4,0xd1]
1037   %res = call < 2 x i64> @llvm.x86.avx512.mask.pmulu.dq.128(< 4 x i32> %a, < 4 x i32> %b, < 2 x i64> %passThru, i8 %mask)
1038   ret < 2 x i64> %res
1039 }
1040
1041 define < 2 x i64> @test_mask_mul_epu32_rrkz_128(< 4 x i32> %a, < 4 x i32> %b, i8 %mask) {
1042   ;CHECK-LABEL: test_mask_mul_epu32_rrkz_128
1043   ;CHECK: vpmuludq %xmm1, %xmm0, %xmm0 {%k1} {z} ## encoding: [0x62,0xf1,0xfd,0x89,0xf4,0xc1]
1044   %res = call < 2 x i64> @llvm.x86.avx512.mask.pmulu.dq.128(< 4 x i32> %a, < 4 x i32> %b, < 2 x i64> zeroinitializer, i8 %mask)
1045   ret < 2 x i64> %res
1046 }
1047
1048 define < 2 x i64> @test_mask_mul_epu32_rm_128(< 4 x i32> %a, < 4 x i32>* %ptr_b) {
1049   ;CHECK-LABEL: test_mask_mul_epu32_rm_128
1050   ;CHECK: vpmuludq (%rdi), %xmm0, %xmm0 ## encoding: [0xc5,0xf9,0xf4,0x07]
1051   %b = load < 4 x i32>, < 4 x i32>* %ptr_b
1052   %res = call < 2 x i64> @llvm.x86.avx512.mask.pmulu.dq.128(< 4 x i32> %a, < 4 x i32> %b, < 2 x i64> zeroinitializer, i8 -1)
1053   ret < 2 x i64> %res
1054 }
1055
1056 define < 2 x i64> @test_mask_mul_epu32_rmk_128(< 4 x i32> %a, < 4 x i32>* %ptr_b, < 2 x i64> %passThru, i8 %mask) {
1057   ;CHECK-LABEL: test_mask_mul_epu32_rmk_128
1058   ;CHECK: vpmuludq (%rdi), %xmm0, %xmm1 {%k1} ## encoding: [0x62,0xf1,0xfd,0x09,0xf4,0x0f]
1059   %b = load < 4 x i32>, < 4 x i32>* %ptr_b
1060   %res = call < 2 x i64> @llvm.x86.avx512.mask.pmulu.dq.128(< 4 x i32> %a, < 4 x i32> %b, < 2 x i64> %passThru, i8 %mask)
1061   ret < 2 x i64> %res
1062 }
1063
1064 define < 2 x i64> @test_mask_mul_epu32_rmkz_128(< 4 x i32> %a, < 4 x i32>* %ptr_b, i8 %mask) {
1065   ;CHECK-LABEL: test_mask_mul_epu32_rmkz_128
1066   ;CHECK: vpmuludq (%rdi), %xmm0, %xmm0 {%k1} {z} ## encoding: [0x62,0xf1,0xfd,0x89,0xf4,0x07]
1067   %b = load < 4 x i32>, < 4 x i32>* %ptr_b
1068   %res = call < 2 x i64> @llvm.x86.avx512.mask.pmulu.dq.128(< 4 x i32> %a, < 4 x i32> %b, < 2 x i64> zeroinitializer, i8 %mask)
1069   ret < 2 x i64> %res
1070 }
1071
1072 define < 2 x i64> @test_mask_mul_epu32_rmb_128(< 4 x i32> %a, i64* %ptr_b) {
1073   ;CHECK-LABEL: test_mask_mul_epu32_rmb_128
1074   ;CHECK: vpmuludq (%rdi){1to2}, %xmm0, %xmm0  ## encoding: [0x62,0xf1,0xfd,0x18,0xf4,0x07]
1075   %q = load i64, i64* %ptr_b
1076   %vecinit.i = insertelement < 2 x i64> undef, i64 %q, i32 0
1077   %b64 = shufflevector < 2 x i64> %vecinit.i, < 2 x i64> undef, <2 x i32> zeroinitializer
1078   %b = bitcast < 2 x i64> %b64 to < 4 x i32>
1079   %res = call < 2 x i64> @llvm.x86.avx512.mask.pmulu.dq.128(< 4 x i32> %a, < 4 x i32> %b, < 2 x i64> zeroinitializer, i8 -1)
1080   ret < 2 x i64> %res
1081 }
1082
1083 define < 2 x i64> @test_mask_mul_epu32_rmbk_128(< 4 x i32> %a, i64* %ptr_b, < 2 x i64> %passThru, i8 %mask) {
1084   ;CHECK-LABEL: test_mask_mul_epu32_rmbk_128
1085   ;CHECK: vpmuludq (%rdi){1to2}, %xmm0, %xmm1 {%k1} ## encoding: [0x62,0xf1,0xfd,0x19,0xf4,0x0f]
1086   %q = load i64, i64* %ptr_b
1087   %vecinit.i = insertelement < 2 x i64> undef, i64 %q, i32 0
1088   %b64 = shufflevector < 2 x i64> %vecinit.i, < 2 x i64> undef, <2 x i32> zeroinitializer
1089   %b = bitcast < 2 x i64> %b64 to < 4 x i32>
1090   %res = call < 2 x i64> @llvm.x86.avx512.mask.pmulu.dq.128(< 4 x i32> %a, < 4 x i32> %b, < 2 x i64> %passThru, i8 %mask)
1091   ret < 2 x i64> %res
1092 }
1093
1094 define < 2 x i64> @test_mask_mul_epu32_rmbkz_128(< 4 x i32> %a, i64* %ptr_b, i8 %mask) {
1095   ;CHECK-LABEL: test_mask_mul_epu32_rmbkz_128
1096   ;CHECK: vpmuludq (%rdi){1to2}, %xmm0, %xmm0 {%k1} {z} ## encoding: [0x62,0xf1,0xfd,0x99,0xf4,0x07]
1097   %q = load i64, i64* %ptr_b
1098   %vecinit.i = insertelement < 2 x i64> undef, i64 %q, i32 0
1099   %b64 = shufflevector < 2 x i64> %vecinit.i, < 2 x i64> undef, < 2 x i32> zeroinitializer
1100   %b = bitcast < 2 x i64> %b64 to < 4 x i32>
1101   %res = call < 2 x i64> @llvm.x86.avx512.mask.pmulu.dq.128(< 4 x i32> %a, < 4 x i32> %b, < 2 x i64> zeroinitializer, i8 %mask)
1102   ret < 2 x i64> %res
1103 }
1104
1105 declare < 2 x i64> @llvm.x86.avx512.mask.pmulu.dq.128(< 4 x i32>, < 4 x i32>, < 2 x i64>, i8)
1106
1107 define < 4 x i64> @test_mask_mul_epu32_rr_256(< 8 x i32> %a, < 8 x i32> %b) {
1108   ;CHECK-LABEL: test_mask_mul_epu32_rr_256
1109   ;CHECK: vpmuludq %ymm1, %ymm0, %ymm0 ## encoding: [0xc5,0xfd,0xf4,0xc1]
1110   %res = call < 4 x i64> @llvm.x86.avx512.mask.pmulu.dq.256(< 8 x i32> %a, < 8 x i32> %b, < 4 x i64> zeroinitializer, i8 -1)
1111   ret < 4 x i64> %res
1112 }
1113
1114 define < 4 x i64> @test_mask_mul_epu32_rrk_256(< 8 x i32> %a, < 8 x i32> %b, < 4 x i64> %passThru, i8 %mask) {
1115   ;CHECK-LABEL: test_mask_mul_epu32_rrk_256
1116   ;CHECK: vpmuludq %ymm1, %ymm0, %ymm2 {%k1} ## encoding: [0x62,0xf1,0xfd,0x29,0xf4,0xd1]
1117   %res = call < 4 x i64> @llvm.x86.avx512.mask.pmulu.dq.256(< 8 x i32> %a, < 8 x i32> %b, < 4 x i64> %passThru, i8 %mask)
1118   ret < 4 x i64> %res
1119 }
1120
1121 define < 4 x i64> @test_mask_mul_epu32_rrkz_256(< 8 x i32> %a, < 8 x i32> %b, i8 %mask) {
1122   ;CHECK-LABEL: test_mask_mul_epu32_rrkz_256
1123   ;CHECK: vpmuludq %ymm1, %ymm0, %ymm0 {%k1} {z} ## encoding: [0x62,0xf1,0xfd,0xa9,0xf4,0xc1]
1124   %res = call < 4 x i64> @llvm.x86.avx512.mask.pmulu.dq.256(< 8 x i32> %a, < 8 x i32> %b, < 4 x i64> zeroinitializer, i8 %mask)
1125   ret < 4 x i64> %res
1126 }
1127
1128 define < 4 x i64> @test_mask_mul_epu32_rm_256(< 8 x i32> %a, < 8 x i32>* %ptr_b) {
1129   ;CHECK-LABEL: test_mask_mul_epu32_rm_256
1130   ;CHECK: vpmuludq (%rdi), %ymm0, %ymm0 ## encoding: [0xc5,0xfd,0xf4,0x07]
1131   %b = load < 8 x i32>, < 8 x i32>* %ptr_b
1132   %res = call < 4 x i64> @llvm.x86.avx512.mask.pmulu.dq.256(< 8 x i32> %a, < 8 x i32> %b, < 4 x i64> zeroinitializer, i8 -1)
1133   ret < 4 x i64> %res
1134 }
1135
1136 define < 4 x i64> @test_mask_mul_epu32_rmk_256(< 8 x i32> %a, < 8 x i32>* %ptr_b, < 4 x i64> %passThru, i8 %mask) {
1137   ;CHECK-LABEL: test_mask_mul_epu32_rmk_256
1138   ;CHECK: vpmuludq (%rdi), %ymm0, %ymm1 {%k1} ## encoding: [0x62,0xf1,0xfd,0x29,0xf4,0x0f]
1139   %b = load < 8 x i32>, < 8 x i32>* %ptr_b
1140   %res = call < 4 x i64> @llvm.x86.avx512.mask.pmulu.dq.256(< 8 x i32> %a, < 8 x i32> %b, < 4 x i64> %passThru, i8 %mask)
1141   ret < 4 x i64> %res
1142 }
1143
1144 define < 4 x i64> @test_mask_mul_epu32_rmkz_256(< 8 x i32> %a, < 8 x i32>* %ptr_b, i8 %mask) {
1145   ;CHECK-LABEL: test_mask_mul_epu32_rmkz_256
1146   ;CHECK: vpmuludq (%rdi), %ymm0, %ymm0 {%k1} {z} ## encoding: [0x62,0xf1,0xfd,0xa9,0xf4,0x07]
1147   %b = load < 8 x i32>, < 8 x i32>* %ptr_b
1148   %res = call < 4 x i64> @llvm.x86.avx512.mask.pmulu.dq.256(< 8 x i32> %a, < 8 x i32> %b, < 4 x i64> zeroinitializer, i8 %mask)
1149   ret < 4 x i64> %res
1150 }
1151
1152 define < 4 x i64> @test_mask_mul_epu32_rmb_256(< 8 x i32> %a, i64* %ptr_b) {
1153   ;CHECK-LABEL: test_mask_mul_epu32_rmb_256
1154   ;CHECK: vpmuludq (%rdi){1to4}, %ymm0, %ymm0  ## encoding: [0x62,0xf1,0xfd,0x38,0xf4,0x07]
1155   %q = load i64, i64* %ptr_b
1156   %vecinit.i = insertelement < 4 x i64> undef, i64 %q, i32 0
1157   %b64 = shufflevector < 4 x i64> %vecinit.i, < 4 x i64> undef, < 4 x i32> zeroinitializer
1158   %b = bitcast < 4 x i64> %b64 to < 8 x i32>
1159   %res = call < 4 x i64> @llvm.x86.avx512.mask.pmulu.dq.256(< 8 x i32> %a, < 8 x i32> %b, < 4 x i64> zeroinitializer, i8 -1)
1160   ret < 4 x i64> %res
1161 }
1162
1163 define < 4 x i64> @test_mask_mul_epu32_rmbk_256(< 8 x i32> %a, i64* %ptr_b, < 4 x i64> %passThru, i8 %mask) {
1164   ;CHECK-LABEL: test_mask_mul_epu32_rmbk_256
1165   ;CHECK: vpmuludq (%rdi){1to4}, %ymm0, %ymm1 {%k1} ## encoding: [0x62,0xf1,0xfd,0x39,0xf4,0x0f]
1166   %q = load i64, i64* %ptr_b
1167   %vecinit.i = insertelement < 4 x i64> undef, i64 %q, i32 0
1168   %b64 = shufflevector < 4 x i64> %vecinit.i, < 4 x i64> undef, < 4 x i32> zeroinitializer
1169   %b = bitcast < 4 x i64> %b64 to < 8 x i32>
1170   %res = call < 4 x i64> @llvm.x86.avx512.mask.pmulu.dq.256(< 8 x i32> %a, < 8 x i32> %b, < 4 x i64> %passThru, i8 %mask)
1171   ret < 4 x i64> %res
1172 }
1173
1174 define < 4 x i64> @test_mask_mul_epu32_rmbkz_256(< 8 x i32> %a, i64* %ptr_b, i8 %mask) {
1175   ;CHECK-LABEL: test_mask_mul_epu32_rmbkz_256
1176   ;CHECK: vpmuludq (%rdi){1to4}, %ymm0, %ymm0 {%k1} {z} ## encoding: [0x62,0xf1,0xfd,0xb9,0xf4,0x07]
1177   %q = load i64, i64* %ptr_b
1178   %vecinit.i = insertelement < 4 x i64> undef, i64 %q, i32 0
1179   %b64 = shufflevector < 4 x i64> %vecinit.i, < 4 x i64> undef, < 4 x i32> zeroinitializer
1180   %b = bitcast < 4 x i64> %b64 to < 8 x i32>
1181   %res = call < 4 x i64> @llvm.x86.avx512.mask.pmulu.dq.256(< 8 x i32> %a, < 8 x i32> %b, < 4 x i64> zeroinitializer, i8 %mask)
1182   ret < 4 x i64> %res
1183 }
1184
1185 declare < 4 x i64> @llvm.x86.avx512.mask.pmulu.dq.256(< 8 x i32>, < 8 x i32>, < 4 x i64>, i8)
1186
1187 define <4 x i32> @test_mask_add_epi32_rr_128(<4 x i32> %a, <4 x i32> %b) {
1188   ;CHECK-LABEL: test_mask_add_epi32_rr_128
1189   ;CHECK: vpaddd %xmm1, %xmm0, %xmm0     ## encoding: [0x62,0xf1,0x7d,0x08,0xfe,0xc1]
1190   %res = call <4 x i32> @llvm.x86.avx512.mask.padd.d.128(<4 x i32> %a, <4 x i32> %b, <4 x i32> zeroinitializer, i8 -1)
1191   ret <4 x i32> %res
1192 }
1193
1194 define <4 x i32> @test_mask_add_epi32_rrk_128(<4 x i32> %a, <4 x i32> %b, <4 x i32> %passThru, i8 %mask) {
1195   ;CHECK-LABEL: test_mask_add_epi32_rrk_128
1196   ;CHECK: vpaddd %xmm1, %xmm0, %xmm2 {%k1} ## encoding: [0x62,0xf1,0x7d,0x09,0xfe,0xd1]
1197   %res = call <4 x i32> @llvm.x86.avx512.mask.padd.d.128(<4 x i32> %a, <4 x i32> %b, <4 x i32> %passThru, i8 %mask)
1198   ret <4 x i32> %res
1199 }
1200
1201 define <4 x i32> @test_mask_add_epi32_rrkz_128(<4 x i32> %a, <4 x i32> %b, i8 %mask) {
1202   ;CHECK-LABEL: test_mask_add_epi32_rrkz_128
1203   ;CHECK: vpaddd %xmm1, %xmm0, %xmm0 {%k1} {z} ## encoding: [0x62,0xf1,0x7d,0x89,0xfe,0xc1]
1204   %res = call <4 x i32> @llvm.x86.avx512.mask.padd.d.128(<4 x i32> %a, <4 x i32> %b, <4 x i32> zeroinitializer, i8 %mask)
1205   ret <4 x i32> %res
1206 }
1207
1208 define <4 x i32> @test_mask_add_epi32_rm_128(<4 x i32> %a, <4 x i32>* %ptr_b) {
1209   ;CHECK-LABEL: test_mask_add_epi32_rm_128
1210   ;CHECK: vpaddd (%rdi), %xmm0, %xmm0    ## encoding: [0x62,0xf1,0x7d,0x08,0xfe,0x07]
1211   %b = load <4 x i32>, <4 x i32>* %ptr_b
1212   %res = call <4 x i32> @llvm.x86.avx512.mask.padd.d.128(<4 x i32> %a, <4 x i32> %b, <4 x i32> zeroinitializer, i8 -1)
1213   ret <4 x i32> %res
1214 }
1215
1216 define <4 x i32> @test_mask_add_epi32_rmk_128(<4 x i32> %a, <4 x i32>* %ptr_b, <4 x i32> %passThru, i8 %mask) {
1217   ;CHECK-LABEL: test_mask_add_epi32_rmk_128
1218   ;CHECK: vpaddd (%rdi), %xmm0, %xmm1 {%k1} ## encoding: [0x62,0xf1,0x7d,0x09,0xfe,0x0f]
1219   %b = load <4 x i32>, <4 x i32>* %ptr_b
1220   %res = call <4 x i32> @llvm.x86.avx512.mask.padd.d.128(<4 x i32> %a, <4 x i32> %b, <4 x i32> %passThru, i8 %mask)
1221   ret <4 x i32> %res
1222 }
1223
1224 define <4 x i32> @test_mask_add_epi32_rmkz_128(<4 x i32> %a, <4 x i32>* %ptr_b, i8 %mask) {
1225   ;CHECK-LABEL: test_mask_add_epi32_rmkz_128
1226   ;CHECK: vpaddd (%rdi), %xmm0, %xmm0 {%k1} {z} ## encoding: [0x62,0xf1,0x7d,0x89,0xfe,0x07]
1227   %b = load <4 x i32>, <4 x i32>* %ptr_b
1228   %res = call <4 x i32> @llvm.x86.avx512.mask.padd.d.128(<4 x i32> %a, <4 x i32> %b, <4 x i32> zeroinitializer, i8 %mask)
1229   ret <4 x i32> %res
1230 }
1231
1232 define <4 x i32> @test_mask_add_epi32_rmb_128(<4 x i32> %a, i32* %ptr_b) {
1233   ;CHECK-LABEL: test_mask_add_epi32_rmb_128
1234   ;CHECK: vpaddd (%rdi){1to4}, %xmm0, %xmm0  ## encoding: [0x62,0xf1,0x7d,0x18,0xfe,0x07]
1235   %q = load i32, i32* %ptr_b
1236   %vecinit.i = insertelement <4 x i32> undef, i32 %q, i32 0
1237   %b = shufflevector <4 x i32> %vecinit.i, <4 x i32> undef, <4 x i32> zeroinitializer
1238   %res = call <4 x i32> @llvm.x86.avx512.mask.padd.d.128(<4 x i32> %a, <4 x i32> %b, <4 x i32> zeroinitializer, i8 -1)
1239   ret <4 x i32> %res
1240 }
1241
1242 define <4 x i32> @test_mask_add_epi32_rmbk_128(<4 x i32> %a, i32* %ptr_b, <4 x i32> %passThru, i8 %mask) {
1243   ;CHECK-LABEL: test_mask_add_epi32_rmbk_128
1244   ;CHECK: vpaddd (%rdi){1to4}, %xmm0, %xmm1 {%k1} ## encoding: [0x62,0xf1,0x7d,0x19,0xfe,0x0f]
1245   %q = load i32, i32* %ptr_b
1246   %vecinit.i = insertelement <4 x i32> undef, i32 %q, i32 0
1247   %b = shufflevector <4 x i32> %vecinit.i, <4 x i32> undef, <4 x i32> zeroinitializer
1248   %res = call <4 x i32> @llvm.x86.avx512.mask.padd.d.128(<4 x i32> %a, <4 x i32> %b, <4 x i32> %passThru, i8 %mask)
1249   ret <4 x i32> %res
1250 }
1251
1252 define <4 x i32> @test_mask_add_epi32_rmbkz_128(<4 x i32> %a, i32* %ptr_b, i8 %mask) {
1253   ;CHECK-LABEL: test_mask_add_epi32_rmbkz_128
1254   ;CHECK: vpaddd (%rdi){1to4}, %xmm0, %xmm0 {%k1} {z} ## encoding: [0x62,0xf1,0x7d,0x99,0xfe,0x07]
1255   %q = load i32, i32* %ptr_b
1256   %vecinit.i = insertelement <4 x i32> undef, i32 %q, i32 0
1257   %b = shufflevector <4 x i32> %vecinit.i, <4 x i32> undef, <4 x i32> zeroinitializer
1258   %res = call <4 x i32> @llvm.x86.avx512.mask.padd.d.128(<4 x i32> %a, <4 x i32> %b, <4 x i32> zeroinitializer, i8 %mask)
1259   ret <4 x i32> %res
1260 }
1261
1262 declare <4 x i32> @llvm.x86.avx512.mask.padd.d.128(<4 x i32>, <4 x i32>, <4 x i32>, i8)
1263
1264 define <4 x i32> @test_mask_sub_epi32_rr_128(<4 x i32> %a, <4 x i32> %b) {
1265   ;CHECK-LABEL: test_mask_sub_epi32_rr_128
1266   ;CHECK: vpsubd %xmm1, %xmm0, %xmm0     ## encoding: [0x62,0xf1,0x7d,0x08,0xfa,0xc1]
1267   %res = call <4 x i32> @llvm.x86.avx512.mask.psub.d.128(<4 x i32> %a, <4 x i32> %b, <4 x i32> zeroinitializer, i8 -1)
1268   ret <4 x i32> %res
1269 }
1270
1271 define <4 x i32> @test_mask_sub_epi32_rrk_128(<4 x i32> %a, <4 x i32> %b, <4 x i32> %passThru, i8 %mask) {
1272   ;CHECK-LABEL: test_mask_sub_epi32_rrk_128
1273   ;CHECK: vpsubd %xmm1, %xmm0, %xmm2 {%k1} ## encoding: [0x62,0xf1,0x7d,0x09,0xfa,0xd1]
1274   %res = call <4 x i32> @llvm.x86.avx512.mask.psub.d.128(<4 x i32> %a, <4 x i32> %b, <4 x i32> %passThru, i8 %mask)
1275   ret <4 x i32> %res
1276 }
1277
1278 define <4 x i32> @test_mask_sub_epi32_rrkz_128(<4 x i32> %a, <4 x i32> %b, i8 %mask) {
1279   ;CHECK-LABEL: test_mask_sub_epi32_rrkz_128
1280   ;CHECK: vpsubd %xmm1, %xmm0, %xmm0 {%k1} {z} ## encoding: [0x62,0xf1,0x7d,0x89,0xfa,0xc1]
1281   %res = call <4 x i32> @llvm.x86.avx512.mask.psub.d.128(<4 x i32> %a, <4 x i32> %b, <4 x i32> zeroinitializer, i8 %mask)
1282   ret <4 x i32> %res
1283 }
1284
1285 define <4 x i32> @test_mask_sub_epi32_rm_128(<4 x i32> %a, <4 x i32>* %ptr_b) {
1286   ;CHECK-LABEL: test_mask_sub_epi32_rm_128
1287   ;CHECK: (%rdi), %xmm0, %xmm0    ## encoding: [0x62,0xf1,0x7d,0x08,0xfa,0x07]
1288   %b = load <4 x i32>, <4 x i32>* %ptr_b
1289   %res = call <4 x i32> @llvm.x86.avx512.mask.psub.d.128(<4 x i32> %a, <4 x i32> %b, <4 x i32> zeroinitializer, i8 -1)
1290   ret <4 x i32> %res
1291 }
1292
1293 define <4 x i32> @test_mask_sub_epi32_rmk_128(<4 x i32> %a, <4 x i32>* %ptr_b, <4 x i32> %passThru, i8 %mask) {
1294   ;CHECK-LABEL: test_mask_sub_epi32_rmk_128
1295   ;CHECK: vpsubd (%rdi), %xmm0, %xmm1 {%k1} ## encoding: [0x62,0xf1,0x7d,0x09,0xfa,0x0f]
1296   %b = load <4 x i32>, <4 x i32>* %ptr_b
1297   %res = call <4 x i32> @llvm.x86.avx512.mask.psub.d.128(<4 x i32> %a, <4 x i32> %b, <4 x i32> %passThru, i8 %mask)
1298   ret <4 x i32> %res
1299 }
1300
1301 define <4 x i32> @test_mask_sub_epi32_rmkz_128(<4 x i32> %a, <4 x i32>* %ptr_b, i8 %mask) {
1302   ;CHECK-LABEL: test_mask_sub_epi32_rmkz_128
1303   ;CHECK: vpsubd (%rdi), %xmm0, %xmm0 {%k1} {z} ## encoding: [0x62,0xf1,0x7d,0x89,0xfa,0x07]
1304   %b = load <4 x i32>, <4 x i32>* %ptr_b
1305   %res = call <4 x i32> @llvm.x86.avx512.mask.psub.d.128(<4 x i32> %a, <4 x i32> %b, <4 x i32> zeroinitializer, i8 %mask)
1306   ret <4 x i32> %res
1307 }
1308
1309 define <4 x i32> @test_mask_sub_epi32_rmb_128(<4 x i32> %a, i32* %ptr_b) {
1310   ;CHECK-LABEL: test_mask_sub_epi32_rmb_128
1311   ;CHECK: vpsubd (%rdi){1to4}, %xmm0, %xmm0  ## encoding: [0x62,0xf1,0x7d,0x18,0xfa,0x07]
1312   %q = load i32, i32* %ptr_b
1313   %vecinit.i = insertelement <4 x i32> undef, i32 %q, i32 0
1314   %b = shufflevector <4 x i32> %vecinit.i, <4 x i32> undef, <4 x i32> zeroinitializer
1315   %res = call <4 x i32> @llvm.x86.avx512.mask.psub.d.128(<4 x i32> %a, <4 x i32> %b, <4 x i32> zeroinitializer, i8 -1)
1316   ret <4 x i32> %res
1317 }
1318
1319 define <4 x i32> @test_mask_sub_epi32_rmbk_128(<4 x i32> %a, i32* %ptr_b, <4 x i32> %passThru, i8 %mask) {
1320   ;CHECK-LABEL: test_mask_sub_epi32_rmbk_128
1321   ;CHECK: vpsubd (%rdi){1to4}, %xmm0, %xmm1 {%k1} ## encoding: [0x62,0xf1,0x7d,0x19,0xfa,0x0f]
1322   %q = load i32, i32* %ptr_b
1323   %vecinit.i = insertelement <4 x i32> undef, i32 %q, i32 0
1324   %b = shufflevector <4 x i32> %vecinit.i, <4 x i32> undef, <4 x i32> zeroinitializer
1325   %res = call <4 x i32> @llvm.x86.avx512.mask.psub.d.128(<4 x i32> %a, <4 x i32> %b, <4 x i32> %passThru, i8 %mask)
1326   ret <4 x i32> %res
1327 }
1328
1329 define <4 x i32> @test_mask_sub_epi32_rmbkz_128(<4 x i32> %a, i32* %ptr_b, i8 %mask) {
1330   ;CHECK-LABEL: test_mask_sub_epi32_rmbkz_128
1331   ;CHECK: vpsubd (%rdi){1to4}, %xmm0, %xmm0 {%k1} {z} ## encoding: [0x62,0xf1,0x7d,0x99,0xfa,0x07]
1332   %q = load i32, i32* %ptr_b
1333   %vecinit.i = insertelement <4 x i32> undef, i32 %q, i32 0
1334   %b = shufflevector <4 x i32> %vecinit.i, <4 x i32> undef, <4 x i32> zeroinitializer
1335   %res = call <4 x i32> @llvm.x86.avx512.mask.psub.d.128(<4 x i32> %a, <4 x i32> %b, <4 x i32> zeroinitializer, i8 %mask)
1336   ret <4 x i32> %res
1337 }
1338
1339 declare <4 x i32> @llvm.x86.avx512.mask.psub.d.128(<4 x i32>, <4 x i32>, <4 x i32>, i8)
1340
1341 define <8 x i32> @test_mask_sub_epi32_rr_256(<8 x i32> %a, <8 x i32> %b) {
1342   ;CHECK-LABEL: test_mask_sub_epi32_rr_256
1343   ;CHECK: vpsubd %ymm1, %ymm0, %ymm0     ## encoding: [0x62,0xf1,0x7d,0x28,0xfa,0xc1]
1344   %res = call <8 x i32> @llvm.x86.avx512.mask.psub.d.256(<8 x i32> %a, <8 x i32> %b, <8 x i32> zeroinitializer, i8 -1)
1345   ret <8 x i32> %res
1346 }
1347
1348 define <8 x i32> @test_mask_sub_epi32_rrk_256(<8 x i32> %a, <8 x i32> %b, <8 x i32> %passThru, i8 %mask) {
1349   ;CHECK-LABEL: test_mask_sub_epi32_rrk_256
1350   ;CHECK: vpsubd %ymm1, %ymm0, %ymm2 {%k1} ## encoding: [0x62,0xf1,0x7d,0x29,0xfa,0xd1]
1351   %res = call <8 x i32> @llvm.x86.avx512.mask.psub.d.256(<8 x i32> %a, <8 x i32> %b, <8 x i32> %passThru, i8 %mask)
1352   ret <8 x i32> %res
1353 }
1354
1355 define <8 x i32> @test_mask_sub_epi32_rrkz_256(<8 x i32> %a, <8 x i32> %b, i8 %mask) {
1356   ;CHECK-LABEL: test_mask_sub_epi32_rrkz_256
1357   ;CHECK: vpsubd %ymm1, %ymm0, %ymm0 {%k1} {z} ## encoding: [0x62,0xf1,0x7d,0xa9,0xfa,0xc1]
1358   %res = call <8 x i32> @llvm.x86.avx512.mask.psub.d.256(<8 x i32> %a, <8 x i32> %b, <8 x i32> zeroinitializer, i8 %mask)
1359   ret <8 x i32> %res
1360 }
1361
1362 define <8 x i32> @test_mask_sub_epi32_rm_256(<8 x i32> %a, <8 x i32>* %ptr_b) {
1363   ;CHECK-LABEL: test_mask_sub_epi32_rm_256
1364   ;CHECK: vpsubd (%rdi), %ymm0, %ymm0    ## encoding: [0x62,0xf1,0x7d,0x28,0xfa,0x07]
1365   %b = load <8 x i32>, <8 x i32>* %ptr_b
1366   %res = call <8 x i32> @llvm.x86.avx512.mask.psub.d.256(<8 x i32> %a, <8 x i32> %b, <8 x i32> zeroinitializer, i8 -1)
1367   ret <8 x i32> %res
1368 }
1369
1370 define <8 x i32> @test_mask_sub_epi32_rmk_256(<8 x i32> %a, <8 x i32>* %ptr_b, <8 x i32> %passThru, i8 %mask) {
1371   ;CHECK-LABEL: test_mask_sub_epi32_rmk_256
1372   ;CHECK: vpsubd (%rdi), %ymm0, %ymm1 {%k1} ## encoding: [0x62,0xf1,0x7d,0x29,0xfa,0x0f]
1373   %b = load <8 x i32>, <8 x i32>* %ptr_b
1374   %res = call <8 x i32> @llvm.x86.avx512.mask.psub.d.256(<8 x i32> %a, <8 x i32> %b, <8 x i32> %passThru, i8 %mask)
1375   ret <8 x i32> %res
1376 }
1377
1378 define <8 x i32> @test_mask_sub_epi32_rmkz_256(<8 x i32> %a, <8 x i32>* %ptr_b, i8 %mask) {
1379   ;CHECK-LABEL: test_mask_sub_epi32_rmkz_256
1380   ;CHECK: vpsubd (%rdi), %ymm0, %ymm0 {%k1} {z} ## encoding: [0x62,0xf1,0x7d,0xa9,0xfa,0x07]
1381   %b = load <8 x i32>, <8 x i32>* %ptr_b
1382   %res = call <8 x i32> @llvm.x86.avx512.mask.psub.d.256(<8 x i32> %a, <8 x i32> %b, <8 x i32> zeroinitializer, i8 %mask)
1383   ret <8 x i32> %res
1384 }
1385
1386 define <8 x i32> @test_mask_sub_epi32_rmb_256(<8 x i32> %a, i32* %ptr_b) {
1387   ;CHECK-LABEL: test_mask_sub_epi32_rmb_256
1388   ;CHECK: vpsubd (%rdi){1to8}, %ymm0, %ymm0  ## encoding: [0x62,0xf1,0x7d,0x38,0xfa,0x07]
1389   %q = load i32, i32* %ptr_b
1390   %vecinit.i = insertelement <8 x i32> undef, i32 %q, i32 0
1391   %b = shufflevector <8 x i32> %vecinit.i, <8 x i32> undef, <8 x i32> zeroinitializer
1392   %res = call <8 x i32> @llvm.x86.avx512.mask.psub.d.256(<8 x i32> %a, <8 x i32> %b, <8 x i32> zeroinitializer, i8 -1)
1393   ret <8 x i32> %res
1394 }
1395
1396 define <8 x i32> @test_mask_sub_epi32_rmbk_256(<8 x i32> %a, i32* %ptr_b, <8 x i32> %passThru, i8 %mask) {
1397   ;CHECK-LABEL: test_mask_sub_epi32_rmbk_256
1398   ;CHECK: vpsubd (%rdi){1to8}, %ymm0, %ymm1 {%k1} ## encoding: [0x62,0xf1,0x7d,0x39,0xfa,0x0f]
1399   %q = load i32, i32* %ptr_b
1400   %vecinit.i = insertelement <8 x i32> undef, i32 %q, i32 0
1401   %b = shufflevector <8 x i32> %vecinit.i, <8 x i32> undef, <8 x i32> zeroinitializer
1402   %res = call <8 x i32> @llvm.x86.avx512.mask.psub.d.256(<8 x i32> %a, <8 x i32> %b, <8 x i32> %passThru, i8 %mask)
1403   ret <8 x i32> %res
1404 }
1405
1406 define <8 x i32> @test_mask_sub_epi32_rmbkz_256(<8 x i32> %a, i32* %ptr_b, i8 %mask) {
1407   ;CHECK-LABEL: test_mask_sub_epi32_rmbkz_256
1408   ;CHECK: vpsubd (%rdi){1to8}, %ymm0, %ymm0 {%k1} {z} ## encoding: [0x62,0xf1,0x7d,0xb9,0xfa,0x07]
1409   %q = load i32, i32* %ptr_b
1410   %vecinit.i = insertelement <8 x i32> undef, i32 %q, i32 0
1411   %b = shufflevector <8 x i32> %vecinit.i, <8 x i32> undef, <8 x i32> zeroinitializer
1412   %res = call <8 x i32> @llvm.x86.avx512.mask.psub.d.256(<8 x i32> %a, <8 x i32> %b, <8 x i32> zeroinitializer, i8 %mask)
1413   ret <8 x i32> %res
1414 }
1415
1416 declare <8 x i32> @llvm.x86.avx512.mask.psub.d.256(<8 x i32>, <8 x i32>, <8 x i32>, i8)
1417
1418 define <8 x i32> @test_mask_add_epi32_rr_256(<8 x i32> %a, <8 x i32> %b) {
1419   ;CHECK-LABEL: test_mask_add_epi32_rr_256
1420   ;CHECK: vpaddd %ymm1, %ymm0, %ymm0     ## encoding: [0x62,0xf1,0x7d,0x28,0xfe,0xc1]
1421   %res = call <8 x i32> @llvm.x86.avx512.mask.padd.d.256(<8 x i32> %a, <8 x i32> %b, <8 x i32> zeroinitializer, i8 -1)
1422   ret <8 x i32> %res
1423 }
1424
1425 define <8 x i32> @test_mask_add_epi32_rrk_256(<8 x i32> %a, <8 x i32> %b, <8 x i32> %passThru, i8 %mask) {
1426   ;CHECK-LABEL: test_mask_add_epi32_rrk_256
1427   ;CHECK: vpaddd %ymm1, %ymm0, %ymm2 {%k1} ## encoding: [0x62,0xf1,0x7d,0x29,0xfe,0xd1]
1428   %res = call <8 x i32> @llvm.x86.avx512.mask.padd.d.256(<8 x i32> %a, <8 x i32> %b, <8 x i32> %passThru, i8 %mask)
1429   ret <8 x i32> %res
1430 }
1431
1432 define <8 x i32> @test_mask_add_epi32_rrkz_256(<8 x i32> %a, <8 x i32> %b, i8 %mask) {
1433   ;CHECK-LABEL: test_mask_add_epi32_rrkz_256
1434   ;CHECK: vpaddd %ymm1, %ymm0, %ymm0 {%k1} {z} ## encoding: [0x62,0xf1,0x7d,0xa9,0xfe,0xc1]
1435   %res = call <8 x i32> @llvm.x86.avx512.mask.padd.d.256(<8 x i32> %a, <8 x i32> %b, <8 x i32> zeroinitializer, i8 %mask)
1436   ret <8 x i32> %res
1437 }
1438
1439 define <8 x i32> @test_mask_add_epi32_rm_256(<8 x i32> %a, <8 x i32>* %ptr_b) {
1440   ;CHECK-LABEL: test_mask_add_epi32_rm_256
1441   ;CHECK: vpaddd (%rdi), %ymm0, %ymm0    ## encoding: [0x62,0xf1,0x7d,0x28,0xfe,0x07]
1442   %b = load <8 x i32>, <8 x i32>* %ptr_b
1443   %res = call <8 x i32> @llvm.x86.avx512.mask.padd.d.256(<8 x i32> %a, <8 x i32> %b, <8 x i32> zeroinitializer, i8 -1)
1444   ret <8 x i32> %res
1445 }
1446
1447 define <8 x i32> @test_mask_add_epi32_rmk_256(<8 x i32> %a, <8 x i32>* %ptr_b, <8 x i32> %passThru, i8 %mask) {
1448   ;CHECK-LABEL: test_mask_add_epi32_rmk_256
1449   ;CHECK: vpaddd (%rdi), %ymm0, %ymm1 {%k1} ## encoding: [0x62,0xf1,0x7d,0x29,0xfe,0x0f]
1450   %b = load <8 x i32>, <8 x i32>* %ptr_b
1451   %res = call <8 x i32> @llvm.x86.avx512.mask.padd.d.256(<8 x i32> %a, <8 x i32> %b, <8 x i32> %passThru, i8 %mask)
1452   ret <8 x i32> %res
1453 }
1454
1455 define <8 x i32> @test_mask_add_epi32_rmkz_256(<8 x i32> %a, <8 x i32>* %ptr_b, i8 %mask) {
1456   ;CHECK-LABEL: test_mask_add_epi32_rmkz_256
1457   ;CHECK: vpaddd (%rdi), %ymm0, %ymm0 {%k1} {z} ## encoding: [0x62,0xf1,0x7d,0xa9,0xfe,0x07]
1458   %b = load <8 x i32>, <8 x i32>* %ptr_b
1459   %res = call <8 x i32> @llvm.x86.avx512.mask.padd.d.256(<8 x i32> %a, <8 x i32> %b, <8 x i32> zeroinitializer, i8 %mask)
1460   ret <8 x i32> %res
1461 }
1462
1463 define <8 x i32> @test_mask_add_epi32_rmb_256(<8 x i32> %a, i32* %ptr_b) {
1464   ;CHECK-LABEL: test_mask_add_epi32_rmb_256
1465   ;CHECK: vpaddd (%rdi){1to8}, %ymm0, %ymm0  ## encoding: [0x62,0xf1,0x7d,0x38,0xfe,0x07]
1466   %q = load i32, i32* %ptr_b
1467   %vecinit.i = insertelement <8 x i32> undef, i32 %q, i32 0
1468   %b = shufflevector <8 x i32> %vecinit.i, <8 x i32> undef, <8 x i32> zeroinitializer
1469   %res = call <8 x i32> @llvm.x86.avx512.mask.padd.d.256(<8 x i32> %a, <8 x i32> %b, <8 x i32> zeroinitializer, i8 -1)
1470   ret <8 x i32> %res
1471 }
1472
1473 define <8 x i32> @test_mask_add_epi32_rmbk_256(<8 x i32> %a, i32* %ptr_b, <8 x i32> %passThru, i8 %mask) {
1474   ;CHECK-LABEL: test_mask_add_epi32_rmbk_256
1475   ;CHECK: vpaddd (%rdi){1to8}, %ymm0, %ymm1 {%k1} ## encoding: [0x62,0xf1,0x7d,0x39,0xfe,0x0f]
1476   %q = load i32, i32* %ptr_b
1477   %vecinit.i = insertelement <8 x i32> undef, i32 %q, i32 0
1478   %b = shufflevector <8 x i32> %vecinit.i, <8 x i32> undef, <8 x i32> zeroinitializer
1479   %res = call <8 x i32> @llvm.x86.avx512.mask.padd.d.256(<8 x i32> %a, <8 x i32> %b, <8 x i32> %passThru, i8 %mask)
1480   ret <8 x i32> %res
1481 }
1482
1483 define <8 x i32> @test_mask_add_epi32_rmbkz_256(<8 x i32> %a, i32* %ptr_b, i8 %mask) {
1484   ;CHECK-LABEL: test_mask_add_epi32_rmbkz_256
1485   ;CHECK: vpaddd (%rdi){1to8}, %ymm0, %ymm0 {%k1} {z} ## encoding: [0x62,0xf1,0x7d,0xb9,0xfe,0x07]
1486   %q = load i32, i32* %ptr_b
1487   %vecinit.i = insertelement <8 x i32> undef, i32 %q, i32 0
1488   %b = shufflevector <8 x i32> %vecinit.i, <8 x i32> undef, <8 x i32> zeroinitializer
1489   %res = call <8 x i32> @llvm.x86.avx512.mask.padd.d.256(<8 x i32> %a, <8 x i32> %b, <8 x i32> zeroinitializer, i8 %mask)
1490   ret <8 x i32> %res
1491 }
1492
1493 declare <8 x i32> @llvm.x86.avx512.mask.padd.d.256(<8 x i32>, <8 x i32>, <8 x i32>, i8)
1494
1495 define <4 x i32> @test_mask_and_epi32_rr_128(<4 x i32> %a, <4 x i32> %b) {
1496   ;CHECK-LABEL: test_mask_and_epi32_rr_128
1497   ;CHECK: vpandd  %xmm1, %xmm0, %xmm0     ## encoding: [0x62,0xf1,0x7d,0x08,0xdb,0xc1]
1498   %res = call <4 x i32> @llvm.x86.avx512.mask.pand.d.128(<4 x i32> %a, <4 x i32> %b, <4 x i32> zeroinitializer, i8 -1)
1499   ret <4 x i32> %res
1500 }
1501
1502 define <4 x i32> @test_mask_and_epi32_rrk_128(<4 x i32> %a, <4 x i32> %b, <4 x i32> %passThru, i8 %mask) {
1503   ;CHECK-LABEL: test_mask_and_epi32_rrk_128
1504   ;CHECK: vpandd  %xmm1, %xmm0, %xmm2 {%k1} ## encoding: [0x62,0xf1,0x7d,0x09,0xdb,0xd1]
1505   %res = call <4 x i32> @llvm.x86.avx512.mask.pand.d.128(<4 x i32> %a, <4 x i32> %b, <4 x i32> %passThru, i8 %mask)
1506   ret <4 x i32> %res
1507 }
1508
1509 define <4 x i32> @test_mask_and_epi32_rrkz_128(<4 x i32> %a, <4 x i32> %b, i8 %mask) {
1510   ;CHECK-LABEL: test_mask_and_epi32_rrkz_128
1511   ;CHECK: vpandd  %xmm1, %xmm0, %xmm0 {%k1} {z} ## encoding: [0x62,0xf1,0x7d,0x89,0xdb,0xc1]
1512   %res = call <4 x i32> @llvm.x86.avx512.mask.pand.d.128(<4 x i32> %a, <4 x i32> %b, <4 x i32> zeroinitializer, i8 %mask)
1513   ret <4 x i32> %res
1514 }
1515
1516 define <4 x i32> @test_mask_and_epi32_rm_128(<4 x i32> %a, <4 x i32>* %ptr_b) {
1517   ;CHECK-LABEL: test_mask_and_epi32_rm_128
1518   ;CHECK: vpandd  (%rdi), %xmm0, %xmm0    ## encoding: [0x62,0xf1,0x7d,0x08,0xdb,0x07]
1519   %b = load <4 x i32>, <4 x i32>* %ptr_b
1520   %res = call <4 x i32> @llvm.x86.avx512.mask.pand.d.128(<4 x i32> %a, <4 x i32> %b, <4 x i32> zeroinitializer, i8 -1)
1521   ret <4 x i32> %res
1522 }
1523
1524 define <4 x i32> @test_mask_and_epi32_rmk_128(<4 x i32> %a, <4 x i32>* %ptr_b, <4 x i32> %passThru, i8 %mask) {
1525   ;CHECK-LABEL: test_mask_and_epi32_rmk_128
1526   ;CHECK: vpandd  (%rdi), %xmm0, %xmm1 {%k1} ## encoding: [0x62,0xf1,0x7d,0x09,0xdb,0x0f]
1527   %b = load <4 x i32>, <4 x i32>* %ptr_b
1528   %res = call <4 x i32> @llvm.x86.avx512.mask.pand.d.128(<4 x i32> %a, <4 x i32> %b, <4 x i32> %passThru, i8 %mask)
1529   ret <4 x i32> %res
1530 }
1531
1532 define <4 x i32> @test_mask_and_epi32_rmkz_128(<4 x i32> %a, <4 x i32>* %ptr_b, i8 %mask) {
1533   ;CHECK-LABEL: test_mask_and_epi32_rmkz_128
1534   ;CHECK: vpandd  (%rdi), %xmm0, %xmm0 {%k1} {z} ## encoding: [0x62,0xf1,0x7d,0x89,0xdb,0x07]
1535   %b = load <4 x i32>, <4 x i32>* %ptr_b
1536   %res = call <4 x i32> @llvm.x86.avx512.mask.pand.d.128(<4 x i32> %a, <4 x i32> %b, <4 x i32> zeroinitializer, i8 %mask)
1537   ret <4 x i32> %res
1538 }
1539
1540 define <4 x i32> @test_mask_and_epi32_rmb_128(<4 x i32> %a, i32* %ptr_b) {
1541   ;CHECK-LABEL: test_mask_and_epi32_rmb_128
1542   ;CHECK: vpandd  (%rdi){1to4}, %xmm0, %xmm0  ## encoding: [0x62,0xf1,0x7d,0x18,0xdb,0x07]
1543   %q = load i32, i32* %ptr_b
1544   %vecinit.i = insertelement <4 x i32> undef, i32 %q, i32 0
1545   %b = shufflevector <4 x i32> %vecinit.i, <4 x i32> undef, <4 x i32> zeroinitializer
1546   %res = call <4 x i32> @llvm.x86.avx512.mask.pand.d.128(<4 x i32> %a, <4 x i32> %b, <4 x i32> zeroinitializer, i8 -1)
1547   ret <4 x i32> %res
1548 }
1549
1550 define <4 x i32> @test_mask_and_epi32_rmbk_128(<4 x i32> %a, i32* %ptr_b, <4 x i32> %passThru, i8 %mask) {
1551   ;CHECK-LABEL: test_mask_and_epi32_rmbk_128
1552   ;CHECK: vpandd  (%rdi){1to4}, %xmm0, %xmm1 {%k1} ## encoding: [0x62,0xf1,0x7d,0x19,0xdb,0x0f]
1553   %q = load i32, i32* %ptr_b
1554   %vecinit.i = insertelement <4 x i32> undef, i32 %q, i32 0
1555   %b = shufflevector <4 x i32> %vecinit.i, <4 x i32> undef, <4 x i32> zeroinitializer
1556   %res = call <4 x i32> @llvm.x86.avx512.mask.pand.d.128(<4 x i32> %a, <4 x i32> %b, <4 x i32> %passThru, i8 %mask)
1557   ret <4 x i32> %res
1558 }
1559
1560 define <4 x i32> @test_mask_and_epi32_rmbkz_128(<4 x i32> %a, i32* %ptr_b, i8 %mask) {
1561   ;CHECK-LABEL: test_mask_and_epi32_rmbkz_128
1562   ;CHECK: vpandd  (%rdi){1to4}, %xmm0, %xmm0 {%k1} {z} ## encoding: [0x62,0xf1,0x7d,0x99,0xdb,0x07]
1563   %q = load i32, i32* %ptr_b
1564   %vecinit.i = insertelement <4 x i32> undef, i32 %q, i32 0
1565   %b = shufflevector <4 x i32> %vecinit.i, <4 x i32> undef, <4 x i32> zeroinitializer
1566   %res = call <4 x i32> @llvm.x86.avx512.mask.pand.d.128(<4 x i32> %a, <4 x i32> %b, <4 x i32> zeroinitializer, i8 %mask)
1567   ret <4 x i32> %res
1568 }
1569
1570 declare <4 x i32> @llvm.x86.avx512.mask.pand.d.128(<4 x i32>, <4 x i32>, <4 x i32>, i8)
1571
1572 define <8 x i32> @test_mask_and_epi32_rr_256(<8 x i32> %a, <8 x i32> %b) {
1573   ;CHECK-LABEL: test_mask_and_epi32_rr_256
1574   ;CHECK: vpandd  %ymm1, %ymm0, %ymm0     ## encoding: [0x62,0xf1,0x7d,0x28,0xdb,0xc1]
1575   %res = call <8 x i32> @llvm.x86.avx512.mask.pand.d.256(<8 x i32> %a, <8 x i32> %b, <8 x i32> zeroinitializer, i8 -1)
1576   ret <8 x i32> %res
1577 }
1578
1579 define <8 x i32> @test_mask_and_epi32_rrk_256(<8 x i32> %a, <8 x i32> %b, <8 x i32> %passThru, i8 %mask) {
1580   ;CHECK-LABEL: test_mask_and_epi32_rrk_256
1581   ;CHECK: vpandd  %ymm1, %ymm0, %ymm2 {%k1} ## encoding: [0x62,0xf1,0x7d,0x29,0xdb,0xd1]
1582   %res = call <8 x i32> @llvm.x86.avx512.mask.pand.d.256(<8 x i32> %a, <8 x i32> %b, <8 x i32> %passThru, i8 %mask)
1583   ret <8 x i32> %res
1584 }
1585
1586 define <8 x i32> @test_mask_and_epi32_rrkz_256(<8 x i32> %a, <8 x i32> %b, i8 %mask) {
1587   ;CHECK-LABEL: test_mask_and_epi32_rrkz_256
1588   ;CHECK: vpandd  %ymm1, %ymm0, %ymm0 {%k1} {z} ## encoding: [0x62,0xf1,0x7d,0xa9,0xdb,0xc1]
1589   %res = call <8 x i32> @llvm.x86.avx512.mask.pand.d.256(<8 x i32> %a, <8 x i32> %b, <8 x i32> zeroinitializer, i8 %mask)
1590   ret <8 x i32> %res
1591 }
1592
1593 define <8 x i32> @test_mask_and_epi32_rm_256(<8 x i32> %a, <8 x i32>* %ptr_b) {
1594   ;CHECK-LABEL: test_mask_and_epi32_rm_256
1595   ;CHECK: vpandd  (%rdi), %ymm0, %ymm0    ## encoding: [0x62,0xf1,0x7d,0x28,0xdb,0x07]
1596   %b = load <8 x i32>, <8 x i32>* %ptr_b
1597   %res = call <8 x i32> @llvm.x86.avx512.mask.pand.d.256(<8 x i32> %a, <8 x i32> %b, <8 x i32> zeroinitializer, i8 -1)
1598   ret <8 x i32> %res
1599 }
1600
1601 define <8 x i32> @test_mask_and_epi32_rmk_256(<8 x i32> %a, <8 x i32>* %ptr_b, <8 x i32> %passThru, i8 %mask) {
1602   ;CHECK-LABEL: test_mask_and_epi32_rmk_256
1603   ;CHECK: vpandd  (%rdi), %ymm0, %ymm1 {%k1} ## encoding: [0x62,0xf1,0x7d,0x29,0xdb,0x0f]
1604   %b = load <8 x i32>, <8 x i32>* %ptr_b
1605   %res = call <8 x i32> @llvm.x86.avx512.mask.pand.d.256(<8 x i32> %a, <8 x i32> %b, <8 x i32> %passThru, i8 %mask)
1606   ret <8 x i32> %res
1607 }
1608
1609 define <8 x i32> @test_mask_and_epi32_rmkz_256(<8 x i32> %a, <8 x i32>* %ptr_b, i8 %mask) {
1610   ;CHECK-LABEL: test_mask_and_epi32_rmkz_256
1611   ;CHECK: vpandd  (%rdi), %ymm0, %ymm0 {%k1} {z} ## encoding: [0x62,0xf1,0x7d,0xa9,0xdb,0x07]
1612   %b = load <8 x i32>, <8 x i32>* %ptr_b
1613   %res = call <8 x i32> @llvm.x86.avx512.mask.pand.d.256(<8 x i32> %a, <8 x i32> %b, <8 x i32> zeroinitializer, i8 %mask)
1614   ret <8 x i32> %res
1615 }
1616
1617 define <8 x i32> @test_mask_and_epi32_rmb_256(<8 x i32> %a, i32* %ptr_b) {
1618   ;CHECK-LABEL: test_mask_and_epi32_rmb_256
1619   ;CHECK: vpandd  (%rdi){1to8}, %ymm0, %ymm0  ## encoding: [0x62,0xf1,0x7d,0x38,0xdb,0x07]
1620   %q = load i32, i32* %ptr_b
1621   %vecinit.i = insertelement <8 x i32> undef, i32 %q, i32 0
1622   %b = shufflevector <8 x i32> %vecinit.i, <8 x i32> undef, <8 x i32> zeroinitializer
1623   %res = call <8 x i32> @llvm.x86.avx512.mask.pand.d.256(<8 x i32> %a, <8 x i32> %b, <8 x i32> zeroinitializer, i8 -1)
1624   ret <8 x i32> %res
1625 }
1626
1627 define <8 x i32> @test_mask_and_epi32_rmbk_256(<8 x i32> %a, i32* %ptr_b, <8 x i32> %passThru, i8 %mask) {
1628   ;CHECK-LABEL: test_mask_and_epi32_rmbk_256
1629   ;CHECK: vpandd  (%rdi){1to8}, %ymm0, %ymm1 {%k1} ## encoding: [0x62,0xf1,0x7d,0x39,0xdb,0x0f]
1630   %q = load i32, i32* %ptr_b
1631   %vecinit.i = insertelement <8 x i32> undef, i32 %q, i32 0
1632   %b = shufflevector <8 x i32> %vecinit.i, <8 x i32> undef, <8 x i32> zeroinitializer
1633   %res = call <8 x i32> @llvm.x86.avx512.mask.pand.d.256(<8 x i32> %a, <8 x i32> %b, <8 x i32> %passThru, i8 %mask)
1634   ret <8 x i32> %res
1635 }
1636
1637 define <8 x i32> @test_mask_and_epi32_rmbkz_256(<8 x i32> %a, i32* %ptr_b, i8 %mask) {
1638   ;CHECK-LABEL: test_mask_and_epi32_rmbkz_256
1639   ;CHECK: vpandd  (%rdi){1to8}, %ymm0, %ymm0 {%k1} {z} ## encoding: [0x62,0xf1,0x7d,0xb9,0xdb,0x07]
1640   %q = load i32, i32* %ptr_b
1641   %vecinit.i = insertelement <8 x i32> undef, i32 %q, i32 0
1642   %b = shufflevector <8 x i32> %vecinit.i, <8 x i32> undef, <8 x i32> zeroinitializer
1643   %res = call <8 x i32> @llvm.x86.avx512.mask.pand.d.256(<8 x i32> %a, <8 x i32> %b, <8 x i32> zeroinitializer, i8 %mask)
1644   ret <8 x i32> %res
1645 }
1646
1647 declare <8 x i32> @llvm.x86.avx512.mask.pand.d.256(<8 x i32>, <8 x i32>, <8 x i32>, i8)
1648
1649 define <4 x i32> @test_mask_or_epi32_rr_128(<4 x i32> %a, <4 x i32> %b) {
1650   ;CHECK-LABEL: test_mask_or_epi32_rr_128
1651   ;CHECK: vpord   %xmm1, %xmm0, %xmm0     ## encoding: [0x62,0xf1,0x7d,0x08,0xeb,0xc1]
1652   %res = call <4 x i32> @llvm.x86.avx512.mask.por.d.128(<4 x i32> %a, <4 x i32> %b, <4 x i32> zeroinitializer, i8 -1)
1653   ret <4 x i32> %res
1654 }
1655
1656 define <4 x i32> @test_mask_or_epi32_rrk_128(<4 x i32> %a, <4 x i32> %b, <4 x i32> %passThru, i8 %mask) {
1657   ;CHECK-LABEL: test_mask_or_epi32_rrk_128
1658   ;CHECK: vpord   %xmm1, %xmm0, %xmm2 {%k1} ## encoding: [0x62,0xf1,0x7d,0x09,0xeb,0xd1]
1659   %res = call <4 x i32> @llvm.x86.avx512.mask.por.d.128(<4 x i32> %a, <4 x i32> %b, <4 x i32> %passThru, i8 %mask)
1660   ret <4 x i32> %res
1661 }
1662
1663 define <4 x i32> @test_mask_or_epi32_rrkz_128(<4 x i32> %a, <4 x i32> %b, i8 %mask) {
1664   ;CHECK-LABEL: test_mask_or_epi32_rrkz_128
1665   ;CHECK: vpord   %xmm1, %xmm0, %xmm0 {%k1} {z} ## encoding: [0x62,0xf1,0x7d,0x89,0xeb,0xc1]
1666   %res = call <4 x i32> @llvm.x86.avx512.mask.por.d.128(<4 x i32> %a, <4 x i32> %b, <4 x i32> zeroinitializer, i8 %mask)
1667   ret <4 x i32> %res
1668 }
1669
1670 define <4 x i32> @test_mask_or_epi32_rm_128(<4 x i32> %a, <4 x i32>* %ptr_b) {
1671   ;CHECK-LABEL: test_mask_or_epi32_rm_128
1672   ;CHECK: vpord   (%rdi), %xmm0, %xmm0    ## encoding: [0x62,0xf1,0x7d,0x08,0xeb,0x07]
1673   %b = load <4 x i32>, <4 x i32>* %ptr_b
1674   %res = call <4 x i32> @llvm.x86.avx512.mask.por.d.128(<4 x i32> %a, <4 x i32> %b, <4 x i32> zeroinitializer, i8 -1)
1675   ret <4 x i32> %res
1676 }
1677
1678 define <4 x i32> @test_mask_or_epi32_rmk_128(<4 x i32> %a, <4 x i32>* %ptr_b, <4 x i32> %passThru, i8 %mask) {
1679   ;CHECK-LABEL: test_mask_or_epi32_rmk_128
1680   ;CHECK: vpord   (%rdi), %xmm0, %xmm1 {%k1} ## encoding: [0x62,0xf1,0x7d,0x09,0xeb,0x0f]
1681   %b = load <4 x i32>, <4 x i32>* %ptr_b
1682   %res = call <4 x i32> @llvm.x86.avx512.mask.por.d.128(<4 x i32> %a, <4 x i32> %b, <4 x i32> %passThru, i8 %mask)
1683   ret <4 x i32> %res
1684 }
1685
1686 define <4 x i32> @test_mask_or_epi32_rmkz_128(<4 x i32> %a, <4 x i32>* %ptr_b, i8 %mask) {
1687   ;CHECK-LABEL: test_mask_or_epi32_rmkz_128
1688   ;CHECK: vpord   (%rdi), %xmm0, %xmm0 {%k1} {z} ## encoding: [0x62,0xf1,0x7d,0x89,0xeb,0x07]
1689   %b = load <4 x i32>, <4 x i32>* %ptr_b
1690   %res = call <4 x i32> @llvm.x86.avx512.mask.por.d.128(<4 x i32> %a, <4 x i32> %b, <4 x i32> zeroinitializer, i8 %mask)
1691   ret <4 x i32> %res
1692 }
1693
1694 define <4 x i32> @test_mask_or_epi32_rmb_128(<4 x i32> %a, i32* %ptr_b) {
1695   ;CHECK-LABEL: test_mask_or_epi32_rmb_128
1696   ;CHECK: vpord   (%rdi){1to4}, %xmm0, %xmm0  ## encoding: [0x62,0xf1,0x7d,0x18,0xeb,0x07]
1697   %q = load i32, i32* %ptr_b
1698   %vecinit.i = insertelement <4 x i32> undef, i32 %q, i32 0
1699   %b = shufflevector <4 x i32> %vecinit.i, <4 x i32> undef, <4 x i32> zeroinitializer
1700   %res = call <4 x i32> @llvm.x86.avx512.mask.por.d.128(<4 x i32> %a, <4 x i32> %b, <4 x i32> zeroinitializer, i8 -1)
1701   ret <4 x i32> %res
1702 }
1703
1704 define <4 x i32> @test_mask_or_epi32_rmbk_128(<4 x i32> %a, i32* %ptr_b, <4 x i32> %passThru, i8 %mask) {
1705   ;CHECK-LABEL: test_mask_or_epi32_rmbk_128
1706   ;CHECK: vpord   (%rdi){1to4}, %xmm0, %xmm1 {%k1} ## encoding: [0x62,0xf1,0x7d,0x19,0xeb,0x0f]
1707   %q = load i32, i32* %ptr_b
1708   %vecinit.i = insertelement <4 x i32> undef, i32 %q, i32 0
1709   %b = shufflevector <4 x i32> %vecinit.i, <4 x i32> undef, <4 x i32> zeroinitializer
1710   %res = call <4 x i32> @llvm.x86.avx512.mask.por.d.128(<4 x i32> %a, <4 x i32> %b, <4 x i32> %passThru, i8 %mask)
1711   ret <4 x i32> %res
1712 }
1713
1714 define <4 x i32> @test_mask_or_epi32_rmbkz_128(<4 x i32> %a, i32* %ptr_b, i8 %mask) {
1715   ;CHECK-LABEL: test_mask_or_epi32_rmbkz_128
1716   ;CHECK: vpord   (%rdi){1to4}, %xmm0, %xmm0 {%k1} {z} ## encoding: [0x62,0xf1,0x7d,0x99,0xeb,0x07]
1717   %q = load i32, i32* %ptr_b
1718   %vecinit.i = insertelement <4 x i32> undef, i32 %q, i32 0
1719   %b = shufflevector <4 x i32> %vecinit.i, <4 x i32> undef, <4 x i32> zeroinitializer
1720   %res = call <4 x i32> @llvm.x86.avx512.mask.por.d.128(<4 x i32> %a, <4 x i32> %b, <4 x i32> zeroinitializer, i8 %mask)
1721   ret <4 x i32> %res
1722 }
1723
1724 declare <4 x i32> @llvm.x86.avx512.mask.por.d.128(<4 x i32>, <4 x i32>, <4 x i32>, i8)
1725
1726 define <8 x i32> @test_mask_or_epi32_rr_256(<8 x i32> %a, <8 x i32> %b) {
1727   ;CHECK-LABEL: test_mask_or_epi32_rr_256
1728   ;CHECK: vpord   %ymm1, %ymm0, %ymm0     ## encoding: [0x62,0xf1,0x7d,0x28,0xeb,0xc1]
1729   %res = call <8 x i32> @llvm.x86.avx512.mask.por.d.256(<8 x i32> %a, <8 x i32> %b, <8 x i32> zeroinitializer, i8 -1)
1730   ret <8 x i32> %res
1731 }
1732
1733 define <8 x i32> @test_mask_or_epi32_rrk_256(<8 x i32> %a, <8 x i32> %b, <8 x i32> %passThru, i8 %mask) {
1734   ;CHECK-LABEL: test_mask_or_epi32_rrk_256
1735   ;CHECK: vpord   %ymm1, %ymm0, %ymm2 {%k1} ## encoding: [0x62,0xf1,0x7d,0x29,0xeb,0xd1]
1736   %res = call <8 x i32> @llvm.x86.avx512.mask.por.d.256(<8 x i32> %a, <8 x i32> %b, <8 x i32> %passThru, i8 %mask)
1737   ret <8 x i32> %res
1738 }
1739
1740 define <8 x i32> @test_mask_or_epi32_rrkz_256(<8 x i32> %a, <8 x i32> %b, i8 %mask) {
1741   ;CHECK-LABEL: test_mask_or_epi32_rrkz_256
1742   ;CHECK: vpord   %ymm1, %ymm0, %ymm0 {%k1} {z} ## encoding: [0x62,0xf1,0x7d,0xa9,0xeb,0xc1]
1743   %res = call <8 x i32> @llvm.x86.avx512.mask.por.d.256(<8 x i32> %a, <8 x i32> %b, <8 x i32> zeroinitializer, i8 %mask)
1744   ret <8 x i32> %res
1745 }
1746
1747 define <8 x i32> @test_mask_or_epi32_rm_256(<8 x i32> %a, <8 x i32>* %ptr_b) {
1748   ;CHECK-LABEL: test_mask_or_epi32_rm_256
1749   ;CHECK: vpord   (%rdi), %ymm0, %ymm0    ## encoding: [0x62,0xf1,0x7d,0x28,0xeb,0x07]
1750   %b = load <8 x i32>, <8 x i32>* %ptr_b
1751   %res = call <8 x i32> @llvm.x86.avx512.mask.por.d.256(<8 x i32> %a, <8 x i32> %b, <8 x i32> zeroinitializer, i8 -1)
1752   ret <8 x i32> %res
1753 }
1754
1755 define <8 x i32> @test_mask_or_epi32_rmk_256(<8 x i32> %a, <8 x i32>* %ptr_b, <8 x i32> %passThru, i8 %mask) {
1756   ;CHECK-LABEL: test_mask_or_epi32_rmk_256
1757   ;CHECK: vpord   (%rdi), %ymm0, %ymm1 {%k1} ## encoding: [0x62,0xf1,0x7d,0x29,0xeb,0x0f]
1758   %b = load <8 x i32>, <8 x i32>* %ptr_b
1759   %res = call <8 x i32> @llvm.x86.avx512.mask.por.d.256(<8 x i32> %a, <8 x i32> %b, <8 x i32> %passThru, i8 %mask)
1760   ret <8 x i32> %res
1761 }
1762
1763 define <8 x i32> @test_mask_or_epi32_rmkz_256(<8 x i32> %a, <8 x i32>* %ptr_b, i8 %mask) {
1764   ;CHECK-LABEL: test_mask_or_epi32_rmkz_256
1765   ;CHECK: vpord   (%rdi), %ymm0, %ymm0 {%k1} {z} ## encoding: [0x62,0xf1,0x7d,0xa9,0xeb,0x07]
1766   %b = load <8 x i32>, <8 x i32>* %ptr_b
1767   %res = call <8 x i32> @llvm.x86.avx512.mask.por.d.256(<8 x i32> %a, <8 x i32> %b, <8 x i32> zeroinitializer, i8 %mask)
1768   ret <8 x i32> %res
1769 }
1770
1771 define <8 x i32> @test_mask_or_epi32_rmb_256(<8 x i32> %a, i32* %ptr_b) {
1772   ;CHECK-LABEL: test_mask_or_epi32_rmb_256
1773   ;CHECK: vpord   (%rdi){1to8}, %ymm0, %ymm0  ## encoding: [0x62,0xf1,0x7d,0x38,0xeb,0x07]
1774   %q = load i32, i32* %ptr_b
1775   %vecinit.i = insertelement <8 x i32> undef, i32 %q, i32 0
1776   %b = shufflevector <8 x i32> %vecinit.i, <8 x i32> undef, <8 x i32> zeroinitializer
1777   %res = call <8 x i32> @llvm.x86.avx512.mask.por.d.256(<8 x i32> %a, <8 x i32> %b, <8 x i32> zeroinitializer, i8 -1)
1778   ret <8 x i32> %res
1779 }
1780
1781 define <8 x i32> @test_mask_or_epi32_rmbk_256(<8 x i32> %a, i32* %ptr_b, <8 x i32> %passThru, i8 %mask) {
1782   ;CHECK-LABEL: test_mask_or_epi32_rmbk_256
1783   ;CHECK: vpord   (%rdi){1to8}, %ymm0, %ymm1 {%k1} ## encoding: [0x62,0xf1,0x7d,0x39,0xeb,0x0f]
1784   %q = load i32, i32* %ptr_b
1785   %vecinit.i = insertelement <8 x i32> undef, i32 %q, i32 0
1786   %b = shufflevector <8 x i32> %vecinit.i, <8 x i32> undef, <8 x i32> zeroinitializer
1787   %res = call <8 x i32> @llvm.x86.avx512.mask.por.d.256(<8 x i32> %a, <8 x i32> %b, <8 x i32> %passThru, i8 %mask)
1788   ret <8 x i32> %res
1789 }
1790
1791 define <8 x i32> @test_mask_or_epi32_rmbkz_256(<8 x i32> %a, i32* %ptr_b, i8 %mask) {
1792   ;CHECK-LABEL: test_mask_or_epi32_rmbkz_256
1793   ;CHECK: vpord   (%rdi){1to8}, %ymm0, %ymm0 {%k1} {z} ## encoding: [0x62,0xf1,0x7d,0xb9,0xeb,0x07]
1794   %q = load i32, i32* %ptr_b
1795   %vecinit.i = insertelement <8 x i32> undef, i32 %q, i32 0
1796   %b = shufflevector <8 x i32> %vecinit.i, <8 x i32> undef, <8 x i32> zeroinitializer
1797   %res = call <8 x i32> @llvm.x86.avx512.mask.por.d.256(<8 x i32> %a, <8 x i32> %b, <8 x i32> zeroinitializer, i8 %mask)
1798   ret <8 x i32> %res
1799 }
1800
1801 declare <8 x i32> @llvm.x86.avx512.mask.por.d.256(<8 x i32>, <8 x i32>, <8 x i32>, i8)
1802
1803 define <4 x i32> @test_mask_xor_epi32_rr_128(<4 x i32> %a, <4 x i32> %b) {
1804   ;CHECK-LABEL: test_mask_xor_epi32_rr_128
1805   ;CHECK: vpxord  %xmm1, %xmm0, %xmm0     ## encoding: [0x62,0xf1,0x7d,0x08,0xef,0xc1]
1806   %res = call <4 x i32> @llvm.x86.avx512.mask.pxor.d.128(<4 x i32> %a, <4 x i32> %b, <4 x i32> zeroinitializer, i8 -1)
1807   ret <4 x i32> %res
1808 }
1809
1810 define <4 x i32> @test_mask_xor_epi32_rrk_128(<4 x i32> %a, <4 x i32> %b, <4 x i32> %passThru, i8 %mask) {
1811   ;CHECK-LABEL: test_mask_xor_epi32_rrk_128
1812   ;CHECK: vpxord  %xmm1, %xmm0, %xmm2 {%k1} ## encoding: [0x62,0xf1,0x7d,0x09,0xef,0xd1]
1813   %res = call <4 x i32> @llvm.x86.avx512.mask.pxor.d.128(<4 x i32> %a, <4 x i32> %b, <4 x i32> %passThru, i8 %mask)
1814   ret <4 x i32> %res
1815 }
1816
1817 define <4 x i32> @test_mask_xor_epi32_rrkz_128(<4 x i32> %a, <4 x i32> %b, i8 %mask) {
1818   ;CHECK-LABEL: test_mask_xor_epi32_rrkz_128
1819   ;CHECK: vpxord  %xmm1, %xmm0, %xmm0 {%k1} {z} ## encoding: [0x62,0xf1,0x7d,0x89,0xef,0xc1]
1820   %res = call <4 x i32> @llvm.x86.avx512.mask.pxor.d.128(<4 x i32> %a, <4 x i32> %b, <4 x i32> zeroinitializer, i8 %mask)
1821   ret <4 x i32> %res
1822 }
1823
1824 define <4 x i32> @test_mask_xor_epi32_rm_128(<4 x i32> %a, <4 x i32>* %ptr_b) {
1825   ;CHECK-LABEL: test_mask_xor_epi32_rm_128
1826   ;CHECK: vpxord  (%rdi), %xmm0, %xmm0    ## encoding: [0x62,0xf1,0x7d,0x08,0xef,0x07]
1827   %b = load <4 x i32>, <4 x i32>* %ptr_b
1828   %res = call <4 x i32> @llvm.x86.avx512.mask.pxor.d.128(<4 x i32> %a, <4 x i32> %b, <4 x i32> zeroinitializer, i8 -1)
1829   ret <4 x i32> %res
1830 }
1831
1832 define <4 x i32> @test_mask_xor_epi32_rmk_128(<4 x i32> %a, <4 x i32>* %ptr_b, <4 x i32> %passThru, i8 %mask) {
1833   ;CHECK-LABEL: test_mask_xor_epi32_rmk_128
1834   ;CHECK: vpxord  (%rdi), %xmm0, %xmm1 {%k1} ## encoding: [0x62,0xf1,0x7d,0x09,0xef,0x0f]
1835   %b = load <4 x i32>, <4 x i32>* %ptr_b
1836   %res = call <4 x i32> @llvm.x86.avx512.mask.pxor.d.128(<4 x i32> %a, <4 x i32> %b, <4 x i32> %passThru, i8 %mask)
1837   ret <4 x i32> %res
1838 }
1839
1840 define <4 x i32> @test_mask_xor_epi32_rmkz_128(<4 x i32> %a, <4 x i32>* %ptr_b, i8 %mask) {
1841   ;CHECK-LABEL: test_mask_xor_epi32_rmkz_128
1842   ;CHECK: vpxord  (%rdi), %xmm0, %xmm0 {%k1} {z} ## encoding: [0x62,0xf1,0x7d,0x89,0xef,0x07]
1843   %b = load <4 x i32>, <4 x i32>* %ptr_b
1844   %res = call <4 x i32> @llvm.x86.avx512.mask.pxor.d.128(<4 x i32> %a, <4 x i32> %b, <4 x i32> zeroinitializer, i8 %mask)
1845   ret <4 x i32> %res
1846 }
1847
1848 define <4 x i32> @test_mask_xor_epi32_rmb_128(<4 x i32> %a, i32* %ptr_b) {
1849   ;CHECK-LABEL: test_mask_xor_epi32_rmb_128
1850   ;CHECK: vpxord  (%rdi){1to4}, %xmm0, %xmm0  ## encoding: [0x62,0xf1,0x7d,0x18,0xef,0x07]
1851   %q = load i32, i32* %ptr_b
1852   %vecinit.i = insertelement <4 x i32> undef, i32 %q, i32 0
1853   %b = shufflevector <4 x i32> %vecinit.i, <4 x i32> undef, <4 x i32> zeroinitializer
1854   %res = call <4 x i32> @llvm.x86.avx512.mask.pxor.d.128(<4 x i32> %a, <4 x i32> %b, <4 x i32> zeroinitializer, i8 -1)
1855   ret <4 x i32> %res
1856 }
1857
1858 define <4 x i32> @test_mask_xor_epi32_rmbk_128(<4 x i32> %a, i32* %ptr_b, <4 x i32> %passThru, i8 %mask) {
1859   ;CHECK-LABEL: test_mask_xor_epi32_rmbk_128
1860   ;CHECK: vpxord  (%rdi){1to4}, %xmm0, %xmm1 {%k1} ## encoding: [0x62,0xf1,0x7d,0x19,0xef,0x0f]
1861   %q = load i32, i32* %ptr_b
1862   %vecinit.i = insertelement <4 x i32> undef, i32 %q, i32 0
1863   %b = shufflevector <4 x i32> %vecinit.i, <4 x i32> undef, <4 x i32> zeroinitializer
1864   %res = call <4 x i32> @llvm.x86.avx512.mask.pxor.d.128(<4 x i32> %a, <4 x i32> %b, <4 x i32> %passThru, i8 %mask)
1865   ret <4 x i32> %res
1866 }
1867
1868 define <4 x i32> @test_mask_xor_epi32_rmbkz_128(<4 x i32> %a, i32* %ptr_b, i8 %mask) {
1869   ;CHECK-LABEL: test_mask_xor_epi32_rmbkz_128
1870   ;CHECK: vpxord  (%rdi){1to4}, %xmm0, %xmm0 {%k1} {z} ## encoding: [0x62,0xf1,0x7d,0x99,0xef,0x07]
1871   %q = load i32, i32* %ptr_b
1872   %vecinit.i = insertelement <4 x i32> undef, i32 %q, i32 0
1873   %b = shufflevector <4 x i32> %vecinit.i, <4 x i32> undef, <4 x i32> zeroinitializer
1874   %res = call <4 x i32> @llvm.x86.avx512.mask.pxor.d.128(<4 x i32> %a, <4 x i32> %b, <4 x i32> zeroinitializer, i8 %mask)
1875   ret <4 x i32> %res
1876 }
1877
1878 declare <4 x i32> @llvm.x86.avx512.mask.pxor.d.128(<4 x i32>, <4 x i32>, <4 x i32>, i8)
1879
1880 define <8 x i32> @test_mask_xor_epi32_rr_256(<8 x i32> %a, <8 x i32> %b) {
1881   ;CHECK-LABEL: test_mask_xor_epi32_rr_256
1882   ;CHECK: vpxord  %ymm1, %ymm0, %ymm0     ## encoding: [0x62,0xf1,0x7d,0x28,0xef,0xc1]
1883   %res = call <8 x i32> @llvm.x86.avx512.mask.pxor.d.256(<8 x i32> %a, <8 x i32> %b, <8 x i32> zeroinitializer, i8 -1)
1884   ret <8 x i32> %res
1885 }
1886
1887 define <8 x i32> @test_mask_xor_epi32_rrk_256(<8 x i32> %a, <8 x i32> %b, <8 x i32> %passThru, i8 %mask) {
1888   ;CHECK-LABEL: test_mask_xor_epi32_rrk_256
1889   ;CHECK: vpxord  %ymm1, %ymm0, %ymm2 {%k1} ## encoding: [0x62,0xf1,0x7d,0x29,0xef,0xd1]
1890   %res = call <8 x i32> @llvm.x86.avx512.mask.pxor.d.256(<8 x i32> %a, <8 x i32> %b, <8 x i32> %passThru, i8 %mask)
1891   ret <8 x i32> %res
1892 }
1893
1894 define <8 x i32> @test_mask_xor_epi32_rrkz_256(<8 x i32> %a, <8 x i32> %b, i8 %mask) {
1895   ;CHECK-LABEL: test_mask_xor_epi32_rrkz_256
1896   ;CHECK: vpxord  %ymm1, %ymm0, %ymm0 {%k1} {z} ## encoding: [0x62,0xf1,0x7d,0xa9,0xef,0xc1]
1897   %res = call <8 x i32> @llvm.x86.avx512.mask.pxor.d.256(<8 x i32> %a, <8 x i32> %b, <8 x i32> zeroinitializer, i8 %mask)
1898   ret <8 x i32> %res
1899 }
1900
1901 define <8 x i32> @test_mask_xor_epi32_rm_256(<8 x i32> %a, <8 x i32>* %ptr_b) {
1902   ;CHECK-LABEL: test_mask_xor_epi32_rm_256
1903   ;CHECK: vpxord  (%rdi), %ymm0, %ymm0    ## encoding: [0x62,0xf1,0x7d,0x28,0xef,0x07]
1904   %b = load <8 x i32>, <8 x i32>* %ptr_b
1905   %res = call <8 x i32> @llvm.x86.avx512.mask.pxor.d.256(<8 x i32> %a, <8 x i32> %b, <8 x i32> zeroinitializer, i8 -1)
1906   ret <8 x i32> %res
1907 }
1908
1909 define <8 x i32> @test_mask_xor_epi32_rmk_256(<8 x i32> %a, <8 x i32>* %ptr_b, <8 x i32> %passThru, i8 %mask) {
1910   ;CHECK-LABEL: test_mask_xor_epi32_rmk_256
1911   ;CHECK: vpxord  (%rdi), %ymm0, %ymm1 {%k1} ## encoding: [0x62,0xf1,0x7d,0x29,0xef,0x0f]
1912   %b = load <8 x i32>, <8 x i32>* %ptr_b
1913   %res = call <8 x i32> @llvm.x86.avx512.mask.pxor.d.256(<8 x i32> %a, <8 x i32> %b, <8 x i32> %passThru, i8 %mask)
1914   ret <8 x i32> %res
1915 }
1916
1917 define <8 x i32> @test_mask_xor_epi32_rmkz_256(<8 x i32> %a, <8 x i32>* %ptr_b, i8 %mask) {
1918   ;CHECK-LABEL: test_mask_xor_epi32_rmkz_256
1919   ;CHECK: vpxord  (%rdi), %ymm0, %ymm0 {%k1} {z} ## encoding: [0x62,0xf1,0x7d,0xa9,0xef,0x07]
1920   %b = load <8 x i32>, <8 x i32>* %ptr_b
1921   %res = call <8 x i32> @llvm.x86.avx512.mask.pxor.d.256(<8 x i32> %a, <8 x i32> %b, <8 x i32> zeroinitializer, i8 %mask)
1922   ret <8 x i32> %res
1923 }
1924
1925 define <8 x i32> @test_mask_xor_epi32_rmb_256(<8 x i32> %a, i32* %ptr_b) {
1926   ;CHECK-LABEL: test_mask_xor_epi32_rmb_256
1927   ;CHECK: vpxord  (%rdi){1to8}, %ymm0, %ymm0  ## encoding: [0x62,0xf1,0x7d,0x38,0xef,0x07]
1928   %q = load i32, i32* %ptr_b
1929   %vecinit.i = insertelement <8 x i32> undef, i32 %q, i32 0
1930   %b = shufflevector <8 x i32> %vecinit.i, <8 x i32> undef, <8 x i32> zeroinitializer
1931   %res = call <8 x i32> @llvm.x86.avx512.mask.pxor.d.256(<8 x i32> %a, <8 x i32> %b, <8 x i32> zeroinitializer, i8 -1)
1932   ret <8 x i32> %res
1933 }
1934
1935 define <8 x i32> @test_mask_xor_epi32_rmbk_256(<8 x i32> %a, i32* %ptr_b, <8 x i32> %passThru, i8 %mask) {
1936   ;CHECK-LABEL: test_mask_xor_epi32_rmbk_256
1937   ;CHECK: vpxord  (%rdi){1to8}, %ymm0, %ymm1 {%k1} ## encoding: [0x62,0xf1,0x7d,0x39,0xef,0x0f]
1938   %q = load i32, i32* %ptr_b
1939   %vecinit.i = insertelement <8 x i32> undef, i32 %q, i32 0
1940   %b = shufflevector <8 x i32> %vecinit.i, <8 x i32> undef, <8 x i32> zeroinitializer
1941   %res = call <8 x i32> @llvm.x86.avx512.mask.pxor.d.256(<8 x i32> %a, <8 x i32> %b, <8 x i32> %passThru, i8 %mask)
1942   ret <8 x i32> %res
1943 }
1944
1945 define <8 x i32> @test_mask_xor_epi32_rmbkz_256(<8 x i32> %a, i32* %ptr_b, i8 %mask) {
1946   ;CHECK-LABEL: test_mask_xor_epi32_rmbkz_256
1947   ;CHECK: vpxord  (%rdi){1to8}, %ymm0, %ymm0 {%k1} {z} ## encoding: [0x62,0xf1,0x7d,0xb9,0xef,0x07]
1948   %q = load i32, i32* %ptr_b
1949   %vecinit.i = insertelement <8 x i32> undef, i32 %q, i32 0
1950   %b = shufflevector <8 x i32> %vecinit.i, <8 x i32> undef, <8 x i32> zeroinitializer
1951   %res = call <8 x i32> @llvm.x86.avx512.mask.pxor.d.256(<8 x i32> %a, <8 x i32> %b, <8 x i32> zeroinitializer, i8 %mask)
1952   ret <8 x i32> %res
1953 }
1954
1955 declare <8 x i32> @llvm.x86.avx512.mask.pxor.d.256(<8 x i32>, <8 x i32>, <8 x i32>, i8)
1956
1957 define <4 x i32> @test_mask_andnot_epi32_rr_128(<4 x i32> %a, <4 x i32> %b) {
1958   ;CHECK-LABEL: test_mask_andnot_epi32_rr_128
1959   ;CHECK: vpandnd  %xmm1, %xmm0, %xmm0     ## encoding: [0x62,0xf1,0x7d,0x08,0xdf,0xc1]
1960   %res = call <4 x i32> @llvm.x86.avx512.mask.pandn.d.128(<4 x i32> %a, <4 x i32> %b, <4 x i32> zeroinitializer, i8 -1)
1961   ret <4 x i32> %res
1962 }
1963
1964 define <4 x i32> @test_mask_andnot_epi32_rrk_128(<4 x i32> %a, <4 x i32> %b, <4 x i32> %passThru, i8 %mask) {
1965   ;CHECK-LABEL: test_mask_andnot_epi32_rrk_128
1966   ;CHECK: vpandnd  %xmm1, %xmm0, %xmm2 {%k1} ## encoding: [0x62,0xf1,0x7d,0x09,0xdf,0xd1]
1967   %res = call <4 x i32> @llvm.x86.avx512.mask.pandn.d.128(<4 x i32> %a, <4 x i32> %b, <4 x i32> %passThru, i8 %mask)
1968   ret <4 x i32> %res
1969 }
1970
1971 define <4 x i32> @test_mask_andnot_epi32_rrkz_128(<4 x i32> %a, <4 x i32> %b, i8 %mask) {
1972   ;CHECK-LABEL: test_mask_andnot_epi32_rrkz_128
1973   ;CHECK: vpandnd  %xmm1, %xmm0, %xmm0 {%k1} {z} ## encoding: [0x62,0xf1,0x7d,0x89,0xdf,0xc1]
1974   %res = call <4 x i32> @llvm.x86.avx512.mask.pandn.d.128(<4 x i32> %a, <4 x i32> %b, <4 x i32> zeroinitializer, i8 %mask)
1975   ret <4 x i32> %res
1976 }
1977
1978 define <4 x i32> @test_mask_andnot_epi32_rm_128(<4 x i32> %a, <4 x i32>* %ptr_b) {
1979   ;CHECK-LABEL: test_mask_andnot_epi32_rm_128
1980   ;CHECK: vpandnd  (%rdi), %xmm0, %xmm0    ## encoding: [0x62,0xf1,0x7d,0x08,0xdf,0x07]
1981   %b = load <4 x i32>, <4 x i32>* %ptr_b
1982   %res = call <4 x i32> @llvm.x86.avx512.mask.pandn.d.128(<4 x i32> %a, <4 x i32> %b, <4 x i32> zeroinitializer, i8 -1)
1983   ret <4 x i32> %res
1984 }
1985
1986 define <4 x i32> @test_mask_andnot_epi32_rmk_128(<4 x i32> %a, <4 x i32>* %ptr_b, <4 x i32> %passThru, i8 %mask) {
1987   ;CHECK-LABEL: test_mask_andnot_epi32_rmk_128
1988   ;CHECK: vpandnd  (%rdi), %xmm0, %xmm1 {%k1} ## encoding: [0x62,0xf1,0x7d,0x09,0xdf,0x0f]
1989   %b = load <4 x i32>, <4 x i32>* %ptr_b
1990   %res = call <4 x i32> @llvm.x86.avx512.mask.pandn.d.128(<4 x i32> %a, <4 x i32> %b, <4 x i32> %passThru, i8 %mask)
1991   ret <4 x i32> %res
1992 }
1993
1994 define <4 x i32> @test_mask_andnot_epi32_rmkz_128(<4 x i32> %a, <4 x i32>* %ptr_b, i8 %mask) {
1995   ;CHECK-LABEL: test_mask_andnot_epi32_rmkz_128
1996   ;CHECK: vpandnd  (%rdi), %xmm0, %xmm0 {%k1} {z} ## encoding: [0x62,0xf1,0x7d,0x89,0xdf,0x07]
1997   %b = load <4 x i32>, <4 x i32>* %ptr_b
1998   %res = call <4 x i32> @llvm.x86.avx512.mask.pandn.d.128(<4 x i32> %a, <4 x i32> %b, <4 x i32> zeroinitializer, i8 %mask)
1999   ret <4 x i32> %res
2000 }
2001
2002 define <4 x i32> @test_mask_andnot_epi32_rmb_128(<4 x i32> %a, i32* %ptr_b) {
2003   ;CHECK-LABEL: test_mask_andnot_epi32_rmb_128
2004   ;CHECK: vpandnd  (%rdi){1to4}, %xmm0, %xmm0  ## encoding: [0x62,0xf1,0x7d,0x18,0xdf,0x07]
2005   %q = load i32, i32* %ptr_b
2006   %vecinit.i = insertelement <4 x i32> undef, i32 %q, i32 0
2007   %b = shufflevector <4 x i32> %vecinit.i, <4 x i32> undef, <4 x i32> zeroinitializer
2008   %res = call <4 x i32> @llvm.x86.avx512.mask.pandn.d.128(<4 x i32> %a, <4 x i32> %b, <4 x i32> zeroinitializer, i8 -1)
2009   ret <4 x i32> %res
2010 }
2011
2012 define <4 x i32> @test_mask_andnot_epi32_rmbk_128(<4 x i32> %a, i32* %ptr_b, <4 x i32> %passThru, i8 %mask) {
2013   ;CHECK-LABEL: test_mask_andnot_epi32_rmbk_128
2014   ;CHECK: vpandnd  (%rdi){1to4}, %xmm0, %xmm1 {%k1} ## encoding: [0x62,0xf1,0x7d,0x19,0xdf,0x0f]
2015   %q = load i32, i32* %ptr_b
2016   %vecinit.i = insertelement <4 x i32> undef, i32 %q, i32 0
2017   %b = shufflevector <4 x i32> %vecinit.i, <4 x i32> undef, <4 x i32> zeroinitializer
2018   %res = call <4 x i32> @llvm.x86.avx512.mask.pandn.d.128(<4 x i32> %a, <4 x i32> %b, <4 x i32> %passThru, i8 %mask)
2019   ret <4 x i32> %res
2020 }
2021
2022 define <4 x i32> @test_mask_andnot_epi32_rmbkz_128(<4 x i32> %a, i32* %ptr_b, i8 %mask) {
2023   ;CHECK-LABEL: test_mask_andnot_epi32_rmbkz_128
2024   ;CHECK: vpandnd  (%rdi){1to4}, %xmm0, %xmm0 {%k1} {z} ## encoding: [0x62,0xf1,0x7d,0x99,0xdf,0x07]
2025   %q = load i32, i32* %ptr_b
2026   %vecinit.i = insertelement <4 x i32> undef, i32 %q, i32 0
2027   %b = shufflevector <4 x i32> %vecinit.i, <4 x i32> undef, <4 x i32> zeroinitializer
2028   %res = call <4 x i32> @llvm.x86.avx512.mask.pandn.d.128(<4 x i32> %a, <4 x i32> %b, <4 x i32> zeroinitializer, i8 %mask)
2029   ret <4 x i32> %res
2030 }
2031
2032 declare <4 x i32> @llvm.x86.avx512.mask.pandn.d.128(<4 x i32>, <4 x i32>, <4 x i32>, i8)
2033
2034 define <8 x i32> @test_mask_andnot_epi32_rr_256(<8 x i32> %a, <8 x i32> %b) {
2035   ;CHECK-LABEL: test_mask_andnot_epi32_rr_256
2036   ;CHECK: vpandnd  %ymm1, %ymm0, %ymm0     ## encoding: [0x62,0xf1,0x7d,0x28,0xdf,0xc1]
2037   %res = call <8 x i32> @llvm.x86.avx512.mask.pandn.d.256(<8 x i32> %a, <8 x i32> %b, <8 x i32> zeroinitializer, i8 -1)
2038   ret <8 x i32> %res
2039 }
2040
2041 define <8 x i32> @test_mask_andnot_epi32_rrk_256(<8 x i32> %a, <8 x i32> %b, <8 x i32> %passThru, i8 %mask) {
2042   ;CHECK-LABEL: test_mask_andnot_epi32_rrk_256
2043   ;CHECK: vpandnd  %ymm1, %ymm0, %ymm2 {%k1} ## encoding: [0x62,0xf1,0x7d,0x29,0xdf,0xd1]
2044   %res = call <8 x i32> @llvm.x86.avx512.mask.pandn.d.256(<8 x i32> %a, <8 x i32> %b, <8 x i32> %passThru, i8 %mask)
2045   ret <8 x i32> %res
2046 }
2047
2048 define <8 x i32> @test_mask_andnot_epi32_rrkz_256(<8 x i32> %a, <8 x i32> %b, i8 %mask) {
2049   ;CHECK-LABEL: test_mask_andnot_epi32_rrkz_256
2050   ;CHECK: vpandnd  %ymm1, %ymm0, %ymm0 {%k1} {z} ## encoding: [0x62,0xf1,0x7d,0xa9,0xdf,0xc1]
2051   %res = call <8 x i32> @llvm.x86.avx512.mask.pandn.d.256(<8 x i32> %a, <8 x i32> %b, <8 x i32> zeroinitializer, i8 %mask)
2052   ret <8 x i32> %res
2053 }
2054
2055 define <8 x i32> @test_mask_andnot_epi32_rm_256(<8 x i32> %a, <8 x i32>* %ptr_b) {
2056   ;CHECK-LABEL: test_mask_andnot_epi32_rm_256
2057   ;CHECK: vpandnd  (%rdi), %ymm0, %ymm0    ## encoding: [0x62,0xf1,0x7d,0x28,0xdf,0x07]
2058   %b = load <8 x i32>, <8 x i32>* %ptr_b
2059   %res = call <8 x i32> @llvm.x86.avx512.mask.pandn.d.256(<8 x i32> %a, <8 x i32> %b, <8 x i32> zeroinitializer, i8 -1)
2060   ret <8 x i32> %res
2061 }
2062
2063 define <8 x i32> @test_mask_andnot_epi32_rmk_256(<8 x i32> %a, <8 x i32>* %ptr_b, <8 x i32> %passThru, i8 %mask) {
2064   ;CHECK-LABEL: test_mask_andnot_epi32_rmk_256
2065   ;CHECK: vpandnd  (%rdi), %ymm0, %ymm1 {%k1} ## encoding: [0x62,0xf1,0x7d,0x29,0xdf,0x0f]
2066   %b = load <8 x i32>, <8 x i32>* %ptr_b
2067   %res = call <8 x i32> @llvm.x86.avx512.mask.pandn.d.256(<8 x i32> %a, <8 x i32> %b, <8 x i32> %passThru, i8 %mask)
2068   ret <8 x i32> %res
2069 }
2070
2071 define <8 x i32> @test_mask_andnot_epi32_rmkz_256(<8 x i32> %a, <8 x i32>* %ptr_b, i8 %mask) {
2072   ;CHECK-LABEL: test_mask_andnot_epi32_rmkz_256
2073   ;CHECK: vpandnd  (%rdi), %ymm0, %ymm0 {%k1} {z} ## encoding: [0x62,0xf1,0x7d,0xa9,0xdf,0x07]
2074   %b = load <8 x i32>, <8 x i32>* %ptr_b
2075   %res = call <8 x i32> @llvm.x86.avx512.mask.pandn.d.256(<8 x i32> %a, <8 x i32> %b, <8 x i32> zeroinitializer, i8 %mask)
2076   ret <8 x i32> %res
2077 }
2078
2079 define <8 x i32> @test_mask_andnot_epi32_rmb_256(<8 x i32> %a, i32* %ptr_b) {
2080   ;CHECK-LABEL: test_mask_andnot_epi32_rmb_256
2081   ;CHECK: vpandnd  (%rdi){1to8}, %ymm0, %ymm0  ## encoding: [0x62,0xf1,0x7d,0x38,0xdf,0x07]
2082   %q = load i32, i32* %ptr_b
2083   %vecinit.i = insertelement <8 x i32> undef, i32 %q, i32 0
2084   %b = shufflevector <8 x i32> %vecinit.i, <8 x i32> undef, <8 x i32> zeroinitializer
2085   %res = call <8 x i32> @llvm.x86.avx512.mask.pandn.d.256(<8 x i32> %a, <8 x i32> %b, <8 x i32> zeroinitializer, i8 -1)
2086   ret <8 x i32> %res
2087 }
2088
2089 define <8 x i32> @test_mask_andnot_epi32_rmbk_256(<8 x i32> %a, i32* %ptr_b, <8 x i32> %passThru, i8 %mask) {
2090   ;CHECK-LABEL: test_mask_andnot_epi32_rmbk_256
2091   ;CHECK: vpandnd  (%rdi){1to8}, %ymm0, %ymm1 {%k1} ## encoding: [0x62,0xf1,0x7d,0x39,0xdf,0x0f]
2092   %q = load i32, i32* %ptr_b
2093   %vecinit.i = insertelement <8 x i32> undef, i32 %q, i32 0
2094   %b = shufflevector <8 x i32> %vecinit.i, <8 x i32> undef, <8 x i32> zeroinitializer
2095   %res = call <8 x i32> @llvm.x86.avx512.mask.pandn.d.256(<8 x i32> %a, <8 x i32> %b, <8 x i32> %passThru, i8 %mask)
2096   ret <8 x i32> %res
2097 }
2098
2099 define <8 x i32> @test_mask_andnot_epi32_rmbkz_256(<8 x i32> %a, i32* %ptr_b, i8 %mask) {
2100   ;CHECK-LABEL: test_mask_andnot_epi32_rmbkz_256
2101   ;CHECK: vpandnd  (%rdi){1to8}, %ymm0, %ymm0 {%k1} {z} ## encoding: [0x62,0xf1,0x7d,0xb9,0xdf,0x07]
2102   %q = load i32, i32* %ptr_b
2103   %vecinit.i = insertelement <8 x i32> undef, i32 %q, i32 0
2104   %b = shufflevector <8 x i32> %vecinit.i, <8 x i32> undef, <8 x i32> zeroinitializer
2105   %res = call <8 x i32> @llvm.x86.avx512.mask.pandn.d.256(<8 x i32> %a, <8 x i32> %b, <8 x i32> zeroinitializer, i8 %mask)
2106   ret <8 x i32> %res
2107 }
2108
2109 declare <8 x i32> @llvm.x86.avx512.mask.pandn.d.256(<8 x i32>, <8 x i32>, <8 x i32>, i8)
2110
2111 define <2 x i64> @test_mask_andnot_epi64_rr_128(<2 x i64> %a, <2 x i64> %b) {
2112   ;CHECK-LABEL: test_mask_andnot_epi64_rr_128
2113   ;CHECK: vpandnq  %xmm1, %xmm0, %xmm0     ## encoding: [0x62,0xf1,0xfd,0x08,0xdf,0xc1]
2114   %res = call <2 x i64> @llvm.x86.avx512.mask.pandn.q.128(<2 x i64> %a, <2 x i64> %b, <2 x i64> zeroinitializer, i8 -1)
2115   ret <2 x i64> %res
2116 }
2117
2118 define <2 x i64> @test_mask_andnot_epi64_rrk_128(<2 x i64> %a, <2 x i64> %b, <2 x i64> %passThru, i8 %mask) {
2119   ;CHECK-LABEL: test_mask_andnot_epi64_rrk_128
2120   ;CHECK: vpandnq  %xmm1, %xmm0, %xmm2 {%k1} ## encoding: [0x62,0xf1,0xfd,0x09,0xdf,0xd1]
2121   %res = call <2 x i64> @llvm.x86.avx512.mask.pandn.q.128(<2 x i64> %a, <2 x i64> %b, <2 x i64> %passThru, i8 %mask)
2122   ret <2 x i64> %res
2123 }
2124
2125 define <2 x i64> @test_mask_andnot_epi64_rrkz_128(<2 x i64> %a, <2 x i64> %b, i8 %mask) {
2126   ;CHECK-LABEL: test_mask_andnot_epi64_rrkz_128
2127   ;CHECK: vpandnq  %xmm1, %xmm0, %xmm0 {%k1} {z} ## encoding: [0x62,0xf1,0xfd,0x89,0xdf,0xc1]
2128   %res = call <2 x i64> @llvm.x86.avx512.mask.pandn.q.128(<2 x i64> %a, <2 x i64> %b, <2 x i64> zeroinitializer, i8 %mask)
2129   ret <2 x i64> %res
2130 }
2131
2132 define <2 x i64> @test_mask_andnot_epi64_rm_128(<2 x i64> %a, <2 x i64>* %ptr_b) {
2133   ;CHECK-LABEL: test_mask_andnot_epi64_rm_128
2134   ;CHECK: vpandnq  (%rdi), %xmm0, %xmm0    ## encoding: [0x62,0xf1,0xfd,0x08,0xdf,0x07]
2135   %b = load <2 x i64>, <2 x i64>* %ptr_b
2136   %res = call <2 x i64> @llvm.x86.avx512.mask.pandn.q.128(<2 x i64> %a, <2 x i64> %b, <2 x i64> zeroinitializer, i8 -1)
2137   ret <2 x i64> %res
2138 }
2139
2140 define <2 x i64> @test_mask_andnot_epi64_rmk_128(<2 x i64> %a, <2 x i64>* %ptr_b, <2 x i64> %passThru, i8 %mask) {
2141   ;CHECK-LABEL: test_mask_andnot_epi64_rmk_128
2142   ;CHECK: vpandnq  (%rdi), %xmm0, %xmm1 {%k1} ## encoding: [0x62,0xf1,0xfd,0x09,0xdf,0x0f]
2143   %b = load <2 x i64>, <2 x i64>* %ptr_b
2144   %res = call <2 x i64> @llvm.x86.avx512.mask.pandn.q.128(<2 x i64> %a, <2 x i64> %b, <2 x i64> %passThru, i8 %mask)
2145   ret <2 x i64> %res
2146 }
2147
2148 define <2 x i64> @test_mask_andnot_epi64_rmkz_128(<2 x i64> %a, <2 x i64>* %ptr_b, i8 %mask) {
2149   ;CHECK-LABEL: test_mask_andnot_epi64_rmkz_128
2150   ;CHECK: vpandnq  (%rdi), %xmm0, %xmm0 {%k1} {z} ## encoding: [0x62,0xf1,0xfd,0x89,0xdf,0x07]
2151   %b = load <2 x i64>, <2 x i64>* %ptr_b
2152   %res = call <2 x i64> @llvm.x86.avx512.mask.pandn.q.128(<2 x i64> %a, <2 x i64> %b, <2 x i64> zeroinitializer, i8 %mask)
2153   ret <2 x i64> %res
2154 }
2155
2156 define <2 x i64> @test_mask_andnot_epi64_rmb_128(<2 x i64> %a, i64* %ptr_b) {
2157   ;CHECK-LABEL: test_mask_andnot_epi64_rmb_128
2158   ;CHECK: vpandnq  (%rdi){1to2}, %xmm0, %xmm0  ## encoding: [0x62,0xf1,0xfd,0x18,0xdf,0x07]
2159   %q = load i64, i64* %ptr_b
2160   %vecinit.i = insertelement <2 x i64> undef, i64 %q, i32 0
2161   %b = shufflevector <2 x i64> %vecinit.i, <2 x i64> undef, <2 x i32> zeroinitializer
2162   %res = call <2 x i64> @llvm.x86.avx512.mask.pandn.q.128(<2 x i64> %a, <2 x i64> %b, <2 x i64> zeroinitializer, i8 -1)
2163   ret <2 x i64> %res
2164 }
2165
2166 define <2 x i64> @test_mask_andnot_epi64_rmbk_128(<2 x i64> %a, i64* %ptr_b, <2 x i64> %passThru, i8 %mask) {
2167   ;CHECK-LABEL: test_mask_andnot_epi64_rmbk_128
2168   ;CHECK: vpandnq  (%rdi){1to2}, %xmm0, %xmm1 {%k1} ## encoding: [0x62,0xf1,0xfd,0x19,0xdf,0x0f]
2169   %q = load i64, i64* %ptr_b
2170   %vecinit.i = insertelement <2 x i64> undef, i64 %q, i32 0
2171   %b = shufflevector <2 x i64> %vecinit.i, <2 x i64> undef, <2 x i32> zeroinitializer
2172   %res = call <2 x i64> @llvm.x86.avx512.mask.pandn.q.128(<2 x i64> %a, <2 x i64> %b, <2 x i64> %passThru, i8 %mask)
2173   ret <2 x i64> %res
2174 }
2175
2176 define <2 x i64> @test_mask_andnot_epi64_rmbkz_128(<2 x i64> %a, i64* %ptr_b, i8 %mask) {
2177   ;CHECK-LABEL: test_mask_andnot_epi64_rmbkz_128
2178   ;CHECK: vpandnq  (%rdi){1to2}, %xmm0, %xmm0 {%k1} {z} ## encoding: [0x62,0xf1,0xfd,0x99,0xdf,0x07]
2179   %q = load i64, i64* %ptr_b
2180   %vecinit.i = insertelement <2 x i64> undef, i64 %q, i32 0
2181   %b = shufflevector <2 x i64> %vecinit.i, <2 x i64> undef, <2 x i32> zeroinitializer
2182   %res = call <2 x i64> @llvm.x86.avx512.mask.pandn.q.128(<2 x i64> %a, <2 x i64> %b, <2 x i64> zeroinitializer, i8 %mask)
2183   ret <2 x i64> %res
2184 }
2185
2186 declare <2 x i64> @llvm.x86.avx512.mask.pandn.q.128(<2 x i64>, <2 x i64>, <2 x i64>, i8)
2187
2188 define <4 x i64> @test_mask_andnot_epi64_rr_256(<4 x i64> %a, <4 x i64> %b) {
2189   ;CHECK-LABEL: test_mask_andnot_epi64_rr_256
2190   ;CHECK: vpandnq  %ymm1, %ymm0, %ymm0     ## encoding: [0x62,0xf1,0xfd,0x28,0xdf,0xc1]
2191   %res = call <4 x i64> @llvm.x86.avx512.mask.pandn.q.256(<4 x i64> %a, <4 x i64> %b, <4 x i64> zeroinitializer, i8 -1)
2192   ret <4 x i64> %res
2193 }
2194
2195 define <4 x i64> @test_mask_andnot_epi64_rrk_256(<4 x i64> %a, <4 x i64> %b, <4 x i64> %passThru, i8 %mask) {
2196   ;CHECK-LABEL: test_mask_andnot_epi64_rrk_256
2197   ;CHECK: vpandnq  %ymm1, %ymm0, %ymm2 {%k1} ## encoding: [0x62,0xf1,0xfd,0x29,0xdf,0xd1]
2198   %res = call <4 x i64> @llvm.x86.avx512.mask.pandn.q.256(<4 x i64> %a, <4 x i64> %b, <4 x i64> %passThru, i8 %mask)
2199   ret <4 x i64> %res
2200 }
2201
2202 define <4 x i64> @test_mask_andnot_epi64_rrkz_256(<4 x i64> %a, <4 x i64> %b, i8 %mask) {
2203   ;CHECK-LABEL: test_mask_andnot_epi64_rrkz_256
2204   ;CHECK: vpandnq  %ymm1, %ymm0, %ymm0 {%k1} {z} ## encoding: [0x62,0xf1,0xfd,0xa9,0xdf,0xc1]
2205   %res = call <4 x i64> @llvm.x86.avx512.mask.pandn.q.256(<4 x i64> %a, <4 x i64> %b, <4 x i64> zeroinitializer, i8 %mask)
2206   ret <4 x i64> %res
2207 }
2208
2209 define <4 x i64> @test_mask_andnot_epi64_rm_256(<4 x i64> %a, <4 x i64>* %ptr_b) {
2210   ;CHECK-LABEL: test_mask_andnot_epi64_rm_256
2211   ;CHECK: vpandnq  (%rdi), %ymm0, %ymm0    ## encoding: [0x62,0xf1,0xfd,0x28,0xdf,0x07]
2212   %b = load <4 x i64>, <4 x i64>* %ptr_b
2213   %res = call <4 x i64> @llvm.x86.avx512.mask.pandn.q.256(<4 x i64> %a, <4 x i64> %b, <4 x i64> zeroinitializer, i8 -1)
2214   ret <4 x i64> %res
2215 }
2216
2217 define <4 x i64> @test_mask_andnot_epi64_rmk_256(<4 x i64> %a, <4 x i64>* %ptr_b, <4 x i64> %passThru, i8 %mask) {
2218   ;CHECK-LABEL: test_mask_andnot_epi64_rmk_256
2219   ;CHECK: vpandnq  (%rdi), %ymm0, %ymm1 {%k1} ## encoding: [0x62,0xf1,0xfd,0x29,0xdf,0x0f]
2220   %b = load <4 x i64>, <4 x i64>* %ptr_b
2221   %res = call <4 x i64> @llvm.x86.avx512.mask.pandn.q.256(<4 x i64> %a, <4 x i64> %b, <4 x i64> %passThru, i8 %mask)
2222   ret <4 x i64> %res
2223 }
2224
2225 define <4 x i64> @test_mask_andnot_epi64_rmkz_256(<4 x i64> %a, <4 x i64>* %ptr_b, i8 %mask) {
2226   ;CHECK-LABEL: test_mask_andnot_epi64_rmkz_256
2227   ;CHECK: vpandnq  (%rdi), %ymm0, %ymm0 {%k1} {z} ## encoding: [0x62,0xf1,0xfd,0xa9,0xdf,0x07]
2228   %b = load <4 x i64>, <4 x i64>* %ptr_b
2229   %res = call <4 x i64> @llvm.x86.avx512.mask.pandn.q.256(<4 x i64> %a, <4 x i64> %b, <4 x i64> zeroinitializer, i8 %mask)
2230   ret <4 x i64> %res
2231 }
2232
2233 define <4 x i64> @test_mask_andnot_epi64_rmb_256(<4 x i64> %a, i64* %ptr_b) {
2234   ;CHECK-LABEL: test_mask_andnot_epi64_rmb_256
2235   ;CHECK: vpandnq  (%rdi){1to4}, %ymm0, %ymm0  ## encoding: [0x62,0xf1,0xfd,0x38,0xdf,0x07]
2236   %q = load i64, i64* %ptr_b
2237   %vecinit.i = insertelement <4 x i64> undef, i64 %q, i32 0
2238   %b = shufflevector <4 x i64> %vecinit.i, <4 x i64> undef, <4 x i32> zeroinitializer
2239   %res = call <4 x i64> @llvm.x86.avx512.mask.pandn.q.256(<4 x i64> %a, <4 x i64> %b, <4 x i64> zeroinitializer, i8 -1)
2240   ret <4 x i64> %res
2241 }
2242
2243 define <4 x i64> @test_mask_andnot_epi64_rmbk_256(<4 x i64> %a, i64* %ptr_b, <4 x i64> %passThru, i8 %mask) {
2244   ;CHECK-LABEL: test_mask_andnot_epi64_rmbk_256
2245   ;CHECK: vpandnq  (%rdi){1to4}, %ymm0, %ymm1 {%k1} ## encoding: [0x62,0xf1,0xfd,0x39,0xdf,0x0f]
2246   %q = load i64, i64* %ptr_b
2247   %vecinit.i = insertelement <4 x i64> undef, i64 %q, i32 0
2248   %b = shufflevector <4 x i64> %vecinit.i, <4 x i64> undef, <4 x i32> zeroinitializer
2249   %res = call <4 x i64> @llvm.x86.avx512.mask.pandn.q.256(<4 x i64> %a, <4 x i64> %b, <4 x i64> %passThru, i8 %mask)
2250   ret <4 x i64> %res
2251 }
2252
2253 define <4 x i64> @test_mask_andnot_epi64_rmbkz_256(<4 x i64> %a, i64* %ptr_b, i8 %mask) {
2254   ;CHECK-LABEL: test_mask_andnot_epi64_rmbkz_256
2255   ;CHECK: vpandnq  (%rdi){1to4}, %ymm0, %ymm0 {%k1} {z} ## encoding: [0x62,0xf1,0xfd,0xb9,0xdf,0x07]
2256   %q = load i64, i64* %ptr_b
2257   %vecinit.i = insertelement <4 x i64> undef, i64 %q, i32 0
2258   %b = shufflevector <4 x i64> %vecinit.i, <4 x i64> undef, <4 x i32> zeroinitializer
2259   %res = call <4 x i64> @llvm.x86.avx512.mask.pandn.q.256(<4 x i64> %a, <4 x i64> %b, <4 x i64> zeroinitializer, i8 %mask)
2260   ret <4 x i64> %res
2261 }
2262
2263 declare <4 x i64> @llvm.x86.avx512.mask.pandn.q.256(<4 x i64>, <4 x i64>, <4 x i64>, i8)
2264
2265 define i8 @test_cmpps_256(<8 x float> %a, <8 x float> %b) {
2266  ;CHECK: vcmpleps  %ymm1, %ymm0, %k0  ## encoding: [0x62,0xf1,0x7c,0x28,0xc2,0xc1,0x02]
2267    %res = call i8 @llvm.x86.avx512.mask.cmp.ps.256(<8 x float> %a, <8 x float> %b, i32 2, i8 -1)
2268    ret i8 %res
2269  }
2270  declare i8 @llvm.x86.avx512.mask.cmp.ps.256(<8 x float> , <8 x float> , i32, i8)
2271
2272 define i8 @test_cmpps_128(<4 x float> %a, <4 x float> %b) {
2273  ;CHECK: vcmpleps  %xmm1, %xmm0, %k0  ## encoding: [0x62,0xf1,0x7c,0x08,0xc2,0xc1,0x02]
2274    %res = call i8 @llvm.x86.avx512.mask.cmp.ps.128(<4 x float> %a, <4 x float> %b, i32 2, i8 -1)
2275    ret i8 %res
2276  }
2277  declare i8 @llvm.x86.avx512.mask.cmp.ps.128(<4 x float> , <4 x float> , i32, i8)
2278
2279 define i8 @test_cmppd_256(<4 x double> %a, <4 x double> %b) {
2280  ;CHECK: vcmplepd  %ymm1, %ymm0, %k0  ## encoding: [0x62,0xf1,0xfd,0x28,0xc2,0xc1,0x02]
2281    %res = call i8 @llvm.x86.avx512.mask.cmp.pd.256(<4 x double> %a, <4 x double> %b, i32 2, i8 -1)
2282    ret i8 %res
2283  }
2284  declare i8 @llvm.x86.avx512.mask.cmp.pd.256(<4 x double> , <4 x double> , i32, i8)
2285
2286 define i8 @test_cmppd_128(<2 x double> %a, <2 x double> %b) {
2287  ;CHECK: vcmplepd  %xmm1, %xmm0, %k0  ## encoding: [0x62,0xf1,0xfd,0x08,0xc2,0xc1,0x02]
2288    %res = call i8 @llvm.x86.avx512.mask.cmp.pd.128(<2 x double> %a, <2 x double> %b, i32 2, i8 -1)
2289    ret i8 %res
2290  }
2291  declare i8 @llvm.x86.avx512.mask.cmp.pd.128(<2 x double> , <2 x double> , i32, i8)
2292
2293 define <8 x float> @test_mm512_maskz_add_ps_256(<8 x float> %a0, <8 x float> %a1, i8 %mask) {
2294   ;CHECK-LABEL: test_mm512_maskz_add_ps_256
2295   ;CHECK: vaddps %ymm1, %ymm0, %ymm0 {%k1} {z}
2296   %res = call <8 x float> @llvm.x86.avx512.mask.add.ps.256(<8 x float> %a0, <8 x float> %a1, <8 x float>zeroinitializer, i8 %mask)
2297   ret <8 x float> %res
2298 }
2299
2300 define <8 x float> @test_mm512_mask_add_ps_256(<8 x float> %a0, <8 x float> %a1, <8 x float> %src, i8 %mask) {
2301   ;CHECK-LABEL: test_mm512_mask_add_ps_256
2302   ;CHECK: vaddps %ymm1, %ymm0, %ymm2 {%k1}
2303   %res = call <8 x float> @llvm.x86.avx512.mask.add.ps.256(<8 x float> %a0, <8 x float> %a1, <8 x float> %src, i8 %mask)
2304   ret <8 x float> %res
2305 }
2306
2307 define <8 x float> @test_mm512_add_ps_256(<8 x float> %a0, <8 x float> %a1, i8 %mask) {
2308   ;CHECK-LABEL: test_mm512_add_ps_256
2309   ;CHECK: vaddps %ymm1, %ymm0, %ymm0
2310   %res = call <8 x float> @llvm.x86.avx512.mask.add.ps.256(<8 x float> %a0, <8 x float> %a1, <8 x float>zeroinitializer, i8 -1)
2311   ret <8 x float> %res
2312 }
2313 declare <8 x float> @llvm.x86.avx512.mask.add.ps.256(<8 x float>, <8 x float>, <8 x float>, i8)
2314
2315 define <4 x float> @test_mm512_maskz_add_ps_128(<4 x float> %a0, <4 x float> %a1, i8 %mask) {
2316   ;CHECK-LABEL: test_mm512_maskz_add_ps_128
2317   ;CHECK: vaddps %xmm1, %xmm0, %xmm0 {%k1} {z}
2318   %res = call <4 x float> @llvm.x86.avx512.mask.add.ps.128(<4 x float> %a0, <4 x float> %a1, <4 x float>zeroinitializer, i8 %mask)
2319   ret <4 x float> %res
2320 }
2321
2322 define <4 x float> @test_mm512_mask_add_ps_128(<4 x float> %a0, <4 x float> %a1, <4 x float> %src, i8 %mask) {
2323   ;CHECK-LABEL: test_mm512_mask_add_ps_128
2324   ;CHECK: vaddps %xmm1, %xmm0, %xmm2 {%k1}
2325   %res = call <4 x float> @llvm.x86.avx512.mask.add.ps.128(<4 x float> %a0, <4 x float> %a1, <4 x float> %src, i8 %mask)
2326   ret <4 x float> %res
2327 }
2328
2329 define <4 x float> @test_mm512_add_ps_128(<4 x float> %a0, <4 x float> %a1, i8 %mask) {
2330   ;CHECK-LABEL: test_mm512_add_ps_128
2331   ;CHECK: vaddps %xmm1, %xmm0, %xmm0
2332   %res = call <4 x float> @llvm.x86.avx512.mask.add.ps.128(<4 x float> %a0, <4 x float> %a1, <4 x float>zeroinitializer, i8 -1)
2333   ret <4 x float> %res
2334 }
2335 declare <4 x float> @llvm.x86.avx512.mask.add.ps.128(<4 x float>, <4 x float>, <4 x float>, i8)
2336
2337 define <8 x float> @test_mm512_maskz_sub_ps_256(<8 x float> %a0, <8 x float> %a1, i8 %mask) {
2338   ;CHECK-LABEL: test_mm512_maskz_sub_ps_256
2339   ;CHECK: vsubps %ymm1, %ymm0, %ymm0 {%k1} {z}
2340   %res = call <8 x float> @llvm.x86.avx512.mask.sub.ps.256(<8 x float> %a0, <8 x float> %a1, <8 x float>zeroinitializer, i8 %mask)
2341   ret <8 x float> %res
2342 }
2343
2344 define <8 x float> @test_mm512_mask_sub_ps_256(<8 x float> %a0, <8 x float> %a1, <8 x float> %src, i8 %mask) {
2345   ;CHECK-LABEL: test_mm512_mask_sub_ps_256
2346   ;CHECK: vsubps %ymm1, %ymm0, %ymm2 {%k1}
2347   %res = call <8 x float> @llvm.x86.avx512.mask.sub.ps.256(<8 x float> %a0, <8 x float> %a1, <8 x float> %src, i8 %mask)
2348   ret <8 x float> %res
2349 }
2350
2351 define <8 x float> @test_mm512_sub_ps_256(<8 x float> %a0, <8 x float> %a1, i8 %mask) {
2352   ;CHECK-LABEL: test_mm512_sub_ps_256
2353   ;CHECK: vsubps %ymm1, %ymm0, %ymm0
2354   %res = call <8 x float> @llvm.x86.avx512.mask.sub.ps.256(<8 x float> %a0, <8 x float> %a1, <8 x float>zeroinitializer, i8 -1)
2355   ret <8 x float> %res
2356 }
2357 declare <8 x float> @llvm.x86.avx512.mask.sub.ps.256(<8 x float>, <8 x float>, <8 x float>, i8)
2358
2359 define <4 x float> @test_mm512_maskz_sub_ps_128(<4 x float> %a0, <4 x float> %a1, i8 %mask) {
2360   ;CHECK-LABEL: test_mm512_maskz_sub_ps_128
2361   ;CHECK: vsubps %xmm1, %xmm0, %xmm0 {%k1} {z}
2362   %res = call <4 x float> @llvm.x86.avx512.mask.sub.ps.128(<4 x float> %a0, <4 x float> %a1, <4 x float>zeroinitializer, i8 %mask)
2363   ret <4 x float> %res
2364 }
2365
2366 define <4 x float> @test_mm512_mask_sub_ps_128(<4 x float> %a0, <4 x float> %a1, <4 x float> %src, i8 %mask) {
2367   ;CHECK-LABEL: test_mm512_mask_sub_ps_128
2368   ;CHECK: vsubps %xmm1, %xmm0, %xmm2 {%k1}
2369   %res = call <4 x float> @llvm.x86.avx512.mask.sub.ps.128(<4 x float> %a0, <4 x float> %a1, <4 x float> %src, i8 %mask)
2370   ret <4 x float> %res
2371 }
2372
2373 define <4 x float> @test_mm512_sub_ps_128(<4 x float> %a0, <4 x float> %a1, i8 %mask) {
2374   ;CHECK-LABEL: test_mm512_sub_ps_128
2375   ;CHECK: vsubps %xmm1, %xmm0, %xmm0
2376   %res = call <4 x float> @llvm.x86.avx512.mask.sub.ps.128(<4 x float> %a0, <4 x float> %a1, <4 x float>zeroinitializer, i8 -1)
2377   ret <4 x float> %res
2378 }
2379 declare <4 x float> @llvm.x86.avx512.mask.sub.ps.128(<4 x float>, <4 x float>, <4 x float>, i8)
2380
2381 define <8 x float> @test_mm512_maskz_mul_ps_256(<8 x float> %a0, <8 x float> %a1, i8 %mask) {
2382   ;CHECK-LABEL: test_mm512_maskz_mul_ps_256
2383   ;CHECK: vmulps %ymm1, %ymm0, %ymm0 {%k1} {z}
2384   %res = call <8 x float> @llvm.x86.avx512.mask.mul.ps.256(<8 x float> %a0, <8 x float> %a1, <8 x float>zeroinitializer, i8 %mask)
2385   ret <8 x float> %res
2386 }
2387
2388 define <8 x float> @test_mm512_mask_mul_ps_256(<8 x float> %a0, <8 x float> %a1, <8 x float> %src, i8 %mask) {
2389   ;CHECK-LABEL: test_mm512_mask_mul_ps_256
2390   ;CHECK: vmulps %ymm1, %ymm0, %ymm2 {%k1}
2391   %res = call <8 x float> @llvm.x86.avx512.mask.mul.ps.256(<8 x float> %a0, <8 x float> %a1, <8 x float> %src, i8 %mask)
2392   ret <8 x float> %res
2393 }
2394
2395 define <8 x float> @test_mm512_mul_ps_256(<8 x float> %a0, <8 x float> %a1, i8 %mask) {
2396   ;CHECK-LABEL: test_mm512_mul_ps_256
2397   ;CHECK: vmulps %ymm1, %ymm0, %ymm0
2398   %res = call <8 x float> @llvm.x86.avx512.mask.mul.ps.256(<8 x float> %a0, <8 x float> %a1, <8 x float>zeroinitializer, i8 -1)
2399   ret <8 x float> %res
2400 }
2401 declare <8 x float> @llvm.x86.avx512.mask.mul.ps.256(<8 x float>, <8 x float>, <8 x float>, i8)
2402
2403 define <4 x float> @test_mm512_maskz_mul_ps_128(<4 x float> %a0, <4 x float> %a1, i8 %mask) {
2404   ;CHECK-LABEL: test_mm512_maskz_mul_ps_128
2405   ;CHECK: vmulps %xmm1, %xmm0, %xmm0 {%k1} {z}
2406   %res = call <4 x float> @llvm.x86.avx512.mask.mul.ps.128(<4 x float> %a0, <4 x float> %a1, <4 x float>zeroinitializer, i8 %mask)
2407   ret <4 x float> %res
2408 }
2409
2410 define <4 x float> @test_mm512_mask_mul_ps_128(<4 x float> %a0, <4 x float> %a1, <4 x float> %src, i8 %mask) {
2411   ;CHECK-LABEL: test_mm512_mask_mul_ps_128
2412   ;CHECK: vmulps %xmm1, %xmm0, %xmm2 {%k1}
2413   %res = call <4 x float> @llvm.x86.avx512.mask.mul.ps.128(<4 x float> %a0, <4 x float> %a1, <4 x float> %src, i8 %mask)
2414   ret <4 x float> %res
2415 }
2416
2417 define <4 x float> @test_mm512_mul_ps_128(<4 x float> %a0, <4 x float> %a1, i8 %mask) {
2418   ;CHECK-LABEL: test_mm512_mul_ps_128
2419   ;CHECK: vmulps %xmm1, %xmm0, %xmm0
2420   %res = call <4 x float> @llvm.x86.avx512.mask.mul.ps.128(<4 x float> %a0, <4 x float> %a1, <4 x float>zeroinitializer, i8 -1)
2421   ret <4 x float> %res
2422 }
2423 declare <4 x float> @llvm.x86.avx512.mask.mul.ps.128(<4 x float>, <4 x float>, <4 x float>, i8)
2424
2425 define <8 x float> @test_mm512_maskz_div_ps_256(<8 x float> %a0, <8 x float> %a1, i8 %mask) {
2426   ;CHECK-LABEL: test_mm512_maskz_div_ps_256
2427   ;CHECK: vdivps %ymm1, %ymm0, %ymm0 {%k1} {z}
2428   %res = call <8 x float> @llvm.x86.avx512.mask.div.ps.256(<8 x float> %a0, <8 x float> %a1, <8 x float>zeroinitializer, i8 %mask)
2429   ret <8 x float> %res
2430 }
2431
2432 define <8 x float> @test_mm512_mask_div_ps_256(<8 x float> %a0, <8 x float> %a1, <8 x float> %src, i8 %mask) {
2433   ;CHECK-LABEL: test_mm512_mask_div_ps_256
2434   ;CHECK: vdivps %ymm1, %ymm0, %ymm2 {%k1}
2435   %res = call <8 x float> @llvm.x86.avx512.mask.div.ps.256(<8 x float> %a0, <8 x float> %a1, <8 x float> %src, i8 %mask)
2436   ret <8 x float> %res
2437 }
2438
2439 define <8 x float> @test_mm512_div_ps_256(<8 x float> %a0, <8 x float> %a1, i8 %mask) {
2440   ;CHECK-LABEL: test_mm512_div_ps_256
2441   ;CHECK: vdivps %ymm1, %ymm0, %ymm0
2442   %res = call <8 x float> @llvm.x86.avx512.mask.div.ps.256(<8 x float> %a0, <8 x float> %a1, <8 x float>zeroinitializer, i8 -1)
2443   ret <8 x float> %res
2444 }
2445 declare <8 x float> @llvm.x86.avx512.mask.div.ps.256(<8 x float>, <8 x float>, <8 x float>, i8)
2446
2447 define <4 x float> @test_mm512_maskz_div_ps_128(<4 x float> %a0, <4 x float> %a1, i8 %mask) {
2448   ;CHECK-LABEL: test_mm512_maskz_div_ps_128
2449   ;CHECK: vdivps %xmm1, %xmm0, %xmm0 {%k1} {z}
2450   %res = call <4 x float> @llvm.x86.avx512.mask.div.ps.128(<4 x float> %a0, <4 x float> %a1, <4 x float>zeroinitializer, i8 %mask)
2451   ret <4 x float> %res
2452 }
2453
2454 define <4 x float> @test_mm512_mask_div_ps_128(<4 x float> %a0, <4 x float> %a1, <4 x float> %src, i8 %mask) {
2455   ;CHECK-LABEL: test_mm512_mask_div_ps_128
2456   ;CHECK: vdivps %xmm1, %xmm0, %xmm2 {%k1}
2457   %res = call <4 x float> @llvm.x86.avx512.mask.div.ps.128(<4 x float> %a0, <4 x float> %a1, <4 x float> %src, i8 %mask)
2458   ret <4 x float> %res
2459 }
2460
2461 define <4 x float> @test_mm512_div_ps_128(<4 x float> %a0, <4 x float> %a1, i8 %mask) {
2462   ;CHECK-LABEL: test_mm512_div_ps_128
2463   ;CHECK: vdivps %xmm1, %xmm0, %xmm0
2464   %res = call <4 x float> @llvm.x86.avx512.mask.div.ps.128(<4 x float> %a0, <4 x float> %a1, <4 x float>zeroinitializer, i8 -1)
2465   ret <4 x float> %res
2466 }
2467 declare <4 x float> @llvm.x86.avx512.mask.div.ps.128(<4 x float>, <4 x float>, <4 x float>, i8)
2468
2469 define <8 x float> @test_mm512_maskz_max_ps_256(<8 x float> %a0, <8 x float> %a1, i8 %mask) {
2470   ;CHECK-LABEL: test_mm512_maskz_max_ps_256
2471   ;CHECK: vmaxps %ymm1, %ymm0, %ymm0 {%k1} {z}
2472   %res = call <8 x float> @llvm.x86.avx512.mask.max.ps.256(<8 x float> %a0, <8 x float> %a1, <8 x float>zeroinitializer, i8 %mask)
2473   ret <8 x float> %res
2474 }
2475
2476 define <8 x float> @test_mm512_mask_max_ps_256(<8 x float> %a0, <8 x float> %a1, <8 x float> %src, i8 %mask) {
2477   ;CHECK-LABEL: test_mm512_mask_max_ps_256
2478   ;CHECK: vmaxps %ymm1, %ymm0, %ymm2 {%k1}
2479   %res = call <8 x float> @llvm.x86.avx512.mask.max.ps.256(<8 x float> %a0, <8 x float> %a1, <8 x float> %src, i8 %mask)
2480   ret <8 x float> %res
2481 }
2482
2483 define <8 x float> @test_mm512_max_ps_256(<8 x float> %a0, <8 x float> %a1, i8 %mask) {
2484   ;CHECK-LABEL: test_mm512_max_ps_256
2485   ;CHECK: vmaxps %ymm1, %ymm0, %ymm0
2486   %res = call <8 x float> @llvm.x86.avx512.mask.max.ps.256(<8 x float> %a0, <8 x float> %a1, <8 x float>zeroinitializer, i8 -1)
2487   ret <8 x float> %res
2488 }
2489 declare <8 x float> @llvm.x86.avx512.mask.max.ps.256(<8 x float>, <8 x float>, <8 x float>, i8)
2490
2491 define <4 x float> @test_mm512_maskz_max_ps_128(<4 x float> %a0, <4 x float> %a1, i8 %mask) {
2492   ;CHECK-LABEL: test_mm512_maskz_max_ps_128
2493   ;CHECK: vmaxps %xmm1, %xmm0, %xmm0 {%k1} {z}
2494   %res = call <4 x float> @llvm.x86.avx512.mask.max.ps.128(<4 x float> %a0, <4 x float> %a1, <4 x float>zeroinitializer, i8 %mask)
2495   ret <4 x float> %res
2496 }
2497
2498 define <4 x float> @test_mm512_mask_max_ps_128(<4 x float> %a0, <4 x float> %a1, <4 x float> %src, i8 %mask) {
2499   ;CHECK-LABEL: test_mm512_mask_max_ps_128
2500   ;CHECK: vmaxps %xmm1, %xmm0, %xmm2 {%k1}
2501   %res = call <4 x float> @llvm.x86.avx512.mask.max.ps.128(<4 x float> %a0, <4 x float> %a1, <4 x float> %src, i8 %mask)
2502   ret <4 x float> %res
2503 }
2504
2505 define <4 x float> @test_mm512_max_ps_128(<4 x float> %a0, <4 x float> %a1, i8 %mask) {
2506   ;CHECK-LABEL: test_mm512_max_ps_128
2507   ;CHECK: vmaxps %xmm1, %xmm0, %xmm0
2508   %res = call <4 x float> @llvm.x86.avx512.mask.max.ps.128(<4 x float> %a0, <4 x float> %a1, <4 x float>zeroinitializer, i8 -1)
2509   ret <4 x float> %res
2510 }
2511 declare <4 x float> @llvm.x86.avx512.mask.max.ps.128(<4 x float>, <4 x float>, <4 x float>, i8)
2512
2513 define <8 x float> @test_mm512_maskz_min_ps_256(<8 x float> %a0, <8 x float> %a1, i8 %mask) {
2514   ;CHECK-LABEL: test_mm512_maskz_min_ps_256
2515   ;CHECK: vminps %ymm1, %ymm0, %ymm0 {%k1} {z}
2516   %res = call <8 x float> @llvm.x86.avx512.mask.min.ps.256(<8 x float> %a0, <8 x float> %a1, <8 x float>zeroinitializer, i8 %mask)
2517   ret <8 x float> %res
2518 }
2519
2520 define <8 x float> @test_mm512_mask_min_ps_256(<8 x float> %a0, <8 x float> %a1, <8 x float> %src, i8 %mask) {
2521   ;CHECK-LABEL: test_mm512_mask_min_ps_256
2522   ;CHECK: vminps %ymm1, %ymm0, %ymm2 {%k1}
2523   %res = call <8 x float> @llvm.x86.avx512.mask.min.ps.256(<8 x float> %a0, <8 x float> %a1, <8 x float> %src, i8 %mask)
2524   ret <8 x float> %res
2525 }
2526
2527 define <8 x float> @test_mm512_min_ps_256(<8 x float> %a0, <8 x float> %a1, i8 %mask) {
2528   ;CHECK-LABEL: test_mm512_min_ps_256
2529   ;CHECK: vminps %ymm1, %ymm0, %ymm0
2530   %res = call <8 x float> @llvm.x86.avx512.mask.min.ps.256(<8 x float> %a0, <8 x float> %a1, <8 x float>zeroinitializer, i8 -1)
2531   ret <8 x float> %res
2532 }
2533 declare <8 x float> @llvm.x86.avx512.mask.min.ps.256(<8 x float>, <8 x float>, <8 x float>, i8)
2534
2535 define <4 x float> @test_mm512_maskz_min_ps_128(<4 x float> %a0, <4 x float> %a1, i8 %mask) {
2536   ;CHECK-LABEL: test_mm512_maskz_min_ps_128
2537   ;CHECK: vminps %xmm1, %xmm0, %xmm0 {%k1} {z}
2538   %res = call <4 x float> @llvm.x86.avx512.mask.min.ps.128(<4 x float> %a0, <4 x float> %a1, <4 x float>zeroinitializer, i8 %mask)
2539   ret <4 x float> %res
2540 }
2541
2542 define <4 x float> @test_mm512_mask_min_ps_128(<4 x float> %a0, <4 x float> %a1, <4 x float> %src, i8 %mask) {
2543   ;CHECK-LABEL: test_mm512_mask_min_ps_128
2544   ;CHECK: vminps %xmm1, %xmm0, %xmm2 {%k1}
2545   %res = call <4 x float> @llvm.x86.avx512.mask.min.ps.128(<4 x float> %a0, <4 x float> %a1, <4 x float> %src, i8 %mask)
2546   ret <4 x float> %res
2547 }
2548
2549 define <4 x float> @test_mm512_min_ps_128(<4 x float> %a0, <4 x float> %a1, i8 %mask) {
2550   ;CHECK-LABEL: test_mm512_min_ps_128
2551   ;CHECK: vminps %xmm1, %xmm0, %xmm0
2552   %res = call <4 x float> @llvm.x86.avx512.mask.min.ps.128(<4 x float> %a0, <4 x float> %a1, <4 x float>zeroinitializer, i8 -1)
2553   ret <4 x float> %res
2554 }
2555 declare <4 x float> @llvm.x86.avx512.mask.min.ps.128(<4 x float>, <4 x float>, <4 x float>, i8)
2556
2557 define <4 x double> @test_sqrt_pd_256(<4 x double> %a0, i8 %mask) {
2558   ; CHECK-LABEL: test_sqrt_pd_256
2559   ; CHECK: vsqrtpd
2560   %res = call <4 x double> @llvm.x86.avx512.mask.sqrt.pd.256(<4 x double> %a0,  <4 x double> zeroinitializer, i8 %mask)
2561   ret <4 x double> %res
2562 }
2563 declare <4 x double> @llvm.x86.avx512.mask.sqrt.pd.256(<4 x double>, <4 x double>, i8) nounwind readnone
2564
2565 define <8 x float> @test_sqrt_ps_256(<8 x float> %a0, i8 %mask) {
2566   ; CHECK-LABEL: test_sqrt_ps_256
2567   ; CHECK: vsqrtps
2568   %res = call <8 x float> @llvm.x86.avx512.mask.sqrt.ps.256(<8 x float> %a0, <8 x float> zeroinitializer, i8 %mask)
2569   ret <8 x float> %res
2570 }
2571
2572 declare <8 x float> @llvm.x86.avx512.mask.sqrt.ps.256(<8 x float>, <8 x float>, i8) nounwind readnone
2573
2574 define <4 x double> @test_getexp_pd_256(<4 x double> %a0) {
2575   ; CHECK-LABEL: test_getexp_pd_256
2576   ; CHECK: vgetexppd
2577   %res = call <4 x double> @llvm.x86.avx512.mask.getexp.pd.256(<4 x double> %a0,  <4 x double> zeroinitializer, i8 -1)
2578   ret <4 x double> %res
2579 }
2580
2581 declare <4 x double> @llvm.x86.avx512.mask.getexp.pd.256(<4 x double>, <4 x double>, i8) nounwind readnone
2582
2583 define <8 x float> @test_getexp_ps_256(<8 x float> %a0) {
2584   ; CHECK-LABEL: test_getexp_ps_256
2585   ; CHECK: vgetexpps
2586   %res = call <8 x float> @llvm.x86.avx512.mask.getexp.ps.256(<8 x float> %a0, <8 x float> zeroinitializer, i8 -1)
2587   ret <8 x float> %res
2588 }
2589 declare <8 x float> @llvm.x86.avx512.mask.getexp.ps.256(<8 x float>, <8 x float>, i8) nounwind readnone
2590
2591 declare <4 x i32> @llvm.x86.avx512.mask.pmaxs.d.128(<4 x i32>, <4 x i32>, <4 x i32>, i8)
2592
2593 ; CHECK-LABEL: @test_int_x86_avx512_mask_pmaxs_d_128
2594 ; CHECK-NOT: call
2595 ; CHECK: vpmaxsd %xmm
2596 ; CHECK: {%k1}
2597 define <4 x i32>@test_int_x86_avx512_mask_pmaxs_d_128(<4 x i32> %x0, <4 x i32> %x1, <4 x i32> %x2, i8 %mask) {
2598   %res = call <4 x i32> @llvm.x86.avx512.mask.pmaxs.d.128(<4 x i32> %x0, <4 x i32> %x1, <4 x i32> %x2 ,i8 %mask)
2599   %res1 = call <4 x i32> @llvm.x86.avx512.mask.pmaxs.d.128(<4 x i32> %x0, <4 x i32> %x1, <4 x i32> zeroinitializer, i8 %mask)
2600   %res2 = add <4 x i32> %res, %res1
2601   ret <4 x i32> %res2
2602 }
2603
2604 declare <8 x i32> @llvm.x86.avx512.mask.pmaxs.d.256(<8 x i32>, <8 x i32>, <8 x i32>, i8)
2605
2606 ; CHECK-LABEL: @test_int_x86_avx512_mask_pmaxs_d_256
2607 ; CHECK-NOT: call
2608 ; CHECK: vpmaxsd %ymm
2609 ; CHECK: {%k1}
2610 define <8 x i32>@test_int_x86_avx512_mask_pmaxs_d_256(<8 x i32> %x0, <8 x i32> %x1, <8 x i32> %x2, i8 %x3) {
2611   %res = call <8 x i32> @llvm.x86.avx512.mask.pmaxs.d.256(<8 x i32> %x0, <8 x i32> %x1, <8 x i32> %x2, i8 %x3)
2612   %res1 = call <8 x i32> @llvm.x86.avx512.mask.pmaxs.d.256(<8 x i32> %x0, <8 x i32> %x1, <8 x i32> %x2, i8 -1)
2613   %res2 = add <8 x i32> %res, %res1
2614   ret <8 x i32> %res2
2615 }
2616
2617 declare <2 x i64> @llvm.x86.avx512.mask.pmaxs.q.128(<2 x i64>, <2 x i64>, <2 x i64>, i8)
2618
2619 ; CHECK-LABEL: @test_int_x86_avx512_mask_pmaxs_q_128
2620 ; CHECK-NOT: call
2621 ; CHECK: vpmaxsq %xmm
2622 ; CHECK: {%k1}
2623 define <2 x i64>@test_int_x86_avx512_mask_pmaxs_q_128(<2 x i64> %x0, <2 x i64> %x1, <2 x i64> %x2, i8 %x3) {
2624   %res = call <2 x i64> @llvm.x86.avx512.mask.pmaxs.q.128(<2 x i64> %x0, <2 x i64> %x1, <2 x i64> %x2, i8 %x3)
2625   %res1 = call <2 x i64> @llvm.x86.avx512.mask.pmaxs.q.128(<2 x i64> %x0, <2 x i64> %x1, <2 x i64> %x2, i8 -1)
2626   %res2 = add <2 x i64> %res, %res1
2627   ret <2 x i64> %res2
2628 }
2629
2630 declare <4 x i64> @llvm.x86.avx512.mask.pmaxs.q.256(<4 x i64>, <4 x i64>, <4 x i64>, i8)
2631
2632 ; CHECK-LABEL: @test_int_x86_avx512_mask_pmaxs_q_256
2633 ; CHECK-NOT: call
2634 ; CHECK: vpmaxsq %ymm
2635 ; CHECK: {%k1}
2636 define <4 x i64>@test_int_x86_avx512_mask_pmaxs_q_256(<4 x i64> %x0, <4 x i64> %x1, <4 x i64> %x2, i8 %mask) {
2637   %res = call <4 x i64> @llvm.x86.avx512.mask.pmaxs.q.256(<4 x i64> %x0, <4 x i64> %x1, <4 x i64> %x2, i8 %mask)
2638   %res1 = call <4 x i64> @llvm.x86.avx512.mask.pmaxs.q.256(<4 x i64> %x0, <4 x i64> %x1, <4 x i64> zeroinitializer, i8 %mask)
2639   %res2 = add <4 x i64> %res, %res1
2640   ret <4 x i64> %res2
2641 }
2642
2643 declare <4 x i32> @llvm.x86.avx512.mask.pmaxu.d.128(<4 x i32>, <4 x i32>, <4 x i32>, i8)
2644
2645 ; CHECK-LABEL: @test_int_x86_avx512_mask_pmaxu_d_128
2646 ; CHECK-NOT: call
2647 ; CHECK: vpmaxud %xmm
2648 ; CHECK: {%k1}
2649 define <4 x i32>@test_int_x86_avx512_mask_pmaxu_d_128(<4 x i32> %x0, <4 x i32> %x1, <4 x i32> %x2,i8 %mask) {
2650   %res = call <4 x i32> @llvm.x86.avx512.mask.pmaxu.d.128(<4 x i32> %x0, <4 x i32> %x1, <4 x i32> %x2, i8 %mask)
2651   %res1 = call <4 x i32> @llvm.x86.avx512.mask.pmaxu.d.128(<4 x i32> %x0, <4 x i32> %x1, <4 x i32> zeroinitializer, i8 %mask)
2652   %res2 = add <4 x i32> %res, %res1
2653   ret <4 x i32> %res2
2654 }
2655
2656 declare <8 x i32> @llvm.x86.avx512.mask.pmaxu.d.256(<8 x i32>, <8 x i32>, <8 x i32>, i8)
2657
2658 ; CHECK-LABEL: @test_int_x86_avx512_mask_pmaxu_d_256
2659 ; CHECK-NOT: call
2660 ; CHECK: vpmaxud %ymm
2661 ; CHECK: {%k1}
2662 define <8 x i32>@test_int_x86_avx512_mask_pmaxu_d_256(<8 x i32> %x0, <8 x i32> %x1, <8 x i32> %x2, i8 %x3) {
2663   %res = call <8 x i32> @llvm.x86.avx512.mask.pmaxu.d.256(<8 x i32> %x0, <8 x i32> %x1, <8 x i32> %x2, i8 %x3)
2664   %res1 = call <8 x i32> @llvm.x86.avx512.mask.pmaxu.d.256(<8 x i32> %x0, <8 x i32> %x1, <8 x i32> %x2, i8 -1)
2665   %res2 = add <8 x i32> %res, %res1
2666   ret <8 x i32> %res2
2667 }
2668
2669 declare <2 x i64> @llvm.x86.avx512.mask.pmaxu.q.128(<2 x i64>, <2 x i64>, <2 x i64>, i8)
2670
2671 ; CHECK-LABEL: @test_int_x86_avx512_mask_pmaxu_q_128
2672 ; CHECK-NOT: call
2673 ; CHECK: vpmaxuq %xmm
2674 ; CHECK: {%k1}
2675 define <2 x i64>@test_int_x86_avx512_mask_pmaxu_q_128(<2 x i64> %x0, <2 x i64> %x1, <2 x i64> %x2, i8 %x3) {
2676   %res = call <2 x i64> @llvm.x86.avx512.mask.pmaxu.q.128(<2 x i64> %x0, <2 x i64> %x1, <2 x i64> %x2, i8 %x3)
2677   %res1 = call <2 x i64> @llvm.x86.avx512.mask.pmaxu.q.128(<2 x i64> %x0, <2 x i64> %x1, <2 x i64> %x2, i8 -1)
2678   %res2 = add <2 x i64> %res, %res1
2679   ret <2 x i64> %res2
2680 }
2681
2682 declare <4 x i64> @llvm.x86.avx512.mask.pmaxu.q.256(<4 x i64>, <4 x i64>, <4 x i64>, i8)
2683
2684 ; CHECK-LABEL: @test_int_x86_avx512_mask_pmaxu_q_256
2685 ; CHECK-NOT: call
2686 ; CHECK: vpmaxuq %ymm
2687 ; CHECK: {%k1}
2688 define <4 x i64>@test_int_x86_avx512_mask_pmaxu_q_256(<4 x i64> %x0, <4 x i64> %x1, <4 x i64> %x2, i8 %mask) {
2689   %res = call <4 x i64> @llvm.x86.avx512.mask.pmaxu.q.256(<4 x i64> %x0, <4 x i64> %x1, <4 x i64> %x2, i8 %mask)
2690   %res1 = call <4 x i64> @llvm.x86.avx512.mask.pmaxu.q.256(<4 x i64> %x0, <4 x i64> %x1, <4 x i64> zeroinitializer, i8 %mask)
2691   %res2 = add <4 x i64> %res, %res1
2692   ret <4 x i64> %res2
2693 }
2694
2695 declare <4 x i32> @llvm.x86.avx512.mask.pmins.d.128(<4 x i32>, <4 x i32>, <4 x i32>, i8)
2696
2697 ; CHECK-LABEL: @test_int_x86_avx512_mask_pmins_d_128
2698 ; CHECK-NOT: call
2699 ; CHECK: vpminsd %xmm
2700 ; CHECK: {%k1}
2701 define <4 x i32>@test_int_x86_avx512_mask_pmins_d_128(<4 x i32> %x0, <4 x i32> %x1, <4 x i32> %x2, i8 %mask) {
2702   %res = call <4 x i32> @llvm.x86.avx512.mask.pmins.d.128(<4 x i32> %x0, <4 x i32> %x1, <4 x i32> %x2, i8 %mask)
2703   %res1 = call <4 x i32> @llvm.x86.avx512.mask.pmins.d.128(<4 x i32> %x0, <4 x i32> %x1, <4 x i32> zeroinitializer, i8 %mask)
2704   %res2 = add <4 x i32> %res, %res1
2705   ret <4 x i32> %res2
2706 }
2707
2708 declare <8 x i32> @llvm.x86.avx512.mask.pmins.d.256(<8 x i32>, <8 x i32>, <8 x i32>, i8)
2709
2710 ; CHECK-LABEL: @test_int_x86_avx512_mask_pmins_d_256
2711 ; CHECK-NOT: call
2712 ; CHECK: vpminsd %ymm
2713 ; CHECK: {%k1}
2714 define <8 x i32>@test_int_x86_avx512_mask_pmins_d_256(<8 x i32> %x0, <8 x i32> %x1, <8 x i32> %x2, i8 %x3) {
2715   %res = call <8 x i32> @llvm.x86.avx512.mask.pmins.d.256(<8 x i32> %x0, <8 x i32> %x1, <8 x i32> %x2, i8 %x3)
2716   %res1 = call <8 x i32> @llvm.x86.avx512.mask.pmins.d.256(<8 x i32> %x0, <8 x i32> %x1, <8 x i32> %x2, i8 -1)
2717   %res2 = add <8 x i32> %res, %res1
2718   ret <8 x i32> %res2
2719 }
2720
2721 declare <2 x i64> @llvm.x86.avx512.mask.pmins.q.128(<2 x i64>, <2 x i64>, <2 x i64>, i8)
2722
2723 ; CHECK-LABEL: @test_int_x86_avx512_mask_pmins_q_128
2724 ; CHECK-NOT: call
2725 ; CHECK: vpminsq %xmm
2726 ; CHECK: {%k1}
2727 define <2 x i64>@test_int_x86_avx512_mask_pmins_q_128(<2 x i64> %x0, <2 x i64> %x1, <2 x i64> %x2, i8 %x3) {
2728   %res = call <2 x i64> @llvm.x86.avx512.mask.pmins.q.128(<2 x i64> %x0, <2 x i64> %x1, <2 x i64> %x2, i8 %x3)
2729   %res1 = call <2 x i64> @llvm.x86.avx512.mask.pmins.q.128(<2 x i64> %x0, <2 x i64> %x1, <2 x i64> %x2, i8 -1)
2730   %res2 = add <2 x i64> %res, %res1
2731   ret <2 x i64> %res2
2732 }
2733
2734 declare <4 x i64> @llvm.x86.avx512.mask.pmins.q.256(<4 x i64>, <4 x i64>, <4 x i64>, i8)
2735
2736 ; CHECK-LABEL: @test_int_x86_avx512_mask_pmins_q_256
2737 ; CHECK-NOT: call
2738 ; CHECK: vpminsq %ymm
2739 ; CHECK: {%k1}
2740 define <4 x i64>@test_int_x86_avx512_mask_pmins_q_256(<4 x i64> %x0, <4 x i64> %x1, <4 x i64> %x2, i8 %mask) {
2741   %res = call <4 x i64> @llvm.x86.avx512.mask.pmins.q.256(<4 x i64> %x0, <4 x i64> %x1, <4 x i64> %x2, i8 %mask)
2742   %res1 = call <4 x i64> @llvm.x86.avx512.mask.pmins.q.256(<4 x i64> %x0, <4 x i64> %x1, <4 x i64> zeroinitializer, i8 %mask)
2743   %res2 = add <4 x i64> %res, %res1
2744   ret <4 x i64> %res2
2745 }
2746
2747 declare <4 x i32> @llvm.x86.avx512.mask.pminu.d.128(<4 x i32>, <4 x i32>, <4 x i32>, i8)
2748
2749 ; CHECK-LABEL: @test_int_x86_avx512_mask_pminu_d_128
2750 ; CHECK-NOT: call
2751 ; CHECK: vpminud %xmm
2752 ; CHECK: {%k1}
2753 define <4 x i32>@test_int_x86_avx512_mask_pminu_d_128(<4 x i32> %x0, <4 x i32> %x1, <4 x i32> %x2, i8 %mask) {
2754   %res = call <4 x i32> @llvm.x86.avx512.mask.pminu.d.128(<4 x i32> %x0, <4 x i32> %x1, <4 x i32> %x2, i8 %mask)
2755   %res1 = call <4 x i32> @llvm.x86.avx512.mask.pminu.d.128(<4 x i32> %x0, <4 x i32> %x1, <4 x i32> zeroinitializer, i8 %mask)
2756   %res2 = add <4 x i32> %res, %res1
2757   ret <4 x i32> %res2
2758 }
2759
2760 declare <8 x i32> @llvm.x86.avx512.mask.pminu.d.256(<8 x i32>, <8 x i32>, <8 x i32>, i8)
2761
2762 ; CHECK-LABEL: @test_int_x86_avx512_mask_pminu_d_256
2763 ; CHECK-NOT: call
2764 ; CHECK: vpminud %ymm
2765 ; CHECK: {%k1}
2766 define <8 x i32>@test_int_x86_avx512_mask_pminu_d_256(<8 x i32> %x0, <8 x i32> %x1, <8 x i32> %x2, i8 %x3) {
2767   %res = call <8 x i32> @llvm.x86.avx512.mask.pminu.d.256(<8 x i32> %x0, <8 x i32> %x1, <8 x i32> %x2, i8 %x3)
2768   %res1 = call <8 x i32> @llvm.x86.avx512.mask.pminu.d.256(<8 x i32> %x0, <8 x i32> %x1, <8 x i32> %x2, i8 -1)
2769   %res2 = add <8 x i32> %res, %res1
2770   ret <8 x i32> %res2
2771 }
2772
2773 declare <2 x i64> @llvm.x86.avx512.mask.pminu.q.128(<2 x i64>, <2 x i64>, <2 x i64>, i8)
2774
2775 ; CHECK-LABEL: @test_int_x86_avx512_mask_pminu_q_128
2776 ; CHECK-NOT: call
2777 ; CHECK: vpminuq %xmm
2778 ; CHECK: {%k1}
2779 define <2 x i64>@test_int_x86_avx512_mask_pminu_q_128(<2 x i64> %x0, <2 x i64> %x1, <2 x i64> %x2, i8 %x3) {
2780   %res = call <2 x i64> @llvm.x86.avx512.mask.pminu.q.128(<2 x i64> %x0, <2 x i64> %x1, <2 x i64> %x2, i8 %x3)
2781   %res1 = call <2 x i64> @llvm.x86.avx512.mask.pminu.q.128(<2 x i64> %x0, <2 x i64> %x1, <2 x i64> %x2, i8 -1)
2782   %res2 = add <2 x i64> %res, %res1
2783   ret <2 x i64> %res2
2784 }
2785
2786 declare <4 x i64> @llvm.x86.avx512.mask.pminu.q.256(<4 x i64>, <4 x i64>, <4 x i64>, i8)
2787
2788 ; CHECK-LABEL: @test_int_x86_avx512_mask_pminu_q_256
2789 ; CHECK-NOT: call
2790 ; CHECK: vpminuq %ymm
2791 ; CHECK: {%k1}
2792 define <4 x i64>@test_int_x86_avx512_mask_pminu_q_256(<4 x i64> %x0, <4 x i64> %x1, <4 x i64> %x2, i8 %mask) {
2793   %res = call <4 x i64> @llvm.x86.avx512.mask.pminu.q.256(<4 x i64> %x0, <4 x i64> %x1, <4 x i64> %x2, i8 %mask)
2794   %res1 = call <4 x i64> @llvm.x86.avx512.mask.pminu.q.256(<4 x i64> %x0, <4 x i64> %x1, <4 x i64> zeroinitializer, i8 %mask)
2795   %res2 = add <4 x i64> %res, %res1
2796   ret <4 x i64> %res2
2797 }
2798
2799 declare <4 x i32> @llvm.x86.avx512.mask.vpermt2var.d.128(<4 x i32>, <4 x i32>, <4 x i32>, i8)
2800
2801 ; CHECK-LABEL: @test_int_x86_avx512_mask_vpermt2var_d_128
2802 ; CHECK-NOT: call
2803 ; CHECK: kmov
2804 ; CHECK: vpermt2d %xmm{{.*}}{%k1}
2805 ; CHECK-NOT: {z}
2806 define <4 x i32>@test_int_x86_avx512_mask_vpermt2var_d_128(<4 x i32> %x0, <4 x i32> %x1, <4 x i32> %x2, i8 %x3) {
2807   %res = call <4 x i32> @llvm.x86.avx512.mask.vpermt2var.d.128(<4 x i32> %x0, <4 x i32> %x1, <4 x i32> %x2, i8 %x3)
2808   %res1 = call <4 x i32> @llvm.x86.avx512.mask.vpermt2var.d.128(<4 x i32> %x0, <4 x i32> %x1, <4 x i32> %x2, i8 -1)
2809   %res2 = add <4 x i32> %res, %res1
2810   ret <4 x i32> %res2
2811 }
2812
2813 declare <4 x i32> @llvm.x86.avx512.maskz.vpermt2var.d.128(<4 x i32>, <4 x i32>, <4 x i32>, i8)
2814
2815 ; CHECK-LABEL: @test_int_x86_avx512_maskz_vpermt2var_d_128
2816 ; CHECK-NOT: call
2817 ; CHECK: kmov
2818 ; CHECK: vpermt2d %xmm{{.*}}{%k1} {z}
2819 define <4 x i32>@test_int_x86_avx512_maskz_vpermt2var_d_128(<4 x i32> %x0, <4 x i32> %x1, <4 x i32> %x2, i8 %x3) {
2820   %res = call <4 x i32> @llvm.x86.avx512.maskz.vpermt2var.d.128(<4 x i32> %x0, <4 x i32> %x1, <4 x i32> %x2, i8 %x3)
2821   %res1 = call <4 x i32> @llvm.x86.avx512.maskz.vpermt2var.d.128(<4 x i32> %x0, <4 x i32> %x1, <4 x i32> %x2, i8 -1)
2822   %res2 = add <4 x i32> %res, %res1
2823   ret <4 x i32> %res2
2824 }
2825
2826 declare <8 x i32> @llvm.x86.avx512.mask.vpermt2var.d.256(<8 x i32>, <8 x i32>, <8 x i32>, i8)
2827
2828 ; CHECK-LABEL: @test_int_x86_avx512_mask_vpermt2var_d_256
2829 ; CHECK-NOT: call
2830 ; CHECK: kmov
2831 ; CHECK: vpermt2d %ymm{{.*}}{%k1}
2832 ; CHECK-NOT: {z}
2833 define <8 x i32>@test_int_x86_avx512_mask_vpermt2var_d_256(<8 x i32> %x0, <8 x i32> %x1, <8 x i32> %x2, i8 %x3) {
2834   %res = call <8 x i32> @llvm.x86.avx512.mask.vpermt2var.d.256(<8 x i32> %x0, <8 x i32> %x1, <8 x i32> %x2, i8 %x3)
2835   %res1 = call <8 x i32> @llvm.x86.avx512.mask.vpermt2var.d.256(<8 x i32> %x0, <8 x i32> %x1, <8 x i32> %x2, i8 -1)
2836   %res2 = add <8 x i32> %res, %res1
2837   ret <8 x i32> %res2
2838 }
2839
2840 declare <8 x i32> @llvm.x86.avx512.maskz.vpermt2var.d.256(<8 x i32>, <8 x i32>, <8 x i32>, i8)
2841
2842 ; CHECK-LABEL: @test_int_x86_avx512_maskz_vpermt2var_d_256
2843 ; CHECK-NOT: call
2844 ; CHECK: kmov
2845 ; CHECK: vpermt2d {{.*}}{%k1} {z}
2846 define <8 x i32>@test_int_x86_avx512_maskz_vpermt2var_d_256(<8 x i32> %x0, <8 x i32> %x1, <8 x i32> %x2, i8 %x3) {
2847   %res = call <8 x i32> @llvm.x86.avx512.maskz.vpermt2var.d.256(<8 x i32> %x0, <8 x i32> %x1, <8 x i32> %x2, i8 %x3)
2848   %res1 = call <8 x i32> @llvm.x86.avx512.maskz.vpermt2var.d.256(<8 x i32> %x0, <8 x i32> %x1, <8 x i32> %x2, i8 -1)
2849   %res2 = add <8 x i32> %res, %res1
2850   ret <8 x i32> %res2
2851 }
2852
2853 declare <2 x double> @llvm.x86.avx512.mask.vpermi2var.pd.128(<2 x double>, <2 x i64>, <2 x double>, i8)
2854
2855 ; CHECK-LABEL: @test_int_x86_avx512_mask_vpermi2var_pd_128
2856 ; CHECK-NOT: call
2857 ; CHECK: kmov
2858 ; CHECK: vpermi2pd %xmm{{.*}}{%k1}
2859 define <2 x double>@test_int_x86_avx512_mask_vpermi2var_pd_128(<2 x double> %x0, <2 x i64> %x1, <2 x double> %x2, i8 %x3) {
2860   %res = call <2 x double> @llvm.x86.avx512.mask.vpermi2var.pd.128(<2 x double> %x0, <2 x i64> %x1, <2 x double> %x2, i8 %x3)
2861   %res1 = call <2 x double> @llvm.x86.avx512.mask.vpermi2var.pd.128(<2 x double> %x0, <2 x i64> %x1, <2 x double> %x2, i8 -1)
2862   %res2 = fadd <2 x double> %res, %res1
2863   ret <2 x double> %res2
2864 }
2865
2866 declare <4 x double> @llvm.x86.avx512.mask.vpermi2var.pd.256(<4 x double>, <4 x i64>, <4 x double>, i8)
2867
2868 ; CHECK-LABEL: @test_int_x86_avx512_mask_vpermi2var_pd_256
2869 ; CHECK-NOT: call
2870 ; CHECK: kmov
2871 ; CHECK: vpermi2pd %ymm{{.*}}{%k1}
2872 define <4 x double>@test_int_x86_avx512_mask_vpermi2var_pd_256(<4 x double> %x0, <4 x i64> %x1, <4 x double> %x2, i8 %x3) {
2873   %res = call <4 x double> @llvm.x86.avx512.mask.vpermi2var.pd.256(<4 x double> %x0, <4 x i64> %x1, <4 x double> %x2, i8 %x3)
2874   %res1 = call <4 x double> @llvm.x86.avx512.mask.vpermi2var.pd.256(<4 x double> %x0, <4 x i64> %x1, <4 x double> %x2, i8 -1)
2875   %res2 = fadd <4 x double> %res, %res1
2876   ret <4 x double> %res2
2877 }
2878
2879 declare <4 x float> @llvm.x86.avx512.mask.vpermi2var.ps.128(<4 x float>, <4 x i32>, <4 x float>, i8)
2880
2881 ; CHECK-LABEL: @test_int_x86_avx512_mask_vpermi2var_ps_128
2882 ; CHECK-NOT: call
2883 ; CHECK: kmov
2884 ; CHECK: vpermi2ps %xmm{{.*}}{%k1}
2885 define <4 x float>@test_int_x86_avx512_mask_vpermi2var_ps_128(<4 x float> %x0, <4 x i32> %x1, <4 x float> %x2, i8 %x3) {
2886   %res = call <4 x float> @llvm.x86.avx512.mask.vpermi2var.ps.128(<4 x float> %x0, <4 x i32> %x1, <4 x float> %x2, i8 %x3)
2887   %res1 = call <4 x float> @llvm.x86.avx512.mask.vpermi2var.ps.128(<4 x float> %x0, <4 x i32> %x1, <4 x float> %x2, i8 -1)
2888   %res2 = fadd <4 x float> %res, %res1
2889   ret <4 x float> %res2
2890 }
2891
2892 declare <8 x float> @llvm.x86.avx512.mask.vpermi2var.ps.256(<8 x float>, <8 x i32>, <8 x float>, i8)
2893
2894 ; CHECK-LABEL: @test_int_x86_avx512_mask_vpermi2var_ps_256
2895 ; CHECK-NOT: call
2896 ; CHECK: kmov
2897 ; CHECK: vpermi2ps %ymm{{.*}}{%k1}
2898 define <8 x float>@test_int_x86_avx512_mask_vpermi2var_ps_256(<8 x float> %x0, <8 x i32> %x1, <8 x float> %x2, i8 %x3) {
2899   %res = call <8 x float> @llvm.x86.avx512.mask.vpermi2var.ps.256(<8 x float> %x0, <8 x i32> %x1, <8 x float> %x2, i8 %x3)
2900   %res1 = call <8 x float> @llvm.x86.avx512.mask.vpermi2var.ps.256(<8 x float> %x0, <8 x i32> %x1, <8 x float> %x2, i8 -1)
2901   %res2 = fadd <8 x float> %res, %res1
2902   ret <8 x float> %res2
2903 }
2904
2905 declare <2 x i64> @llvm.x86.avx512.mask.pabs.q.128(<2 x i64>, <2 x i64>, i8)
2906
2907 ; CHECK-LABEL: @test_int_x86_avx512_mask_pabs_q_128
2908 ; CHECK-NOT: call
2909 ; CHECK: kmov
2910 ; CHECK: vpabsq{{.*}}{%k1}
2911 define <2 x i64>@test_int_x86_avx512_mask_pabs_q_128(<2 x i64> %x0, <2 x i64> %x1, i8 %x2) {
2912   %res = call <2 x i64> @llvm.x86.avx512.mask.pabs.q.128(<2 x i64> %x0, <2 x i64> %x1, i8 %x2)
2913   %res1 = call <2 x i64> @llvm.x86.avx512.mask.pabs.q.128(<2 x i64> %x0, <2 x i64> %x1, i8 -1)
2914   %res2 = add <2 x i64> %res, %res1
2915   ret <2 x i64> %res2
2916 }
2917
2918 declare <4 x i64> @llvm.x86.avx512.mask.pabs.q.256(<4 x i64>, <4 x i64>, i8)
2919
2920 ; CHECK-LABEL: @test_int_x86_avx512_mask_pabs_q_256
2921 ; CHECK-NOT: call
2922 ; CHECK: kmov
2923 ; CHECK: vpabsq{{.*}}{%k1}
2924 define <4 x i64>@test_int_x86_avx512_mask_pabs_q_256(<4 x i64> %x0, <4 x i64> %x1, i8 %x2) {
2925   %res = call <4 x i64> @llvm.x86.avx512.mask.pabs.q.256(<4 x i64> %x0, <4 x i64> %x1, i8 %x2)
2926   %res1 = call <4 x i64> @llvm.x86.avx512.mask.pabs.q.256(<4 x i64> %x0, <4 x i64> %x1, i8 -1)
2927   %res2 = add <4 x i64> %res, %res1
2928   ret <4 x i64> %res2
2929 }
2930
2931 declare <4 x i32> @llvm.x86.avx512.mask.pabs.d.128(<4 x i32>, <4 x i32>, i8)
2932
2933 ; CHECK-LABEL: @test_int_x86_avx512_mask_pabs_d_128
2934 ; CHECK-NOT: call
2935 ; CHECK: kmov
2936 ; CHECK: vpabsd{{.*}}{%k1}
2937 define <4 x i32>@test_int_x86_avx512_mask_pabs_d_128(<4 x i32> %x0, <4 x i32> %x1, i8 %x2) {
2938   %res = call <4 x i32> @llvm.x86.avx512.mask.pabs.d.128(<4 x i32> %x0, <4 x i32> %x1, i8 %x2)
2939   %res1 = call <4 x i32> @llvm.x86.avx512.mask.pabs.d.128(<4 x i32> %x0, <4 x i32> %x1, i8 -1)
2940   %res2 = add <4 x i32> %res, %res1
2941   ret <4 x i32> %res2
2942 }
2943
2944 declare <8 x i32> @llvm.x86.avx512.mask.pabs.d.256(<8 x i32>, <8 x i32>, i8)
2945
2946 ; CHECK-LABEL: @test_int_x86_avx512_mask_pabs_d_256
2947 ; CHECK-NOT: call
2948 ; CHECK: kmov
2949 ; CHECK: vpabsd{{.*}}{%k1}
2950 define <8 x i32>@test_int_x86_avx512_mask_pabs_d_256(<8 x i32> %x0, <8 x i32> %x1, i8 %x2) {
2951   %res = call <8 x i32> @llvm.x86.avx512.mask.pabs.d.256(<8 x i32> %x0, <8 x i32> %x1, i8 %x2)
2952   %res1 = call <8 x i32> @llvm.x86.avx512.mask.pabs.d.256(<8 x i32> %x0, <8 x i32> %x1, i8 -1)
2953   %res2 = add <8 x i32> %res, %res1
2954   ret <8 x i32> %res2
2955 }
2956
2957
2958 declare <2 x double> @llvm.x86.avx512.mask.scalef.pd.128(<2 x double>, <2 x double>, <2 x double>, i8)
2959
2960 ; CHECK-LABEL: @test_int_x86_avx512_mask_scalef_pd_128
2961 ; CHECK-NOT: call
2962 ; CHECK: kmov
2963 ; CHECK: vscalefpd{{.*}}{%k1}
2964 define <2 x double>@test_int_x86_avx512_mask_scalef_pd_128(<2 x double> %x0, <2 x double> %x1, <2 x double> %x2, i8 %x3) {
2965   %res = call <2 x double> @llvm.x86.avx512.mask.scalef.pd.128(<2 x double> %x0, <2 x double> %x1, <2 x double> %x2, i8 %x3)
2966   %res1 = call <2 x double> @llvm.x86.avx512.mask.scalef.pd.128(<2 x double> %x0, <2 x double> %x1, <2 x double> %x2, i8 -1)
2967   %res2 = fadd <2 x double> %res, %res1
2968   ret <2 x double> %res2
2969 }
2970
2971 declare <4 x double> @llvm.x86.avx512.mask.scalef.pd.256(<4 x double>, <4 x double>, <4 x double>, i8)
2972
2973 ; CHECK-LABEL: @test_int_x86_avx512_mask_scalef_pd_256
2974 ; CHECK-NOT: call
2975 ; CHECK: kmov
2976 ; CHECK: vscalefpd{{.*}}{%k1}
2977 define <4 x double>@test_int_x86_avx512_mask_scalef_pd_256(<4 x double> %x0, <4 x double> %x1, <4 x double> %x2, i8 %x3) {
2978   %res = call <4 x double> @llvm.x86.avx512.mask.scalef.pd.256(<4 x double> %x0, <4 x double> %x1, <4 x double> %x2, i8 %x3)
2979   %res1 = call <4 x double> @llvm.x86.avx512.mask.scalef.pd.256(<4 x double> %x0, <4 x double> %x1, <4 x double> %x2, i8 -1)
2980   %res2 = fadd <4 x double> %res, %res1
2981   ret <4 x double> %res2
2982 }
2983
2984 declare <4 x float> @llvm.x86.avx512.mask.scalef.ps.128(<4 x float>, <4 x float>, <4 x float>, i8)
2985 ; CHECK-LABEL: @test_int_x86_avx512_mask_scalef_ps_128
2986 ; CHECK-NOT: call
2987 ; CHECK: kmov
2988 ; CHECK: vscalefps{{.*}}{%k1}
2989 define <4 x float>@test_int_x86_avx512_mask_scalef_ps_128(<4 x float> %x0, <4 x float> %x1, <4 x float> %x2, i8 %x3) {
2990   %res = call <4 x float> @llvm.x86.avx512.mask.scalef.ps.128(<4 x float> %x0, <4 x float> %x1, <4 x float> %x2, i8 %x3)
2991   %res1 = call <4 x float> @llvm.x86.avx512.mask.scalef.ps.128(<4 x float> %x0, <4 x float> %x1, <4 x float> %x2, i8 -1)
2992   %res2 = fadd <4 x float> %res, %res1
2993   ret <4 x float> %res2
2994 }
2995
2996 declare <8 x float> @llvm.x86.avx512.mask.scalef.ps.256(<8 x float>, <8 x float>, <8 x float>, i8)
2997 ; CHECK-LABEL: @test_int_x86_avx512_mask_scalef_ps_256
2998 ; CHECK-NOT: call
2999 ; CHECK: kmov
3000 ; CHECK: vscalefps{{.*}}{%k1}
3001 define <8 x float>@test_int_x86_avx512_mask_scalef_ps_256(<8 x float> %x0, <8 x float> %x1, <8 x float> %x2, i8 %x3) {
3002   %res = call <8 x float> @llvm.x86.avx512.mask.scalef.ps.256(<8 x float> %x0, <8 x float> %x1, <8 x float> %x2, i8 %x3)
3003   %res1 = call <8 x float> @llvm.x86.avx512.mask.scalef.ps.256(<8 x float> %x0, <8 x float> %x1, <8 x float> %x2, i8 -1)
3004   %res2 = fadd <8 x float> %res, %res1
3005   ret <8 x float> %res2
3006 }
3007
3008 declare <2 x double> @llvm.x86.avx512.mask.unpckh.pd.128(<2 x double>, <2 x double>, <2 x double>, i8)
3009
3010 define <2 x double>@test_int_x86_avx512_mask_unpckh_pd_128(<2 x double> %x0, <2 x double> %x1, <2 x double> %x2, i8 %x3) {
3011 ; CHECK-LABEL: test_int_x86_avx512_mask_unpckh_pd_128:
3012 ; CHECK:         vunpckhpd %xmm1, %xmm0, %xmm2 {%k1}
3013 ; CHECK-NEXT:    vunpckhpd %xmm1, %xmm0, %xmm0 ## encoding: [0x62,0xf1,0xfd,0x08,0x15,0xc1]
3014   %res = call <2 x double> @llvm.x86.avx512.mask.unpckh.pd.128(<2 x double> %x0, <2 x double> %x1, <2 x double> %x2, i8 %x3)
3015   %res1 = call <2 x double> @llvm.x86.avx512.mask.unpckh.pd.128(<2 x double> %x0, <2 x double> %x1, <2 x double> %x2, i8 -1)
3016   %res2 = fadd <2 x double> %res, %res1
3017   ret <2 x double> %res2
3018 }
3019
3020 declare <4 x double> @llvm.x86.avx512.mask.unpckh.pd.256(<4 x double>, <4 x double>, <4 x double>, i8)
3021
3022 define <4 x double>@test_int_x86_avx512_mask_unpckh_pd_256(<4 x double> %x0, <4 x double> %x1, <4 x double> %x2, i8 %x3) {
3023 ; CHECK-LABEL: test_int_x86_avx512_mask_unpckh_pd_256:
3024 ; CHECK:         vunpckhpd %ymm1, %ymm0, %ymm2 {%k1}
3025 ; CHECK-NEXT:    vunpckhpd %ymm1, %ymm0, %ymm0 ## encoding: [0x62,0xf1,0xfd,0x28,0x15,0xc1]
3026   %res = call <4 x double> @llvm.x86.avx512.mask.unpckh.pd.256(<4 x double> %x0, <4 x double> %x1, <4 x double> %x2, i8 %x3)
3027   %res1 = call <4 x double> @llvm.x86.avx512.mask.unpckh.pd.256(<4 x double> %x0, <4 x double> %x1, <4 x double> %x2, i8 -1)
3028   %res2 = fadd <4 x double> %res, %res1
3029   ret <4 x double> %res2
3030 }
3031
3032 declare <4 x float> @llvm.x86.avx512.mask.unpckh.ps.128(<4 x float>, <4 x float>, <4 x float>, i8)
3033
3034 define <4 x float>@test_int_x86_avx512_mask_unpckh_ps_128(<4 x float> %x0, <4 x float> %x1, <4 x float> %x2, i8 %x3) {
3035 ; CHECK-LABEL: test_int_x86_avx512_mask_unpckh_ps_128:
3036 ; CHECK:         vunpckhps %xmm1, %xmm0, %xmm2 {%k1}
3037 ; CHECK-NEXT:    vunpckhps %xmm1, %xmm0, %xmm0 ## encoding: [0x62,0xf1,0x7c,0x08,0x15,0xc1]
3038   %res = call <4 x float> @llvm.x86.avx512.mask.unpckh.ps.128(<4 x float> %x0, <4 x float> %x1, <4 x float> %x2, i8 %x3)
3039   %res1 = call <4 x float> @llvm.x86.avx512.mask.unpckh.ps.128(<4 x float> %x0, <4 x float> %x1, <4 x float> %x2, i8 -1)
3040   %res2 = fadd <4 x float> %res, %res1
3041   ret <4 x float> %res2
3042 }
3043
3044 declare <8 x float> @llvm.x86.avx512.mask.unpckh.ps.256(<8 x float>, <8 x float>, <8 x float>, i8)
3045
3046 define <8 x float>@test_int_x86_avx512_mask_unpckh_ps_256(<8 x float> %x0, <8 x float> %x1, <8 x float> %x2, i8 %x3) {
3047 ; CHECK-LABEL: test_int_x86_avx512_mask_unpckh_ps_256:
3048 ; CHECK:       ## BB#0:
3049 ; CHECK:         vunpckhps %ymm1, %ymm0, %ymm2 {%k1}
3050 ; CHECK-NEXT:    vunpckhps %ymm1, %ymm0, %ymm0 ## encoding: [0x62,0xf1,0x7c,0x28,0x15,0xc1]
3051   %res = call <8 x float> @llvm.x86.avx512.mask.unpckh.ps.256(<8 x float> %x0, <8 x float> %x1, <8 x float> %x2, i8 %x3)
3052   %res1 = call <8 x float> @llvm.x86.avx512.mask.unpckh.ps.256(<8 x float> %x0, <8 x float> %x1, <8 x float> %x2, i8 -1)
3053   %res2 = fadd <8 x float> %res, %res1
3054   ret <8 x float> %res2
3055 }
3056
3057 declare <2 x double> @llvm.x86.avx512.mask.unpckl.pd.128(<2 x double>, <2 x double>, <2 x double>, i8)
3058
3059 define <2 x double>@test_int_x86_avx512_mask_unpckl_pd_128(<2 x double> %x0, <2 x double> %x1, <2 x double> %x2, i8 %x3) {
3060 ; CHECK-LABEL: test_int_x86_avx512_mask_unpckl_pd_128:
3061 ; CHECK:         vunpcklpd %xmm1, %xmm0, %xmm2 {%k1}
3062 ; CHECK-NEXT:    vunpcklpd %xmm1, %xmm0, %xmm0 ## encoding: [0x62,0xf1,0xfd,0x08,0x14,0xc1]
3063   %res = call <2 x double> @llvm.x86.avx512.mask.unpckl.pd.128(<2 x double> %x0, <2 x double> %x1, <2 x double> %x2, i8 %x3)
3064   %res1 = call <2 x double> @llvm.x86.avx512.mask.unpckl.pd.128(<2 x double> %x0, <2 x double> %x1, <2 x double> %x2, i8 -1)
3065   %res2 = fadd <2 x double> %res, %res1
3066   ret <2 x double> %res2
3067 }
3068
3069 declare <4 x double> @llvm.x86.avx512.mask.unpckl.pd.256(<4 x double>, <4 x double>, <4 x double>, i8)
3070
3071 define <4 x double>@test_int_x86_avx512_mask_unpckl_pd_256(<4 x double> %x0, <4 x double> %x1, <4 x double> %x2, i8 %x3) {
3072 ; CHECK-LABEL: test_int_x86_avx512_mask_unpckl_pd_256:
3073 ; CHECK:         vunpcklpd %ymm1, %ymm0, %ymm2 {%k1}
3074 ; CHECK-NEXT:    vunpcklpd %ymm1, %ymm0, %ymm0 ## encoding: [0x62,0xf1,0xfd,0x28,0x14,0xc1]
3075   %res = call <4 x double> @llvm.x86.avx512.mask.unpckl.pd.256(<4 x double> %x0, <4 x double> %x1, <4 x double> %x2, i8 %x3)
3076   %res1 = call <4 x double> @llvm.x86.avx512.mask.unpckl.pd.256(<4 x double> %x0, <4 x double> %x1, <4 x double> %x2, i8 -1)
3077   %res2 = fadd <4 x double> %res, %res1
3078   ret <4 x double> %res2
3079 }
3080
3081 declare <4 x float> @llvm.x86.avx512.mask.unpckl.ps.128(<4 x float>, <4 x float>, <4 x float>, i8)
3082
3083 define <4 x float>@test_int_x86_avx512_mask_unpckl_ps_128(<4 x float> %x0, <4 x float> %x1, <4 x float> %x2, i8 %x3) {
3084 ; CHECK-LABEL: test_int_x86_avx512_mask_unpckl_ps_128:
3085 ; CHECK:         vunpcklps %xmm1, %xmm0, %xmm2 {%k1}
3086 ; CHECK-NEXT:    vunpcklps %xmm1, %xmm0, %xmm0 ## encoding: [0x62,0xf1,0x7c,0x08,0x14,0xc1]
3087   %res = call <4 x float> @llvm.x86.avx512.mask.unpckl.ps.128(<4 x float> %x0, <4 x float> %x1, <4 x float> %x2, i8 %x3)
3088   %res1 = call <4 x float> @llvm.x86.avx512.mask.unpckl.ps.128(<4 x float> %x0, <4 x float> %x1, <4 x float> %x2, i8 -1)
3089   %res2 = fadd <4 x float> %res, %res1
3090   ret <4 x float> %res2
3091 }
3092
3093 declare <8 x float> @llvm.x86.avx512.mask.unpckl.ps.256(<8 x float>, <8 x float>, <8 x float>, i8)
3094
3095 define <8 x float>@test_int_x86_avx512_mask_unpckl_ps_256(<8 x float> %x0, <8 x float> %x1, <8 x float> %x2, i8 %x3) {
3096 ; CHECK-LABEL: test_int_x86_avx512_mask_unpckl_ps_256:
3097 ; CHECK:         vunpcklps %ymm1, %ymm0, %ymm2 {%k1}
3098 ; CHECK-NEXT:    vunpcklps %ymm1, %ymm0, %ymm0 ## encoding: [0x62,0xf1,0x7c,0x28,0x14,0xc1]
3099   %res = call <8 x float> @llvm.x86.avx512.mask.unpckl.ps.256(<8 x float> %x0, <8 x float> %x1, <8 x float> %x2, i8 %x3)
3100   %res1 = call <8 x float> @llvm.x86.avx512.mask.unpckl.ps.256(<8 x float> %x0, <8 x float> %x1, <8 x float> %x2, i8 -1)
3101   %res2 = fadd <8 x float> %res, %res1
3102   ret <8 x float> %res2
3103 }
3104
3105 declare <4 x i32> @llvm.x86.avx512.mask.punpckhd.q.128(<4 x i32>, <4 x i32>, <4 x i32>, i8)
3106
3107 define <4 x i32>@test_int_x86_avx512_mask_punpckhd_q_128(<4 x i32> %x0, <4 x i32> %x1, <4 x i32> %x2, i8 %x3) {
3108 ; CHECK-LABEL: test_int_x86_avx512_mask_punpckhd_q_128:
3109 ; CHECK:         vpunpckhdq %xmm1, %xmm0, %xmm2 {%k1}
3110 ; CHECK-NEXT:    vpunpckhdq %xmm1, %xmm0, %xmm0 ## encoding: [0x62,0xf1,0x7d,0x08,0x6a,0xc1]
3111   %res = call <4 x i32> @llvm.x86.avx512.mask.punpckhd.q.128(<4 x i32> %x0, <4 x i32> %x1, <4 x i32> %x2, i8 %x3)
3112   %res1 = call <4 x i32> @llvm.x86.avx512.mask.punpckhd.q.128(<4 x i32> %x0, <4 x i32> %x1, <4 x i32> %x2, i8 -1)
3113   %res2 = add <4 x i32> %res, %res1
3114   ret <4 x i32> %res2
3115 }
3116
3117 declare <4 x i32> @llvm.x86.avx512.mask.punpckld.q.128(<4 x i32>, <4 x i32>, <4 x i32>, i8)
3118
3119 define <4 x i32>@test_int_x86_avx512_mask_punpckld_q_128(<4 x i32> %x0, <4 x i32> %x1, <4 x i32> %x2, i8 %x3) {
3120 ; CHECK-LABEL: test_int_x86_avx512_mask_punpckld_q_128:
3121 ; CHECK:         vpunpckldq %xmm1, %xmm0, %xmm2 {%k1}
3122 ; CHECK-NEXT:    vpunpckldq %xmm1, %xmm0, %xmm0 ## encoding: [0x62,0xf1,0x7d,0x08,0x62,0xc1]
3123   %res = call <4 x i32> @llvm.x86.avx512.mask.punpckld.q.128(<4 x i32> %x0, <4 x i32> %x1, <4 x i32> %x2, i8 %x3)
3124   %res1 = call <4 x i32> @llvm.x86.avx512.mask.punpckld.q.128(<4 x i32> %x0, <4 x i32> %x1, <4 x i32> %x2, i8 -1)
3125   %res2 = add <4 x i32> %res, %res1
3126   ret <4 x i32> %res2
3127 }
3128
3129 declare <8 x i32> @llvm.x86.avx512.mask.punpckhd.q.256(<8 x i32>, <8 x i32>, <8 x i32>, i8)
3130
3131 define <8 x i32>@test_int_x86_avx512_mask_punpckhd_q_256(<8 x i32> %x0, <8 x i32> %x1, <8 x i32> %x2, i8 %x3) {
3132 ; CHECK-LABEL: test_int_x86_avx512_mask_punpckhd_q_256:
3133 ; CHECK:       ## BB#0:
3134 ; CHECK:         vpunpckhdq %ymm1, %ymm0, %ymm2 {%k1}
3135 ; CHECK-NEXT:    vpunpckhdq %ymm1, %ymm0, %ymm0 ## encoding: [0x62,0xf1,0x7d,0x28,0x6a,0xc1]
3136   %res = call <8 x i32> @llvm.x86.avx512.mask.punpckhd.q.256(<8 x i32> %x0, <8 x i32> %x1, <8 x i32> %x2, i8 %x3)
3137   %res1 = call <8 x i32> @llvm.x86.avx512.mask.punpckhd.q.256(<8 x i32> %x0, <8 x i32> %x1, <8 x i32> %x2, i8 -1)
3138   %res2 = add <8 x i32> %res, %res1
3139   ret <8 x i32> %res2
3140 }
3141
3142 declare <8 x i32> @llvm.x86.avx512.mask.punpckld.q.256(<8 x i32>, <8 x i32>, <8 x i32>, i8)
3143
3144 define <8 x i32>@test_int_x86_avx512_mask_punpckld_q_256(<8 x i32> %x0, <8 x i32> %x1, <8 x i32> %x2, i8 %x3) {
3145 ; CHECK-LABEL: test_int_x86_avx512_mask_punpckld_q_256:
3146 ; CHECK:         vpunpckldq %ymm1, %ymm0, %ymm2 {%k1}
3147 ; CHECK-NEXT:    vpunpckldq %ymm1, %ymm0, %ymm0 ## encoding: [0x62,0xf1,0x7d,0x28,0x62,0xc1]
3148   %res = call <8 x i32> @llvm.x86.avx512.mask.punpckld.q.256(<8 x i32> %x0, <8 x i32> %x1, <8 x i32> %x2, i8 %x3)
3149   %res1 = call <8 x i32> @llvm.x86.avx512.mask.punpckld.q.256(<8 x i32> %x0, <8 x i32> %x1, <8 x i32> %x2, i8 -1)
3150   %res2 = add <8 x i32> %res, %res1
3151   ret <8 x i32> %res2
3152 }
3153
3154 declare <2 x i64> @llvm.x86.avx512.mask.punpckhqd.q.128(<2 x i64>, <2 x i64>, <2 x i64>, i8)
3155
3156 define <2 x i64>@test_int_x86_avx512_mask_punpckhqd_q_128(<2 x i64> %x0, <2 x i64> %x1, <2 x i64> %x2, i8 %x3) {
3157 ; CHECK-LABEL: test_int_x86_avx512_mask_punpckhqd_q_128:
3158 ; CHECK:         vpunpckhqdq %xmm1, %xmm0, %xmm2 {%k1}
3159 ; CHECK-NEXT:    vpunpckhqdq %xmm1, %xmm0, %xmm0 ## encoding: [0x62,0xf1,0xfd,0x08,0x6d,0xc1]
3160   %res = call <2 x i64> @llvm.x86.avx512.mask.punpckhqd.q.128(<2 x i64> %x0, <2 x i64> %x1, <2 x i64> %x2, i8 %x3)
3161   %res1 = call <2 x i64> @llvm.x86.avx512.mask.punpckhqd.q.128(<2 x i64> %x0, <2 x i64> %x1, <2 x i64> %x2, i8 -1)
3162   %res2 = add <2 x i64> %res, %res1
3163   ret <2 x i64> %res2
3164 }
3165
3166 declare <2 x i64> @llvm.x86.avx512.mask.punpcklqd.q.128(<2 x i64>, <2 x i64>, <2 x i64>, i8)
3167
3168 define <2 x i64>@test_int_x86_avx512_mask_punpcklqd_q_128(<2 x i64> %x0, <2 x i64> %x1, <2 x i64> %x2, i8 %x3) {
3169 ; CHECK-LABEL: test_int_x86_avx512_mask_punpcklqd_q_128:
3170 ; CHECK:         vpunpcklqdq %xmm1, %xmm0, %xmm2 {%k1}
3171 ; CHECK-NEXT:    vpunpcklqdq %xmm1, %xmm0, %xmm0 ## encoding: [0x62,0xf1,0xfd,0x08,0x6c,0xc1]
3172   %res = call <2 x i64> @llvm.x86.avx512.mask.punpcklqd.q.128(<2 x i64> %x0, <2 x i64> %x1, <2 x i64> %x2, i8 %x3)
3173   %res1 = call <2 x i64> @llvm.x86.avx512.mask.punpcklqd.q.128(<2 x i64> %x0, <2 x i64> %x1, <2 x i64> %x2, i8 -1)
3174   %res2 = add <2 x i64> %res, %res1
3175   ret <2 x i64> %res2
3176 }
3177
3178 declare <4 x i64> @llvm.x86.avx512.mask.punpcklqd.q.256(<4 x i64>, <4 x i64>, <4 x i64>, i8)
3179
3180 define <4 x i64>@test_int_x86_avx512_mask_punpcklqd_q_256(<4 x i64> %x0, <4 x i64> %x1, <4 x i64> %x2, i8 %x3) {
3181 ; CHECK-LABEL: test_int_x86_avx512_mask_punpcklqd_q_256:
3182 ; CHECK:         vpunpcklqdq %ymm1, %ymm0, %ymm2 {%k1}
3183 ; CHECK-NEXT:    vpunpcklqdq %ymm1, %ymm0, %ymm0 ## encoding: [0x62,0xf1,0xfd,0x28,0x6c,0xc1]
3184   %res = call <4 x i64> @llvm.x86.avx512.mask.punpcklqd.q.256(<4 x i64> %x0, <4 x i64> %x1, <4 x i64> %x2, i8 %x3)
3185   %res1 = call <4 x i64> @llvm.x86.avx512.mask.punpcklqd.q.256(<4 x i64> %x0, <4 x i64> %x1, <4 x i64> %x2, i8 -1)
3186   %res2 = add <4 x i64> %res, %res1
3187   ret <4 x i64> %res2
3188 }
3189
3190 declare <4 x i64> @llvm.x86.avx512.mask.punpckhqd.q.256(<4 x i64>, <4 x i64>, <4 x i64>, i8)
3191
3192 define <4 x i64>@test_int_x86_avx512_mask_punpckhqd_q_256(<4 x i64> %x0, <4 x i64> %x1, <4 x i64> %x2, i8 %x3) {
3193 ; CHECK-LABEL: test_int_x86_avx512_mask_punpckhqd_q_256:
3194 ; CHECK:         vpunpckhqdq %ymm1, %ymm0, %ymm2 {%k1}
3195 ; CHECK-NEXT:    vpunpckhqdq %ymm1, %ymm0, %ymm0 ## encoding: [0x62,0xf1,0xfd,0x28,0x6d,0xc1]
3196   %res = call <4 x i64> @llvm.x86.avx512.mask.punpckhqd.q.256(<4 x i64> %x0, <4 x i64> %x1, <4 x i64> %x2, i8 %x3)
3197   %res1 = call <4 x i64> @llvm.x86.avx512.mask.punpckhqd.q.256(<4 x i64> %x0, <4 x i64> %x1, <4 x i64> %x2, i8 -1)
3198   %res2 = add <4 x i64> %res, %res1
3199   ret <4 x i64> %res2
3200 }
3201
3202 declare <16 x i8> @llvm.x86.avx512.mask.pmov.qb.128(<2 x i64>, <16 x i8>, i8)
3203
3204 define <16 x i8>@test_int_x86_avx512_mask_pmov_qb_128(<2 x i64> %x0, <16 x i8> %x1, i8 %x2) {
3205 ; CHECK-LABEL: test_int_x86_avx512_mask_pmov_qb_128:
3206 ; CHECK:       vpmovqb %xmm0, %xmm1 {%k1}
3207 ; CHECK-NEXT:  vpmovqb %xmm0, %xmm2 {%k1} {z}
3208 ; CHECK-NEXT:  vpmovqb %xmm0, %xmm0
3209     %res0 = call <16 x i8> @llvm.x86.avx512.mask.pmov.qb.128(<2 x i64> %x0, <16 x i8> %x1, i8 -1)
3210     %res1 = call <16 x i8> @llvm.x86.avx512.mask.pmov.qb.128(<2 x i64> %x0, <16 x i8> %x1, i8 %x2)
3211     %res2 = call <16 x i8> @llvm.x86.avx512.mask.pmov.qb.128(<2 x i64> %x0, <16 x i8> zeroinitializer, i8 %x2)
3212     %res3 = add <16 x i8> %res0, %res1
3213     %res4 = add <16 x i8> %res3, %res2
3214     ret <16 x i8> %res4
3215 }
3216
3217 declare void @llvm.x86.avx512.mask.pmov.qb.mem.128(i8* %ptr, <2 x i64>, i8)
3218
3219 define void @test_int_x86_avx512_mask_pmov_qb_mem_128(i8* %ptr, <2 x i64> %x1, i8 %x2) {
3220 ; CHECK-LABEL: test_int_x86_avx512_mask_pmov_qb_mem_128:
3221 ; CHECK:  vpmovqb %xmm0, (%rdi)
3222 ; CHECK:  vpmovqb %xmm0, (%rdi) {%k1}
3223     call void @llvm.x86.avx512.mask.pmov.qb.mem.128(i8* %ptr, <2 x i64> %x1, i8 -1)
3224     call void @llvm.x86.avx512.mask.pmov.qb.mem.128(i8* %ptr, <2 x i64> %x1, i8 %x2)
3225     ret void
3226 }
3227
3228 declare <16 x i8> @llvm.x86.avx512.mask.pmovs.qb.128(<2 x i64>, <16 x i8>, i8)
3229
3230 define <16 x i8>@test_int_x86_avx512_mask_pmovs_qb_128(<2 x i64> %x0, <16 x i8> %x1, i8 %x2) {
3231 ; CHECK-LABEL: test_int_x86_avx512_mask_pmovs_qb_128:
3232 ; CHECK:       vpmovsqb %xmm0, %xmm1 {%k1}
3233 ; CHECK-NEXT:  vpmovsqb %xmm0, %xmm2 {%k1} {z}
3234 ; CHECK-NEXT:  vpmovsqb %xmm0, %xmm0
3235     %res0 = call <16 x i8> @llvm.x86.avx512.mask.pmovs.qb.128(<2 x i64> %x0, <16 x i8> %x1, i8 -1)
3236     %res1 = call <16 x i8> @llvm.x86.avx512.mask.pmovs.qb.128(<2 x i64> %x0, <16 x i8> %x1, i8 %x2)
3237     %res2 = call <16 x i8> @llvm.x86.avx512.mask.pmovs.qb.128(<2 x i64> %x0, <16 x i8> zeroinitializer, i8 %x2)
3238     %res3 = add <16 x i8> %res0, %res1
3239     %res4 = add <16 x i8> %res3, %res2
3240     ret <16 x i8> %res4
3241 }
3242
3243 declare void @llvm.x86.avx512.mask.pmovs.qb.mem.128(i8* %ptr, <2 x i64>, i8)
3244
3245 define void @test_int_x86_avx512_mask_pmovs_qb_mem_128(i8* %ptr, <2 x i64> %x1, i8 %x2) {
3246 ; CHECK-LABEL: test_int_x86_avx512_mask_pmovs_qb_mem_128:
3247 ; CHECK:  vpmovsqb %xmm0, (%rdi)
3248 ; CHECK:  vpmovsqb %xmm0, (%rdi) {%k1}
3249     call void @llvm.x86.avx512.mask.pmovs.qb.mem.128(i8* %ptr, <2 x i64> %x1, i8 -1)
3250     call void @llvm.x86.avx512.mask.pmovs.qb.mem.128(i8* %ptr, <2 x i64> %x1, i8 %x2)
3251     ret void
3252 }
3253
3254 declare <16 x i8> @llvm.x86.avx512.mask.pmovus.qb.128(<2 x i64>, <16 x i8>, i8)
3255
3256 define <16 x i8>@test_int_x86_avx512_mask_pmovus_qb_128(<2 x i64> %x0, <16 x i8> %x1, i8 %x2) {
3257 ; CHECK-LABEL: test_int_x86_avx512_mask_pmovus_qb_128:
3258 ; CHECK:       vpmovusqb %xmm0, %xmm1 {%k1}
3259 ; CHECK-NEXT:  vpmovusqb %xmm0, %xmm2 {%k1} {z}
3260 ; CHECK-NEXT:  vpmovusqb %xmm0, %xmm0
3261     %res0 = call <16 x i8> @llvm.x86.avx512.mask.pmovus.qb.128(<2 x i64> %x0, <16 x i8> %x1, i8 -1)
3262     %res1 = call <16 x i8> @llvm.x86.avx512.mask.pmovus.qb.128(<2 x i64> %x0, <16 x i8> %x1, i8 %x2)
3263     %res2 = call <16 x i8> @llvm.x86.avx512.mask.pmovus.qb.128(<2 x i64> %x0, <16 x i8> zeroinitializer, i8 %x2)
3264     %res3 = add <16 x i8> %res0, %res1
3265     %res4 = add <16 x i8> %res3, %res2
3266     ret <16 x i8> %res4
3267 }
3268
3269 declare void @llvm.x86.avx512.mask.pmovus.qb.mem.128(i8* %ptr, <2 x i64>, i8)
3270
3271 define void @test_int_x86_avx512_mask_pmovus_qb_mem_128(i8* %ptr, <2 x i64> %x1, i8 %x2) {
3272 ; CHECK-LABEL: test_int_x86_avx512_mask_pmovus_qb_mem_128:
3273 ; CHECK:  vpmovusqb %xmm0, (%rdi)
3274 ; CHECK:  vpmovusqb %xmm0, (%rdi) {%k1}
3275     call void @llvm.x86.avx512.mask.pmovus.qb.mem.128(i8* %ptr, <2 x i64> %x1, i8 -1)
3276     call void @llvm.x86.avx512.mask.pmovus.qb.mem.128(i8* %ptr, <2 x i64> %x1, i8 %x2)
3277     ret void
3278 }
3279
3280 declare <16 x i8> @llvm.x86.avx512.mask.pmov.qb.256(<4 x i64>, <16 x i8>, i8)
3281
3282 define <16 x i8>@test_int_x86_avx512_mask_pmov_qb_256(<4 x i64> %x0, <16 x i8> %x1, i8 %x2) {
3283 ; CHECK-LABEL: test_int_x86_avx512_mask_pmov_qb_256:
3284 ; CHECK:       vpmovqb %ymm0, %xmm1 {%k1}
3285 ; CHECK-NEXT:  vpmovqb %ymm0, %xmm2 {%k1} {z}
3286 ; CHECK-NEXT:  vpmovqb %ymm0, %xmm0
3287     %res0 = call <16 x i8> @llvm.x86.avx512.mask.pmov.qb.256(<4 x i64> %x0, <16 x i8> %x1, i8 -1)
3288     %res1 = call <16 x i8> @llvm.x86.avx512.mask.pmov.qb.256(<4 x i64> %x0, <16 x i8> %x1, i8 %x2)
3289     %res2 = call <16 x i8> @llvm.x86.avx512.mask.pmov.qb.256(<4 x i64> %x0, <16 x i8> zeroinitializer, i8 %x2)
3290     %res3 = add <16 x i8> %res0, %res1
3291     %res4 = add <16 x i8> %res3, %res2
3292     ret <16 x i8> %res4
3293 }
3294
3295 declare void @llvm.x86.avx512.mask.pmov.qb.mem.256(i8* %ptr, <4 x i64>, i8)
3296
3297 define void @test_int_x86_avx512_mask_pmov_qb_mem_256(i8* %ptr, <4 x i64> %x1, i8 %x2) {
3298 ; CHECK-LABEL: test_int_x86_avx512_mask_pmov_qb_mem_256:
3299 ; CHECK:  vpmovqb %ymm0, (%rdi)
3300 ; CHECK:  vpmovqb %ymm0, (%rdi) {%k1}
3301     call void @llvm.x86.avx512.mask.pmov.qb.mem.256(i8* %ptr, <4 x i64> %x1, i8 -1)
3302     call void @llvm.x86.avx512.mask.pmov.qb.mem.256(i8* %ptr, <4 x i64> %x1, i8 %x2)
3303     ret void
3304 }
3305
3306 declare <16 x i8> @llvm.x86.avx512.mask.pmovs.qb.256(<4 x i64>, <16 x i8>, i8)
3307
3308 define <16 x i8>@test_int_x86_avx512_mask_pmovs_qb_256(<4 x i64> %x0, <16 x i8> %x1, i8 %x2) {
3309 ; CHECK-LABEL: test_int_x86_avx512_mask_pmovs_qb_256:
3310 ; CHECK:       vpmovsqb %ymm0, %xmm1 {%k1}
3311 ; CHECK-NEXT:  vpmovsqb %ymm0, %xmm2 {%k1} {z}
3312 ; CHECK-NEXT:  vpmovsqb %ymm0, %xmm0
3313     %res0 = call <16 x i8> @llvm.x86.avx512.mask.pmovs.qb.256(<4 x i64> %x0, <16 x i8> %x1, i8 -1)
3314     %res1 = call <16 x i8> @llvm.x86.avx512.mask.pmovs.qb.256(<4 x i64> %x0, <16 x i8> %x1, i8 %x2)
3315     %res2 = call <16 x i8> @llvm.x86.avx512.mask.pmovs.qb.256(<4 x i64> %x0, <16 x i8> zeroinitializer, i8 %x2)
3316     %res3 = add <16 x i8> %res0, %res1
3317     %res4 = add <16 x i8> %res3, %res2
3318     ret <16 x i8> %res4
3319 }
3320
3321 declare void @llvm.x86.avx512.mask.pmovs.qb.mem.256(i8* %ptr, <4 x i64>, i8)
3322
3323 define void @test_int_x86_avx512_mask_pmovs_qb_mem_256(i8* %ptr, <4 x i64> %x1, i8 %x2) {
3324 ; CHECK-LABEL: test_int_x86_avx512_mask_pmovs_qb_mem_256:
3325 ; CHECK:  vpmovsqb %ymm0, (%rdi)
3326 ; CHECK:  vpmovsqb %ymm0, (%rdi) {%k1}
3327     call void @llvm.x86.avx512.mask.pmovs.qb.mem.256(i8* %ptr, <4 x i64> %x1, i8 -1)
3328     call void @llvm.x86.avx512.mask.pmovs.qb.mem.256(i8* %ptr, <4 x i64> %x1, i8 %x2)
3329     ret void
3330 }
3331
3332 declare <16 x i8> @llvm.x86.avx512.mask.pmovus.qb.256(<4 x i64>, <16 x i8>, i8)
3333
3334 define <16 x i8>@test_int_x86_avx512_mask_pmovus_qb_256(<4 x i64> %x0, <16 x i8> %x1, i8 %x2) {
3335 ; CHECK-LABEL: test_int_x86_avx512_mask_pmovus_qb_256:
3336 ; CHECK:       vpmovusqb %ymm0, %xmm1 {%k1}
3337 ; CHECK-NEXT:  vpmovusqb %ymm0, %xmm2 {%k1} {z}
3338 ; CHECK-NEXT:  vpmovusqb %ymm0, %xmm0
3339     %res0 = call <16 x i8> @llvm.x86.avx512.mask.pmovus.qb.256(<4 x i64> %x0, <16 x i8> %x1, i8 -1)
3340     %res1 = call <16 x i8> @llvm.x86.avx512.mask.pmovus.qb.256(<4 x i64> %x0, <16 x i8> %x1, i8 %x2)
3341     %res2 = call <16 x i8> @llvm.x86.avx512.mask.pmovus.qb.256(<4 x i64> %x0, <16 x i8> zeroinitializer, i8 %x2)
3342     %res3 = add <16 x i8> %res0, %res1
3343     %res4 = add <16 x i8> %res3, %res2
3344     ret <16 x i8> %res4
3345 }
3346
3347 declare void @llvm.x86.avx512.mask.pmovus.qb.mem.256(i8* %ptr, <4 x i64>, i8)
3348
3349 define void @test_int_x86_avx512_mask_pmovus_qb_mem_256(i8* %ptr, <4 x i64> %x1, i8 %x2) {
3350 ; CHECK-LABEL: test_int_x86_avx512_mask_pmovus_qb_mem_256:
3351 ; CHECK:  vpmovusqb %ymm0, (%rdi)
3352 ; CHECK:  vpmovusqb %ymm0, (%rdi) {%k1}
3353     call void @llvm.x86.avx512.mask.pmovus.qb.mem.256(i8* %ptr, <4 x i64> %x1, i8 -1)
3354     call void @llvm.x86.avx512.mask.pmovus.qb.mem.256(i8* %ptr, <4 x i64> %x1, i8 %x2)
3355     ret void
3356 }
3357
3358 declare <8 x i16> @llvm.x86.avx512.mask.pmov.qw.128(<2 x i64>, <8 x i16>, i8)
3359
3360 define <8 x i16>@test_int_x86_avx512_mask_pmov_qw_128(<2 x i64> %x0, <8 x i16> %x1, i8 %x2) {
3361 ; CHECK-LABEL: test_int_x86_avx512_mask_pmov_qw_128:
3362 ; CHECK:       vpmovqw %xmm0, %xmm1 {%k1}
3363 ; CHECK-NEXT:  vpmovqw %xmm0, %xmm2 {%k1} {z}
3364 ; CHECK-NEXT:  vpmovqw %xmm0, %xmm0
3365     %res0 = call <8 x i16> @llvm.x86.avx512.mask.pmov.qw.128(<2 x i64> %x0, <8 x i16> %x1, i8 -1)
3366     %res1 = call <8 x i16> @llvm.x86.avx512.mask.pmov.qw.128(<2 x i64> %x0, <8 x i16> %x1, i8 %x2)
3367     %res2 = call <8 x i16> @llvm.x86.avx512.mask.pmov.qw.128(<2 x i64> %x0, <8 x i16> zeroinitializer, i8 %x2)
3368     %res3 = add <8 x i16> %res0, %res1
3369     %res4 = add <8 x i16> %res3, %res2
3370     ret <8 x i16> %res4
3371 }
3372
3373 declare void @llvm.x86.avx512.mask.pmov.qw.mem.128(i8* %ptr, <2 x i64>, i8)
3374
3375 define void @test_int_x86_avx512_mask_pmov_qw_mem_128(i8* %ptr, <2 x i64> %x1, i8 %x2) {
3376 ; CHECK-LABEL: test_int_x86_avx512_mask_pmov_qw_mem_128:
3377 ; CHECK:  vpmovqw %xmm0, (%rdi)
3378 ; CHECK:  vpmovqw %xmm0, (%rdi) {%k1}
3379     call void @llvm.x86.avx512.mask.pmov.qw.mem.128(i8* %ptr, <2 x i64> %x1, i8 -1)
3380     call void @llvm.x86.avx512.mask.pmov.qw.mem.128(i8* %ptr, <2 x i64> %x1, i8 %x2)
3381     ret void
3382 }
3383
3384 declare <8 x i16> @llvm.x86.avx512.mask.pmovs.qw.128(<2 x i64>, <8 x i16>, i8)
3385
3386 define <8 x i16>@test_int_x86_avx512_mask_pmovs_qw_128(<2 x i64> %x0, <8 x i16> %x1, i8 %x2) {
3387 ; CHECK-LABEL: test_int_x86_avx512_mask_pmovs_qw_128:
3388 ; CHECK:       vpmovsqw %xmm0, %xmm1 {%k1}
3389 ; CHECK-NEXT:  vpmovsqw %xmm0, %xmm2 {%k1} {z}
3390 ; CHECK-NEXT:  vpmovsqw %xmm0, %xmm0
3391     %res0 = call <8 x i16> @llvm.x86.avx512.mask.pmovs.qw.128(<2 x i64> %x0, <8 x i16> %x1, i8 -1)
3392     %res1 = call <8 x i16> @llvm.x86.avx512.mask.pmovs.qw.128(<2 x i64> %x0, <8 x i16> %x1, i8 %x2)
3393     %res2 = call <8 x i16> @llvm.x86.avx512.mask.pmovs.qw.128(<2 x i64> %x0, <8 x i16> zeroinitializer, i8 %x2)
3394     %res3 = add <8 x i16> %res0, %res1
3395     %res4 = add <8 x i16> %res3, %res2
3396     ret <8 x i16> %res4
3397 }
3398
3399 declare void @llvm.x86.avx512.mask.pmovs.qw.mem.128(i8* %ptr, <2 x i64>, i8)
3400
3401 define void @test_int_x86_avx512_mask_pmovs_qw_mem_128(i8* %ptr, <2 x i64> %x1, i8 %x2) {
3402 ; CHECK-LABEL: test_int_x86_avx512_mask_pmovs_qw_mem_128:
3403 ; CHECK:  vpmovsqw %xmm0, (%rdi)
3404 ; CHECK:  vpmovsqw %xmm0, (%rdi) {%k1}
3405     call void @llvm.x86.avx512.mask.pmovs.qw.mem.128(i8* %ptr, <2 x i64> %x1, i8 -1)
3406     call void @llvm.x86.avx512.mask.pmovs.qw.mem.128(i8* %ptr, <2 x i64> %x1, i8 %x2)
3407     ret void
3408 }
3409
3410 declare <8 x i16> @llvm.x86.avx512.mask.pmovus.qw.128(<2 x i64>, <8 x i16>, i8)
3411
3412 define <8 x i16>@test_int_x86_avx512_mask_pmovus_qw_128(<2 x i64> %x0, <8 x i16> %x1, i8 %x2) {
3413 ; CHECK-LABEL: test_int_x86_avx512_mask_pmovus_qw_128:
3414 ; CHECK:       vpmovusqw %xmm0, %xmm1 {%k1}
3415 ; CHECK-NEXT:  vpmovusqw %xmm0, %xmm2 {%k1} {z}
3416 ; CHECK-NEXT:  vpmovusqw %xmm0, %xmm0
3417     %res0 = call <8 x i16> @llvm.x86.avx512.mask.pmovus.qw.128(<2 x i64> %x0, <8 x i16> %x1, i8 -1)
3418     %res1 = call <8 x i16> @llvm.x86.avx512.mask.pmovus.qw.128(<2 x i64> %x0, <8 x i16> %x1, i8 %x2)
3419     %res2 = call <8 x i16> @llvm.x86.avx512.mask.pmovus.qw.128(<2 x i64> %x0, <8 x i16> zeroinitializer, i8 %x2)
3420     %res3 = add <8 x i16> %res0, %res1
3421     %res4 = add <8 x i16> %res3, %res2
3422     ret <8 x i16> %res4
3423 }
3424
3425 declare void @llvm.x86.avx512.mask.pmovus.qw.mem.128(i8* %ptr, <2 x i64>, i8)
3426
3427 define void @test_int_x86_avx512_mask_pmovus_qw_mem_128(i8* %ptr, <2 x i64> %x1, i8 %x2) {
3428 ; CHECK-LABEL: test_int_x86_avx512_mask_pmovus_qw_mem_128:
3429 ; CHECK:  vpmovusqw %xmm0, (%rdi)
3430 ; CHECK:  vpmovusqw %xmm0, (%rdi) {%k1}
3431     call void @llvm.x86.avx512.mask.pmovus.qw.mem.128(i8* %ptr, <2 x i64> %x1, i8 -1)
3432     call void @llvm.x86.avx512.mask.pmovus.qw.mem.128(i8* %ptr, <2 x i64> %x1, i8 %x2)
3433     ret void
3434 }
3435
3436 declare <8 x i16> @llvm.x86.avx512.mask.pmov.qw.256(<4 x i64>, <8 x i16>, i8)
3437
3438 define <8 x i16>@test_int_x86_avx512_mask_pmov_qw_256(<4 x i64> %x0, <8 x i16> %x1, i8 %x2) {
3439 ; CHECK-LABEL: test_int_x86_avx512_mask_pmov_qw_256:
3440 ; CHECK:       vpmovqw %ymm0, %xmm1 {%k1}
3441 ; CHECK-NEXT:  vpmovqw %ymm0, %xmm2 {%k1} {z}
3442 ; CHECK-NEXT:  vpmovqw %ymm0, %xmm0
3443     %res0 = call <8 x i16> @llvm.x86.avx512.mask.pmov.qw.256(<4 x i64> %x0, <8 x i16> %x1, i8 -1)
3444     %res1 = call <8 x i16> @llvm.x86.avx512.mask.pmov.qw.256(<4 x i64> %x0, <8 x i16> %x1, i8 %x2)
3445     %res2 = call <8 x i16> @llvm.x86.avx512.mask.pmov.qw.256(<4 x i64> %x0, <8 x i16> zeroinitializer, i8 %x2)
3446     %res3 = add <8 x i16> %res0, %res1
3447     %res4 = add <8 x i16> %res3, %res2
3448     ret <8 x i16> %res4
3449 }
3450
3451 declare void @llvm.x86.avx512.mask.pmov.qw.mem.256(i8* %ptr, <4 x i64>, i8)
3452
3453 define void @test_int_x86_avx512_mask_pmov_qw_mem_256(i8* %ptr, <4 x i64> %x1, i8 %x2) {
3454 ; CHECK-LABEL: test_int_x86_avx512_mask_pmov_qw_mem_256:
3455 ; CHECK:  vpmovqw %ymm0, (%rdi)
3456 ; CHECK:  vpmovqw %ymm0, (%rdi) {%k1}
3457     call void @llvm.x86.avx512.mask.pmov.qw.mem.256(i8* %ptr, <4 x i64> %x1, i8 -1)
3458     call void @llvm.x86.avx512.mask.pmov.qw.mem.256(i8* %ptr, <4 x i64> %x1, i8 %x2)
3459     ret void
3460 }
3461
3462 declare <8 x i16> @llvm.x86.avx512.mask.pmovs.qw.256(<4 x i64>, <8 x i16>, i8)
3463
3464 define <8 x i16>@test_int_x86_avx512_mask_pmovs_qw_256(<4 x i64> %x0, <8 x i16> %x1, i8 %x2) {
3465 ; CHECK-LABEL: test_int_x86_avx512_mask_pmovs_qw_256:
3466 ; CHECK:       vpmovsqw %ymm0, %xmm1 {%k1}
3467 ; CHECK-NEXT:  vpmovsqw %ymm0, %xmm2 {%k1} {z}
3468 ; CHECK-NEXT:  vpmovsqw %ymm0, %xmm0
3469     %res0 = call <8 x i16> @llvm.x86.avx512.mask.pmovs.qw.256(<4 x i64> %x0, <8 x i16> %x1, i8 -1)
3470     %res1 = call <8 x i16> @llvm.x86.avx512.mask.pmovs.qw.256(<4 x i64> %x0, <8 x i16> %x1, i8 %x2)
3471     %res2 = call <8 x i16> @llvm.x86.avx512.mask.pmovs.qw.256(<4 x i64> %x0, <8 x i16> zeroinitializer, i8 %x2)
3472     %res3 = add <8 x i16> %res0, %res1
3473     %res4 = add <8 x i16> %res3, %res2
3474     ret <8 x i16> %res4
3475 }
3476
3477 declare void @llvm.x86.avx512.mask.pmovs.qw.mem.256(i8* %ptr, <4 x i64>, i8)
3478
3479 define void @test_int_x86_avx512_mask_pmovs_qw_mem_256(i8* %ptr, <4 x i64> %x1, i8 %x2) {
3480 ; CHECK-LABEL: test_int_x86_avx512_mask_pmovs_qw_mem_256:
3481 ; CHECK:  vpmovsqw %ymm0, (%rdi)
3482 ; CHECK:  vpmovsqw %ymm0, (%rdi) {%k1}
3483     call void @llvm.x86.avx512.mask.pmovs.qw.mem.256(i8* %ptr, <4 x i64> %x1, i8 -1)
3484     call void @llvm.x86.avx512.mask.pmovs.qw.mem.256(i8* %ptr, <4 x i64> %x1, i8 %x2)
3485     ret void
3486 }
3487
3488 declare <8 x i16> @llvm.x86.avx512.mask.pmovus.qw.256(<4 x i64>, <8 x i16>, i8)
3489
3490 define <8 x i16>@test_int_x86_avx512_mask_pmovus_qw_256(<4 x i64> %x0, <8 x i16> %x1, i8 %x2) {
3491 ; CHECK-LABEL: test_int_x86_avx512_mask_pmovus_qw_256:
3492 ; CHECK:       vpmovusqw %ymm0, %xmm1 {%k1}
3493 ; CHECK-NEXT:  vpmovusqw %ymm0, %xmm2 {%k1} {z}
3494 ; CHECK-NEXT:  vpmovusqw %ymm0, %xmm0
3495     %res0 = call <8 x i16> @llvm.x86.avx512.mask.pmovus.qw.256(<4 x i64> %x0, <8 x i16> %x1, i8 -1)
3496     %res1 = call <8 x i16> @llvm.x86.avx512.mask.pmovus.qw.256(<4 x i64> %x0, <8 x i16> %x1, i8 %x2)
3497     %res2 = call <8 x i16> @llvm.x86.avx512.mask.pmovus.qw.256(<4 x i64> %x0, <8 x i16> zeroinitializer, i8 %x2)
3498     %res3 = add <8 x i16> %res0, %res1
3499     %res4 = add <8 x i16> %res3, %res2
3500     ret <8 x i16> %res4
3501 }
3502
3503 declare void @llvm.x86.avx512.mask.pmovus.qw.mem.256(i8* %ptr, <4 x i64>, i8)
3504
3505 define void @test_int_x86_avx512_mask_pmovus_qw_mem_256(i8* %ptr, <4 x i64> %x1, i8 %x2) {
3506 ; CHECK-LABEL: test_int_x86_avx512_mask_pmovus_qw_mem_256:
3507 ; CHECK:  vpmovusqw %ymm0, (%rdi)
3508 ; CHECK:  vpmovusqw %ymm0, (%rdi) {%k1}
3509     call void @llvm.x86.avx512.mask.pmovus.qw.mem.256(i8* %ptr, <4 x i64> %x1, i8 -1)
3510     call void @llvm.x86.avx512.mask.pmovus.qw.mem.256(i8* %ptr, <4 x i64> %x1, i8 %x2)
3511     ret void
3512 }
3513
3514 declare <4 x i32> @llvm.x86.avx512.mask.pmov.qd.128(<2 x i64>, <4 x i32>, i8)
3515
3516 define <4 x i32>@test_int_x86_avx512_mask_pmov_qd_128(<2 x i64> %x0, <4 x i32> %x1, i8 %x2) {
3517 ; CHECK-LABEL: test_int_x86_avx512_mask_pmov_qd_128:
3518 ; CHECK:       vpmovqd %xmm0, %xmm1 {%k1}
3519 ; CHECK-NEXT:  vpmovqd %xmm0, %xmm2 {%k1} {z}
3520 ; CHECK-NEXT:  vpmovqd %xmm0, %xmm0
3521     %res0 = call <4 x i32> @llvm.x86.avx512.mask.pmov.qd.128(<2 x i64> %x0, <4 x i32> %x1, i8 -1)
3522     %res1 = call <4 x i32> @llvm.x86.avx512.mask.pmov.qd.128(<2 x i64> %x0, <4 x i32> %x1, i8 %x2)
3523     %res2 = call <4 x i32> @llvm.x86.avx512.mask.pmov.qd.128(<2 x i64> %x0, <4 x i32> zeroinitializer, i8 %x2)
3524     %res3 = add <4 x i32> %res0, %res1
3525     %res4 = add <4 x i32> %res3, %res2
3526     ret <4 x i32> %res4
3527 }
3528
3529 declare void @llvm.x86.avx512.mask.pmov.qd.mem.128(i8* %ptr, <2 x i64>, i8)
3530
3531 define void @test_int_x86_avx512_mask_pmov_qd_mem_128(i8* %ptr, <2 x i64> %x1, i8 %x2) {
3532 ; CHECK-LABEL: test_int_x86_avx512_mask_pmov_qd_mem_128:
3533 ; CHECK:  vpmovqd %xmm0, (%rdi)
3534 ; CHECK:  vpmovqd %xmm0, (%rdi) {%k1}
3535     call void @llvm.x86.avx512.mask.pmov.qd.mem.128(i8* %ptr, <2 x i64> %x1, i8 -1)
3536     call void @llvm.x86.avx512.mask.pmov.qd.mem.128(i8* %ptr, <2 x i64> %x1, i8 %x2)
3537     ret void
3538 }
3539
3540 declare <4 x i32> @llvm.x86.avx512.mask.pmovs.qd.128(<2 x i64>, <4 x i32>, i8)
3541
3542 define <4 x i32>@test_int_x86_avx512_mask_pmovs_qd_128(<2 x i64> %x0, <4 x i32> %x1, i8 %x2) {
3543 ; CHECK-LABEL: test_int_x86_avx512_mask_pmovs_qd_128:
3544 ; CHECK:       vpmovsqd %xmm0, %xmm1 {%k1}
3545 ; CHECK-NEXT:  vpmovsqd %xmm0, %xmm2 {%k1} {z}
3546 ; CHECK-NEXT:  vpmovsqd %xmm0, %xmm0
3547     %res0 = call <4 x i32> @llvm.x86.avx512.mask.pmovs.qd.128(<2 x i64> %x0, <4 x i32> %x1, i8 -1)
3548     %res1 = call <4 x i32> @llvm.x86.avx512.mask.pmovs.qd.128(<2 x i64> %x0, <4 x i32> %x1, i8 %x2)
3549     %res2 = call <4 x i32> @llvm.x86.avx512.mask.pmovs.qd.128(<2 x i64> %x0, <4 x i32> zeroinitializer, i8 %x2)
3550     %res3 = add <4 x i32> %res0, %res1
3551     %res4 = add <4 x i32> %res3, %res2
3552     ret <4 x i32> %res4
3553 }
3554
3555 declare void @llvm.x86.avx512.mask.pmovs.qd.mem.128(i8* %ptr, <2 x i64>, i8)
3556
3557 define void @test_int_x86_avx512_mask_pmovs_qd_mem_128(i8* %ptr, <2 x i64> %x1, i8 %x2) {
3558 ; CHECK-LABEL: test_int_x86_avx512_mask_pmovs_qd_mem_128:
3559 ; CHECK:  vpmovsqd %xmm0, (%rdi)
3560 ; CHECK:  vpmovsqd %xmm0, (%rdi) {%k1}
3561     call void @llvm.x86.avx512.mask.pmovs.qd.mem.128(i8* %ptr, <2 x i64> %x1, i8 -1)
3562     call void @llvm.x86.avx512.mask.pmovs.qd.mem.128(i8* %ptr, <2 x i64> %x1, i8 %x2)
3563     ret void
3564 }
3565
3566 declare <4 x i32> @llvm.x86.avx512.mask.pmovus.qd.128(<2 x i64>, <4 x i32>, i8)
3567
3568 define <4 x i32>@test_int_x86_avx512_mask_pmovus_qd_128(<2 x i64> %x0, <4 x i32> %x1, i8 %x2) {
3569 ; CHECK-LABEL: test_int_x86_avx512_mask_pmovus_qd_128:
3570 ; CHECK:       vpmovusqd %xmm0, %xmm1 {%k1}
3571 ; CHECK-NEXT:  vpmovusqd %xmm0, %xmm2 {%k1} {z}
3572 ; CHECK-NEXT:  vpmovusqd %xmm0, %xmm0
3573     %res0 = call <4 x i32> @llvm.x86.avx512.mask.pmovus.qd.128(<2 x i64> %x0, <4 x i32> %x1, i8 -1)
3574     %res1 = call <4 x i32> @llvm.x86.avx512.mask.pmovus.qd.128(<2 x i64> %x0, <4 x i32> %x1, i8 %x2)
3575     %res2 = call <4 x i32> @llvm.x86.avx512.mask.pmovus.qd.128(<2 x i64> %x0, <4 x i32> zeroinitializer, i8 %x2)
3576     %res3 = add <4 x i32> %res0, %res1
3577     %res4 = add <4 x i32> %res3, %res2
3578     ret <4 x i32> %res4
3579 }
3580
3581 declare void @llvm.x86.avx512.mask.pmovus.qd.mem.128(i8* %ptr, <2 x i64>, i8)
3582
3583 define void @test_int_x86_avx512_mask_pmovus_qd_mem_128(i8* %ptr, <2 x i64> %x1, i8 %x2) {
3584 ; CHECK-LABEL: test_int_x86_avx512_mask_pmovus_qd_mem_128:
3585 ; CHECK:  vpmovusqd %xmm0, (%rdi)
3586 ; CHECK:  vpmovusqd %xmm0, (%rdi) {%k1}
3587     call void @llvm.x86.avx512.mask.pmovus.qd.mem.128(i8* %ptr, <2 x i64> %x1, i8 -1)
3588     call void @llvm.x86.avx512.mask.pmovus.qd.mem.128(i8* %ptr, <2 x i64> %x1, i8 %x2)
3589     ret void
3590 }
3591
3592 declare <4 x i32> @llvm.x86.avx512.mask.pmov.qd.256(<4 x i64>, <4 x i32>, i8)
3593
3594 define <4 x i32>@test_int_x86_avx512_mask_pmov_qd_256(<4 x i64> %x0, <4 x i32> %x1, i8 %x2) {
3595 ; CHECK-LABEL: test_int_x86_avx512_mask_pmov_qd_256:
3596 ; CHECK:       vpmovqd %ymm0, %xmm1 {%k1}
3597 ; CHECK-NEXT:  vpmovqd %ymm0, %xmm2 {%k1} {z}
3598 ; CHECK-NEXT:  vpmovqd %ymm0, %xmm0
3599     %res0 = call <4 x i32> @llvm.x86.avx512.mask.pmov.qd.256(<4 x i64> %x0, <4 x i32> %x1, i8 -1)
3600     %res1 = call <4 x i32> @llvm.x86.avx512.mask.pmov.qd.256(<4 x i64> %x0, <4 x i32> %x1, i8 %x2)
3601     %res2 = call <4 x i32> @llvm.x86.avx512.mask.pmov.qd.256(<4 x i64> %x0, <4 x i32> zeroinitializer, i8 %x2)
3602     %res3 = add <4 x i32> %res0, %res1
3603     %res4 = add <4 x i32> %res3, %res2
3604     ret <4 x i32> %res4
3605 }
3606
3607 declare void @llvm.x86.avx512.mask.pmov.qd.mem.256(i8* %ptr, <4 x i64>, i8)
3608
3609 define void @test_int_x86_avx512_mask_pmov_qd_mem_256(i8* %ptr, <4 x i64> %x1, i8 %x2) {
3610 ; CHECK-LABEL: test_int_x86_avx512_mask_pmov_qd_mem_256:
3611 ; CHECK:  vpmovqd %ymm0, (%rdi)
3612 ; CHECK:  vpmovqd %ymm0, (%rdi) {%k1}
3613     call void @llvm.x86.avx512.mask.pmov.qd.mem.256(i8* %ptr, <4 x i64> %x1, i8 -1)
3614     call void @llvm.x86.avx512.mask.pmov.qd.mem.256(i8* %ptr, <4 x i64> %x1, i8 %x2)
3615     ret void
3616 }
3617
3618 declare <4 x i32> @llvm.x86.avx512.mask.pmovs.qd.256(<4 x i64>, <4 x i32>, i8)
3619
3620 define <4 x i32>@test_int_x86_avx512_mask_pmovs_qd_256(<4 x i64> %x0, <4 x i32> %x1, i8 %x2) {
3621 ; CHECK-LABEL: test_int_x86_avx512_mask_pmovs_qd_256:
3622 ; CHECK:       vpmovsqd %ymm0, %xmm1 {%k1}
3623 ; CHECK-NEXT:  vpmovsqd %ymm0, %xmm2 {%k1} {z}
3624 ; CHECK-NEXT:  vpmovsqd %ymm0, %xmm0
3625     %res0 = call <4 x i32> @llvm.x86.avx512.mask.pmovs.qd.256(<4 x i64> %x0, <4 x i32> %x1, i8 -1)
3626     %res1 = call <4 x i32> @llvm.x86.avx512.mask.pmovs.qd.256(<4 x i64> %x0, <4 x i32> %x1, i8 %x2)
3627     %res2 = call <4 x i32> @llvm.x86.avx512.mask.pmovs.qd.256(<4 x i64> %x0, <4 x i32> zeroinitializer, i8 %x2)
3628     %res3 = add <4 x i32> %res0, %res1
3629     %res4 = add <4 x i32> %res3, %res2
3630     ret <4 x i32> %res4
3631 }
3632
3633 declare void @llvm.x86.avx512.mask.pmovs.qd.mem.256(i8* %ptr, <4 x i64>, i8)
3634
3635 define void @test_int_x86_avx512_mask_pmovs_qd_mem_256(i8* %ptr, <4 x i64> %x1, i8 %x2) {
3636 ; CHECK-LABEL: test_int_x86_avx512_mask_pmovs_qd_mem_256:
3637 ; CHECK:  vpmovsqd %ymm0, (%rdi)
3638 ; CHECK:  vpmovsqd %ymm0, (%rdi) {%k1}
3639     call void @llvm.x86.avx512.mask.pmovs.qd.mem.256(i8* %ptr, <4 x i64> %x1, i8 -1)
3640     call void @llvm.x86.avx512.mask.pmovs.qd.mem.256(i8* %ptr, <4 x i64> %x1, i8 %x2)
3641     ret void
3642 }
3643
3644 declare <4 x i32> @llvm.x86.avx512.mask.pmovus.qd.256(<4 x i64>, <4 x i32>, i8)
3645
3646 define <4 x i32>@test_int_x86_avx512_mask_pmovus_qd_256(<4 x i64> %x0, <4 x i32> %x1, i8 %x2) {
3647 ; CHECK-LABEL: test_int_x86_avx512_mask_pmovus_qd_256:
3648 ; CHECK:       vpmovusqd %ymm0, %xmm1 {%k1}
3649 ; CHECK-NEXT:  vpmovusqd %ymm0, %xmm2 {%k1} {z}
3650 ; CHECK-NEXT:  vpmovusqd %ymm0, %xmm0
3651     %res0 = call <4 x i32> @llvm.x86.avx512.mask.pmovus.qd.256(<4 x i64> %x0, <4 x i32> %x1, i8 -1)
3652     %res1 = call <4 x i32> @llvm.x86.avx512.mask.pmovus.qd.256(<4 x i64> %x0, <4 x i32> %x1, i8 %x2)
3653     %res2 = call <4 x i32> @llvm.x86.avx512.mask.pmovus.qd.256(<4 x i64> %x0, <4 x i32> zeroinitializer, i8 %x2)
3654     %res3 = add <4 x i32> %res0, %res1
3655     %res4 = add <4 x i32> %res3, %res2
3656     ret <4 x i32> %res4
3657 }
3658
3659 declare void @llvm.x86.avx512.mask.pmovus.qd.mem.256(i8* %ptr, <4 x i64>, i8)
3660
3661 define void @test_int_x86_avx512_mask_pmovus_qd_mem_256(i8* %ptr, <4 x i64> %x1, i8 %x2) {
3662 ; CHECK-LABEL: test_int_x86_avx512_mask_pmovus_qd_mem_256:
3663 ; CHECK:  vpmovusqd %ymm0, (%rdi)
3664 ; CHECK:  vpmovusqd %ymm0, (%rdi) {%k1}
3665     call void @llvm.x86.avx512.mask.pmovus.qd.mem.256(i8* %ptr, <4 x i64> %x1, i8 -1)
3666     call void @llvm.x86.avx512.mask.pmovus.qd.mem.256(i8* %ptr, <4 x i64> %x1, i8 %x2)
3667     ret void
3668 }
3669
3670 declare <16 x i8> @llvm.x86.avx512.mask.pmov.db.128(<4 x i32>, <16 x i8>, i8)
3671
3672 define <16 x i8>@test_int_x86_avx512_mask_pmov_db_128(<4 x i32> %x0, <16 x i8> %x1, i8 %x2) {
3673 ; CHECK-LABEL: test_int_x86_avx512_mask_pmov_db_128:
3674 ; CHECK:       vpmovdb %xmm0, %xmm1 {%k1}
3675 ; CHECK-NEXT:  vpmovdb %xmm0, %xmm2 {%k1} {z}
3676 ; CHECK-NEXT:  vpmovdb %xmm0, %xmm0
3677     %res0 = call <16 x i8> @llvm.x86.avx512.mask.pmov.db.128(<4 x i32> %x0, <16 x i8> %x1, i8 -1)
3678     %res1 = call <16 x i8> @llvm.x86.avx512.mask.pmov.db.128(<4 x i32> %x0, <16 x i8> %x1, i8 %x2)
3679     %res2 = call <16 x i8> @llvm.x86.avx512.mask.pmov.db.128(<4 x i32> %x0, <16 x i8> zeroinitializer, i8 %x2)
3680     %res3 = add <16 x i8> %res0, %res1
3681     %res4 = add <16 x i8> %res3, %res2
3682     ret <16 x i8> %res4
3683 }
3684
3685 declare void @llvm.x86.avx512.mask.pmov.db.mem.128(i8* %ptr, <4 x i32>, i8)
3686
3687 define void @test_int_x86_avx512_mask_pmov_db_mem_128(i8* %ptr, <4 x i32> %x1, i8 %x2) {
3688 ; CHECK-LABEL: test_int_x86_avx512_mask_pmov_db_mem_128:
3689 ; CHECK:  vpmovdb %xmm0, (%rdi)
3690 ; CHECK:  vpmovdb %xmm0, (%rdi) {%k1}
3691     call void @llvm.x86.avx512.mask.pmov.db.mem.128(i8* %ptr, <4 x i32> %x1, i8 -1)
3692     call void @llvm.x86.avx512.mask.pmov.db.mem.128(i8* %ptr, <4 x i32> %x1, i8 %x2)
3693     ret void
3694 }
3695
3696 declare <16 x i8> @llvm.x86.avx512.mask.pmovs.db.128(<4 x i32>, <16 x i8>, i8)
3697
3698 define <16 x i8>@test_int_x86_avx512_mask_pmovs_db_128(<4 x i32> %x0, <16 x i8> %x1, i8 %x2) {
3699 ; CHECK-LABEL: test_int_x86_avx512_mask_pmovs_db_128:
3700 ; CHECK:       vpmovsdb %xmm0, %xmm1 {%k1}
3701 ; CHECK-NEXT:  vpmovsdb %xmm0, %xmm2 {%k1} {z}
3702 ; CHECK-NEXT:  vpmovsdb %xmm0, %xmm0
3703     %res0 = call <16 x i8> @llvm.x86.avx512.mask.pmovs.db.128(<4 x i32> %x0, <16 x i8> %x1, i8 -1)
3704     %res1 = call <16 x i8> @llvm.x86.avx512.mask.pmovs.db.128(<4 x i32> %x0, <16 x i8> %x1, i8 %x2)
3705     %res2 = call <16 x i8> @llvm.x86.avx512.mask.pmovs.db.128(<4 x i32> %x0, <16 x i8> zeroinitializer, i8 %x2)
3706     %res3 = add <16 x i8> %res0, %res1
3707     %res4 = add <16 x i8> %res3, %res2
3708     ret <16 x i8> %res4
3709 }
3710
3711 declare void @llvm.x86.avx512.mask.pmovs.db.mem.128(i8* %ptr, <4 x i32>, i8)
3712
3713 define void @test_int_x86_avx512_mask_pmovs_db_mem_128(i8* %ptr, <4 x i32> %x1, i8 %x2) {
3714 ; CHECK-LABEL: test_int_x86_avx512_mask_pmovs_db_mem_128:
3715 ; CHECK:  vpmovsdb %xmm0, (%rdi)
3716 ; CHECK:  vpmovsdb %xmm0, (%rdi) {%k1}
3717     call void @llvm.x86.avx512.mask.pmovs.db.mem.128(i8* %ptr, <4 x i32> %x1, i8 -1)
3718     call void @llvm.x86.avx512.mask.pmovs.db.mem.128(i8* %ptr, <4 x i32> %x1, i8 %x2)
3719     ret void
3720 }
3721
3722 declare <16 x i8> @llvm.x86.avx512.mask.pmovus.db.128(<4 x i32>, <16 x i8>, i8)
3723
3724 define <16 x i8>@test_int_x86_avx512_mask_pmovus_db_128(<4 x i32> %x0, <16 x i8> %x1, i8 %x2) {
3725 ; CHECK-LABEL: test_int_x86_avx512_mask_pmovus_db_128:
3726 ; CHECK:       vpmovusdb %xmm0, %xmm1 {%k1}
3727 ; CHECK-NEXT:  vpmovusdb %xmm0, %xmm2 {%k1} {z}
3728 ; CHECK-NEXT:  vpmovusdb %xmm0, %xmm0
3729     %res0 = call <16 x i8> @llvm.x86.avx512.mask.pmovus.db.128(<4 x i32> %x0, <16 x i8> %x1, i8 -1)
3730     %res1 = call <16 x i8> @llvm.x86.avx512.mask.pmovus.db.128(<4 x i32> %x0, <16 x i8> %x1, i8 %x2)
3731     %res2 = call <16 x i8> @llvm.x86.avx512.mask.pmovus.db.128(<4 x i32> %x0, <16 x i8> zeroinitializer, i8 %x2)
3732     %res3 = add <16 x i8> %res0, %res1
3733     %res4 = add <16 x i8> %res3, %res2
3734     ret <16 x i8> %res4
3735 }
3736
3737 declare void @llvm.x86.avx512.mask.pmovus.db.mem.128(i8* %ptr, <4 x i32>, i8)
3738
3739 define void @test_int_x86_avx512_mask_pmovus_db_mem_128(i8* %ptr, <4 x i32> %x1, i8 %x2) {
3740 ; CHECK-LABEL: test_int_x86_avx512_mask_pmovus_db_mem_128:
3741 ; CHECK:  vpmovusdb %xmm0, (%rdi)
3742 ; CHECK:  vpmovusdb %xmm0, (%rdi) {%k1}
3743     call void @llvm.x86.avx512.mask.pmovus.db.mem.128(i8* %ptr, <4 x i32> %x1, i8 -1)
3744     call void @llvm.x86.avx512.mask.pmovus.db.mem.128(i8* %ptr, <4 x i32> %x1, i8 %x2)
3745     ret void
3746 }
3747
3748 declare <16 x i8> @llvm.x86.avx512.mask.pmov.db.256(<8 x i32>, <16 x i8>, i8)
3749
3750 define <16 x i8>@test_int_x86_avx512_mask_pmov_db_256(<8 x i32> %x0, <16 x i8> %x1, i8 %x2) {
3751 ; CHECK-LABEL: test_int_x86_avx512_mask_pmov_db_256:
3752 ; CHECK:       vpmovdb %ymm0, %xmm1 {%k1}
3753 ; CHECK-NEXT:  vpmovdb %ymm0, %xmm2 {%k1} {z}
3754 ; CHECK-NEXT:  vpmovdb %ymm0, %xmm0
3755     %res0 = call <16 x i8> @llvm.x86.avx512.mask.pmov.db.256(<8 x i32> %x0, <16 x i8> %x1, i8 -1)
3756     %res1 = call <16 x i8> @llvm.x86.avx512.mask.pmov.db.256(<8 x i32> %x0, <16 x i8> %x1, i8 %x2)
3757     %res2 = call <16 x i8> @llvm.x86.avx512.mask.pmov.db.256(<8 x i32> %x0, <16 x i8> zeroinitializer, i8 %x2)
3758     %res3 = add <16 x i8> %res0, %res1
3759     %res4 = add <16 x i8> %res3, %res2
3760     ret <16 x i8> %res4
3761 }
3762
3763 declare void @llvm.x86.avx512.mask.pmov.db.mem.256(i8* %ptr, <8 x i32>, i8)
3764
3765 define void @test_int_x86_avx512_mask_pmov_db_mem_256(i8* %ptr, <8 x i32> %x1, i8 %x2) {
3766 ; CHECK-LABEL: test_int_x86_avx512_mask_pmov_db_mem_256:
3767 ; CHECK:  vpmovdb %ymm0, (%rdi)
3768 ; CHECK:  vpmovdb %ymm0, (%rdi) {%k1}
3769     call void @llvm.x86.avx512.mask.pmov.db.mem.256(i8* %ptr, <8 x i32> %x1, i8 -1)
3770     call void @llvm.x86.avx512.mask.pmov.db.mem.256(i8* %ptr, <8 x i32> %x1, i8 %x2)
3771     ret void
3772 }
3773
3774 declare <16 x i8> @llvm.x86.avx512.mask.pmovs.db.256(<8 x i32>, <16 x i8>, i8)
3775
3776 define <16 x i8>@test_int_x86_avx512_mask_pmovs_db_256(<8 x i32> %x0, <16 x i8> %x1, i8 %x2) {
3777 ; CHECK-LABEL: test_int_x86_avx512_mask_pmovs_db_256:
3778 ; CHECK:       vpmovsdb %ymm0, %xmm1 {%k1}
3779 ; CHECK-NEXT:  vpmovsdb %ymm0, %xmm2 {%k1} {z}
3780 ; CHECK-NEXT:  vpmovsdb %ymm0, %xmm0
3781     %res0 = call <16 x i8> @llvm.x86.avx512.mask.pmovs.db.256(<8 x i32> %x0, <16 x i8> %x1, i8 -1)
3782     %res1 = call <16 x i8> @llvm.x86.avx512.mask.pmovs.db.256(<8 x i32> %x0, <16 x i8> %x1, i8 %x2)
3783     %res2 = call <16 x i8> @llvm.x86.avx512.mask.pmovs.db.256(<8 x i32> %x0, <16 x i8> zeroinitializer, i8 %x2)
3784     %res3 = add <16 x i8> %res0, %res1
3785     %res4 = add <16 x i8> %res3, %res2
3786     ret <16 x i8> %res4
3787 }
3788
3789 declare void @llvm.x86.avx512.mask.pmovs.db.mem.256(i8* %ptr, <8 x i32>, i8)
3790
3791 define void @test_int_x86_avx512_mask_pmovs_db_mem_256(i8* %ptr, <8 x i32> %x1, i8 %x2) {
3792 ; CHECK-LABEL: test_int_x86_avx512_mask_pmovs_db_mem_256:
3793 ; CHECK:  vpmovsdb %ymm0, (%rdi)
3794 ; CHECK:  vpmovsdb %ymm0, (%rdi) {%k1}
3795     call void @llvm.x86.avx512.mask.pmovs.db.mem.256(i8* %ptr, <8 x i32> %x1, i8 -1)
3796     call void @llvm.x86.avx512.mask.pmovs.db.mem.256(i8* %ptr, <8 x i32> %x1, i8 %x2)
3797     ret void
3798 }
3799
3800 declare <16 x i8> @llvm.x86.avx512.mask.pmovus.db.256(<8 x i32>, <16 x i8>, i8)
3801
3802 define <16 x i8>@test_int_x86_avx512_mask_pmovus_db_256(<8 x i32> %x0, <16 x i8> %x1, i8 %x2) {
3803 ; CHECK-LABEL: test_int_x86_avx512_mask_pmovus_db_256:
3804 ; CHECK:       vpmovusdb %ymm0, %xmm1 {%k1}
3805 ; CHECK-NEXT:  vpmovusdb %ymm0, %xmm2 {%k1} {z}
3806 ; CHECK-NEXT:  vpmovusdb %ymm0, %xmm0
3807     %res0 = call <16 x i8> @llvm.x86.avx512.mask.pmovus.db.256(<8 x i32> %x0, <16 x i8> %x1, i8 -1)
3808     %res1 = call <16 x i8> @llvm.x86.avx512.mask.pmovus.db.256(<8 x i32> %x0, <16 x i8> %x1, i8 %x2)
3809     %res2 = call <16 x i8> @llvm.x86.avx512.mask.pmovus.db.256(<8 x i32> %x0, <16 x i8> zeroinitializer, i8 %x2)
3810     %res3 = add <16 x i8> %res0, %res1
3811     %res4 = add <16 x i8> %res3, %res2
3812     ret <16 x i8> %res4
3813 }
3814
3815 declare void @llvm.x86.avx512.mask.pmovus.db.mem.256(i8* %ptr, <8 x i32>, i8)
3816
3817 define void @test_int_x86_avx512_mask_pmovus_db_mem_256(i8* %ptr, <8 x i32> %x1, i8 %x2) {
3818 ; CHECK-LABEL: test_int_x86_avx512_mask_pmovus_db_mem_256:
3819 ; CHECK:  vpmovusdb %ymm0, (%rdi)
3820 ; CHECK:  vpmovusdb %ymm0, (%rdi) {%k1}
3821     call void @llvm.x86.avx512.mask.pmovus.db.mem.256(i8* %ptr, <8 x i32> %x1, i8 -1)
3822     call void @llvm.x86.avx512.mask.pmovus.db.mem.256(i8* %ptr, <8 x i32> %x1, i8 %x2)
3823     ret void
3824 }
3825
3826 declare <8 x i16> @llvm.x86.avx512.mask.pmov.dw.128(<4 x i32>, <8 x i16>, i8)
3827
3828 define <8 x i16>@test_int_x86_avx512_mask_pmov_dw_128(<4 x i32> %x0, <8 x i16> %x1, i8 %x2) {
3829 ; CHECK-LABEL: test_int_x86_avx512_mask_pmov_dw_128:
3830 ; CHECK:       vpmovdw %xmm0, %xmm1 {%k1}
3831 ; CHECK-NEXT:  vpmovdw %xmm0, %xmm2 {%k1} {z}
3832 ; CHECK-NEXT:  vpmovdw %xmm0, %xmm0
3833     %res0 = call <8 x i16> @llvm.x86.avx512.mask.pmov.dw.128(<4 x i32> %x0, <8 x i16> %x1, i8 -1)
3834     %res1 = call <8 x i16> @llvm.x86.avx512.mask.pmov.dw.128(<4 x i32> %x0, <8 x i16> %x1, i8 %x2)
3835     %res2 = call <8 x i16> @llvm.x86.avx512.mask.pmov.dw.128(<4 x i32> %x0, <8 x i16> zeroinitializer, i8 %x2)
3836     %res3 = add <8 x i16> %res0, %res1
3837     %res4 = add <8 x i16> %res3, %res2
3838     ret <8 x i16> %res4
3839 }
3840
3841 declare void @llvm.x86.avx512.mask.pmov.dw.mem.128(i8* %ptr, <4 x i32>, i8)
3842
3843 define void @test_int_x86_avx512_mask_pmov_dw_mem_128(i8* %ptr, <4 x i32> %x1, i8 %x2) {
3844 ; CHECK-LABEL: test_int_x86_avx512_mask_pmov_dw_mem_128:
3845 ; CHECK:  vpmovdw %xmm0, (%rdi)
3846 ; CHECK:  vpmovdw %xmm0, (%rdi) {%k1}
3847     call void @llvm.x86.avx512.mask.pmov.dw.mem.128(i8* %ptr, <4 x i32> %x1, i8 -1)
3848     call void @llvm.x86.avx512.mask.pmov.dw.mem.128(i8* %ptr, <4 x i32> %x1, i8 %x2)
3849     ret void
3850 }
3851
3852 declare <8 x i16> @llvm.x86.avx512.mask.pmovs.dw.128(<4 x i32>, <8 x i16>, i8)
3853
3854 define <8 x i16>@test_int_x86_avx512_mask_pmovs_dw_128(<4 x i32> %x0, <8 x i16> %x1, i8 %x2) {
3855 ; CHECK-LABEL: test_int_x86_avx512_mask_pmovs_dw_128:
3856 ; CHECK:       vpmovsdw %xmm0, %xmm1 {%k1}
3857 ; CHECK-NEXT:  vpmovsdw %xmm0, %xmm2 {%k1} {z}
3858 ; CHECK-NEXT:  vpmovsdw %xmm0, %xmm0
3859     %res0 = call <8 x i16> @llvm.x86.avx512.mask.pmovs.dw.128(<4 x i32> %x0, <8 x i16> %x1, i8 -1)
3860     %res1 = call <8 x i16> @llvm.x86.avx512.mask.pmovs.dw.128(<4 x i32> %x0, <8 x i16> %x1, i8 %x2)
3861     %res2 = call <8 x i16> @llvm.x86.avx512.mask.pmovs.dw.128(<4 x i32> %x0, <8 x i16> zeroinitializer, i8 %x2)
3862     %res3 = add <8 x i16> %res0, %res1
3863     %res4 = add <8 x i16> %res3, %res2
3864     ret <8 x i16> %res4
3865 }
3866
3867 declare void @llvm.x86.avx512.mask.pmovs.dw.mem.128(i8* %ptr, <4 x i32>, i8)
3868
3869 define void @test_int_x86_avx512_mask_pmovs_dw_mem_128(i8* %ptr, <4 x i32> %x1, i8 %x2) {
3870 ; CHECK-LABEL: test_int_x86_avx512_mask_pmovs_dw_mem_128:
3871 ; CHECK:  vpmovsdw %xmm0, (%rdi)
3872 ; CHECK:  vpmovsdw %xmm0, (%rdi) {%k1}
3873     call void @llvm.x86.avx512.mask.pmovs.dw.mem.128(i8* %ptr, <4 x i32> %x1, i8 -1)
3874     call void @llvm.x86.avx512.mask.pmovs.dw.mem.128(i8* %ptr, <4 x i32> %x1, i8 %x2)
3875     ret void
3876 }
3877
3878 declare <8 x i16> @llvm.x86.avx512.mask.pmovus.dw.128(<4 x i32>, <8 x i16>, i8)
3879
3880 define <8 x i16>@test_int_x86_avx512_mask_pmovus_dw_128(<4 x i32> %x0, <8 x i16> %x1, i8 %x2) {
3881 ; CHECK-LABEL: test_int_x86_avx512_mask_pmovus_dw_128:
3882 ; CHECK:       vpmovusdw %xmm0, %xmm1 {%k1}
3883 ; CHECK-NEXT:  vpmovusdw %xmm0, %xmm2 {%k1} {z}
3884 ; CHECK-NEXT:  vpmovusdw %xmm0, %xmm0
3885     %res0 = call <8 x i16> @llvm.x86.avx512.mask.pmovus.dw.128(<4 x i32> %x0, <8 x i16> %x1, i8 -1)
3886     %res1 = call <8 x i16> @llvm.x86.avx512.mask.pmovus.dw.128(<4 x i32> %x0, <8 x i16> %x1, i8 %x2)
3887     %res2 = call <8 x i16> @llvm.x86.avx512.mask.pmovus.dw.128(<4 x i32> %x0, <8 x i16> zeroinitializer, i8 %x2)
3888     %res3 = add <8 x i16> %res0, %res1
3889     %res4 = add <8 x i16> %res3, %res2
3890     ret <8 x i16> %res4
3891 }
3892
3893 declare void @llvm.x86.avx512.mask.pmovus.dw.mem.128(i8* %ptr, <4 x i32>, i8)
3894
3895 define void @test_int_x86_avx512_mask_pmovus_dw_mem_128(i8* %ptr, <4 x i32> %x1, i8 %x2) {
3896 ; CHECK-LABEL: test_int_x86_avx512_mask_pmovus_dw_mem_128:
3897 ; CHECK:  vpmovusdw %xmm0, (%rdi)
3898 ; CHECK:  vpmovusdw %xmm0, (%rdi) {%k1}
3899     call void @llvm.x86.avx512.mask.pmovus.dw.mem.128(i8* %ptr, <4 x i32> %x1, i8 -1)
3900     call void @llvm.x86.avx512.mask.pmovus.dw.mem.128(i8* %ptr, <4 x i32> %x1, i8 %x2)
3901     ret void
3902 }
3903
3904 declare <8 x i16> @llvm.x86.avx512.mask.pmov.dw.256(<8 x i32>, <8 x i16>, i8)
3905
3906 define <8 x i16>@test_int_x86_avx512_mask_pmov_dw_256(<8 x i32> %x0, <8 x i16> %x1, i8 %x2) {
3907 ; CHECK-LABEL: test_int_x86_avx512_mask_pmov_dw_256:
3908 ; CHECK:       vpmovdw %ymm0, %xmm1 {%k1}
3909 ; CHECK-NEXT:  vpmovdw %ymm0, %xmm2 {%k1} {z}
3910 ; CHECK-NEXT:  vpmovdw %ymm0, %xmm0
3911     %res0 = call <8 x i16> @llvm.x86.avx512.mask.pmov.dw.256(<8 x i32> %x0, <8 x i16> %x1, i8 -1)
3912     %res1 = call <8 x i16> @llvm.x86.avx512.mask.pmov.dw.256(<8 x i32> %x0, <8 x i16> %x1, i8 %x2)
3913     %res2 = call <8 x i16> @llvm.x86.avx512.mask.pmov.dw.256(<8 x i32> %x0, <8 x i16> zeroinitializer, i8 %x2)
3914     %res3 = add <8 x i16> %res0, %res1
3915     %res4 = add <8 x i16> %res3, %res2
3916     ret <8 x i16> %res4
3917 }
3918
3919 declare void @llvm.x86.avx512.mask.pmov.dw.mem.256(i8* %ptr, <8 x i32>, i8)
3920
3921 define void @test_int_x86_avx512_mask_pmov_dw_mem_256(i8* %ptr, <8 x i32> %x1, i8 %x2) {
3922 ; CHECK-LABEL: test_int_x86_avx512_mask_pmov_dw_mem_256:
3923 ; CHECK:  vpmovdw %ymm0, (%rdi)
3924 ; CHECK:  vpmovdw %ymm0, (%rdi) {%k1}
3925     call void @llvm.x86.avx512.mask.pmov.dw.mem.256(i8* %ptr, <8 x i32> %x1, i8 -1)
3926     call void @llvm.x86.avx512.mask.pmov.dw.mem.256(i8* %ptr, <8 x i32> %x1, i8 %x2)
3927     ret void
3928 }
3929
3930 declare <8 x i16> @llvm.x86.avx512.mask.pmovs.dw.256(<8 x i32>, <8 x i16>, i8)
3931
3932 define <8 x i16>@test_int_x86_avx512_mask_pmovs_dw_256(<8 x i32> %x0, <8 x i16> %x1, i8 %x2) {
3933 ; CHECK-LABEL: test_int_x86_avx512_mask_pmovs_dw_256:
3934 ; CHECK:       vpmovsdw %ymm0, %xmm1 {%k1}
3935 ; CHECK-NEXT:  vpmovsdw %ymm0, %xmm2 {%k1} {z}
3936 ; CHECK-NEXT:  vpmovsdw %ymm0, %xmm0
3937     %res0 = call <8 x i16> @llvm.x86.avx512.mask.pmovs.dw.256(<8 x i32> %x0, <8 x i16> %x1, i8 -1)
3938     %res1 = call <8 x i16> @llvm.x86.avx512.mask.pmovs.dw.256(<8 x i32> %x0, <8 x i16> %x1, i8 %x2)
3939     %res2 = call <8 x i16> @llvm.x86.avx512.mask.pmovs.dw.256(<8 x i32> %x0, <8 x i16> zeroinitializer, i8 %x2)
3940     %res3 = add <8 x i16> %res0, %res1
3941     %res4 = add <8 x i16> %res3, %res2
3942     ret <8 x i16> %res4
3943 }
3944
3945 declare void @llvm.x86.avx512.mask.pmovs.dw.mem.256(i8* %ptr, <8 x i32>, i8)
3946
3947 define void @test_int_x86_avx512_mask_pmovs_dw_mem_256(i8* %ptr, <8 x i32> %x1, i8 %x2) {
3948 ; CHECK-LABEL: test_int_x86_avx512_mask_pmovs_dw_mem_256:
3949 ; CHECK:  vpmovsdw %ymm0, (%rdi)
3950 ; CHECK:  vpmovsdw %ymm0, (%rdi) {%k1}
3951     call void @llvm.x86.avx512.mask.pmovs.dw.mem.256(i8* %ptr, <8 x i32> %x1, i8 -1)
3952     call void @llvm.x86.avx512.mask.pmovs.dw.mem.256(i8* %ptr, <8 x i32> %x1, i8 %x2)
3953     ret void
3954 }
3955
3956 declare <8 x i16> @llvm.x86.avx512.mask.pmovus.dw.256(<8 x i32>, <8 x i16>, i8)
3957
3958 define <8 x i16>@test_int_x86_avx512_mask_pmovus_dw_256(<8 x i32> %x0, <8 x i16> %x1, i8 %x2) {
3959 ; CHECK-LABEL: test_int_x86_avx512_mask_pmovus_dw_256:
3960 ; CHECK:       vpmovusdw %ymm0, %xmm1 {%k1}
3961 ; CHECK-NEXT:  vpmovusdw %ymm0, %xmm2 {%k1} {z}
3962 ; CHECK-NEXT:  vpmovusdw %ymm0, %xmm0
3963     %res0 = call <8 x i16> @llvm.x86.avx512.mask.pmovus.dw.256(<8 x i32> %x0, <8 x i16> %x1, i8 -1)
3964     %res1 = call <8 x i16> @llvm.x86.avx512.mask.pmovus.dw.256(<8 x i32> %x0, <8 x i16> %x1, i8 %x2)
3965     %res2 = call <8 x i16> @llvm.x86.avx512.mask.pmovus.dw.256(<8 x i32> %x0, <8 x i16> zeroinitializer, i8 %x2)
3966     %res3 = add <8 x i16> %res0, %res1
3967     %res4 = add <8 x i16> %res3, %res2
3968     ret <8 x i16> %res4
3969 }
3970
3971 declare void @llvm.x86.avx512.mask.pmovus.dw.mem.256(i8* %ptr, <8 x i32>, i8)
3972
3973 define void @test_int_x86_avx512_mask_pmovus_dw_mem_256(i8* %ptr, <8 x i32> %x1, i8 %x2) {
3974 ; CHECK-LABEL: test_int_x86_avx512_mask_pmovus_dw_mem_256:
3975 ; CHECK:  vpmovusdw %ymm0, (%rdi)
3976 ; CHECK:  vpmovusdw %ymm0, (%rdi) {%k1}
3977     call void @llvm.x86.avx512.mask.pmovus.dw.mem.256(i8* %ptr, <8 x i32> %x1, i8 -1)
3978     call void @llvm.x86.avx512.mask.pmovus.dw.mem.256(i8* %ptr, <8 x i32> %x1, i8 %x2)
3979     ret void
3980 }
3981
3982 declare <2 x double> @llvm.x86.avx512.mask.cvtdq2pd.128(<4 x i32>, <2 x double>, i8)
3983
3984 define <2 x double>@test_int_x86_avx512_mask_cvt_dq2pd_128(<4 x i32> %x0, <2 x double> %x1, i8 %x2) {
3985 ; CHECK-LABEL: test_int_x86_avx512_mask_cvt_dq2pd_128:
3986 ; CHECK:       ## BB#0:
3987 ; CHECK-NEXT:    movzbl %dil, %eax
3988 ; CHECK-NEXT:    kmovw %eax, %k1
3989 ; CHECK-NEXT:    vcvtdq2pd %xmm0, %xmm1 {%k1}
3990 ; CHECK-NEXT:    vcvtdq2pd %xmm0, %xmm0
3991 ; CHECK-NEXT:    vaddpd %xmm0, %xmm1, %xmm0
3992 ; CHECK-NEXT:    retq
3993   %res = call <2 x double> @llvm.x86.avx512.mask.cvtdq2pd.128(<4 x i32> %x0, <2 x double> %x1, i8 %x2)
3994   %res1 = call <2 x double> @llvm.x86.avx512.mask.cvtdq2pd.128(<4 x i32> %x0, <2 x double> %x1, i8 -1)
3995   %res2 = fadd <2 x double> %res, %res1
3996   ret <2 x double> %res2
3997 }
3998
3999 declare <4 x double> @llvm.x86.avx512.mask.cvtdq2pd.256(<4 x i32>, <4 x double>, i8)
4000
4001 define <4 x double>@test_int_x86_avx512_mask_cvt_dq2pd_256(<4 x i32> %x0, <4 x double> %x1, i8 %x2) {
4002 ; CHECK-LABEL: test_int_x86_avx512_mask_cvt_dq2pd_256:
4003 ; CHECK:       ## BB#0:
4004 ; CHECK-NEXT:    movzbl %dil, %eax
4005 ; CHECK-NEXT:    kmovw %eax, %k1
4006 ; CHECK-NEXT:    vcvtdq2pd %xmm0, %ymm1 {%k1}
4007 ; CHECK-NEXT:    vcvtdq2pd %xmm0, %ymm0
4008 ; CHECK-NEXT:    vaddpd %ymm0, %ymm1, %ymm0
4009 ; CHECK-NEXT:    retq
4010   %res = call <4 x double> @llvm.x86.avx512.mask.cvtdq2pd.256(<4 x i32> %x0, <4 x double> %x1, i8 %x2)
4011   %res1 = call <4 x double> @llvm.x86.avx512.mask.cvtdq2pd.256(<4 x i32> %x0, <4 x double> %x1, i8 -1)
4012   %res2 = fadd <4 x double> %res, %res1
4013   ret <4 x double> %res2
4014 }
4015
4016 declare <4 x float> @llvm.x86.avx512.mask.cvtdq2ps.128(<4 x i32>, <4 x float>, i8)
4017
4018 define <4 x float>@test_int_x86_avx512_mask_cvt_dq2ps_128(<4 x i32> %x0, <4 x float> %x1, i8 %x2) {
4019 ; CHECK-LABEL: test_int_x86_avx512_mask_cvt_dq2ps_128:
4020 ; CHECK:       ## BB#0:
4021 ; CHECK-NEXT:    movzbl %dil, %eax
4022 ; CHECK-NEXT:    kmovw %eax, %k1
4023 ; CHECK-NEXT:    vcvtdq2ps %xmm0, %xmm1 {%k1}
4024 ; CHECK-NEXT:    vcvtdq2ps %xmm0, %xmm0
4025 ; CHECK-NEXT:    vaddps %xmm0, %xmm1, %xmm0
4026 ; CHECK-NEXT:    retq
4027   %res = call <4 x float> @llvm.x86.avx512.mask.cvtdq2ps.128(<4 x i32> %x0, <4 x float> %x1, i8 %x2)
4028   %res1 = call <4 x float> @llvm.x86.avx512.mask.cvtdq2ps.128(<4 x i32> %x0, <4 x float> %x1, i8 -1)
4029   %res2 = fadd <4 x float> %res, %res1
4030   ret <4 x float> %res2
4031 }
4032
4033 declare <8 x float> @llvm.x86.avx512.mask.cvtdq2ps.256(<8 x i32>, <8 x float>, i8)
4034
4035 define <8 x float>@test_int_x86_avx512_mask_cvt_dq2ps_256(<8 x i32> %x0, <8 x float> %x1, i8 %x2) {
4036 ; CHECK-LABEL: test_int_x86_avx512_mask_cvt_dq2ps_256:
4037 ; CHECK:       ## BB#0:
4038 ; CHECK-NEXT:    movzbl %dil, %eax
4039 ; CHECK-NEXT:    kmovw %eax, %k1
4040 ; CHECK-NEXT:    vcvtdq2ps %ymm0, %ymm1 {%k1}
4041 ; CHECK-NEXT:    vcvtdq2ps %ymm0, %ymm0
4042 ; CHECK-NEXT:    vaddps %ymm0, %ymm1, %ymm0
4043 ; CHECK-NEXT:    retq
4044   %res = call <8 x float> @llvm.x86.avx512.mask.cvtdq2ps.256(<8 x i32> %x0, <8 x float> %x1, i8 %x2)
4045   %res1 = call <8 x float> @llvm.x86.avx512.mask.cvtdq2ps.256(<8 x i32> %x0, <8 x float> %x1, i8 -1)
4046   %res2 = fadd <8 x float> %res, %res1
4047   ret <8 x float> %res2
4048 }
4049
4050 declare <4 x i32> @llvm.x86.avx512.mask.cvtpd2dq.128(<2 x double>, <4 x i32>, i8)
4051
4052 define <4 x i32>@test_int_x86_avx512_mask_cvt_pd2dq_128(<2 x double> %x0, <4 x i32> %x1, i8 %x2) {
4053 ; CHECK-LABEL: test_int_x86_avx512_mask_cvt_pd2dq_128:
4054 ; CHECK:       ## BB#0:
4055 ; CHECK-NEXT:    movzbl %dil, %eax
4056 ; CHECK-NEXT:    kmovw %eax, %k1
4057 ; CHECK-NEXT:    vcvtpd2dq %xmm0, %xmm1 {%k1}
4058 ; CHECK-NEXT:    vcvtpd2dq %xmm0, %xmm0
4059 ; CHECK-NEXT:    vpaddd %xmm0, %xmm1, %xmm0
4060 ; CHECK-NEXT:    retq
4061   %res = call <4 x i32> @llvm.x86.avx512.mask.cvtpd2dq.128(<2 x double> %x0, <4 x i32> %x1, i8 %x2)
4062   %res1 = call <4 x i32> @llvm.x86.avx512.mask.cvtpd2dq.128(<2 x double> %x0, <4 x i32> %x1, i8 -1)
4063   %res2 = add <4 x i32> %res, %res1
4064   ret <4 x i32> %res2
4065 }
4066
4067 declare <4 x i32> @llvm.x86.avx512.mask.cvtpd2dq.256(<4 x double>, <4 x i32>, i8)
4068
4069 define <4 x i32>@test_int_x86_avx512_mask_cvt_pd2dq_256(<4 x double> %x0, <4 x i32> %x1, i8 %x2) {
4070 ; CHECK-LABEL: test_int_x86_avx512_mask_cvt_pd2dq_256:
4071 ; CHECK:       ## BB#0:
4072 ; CHECK-NEXT:    movzbl %dil, %eax
4073 ; CHECK-NEXT:    kmovw %eax, %k1
4074 ; CHECK-NEXT:    vcvtpd2dq %ymm0, %xmm1 {%k1}
4075 ; CHECK-NEXT:    vcvtpd2dq %ymm0, %xmm0
4076 ; CHECK-NEXT:    vpaddd %xmm0, %xmm1, %xmm0
4077 ; CHECK-NEXT:    retq
4078   %res = call <4 x i32> @llvm.x86.avx512.mask.cvtpd2dq.256(<4 x double> %x0, <4 x i32> %x1, i8 %x2)
4079   %res1 = call <4 x i32> @llvm.x86.avx512.mask.cvtpd2dq.256(<4 x double> %x0, <4 x i32> %x1, i8 -1)
4080   %res2 = add <4 x i32> %res, %res1
4081   ret <4 x i32> %res2
4082 }
4083
4084 declare <4 x float> @llvm.x86.avx512.mask.cvtpd2ps.256(<4 x double>, <4 x float>, i8)
4085
4086 define <4 x float>@test_int_x86_avx512_mask_cvt_pd2ps_256(<4 x double> %x0, <4 x float> %x1, i8 %x2) {
4087 ; CHECK-LABEL: test_int_x86_avx512_mask_cvt_pd2ps_256:
4088 ; CHECK:       ## BB#0:
4089 ; CHECK-NEXT:    movzbl %dil, %eax
4090 ; CHECK-NEXT:    kmovw %eax, %k1
4091 ; CHECK-NEXT:    vcvtpd2ps %ymm0, %xmm1 {%k1}
4092 ; CHECK-NEXT:    vcvtpd2ps %ymm0, %xmm0
4093 ; CHECK-NEXT:    vaddps %xmm0, %xmm1, %xmm0
4094 ; CHECK-NEXT:    retq
4095   %res = call <4 x float> @llvm.x86.avx512.mask.cvtpd2ps.256(<4 x double> %x0, <4 x float> %x1, i8 %x2)
4096   %res1 = call <4 x float> @llvm.x86.avx512.mask.cvtpd2ps.256(<4 x double> %x0, <4 x float> %x1, i8 -1)
4097   %res2 = fadd <4 x float> %res, %res1
4098   ret <4 x float> %res2
4099 }
4100
4101 declare <4 x float> @llvm.x86.avx512.mask.cvtpd2ps(<2 x double>, <4 x float>, i8)
4102
4103 define <4 x float>@test_int_x86_avx512_mask_cvt_pd2ps(<2 x double> %x0, <4 x float> %x1, i8 %x2) {
4104 ; CHECK-LABEL: test_int_x86_avx512_mask_cvt_pd2ps:
4105 ; CHECK:       ## BB#0:
4106 ; CHECK-NEXT:    movzbl %dil, %eax
4107 ; CHECK-NEXT:    kmovw %eax, %k1
4108 ; CHECK-NEXT:    vcvtpd2ps %xmm0, %xmm1 {%k1}
4109 ; CHECK-NEXT:    vcvtpd2ps %xmm0, %xmm0
4110 ; CHECK-NEXT:    vaddps %xmm0, %xmm1, %xmm0
4111 ; CHECK-NEXT:    retq
4112   %res = call <4 x float> @llvm.x86.avx512.mask.cvtpd2ps(<2 x double> %x0, <4 x float> %x1, i8 %x2)
4113   %res1 = call <4 x float> @llvm.x86.avx512.mask.cvtpd2ps(<2 x double> %x0, <4 x float> %x1, i8 -1)
4114   %res2 = fadd <4 x float> %res, %res1
4115   ret <4 x float> %res2
4116 }
4117
4118 declare <4 x i32> @llvm.x86.avx512.mask.cvtpd2udq.128(<2 x double>, <4 x i32>, i8)
4119
4120 define <4 x i32>@test_int_x86_avx512_mask_cvt_pd2udq_128(<2 x double> %x0, <4 x i32> %x1, i8 %x2) {
4121 ; CHECK-LABEL: test_int_x86_avx512_mask_cvt_pd2udq_128:
4122 ; CHECK:       ## BB#0:
4123 ; CHECK-NEXT:    movzbl %dil, %eax
4124 ; CHECK-NEXT:    kmovw %eax, %k1
4125 ; CHECK-NEXT:    vcvtpd2udq %xmm0, %xmm1 {%k1}
4126 ; CHECK-NEXT:    vcvtpd2udq %xmm0, %xmm0
4127 ; CHECK-NEXT:    vpaddd %xmm0, %xmm1, %xmm0
4128 ; CHECK-NEXT:    retq
4129   %res = call <4 x i32> @llvm.x86.avx512.mask.cvtpd2udq.128(<2 x double> %x0, <4 x i32> %x1, i8 %x2)
4130   %res1 = call <4 x i32> @llvm.x86.avx512.mask.cvtpd2udq.128(<2 x double> %x0, <4 x i32> %x1, i8 -1)
4131   %res2 = add <4 x i32> %res, %res1
4132   ret <4 x i32> %res2
4133 }
4134
4135 declare <4 x i32> @llvm.x86.avx512.mask.cvtpd2udq.256(<4 x double>, <4 x i32>, i8)
4136
4137 define <4 x i32>@test_int_x86_avx512_mask_cvt_pd2udq_256(<4 x double> %x0, <4 x i32> %x1, i8 %x2) {
4138 ; CHECK-LABEL: test_int_x86_avx512_mask_cvt_pd2udq_256:
4139 ; CHECK:       ## BB#0:
4140 ; CHECK-NEXT:    movzbl %dil, %eax
4141 ; CHECK-NEXT:    kmovw %eax, %k1
4142 ; CHECK-NEXT:    vcvtpd2udq %ymm0, %xmm1 {%k1}
4143 ; CHECK-NEXT:    vcvtpd2udq %ymm0, %xmm0
4144 ; CHECK-NEXT:    vpaddd %xmm0, %xmm1, %xmm0
4145 ; CHECK-NEXT:    retq
4146   %res = call <4 x i32> @llvm.x86.avx512.mask.cvtpd2udq.256(<4 x double> %x0, <4 x i32> %x1, i8 %x2)
4147   %res1 = call <4 x i32> @llvm.x86.avx512.mask.cvtpd2udq.256(<4 x double> %x0, <4 x i32> %x1, i8 -1)
4148   %res2 = add <4 x i32> %res, %res1
4149   ret <4 x i32> %res2
4150 }
4151
4152 declare <4 x i32> @llvm.x86.avx512.mask.cvtps2dq.128(<4 x float>, <4 x i32>, i8)
4153
4154 define <4 x i32>@test_int_x86_avx512_mask_cvt_ps2dq_128(<4 x float> %x0, <4 x i32> %x1, i8 %x2) {
4155 ; CHECK-LABEL: test_int_x86_avx512_mask_cvt_ps2dq_128:
4156 ; CHECK:       ## BB#0:
4157 ; CHECK-NEXT:    movzbl %dil, %eax
4158 ; CHECK-NEXT:    kmovw %eax, %k1
4159 ; CHECK-NEXT:    vcvtps2dq %xmm0, %xmm1 {%k1}
4160 ; CHECK-NEXT:    vcvtps2dq %xmm0, %xmm0
4161 ; CHECK-NEXT:    vpaddd %xmm0, %xmm1, %xmm0
4162 ; CHECK-NEXT:    retq
4163   %res = call <4 x i32> @llvm.x86.avx512.mask.cvtps2dq.128(<4 x float> %x0, <4 x i32> %x1, i8 %x2)
4164   %res1 = call <4 x i32> @llvm.x86.avx512.mask.cvtps2dq.128(<4 x float> %x0, <4 x i32> %x1, i8 -1)
4165   %res2 = add <4 x i32> %res, %res1
4166   ret <4 x i32> %res2
4167 }
4168
4169 declare <8 x i32> @llvm.x86.avx512.mask.cvtps2dq.256(<8 x float>, <8 x i32>, i8)
4170
4171 define <8 x i32>@test_int_x86_avx512_mask_cvt_ps2dq_256(<8 x float> %x0, <8 x i32> %x1, i8 %x2) {
4172 ; CHECK-LABEL: test_int_x86_avx512_mask_cvt_ps2dq_256:
4173 ; CHECK:       ## BB#0:
4174 ; CHECK-NEXT:    movzbl %dil, %eax
4175 ; CHECK-NEXT:    kmovw %eax, %k1
4176 ; CHECK-NEXT:    vcvtps2dq %ymm0, %ymm1 {%k1}
4177 ; CHECK-NEXT:    vcvtps2dq %ymm0, %ymm0
4178 ; CHECK-NEXT:    vpaddd %ymm0, %ymm1, %ymm0
4179 ; CHECK-NEXT:    retq
4180   %res = call <8 x i32> @llvm.x86.avx512.mask.cvtps2dq.256(<8 x float> %x0, <8 x i32> %x1, i8 %x2)
4181   %res1 = call <8 x i32> @llvm.x86.avx512.mask.cvtps2dq.256(<8 x float> %x0, <8 x i32> %x1, i8 -1)
4182   %res2 = add <8 x i32> %res, %res1
4183   ret <8 x i32> %res2
4184 }
4185
4186 declare <2 x double> @llvm.x86.avx512.mask.cvtps2pd.128(<4 x float>, <2 x double>, i8)
4187
4188 define <2 x double>@test_int_x86_avx512_mask_cvt_ps2pd_128(<4 x float> %x0, <2 x double> %x1, i8 %x2) {
4189 ; CHECK-LABEL: test_int_x86_avx512_mask_cvt_ps2pd_128:
4190 ; CHECK:       ## BB#0:
4191 ; CHECK-NEXT:    movzbl %dil, %eax
4192 ; CHECK-NEXT:    kmovw %eax, %k1
4193 ; CHECK-NEXT:    vcvtps2pd %xmm0, %xmm1 {%k1}
4194 ; CHECK-NEXT:    vcvtps2pd %xmm0, %xmm0
4195 ; CHECK-NEXT:    vaddpd %xmm0, %xmm1, %xmm0
4196 ; CHECK-NEXT:    retq
4197   %res = call <2 x double> @llvm.x86.avx512.mask.cvtps2pd.128(<4 x float> %x0, <2 x double> %x1, i8 %x2)
4198   %res1 = call <2 x double> @llvm.x86.avx512.mask.cvtps2pd.128(<4 x float> %x0, <2 x double> %x1, i8 -1)
4199   %res2 = fadd <2 x double> %res, %res1
4200   ret <2 x double> %res2
4201 }
4202
4203 declare <4 x double> @llvm.x86.avx512.mask.cvtps2pd.256(<4 x float>, <4 x double>, i8)
4204
4205 define <4 x double>@test_int_x86_avx512_mask_cvt_ps2pd_256(<4 x float> %x0, <4 x double> %x1, i8 %x2) {
4206 ; CHECK-LABEL: test_int_x86_avx512_mask_cvt_ps2pd_256:
4207 ; CHECK:       ## BB#0:
4208 ; CHECK-NEXT:    movzbl %dil, %eax
4209 ; CHECK-NEXT:    kmovw %eax, %k1
4210 ; CHECK-NEXT:    vcvtps2pd %xmm0, %ymm1 {%k1}
4211 ; CHECK-NEXT:    vcvtps2pd %xmm0, %ymm0
4212 ; CHECK-NEXT:    vaddpd %ymm0, %ymm1, %ymm0
4213 ; CHECK-NEXT:    retq
4214   %res = call <4 x double> @llvm.x86.avx512.mask.cvtps2pd.256(<4 x float> %x0, <4 x double> %x1, i8 %x2)
4215   %res1 = call <4 x double> @llvm.x86.avx512.mask.cvtps2pd.256(<4 x float> %x0, <4 x double> %x1, i8 -1)
4216   %res2 = fadd <4 x double> %res, %res1
4217   ret <4 x double> %res2
4218 }
4219
4220 declare <4 x i32> @llvm.x86.avx512.mask.cvtps2udq.128(<4 x float>, <4 x i32>, i8)
4221
4222 define <4 x i32>@test_int_x86_avx512_mask_cvt_ps2udq_128(<4 x float> %x0, <4 x i32> %x1, i8 %x2) {
4223 ; CHECK-LABEL: test_int_x86_avx512_mask_cvt_ps2udq_128:
4224 ; CHECK:       ## BB#0:
4225 ; CHECK-NEXT:    movzbl %dil, %eax
4226 ; CHECK-NEXT:    kmovw %eax, %k1
4227 ; CHECK-NEXT:    vcvtps2udq %xmm0, %xmm1 {%k1}
4228 ; CHECK-NEXT:    vcvtps2udq %xmm0, %xmm0
4229 ; CHECK-NEXT:    vpaddd %xmm0, %xmm1, %xmm0
4230 ; CHECK-NEXT:    retq
4231   %res = call <4 x i32> @llvm.x86.avx512.mask.cvtps2udq.128(<4 x float> %x0, <4 x i32> %x1, i8 %x2)
4232   %res1 = call <4 x i32> @llvm.x86.avx512.mask.cvtps2udq.128(<4 x float> %x0, <4 x i32> %x1, i8 -1)
4233   %res2 = add <4 x i32> %res, %res1
4234   ret <4 x i32> %res2
4235 }
4236
4237 declare <8 x i32> @llvm.x86.avx512.mask.cvtps2udq.256(<8 x float>, <8 x i32>, i8)
4238
4239 define <8 x i32>@test_int_x86_avx512_mask_cvt_ps2udq_256(<8 x float> %x0, <8 x i32> %x1, i8 %x2) {
4240 ; CHECK-LABEL: test_int_x86_avx512_mask_cvt_ps2udq_256:
4241 ; CHECK:       ## BB#0:
4242 ; CHECK-NEXT:    movzbl %dil, %eax
4243 ; CHECK-NEXT:    kmovw %eax, %k1
4244 ; CHECK-NEXT:    vcvtps2udq %ymm0, %ymm1 {%k1}
4245 ; CHECK-NEXT:    vcvtps2udq %ymm0, %ymm0
4246 ; CHECK-NEXT:    vpaddd %ymm0, %ymm1, %ymm0
4247 ; CHECK-NEXT:    retq
4248   %res = call <8 x i32> @llvm.x86.avx512.mask.cvtps2udq.256(<8 x float> %x0, <8 x i32> %x1, i8 %x2)
4249   %res1 = call <8 x i32> @llvm.x86.avx512.mask.cvtps2udq.256(<8 x float> %x0, <8 x i32> %x1, i8 -1)
4250   %res2 = add <8 x i32> %res, %res1
4251   ret <8 x i32> %res2
4252 }
4253
4254 declare <4 x i32> @llvm.x86.avx512.mask.cvttpd2dq.128(<2 x double>, <4 x i32>, i8)
4255
4256 define <4 x i32>@test_int_x86_avx512_mask_cvtt_pd2dq_128(<2 x double> %x0, <4 x i32> %x1, i8 %x2) {
4257 ; CHECK-LABEL: test_int_x86_avx512_mask_cvtt_pd2dq_128:
4258 ; CHECK:       ## BB#0:
4259 ; CHECK-NEXT:    movzbl %dil, %eax
4260 ; CHECK-NEXT:    kmovw %eax, %k1
4261 ; CHECK-NEXT:    vcvttpd2dq %xmm0, %xmm1 {%k1}
4262 ; CHECK-NEXT:    vcvttpd2dq %xmm0, %xmm0
4263 ; CHECK-NEXT:    vpaddd %xmm0, %xmm1, %xmm0
4264 ; CHECK-NEXT:    retq
4265   %res = call <4 x i32> @llvm.x86.avx512.mask.cvttpd2dq.128(<2 x double> %x0, <4 x i32> %x1, i8 %x2)
4266   %res1 = call <4 x i32> @llvm.x86.avx512.mask.cvttpd2dq.128(<2 x double> %x0, <4 x i32> %x1, i8 -1)
4267   %res2 = add <4 x i32> %res, %res1
4268   ret <4 x i32> %res2
4269 }
4270
4271 declare <4 x i32> @llvm.x86.avx512.mask.cvttpd2dq.256(<4 x double>, <4 x i32>, i8)
4272
4273 define <4 x i32>@test_int_x86_avx512_mask_cvtt_pd2dq_256(<4 x double> %x0, <4 x i32> %x1, i8 %x2) {
4274 ; CHECK-LABEL: test_int_x86_avx512_mask_cvtt_pd2dq_256:
4275 ; CHECK:       ## BB#0:
4276 ; CHECK-NEXT:    movzbl %dil, %eax
4277 ; CHECK-NEXT:    kmovw %eax, %k1
4278 ; CHECK-NEXT:    vcvttpd2dq %ymm0, %xmm1 {%k1}
4279 ; CHECK-NEXT:    vcvttpd2dq %ymm0, %xmm0
4280 ; CHECK-NEXT:    vpaddd %xmm0, %xmm1, %xmm0
4281 ; CHECK-NEXT:    retq
4282   %res = call <4 x i32> @llvm.x86.avx512.mask.cvttpd2dq.256(<4 x double> %x0, <4 x i32> %x1, i8 %x2)
4283   %res1 = call <4 x i32> @llvm.x86.avx512.mask.cvttpd2dq.256(<4 x double> %x0, <4 x i32> %x1, i8 -1)
4284   %res2 = add <4 x i32> %res, %res1
4285   ret <4 x i32> %res2
4286 }
4287
4288 declare <4 x i32> @llvm.x86.avx512.mask.cvttpd2udq.128(<2 x double>, <4 x i32>, i8)
4289
4290 define <4 x i32>@test_int_x86_avx512_mask_cvtt_pd2udq_128(<2 x double> %x0, <4 x i32> %x1, i8 %x2) {
4291 ; CHECK-LABEL: test_int_x86_avx512_mask_cvtt_pd2udq_128:
4292 ; CHECK:       ## BB#0:
4293 ; CHECK-NEXT:    movzbl %dil, %eax
4294 ; CHECK-NEXT:    kmovw %eax, %k1
4295 ; CHECK-NEXT:    vcvttpd2udq %xmm0, %xmm1 {%k1}
4296 ; CHECK-NEXT:    vcvttpd2udq %xmm0, %xmm0
4297 ; CHECK-NEXT:    vpaddd %xmm0, %xmm1, %xmm0
4298 ; CHECK-NEXT:    retq
4299   %res = call <4 x i32> @llvm.x86.avx512.mask.cvttpd2udq.128(<2 x double> %x0, <4 x i32> %x1, i8 %x2)
4300   %res1 = call <4 x i32> @llvm.x86.avx512.mask.cvttpd2udq.128(<2 x double> %x0, <4 x i32> %x1, i8 -1)
4301   %res2 = add <4 x i32> %res, %res1
4302   ret <4 x i32> %res2
4303 }
4304
4305 declare <4 x i32> @llvm.x86.avx512.mask.cvttpd2udq.256(<4 x double>, <4 x i32>, i8)
4306
4307 define <4 x i32>@test_int_x86_avx512_mask_cvtt_pd2udq_256(<4 x double> %x0, <4 x i32> %x1, i8 %x2) {
4308 ; CHECK-LABEL: test_int_x86_avx512_mask_cvtt_pd2udq_256:
4309 ; CHECK:       ## BB#0:
4310 ; CHECK-NEXT:    movzbl %dil, %eax
4311 ; CHECK-NEXT:    kmovw %eax, %k1
4312 ; CHECK-NEXT:    vcvttpd2udq %ymm0, %xmm1 {%k1}
4313 ; CHECK-NEXT:    vcvttpd2udq %ymm0, %xmm0
4314 ; CHECK-NEXT:    vpaddd %xmm0, %xmm1, %xmm0
4315 ; CHECK-NEXT:    retq
4316   %res = call <4 x i32> @llvm.x86.avx512.mask.cvttpd2udq.256(<4 x double> %x0, <4 x i32> %x1, i8 %x2)
4317   %res1 = call <4 x i32> @llvm.x86.avx512.mask.cvttpd2udq.256(<4 x double> %x0, <4 x i32> %x1, i8 -1)
4318   %res2 = add <4 x i32> %res, %res1
4319   ret <4 x i32> %res2
4320 }
4321
4322 declare <4 x i32> @llvm.x86.avx512.mask.cvttps2dq.128(<4 x float>, <4 x i32>, i8)
4323
4324 define <4 x i32>@test_int_x86_avx512_mask_cvtt_ps2dq_128(<4 x float> %x0, <4 x i32> %x1, i8 %x2) {
4325 ; CHECK-LABEL: test_int_x86_avx512_mask_cvtt_ps2dq_128:
4326 ; CHECK:       ## BB#0:
4327 ; CHECK-NEXT:    movzbl %dil, %eax
4328 ; CHECK-NEXT:    kmovw %eax, %k1
4329 ; CHECK-NEXT:    vcvttps2dq %xmm0, %xmm1 {%k1}
4330 ; CHECK-NEXT:    vcvttps2dq %xmm0, %xmm0
4331 ; CHECK-NEXT:    vpaddd %xmm0, %xmm1, %xmm0
4332 ; CHECK-NEXT:    retq
4333   %res = call <4 x i32> @llvm.x86.avx512.mask.cvttps2dq.128(<4 x float> %x0, <4 x i32> %x1, i8 %x2)
4334   %res1 = call <4 x i32> @llvm.x86.avx512.mask.cvttps2dq.128(<4 x float> %x0, <4 x i32> %x1, i8 -1)
4335   %res2 = add <4 x i32> %res, %res1
4336   ret <4 x i32> %res2
4337 }
4338
4339 declare <8 x i32> @llvm.x86.avx512.mask.cvttps2dq.256(<8 x float>, <8 x i32>, i8)
4340
4341 define <8 x i32>@test_int_x86_avx512_mask_cvtt_ps2dq_256(<8 x float> %x0, <8 x i32> %x1, i8 %x2) {
4342 ; CHECK-LABEL: test_int_x86_avx512_mask_cvtt_ps2dq_256:
4343 ; CHECK:       ## BB#0:
4344 ; CHECK-NEXT:    movzbl %dil, %eax
4345 ; CHECK-NEXT:    kmovw %eax, %k1
4346 ; CHECK-NEXT:    vcvttps2dq %ymm0, %ymm1 {%k1}
4347 ; CHECK-NEXT:    vcvttps2dq %ymm0, %ymm0
4348 ; CHECK-NEXT:    vpaddd %ymm0, %ymm1, %ymm0
4349 ; CHECK-NEXT:    retq
4350   %res = call <8 x i32> @llvm.x86.avx512.mask.cvttps2dq.256(<8 x float> %x0, <8 x i32> %x1, i8 %x2)
4351   %res1 = call <8 x i32> @llvm.x86.avx512.mask.cvttps2dq.256(<8 x float> %x0, <8 x i32> %x1, i8 -1)
4352   %res2 = add <8 x i32> %res, %res1
4353   ret <8 x i32> %res2
4354 }
4355
4356 declare <4 x i32> @llvm.x86.avx512.mask.cvttps2udq.128(<4 x float>, <4 x i32>, i8)
4357
4358 define <4 x i32>@test_int_x86_avx512_mask_cvtt_ps2udq_128(<4 x float> %x0, <4 x i32> %x1, i8 %x2) {
4359 ; CHECK-LABEL: test_int_x86_avx512_mask_cvtt_ps2udq_128:
4360 ; CHECK:       ## BB#0:
4361 ; CHECK-NEXT:    movzbl %dil, %eax
4362 ; CHECK-NEXT:    kmovw %eax, %k1
4363 ; CHECK-NEXT:    vcvttps2udq %xmm0, %xmm1 {%k1}
4364 ; CHECK-NEXT:    vcvttps2udq %xmm0, %xmm0
4365 ; CHECK-NEXT:    vpaddd %xmm0, %xmm1, %xmm0
4366 ; CHECK-NEXT:    retq
4367   %res = call <4 x i32> @llvm.x86.avx512.mask.cvttps2udq.128(<4 x float> %x0, <4 x i32> %x1, i8 %x2)
4368   %res1 = call <4 x i32> @llvm.x86.avx512.mask.cvttps2udq.128(<4 x float> %x0, <4 x i32> %x1, i8 -1)
4369   %res2 = add <4 x i32> %res, %res1
4370   ret <4 x i32> %res2
4371 }
4372
4373 declare <8 x i32> @llvm.x86.avx512.mask.cvttps2udq.256(<8 x float>, <8 x i32>, i8)
4374
4375 define <8 x i32>@test_int_x86_avx512_mask_cvtt_ps2udq_256(<8 x float> %x0, <8 x i32> %x1, i8 %x2) {
4376 ; CHECK-LABEL: test_int_x86_avx512_mask_cvtt_ps2udq_256:
4377 ; CHECK:       ## BB#0:
4378 ; CHECK-NEXT:    movzbl %dil, %eax
4379 ; CHECK-NEXT:    kmovw %eax, %k1
4380 ; CHECK-NEXT:    vcvttps2udq %ymm0, %ymm1 {%k1}
4381 ; CHECK-NEXT:    vcvttps2udq %ymm0, %ymm0
4382 ; CHECK-NEXT:    vpaddd %ymm0, %ymm1, %ymm0
4383 ; CHECK-NEXT:    retq
4384   %res = call <8 x i32> @llvm.x86.avx512.mask.cvttps2udq.256(<8 x float> %x0, <8 x i32> %x1, i8 %x2)
4385   %res1 = call <8 x i32> @llvm.x86.avx512.mask.cvttps2udq.256(<8 x float> %x0, <8 x i32> %x1, i8 -1)
4386   %res2 = add <8 x i32> %res, %res1
4387   ret <8 x i32> %res2
4388 }
4389
4390 declare <2 x double> @llvm.x86.avx512.mask.cvtudq2pd.128(<4 x i32>, <2 x double>, i8)
4391
4392 define <2 x double>@test_int_x86_avx512_mask_cvt_udq2pd_128(<4 x i32> %x0, <2 x double> %x1, i8 %x2) {
4393 ; CHECK-LABEL: test_int_x86_avx512_mask_cvt_udq2pd_128:
4394 ; CHECK:       ## BB#0:
4395 ; CHECK-NEXT:    movzbl %dil, %eax
4396 ; CHECK-NEXT:    kmovw %eax, %k1
4397 ; CHECK-NEXT:    vcvtudq2pd %xmm0, %xmm1 {%k1}
4398 ; CHECK-NEXT:    vcvtudq2pd %xmm0, %xmm0
4399 ; CHECK-NEXT:    vaddpd %xmm0, %xmm1, %xmm0
4400 ; CHECK-NEXT:    retq
4401   %res = call <2 x double> @llvm.x86.avx512.mask.cvtudq2pd.128(<4 x i32> %x0, <2 x double> %x1, i8 %x2)
4402   %res1 = call <2 x double> @llvm.x86.avx512.mask.cvtudq2pd.128(<4 x i32> %x0, <2 x double> %x1, i8 -1)
4403   %res2 = fadd <2 x double> %res, %res1
4404   ret <2 x double> %res2
4405 }
4406
4407 declare <4 x double> @llvm.x86.avx512.mask.cvtudq2pd.256(<4 x i32>, <4 x double>, i8)
4408
4409 define <4 x double>@test_int_x86_avx512_mask_cvt_udq2pd_256(<4 x i32> %x0, <4 x double> %x1, i8 %x2) {
4410 ; CHECK-LABEL: test_int_x86_avx512_mask_cvt_udq2pd_256:
4411 ; CHECK:       ## BB#0:
4412 ; CHECK-NEXT:    movzbl %dil, %eax
4413 ; CHECK-NEXT:    kmovw %eax, %k1
4414 ; CHECK-NEXT:    vcvtudq2pd %xmm0, %ymm1 {%k1}
4415 ; CHECK-NEXT:    vcvtudq2pd %xmm0, %ymm0
4416 ; CHECK-NEXT:    vaddpd %ymm0, %ymm1, %ymm0
4417 ; CHECK-NEXT:    retq
4418   %res = call <4 x double> @llvm.x86.avx512.mask.cvtudq2pd.256(<4 x i32> %x0, <4 x double> %x1, i8 %x2)
4419   %res1 = call <4 x double> @llvm.x86.avx512.mask.cvtudq2pd.256(<4 x i32> %x0, <4 x double> %x1, i8 -1)
4420   %res2 = fadd <4 x double> %res, %res1
4421   ret <4 x double> %res2
4422 }
4423
4424 declare <4 x float> @llvm.x86.avx512.mask.cvtudq2ps.128(<4 x i32>, <4 x float>, i8)
4425
4426 define <4 x float>@test_int_x86_avx512_mask_cvt_udq2ps_128(<4 x i32> %x0, <4 x float> %x1, i8 %x2) {
4427 ; CHECK-LABEL: test_int_x86_avx512_mask_cvt_udq2ps_128:
4428 ; CHECK:       ## BB#0:
4429 ; CHECK-NEXT:    movzbl %dil, %eax
4430 ; CHECK-NEXT:    kmovw %eax, %k1
4431 ; CHECK-NEXT:    vcvtudq2ps %xmm0, %xmm1 {%k1}
4432 ; CHECK-NEXT:    vcvtudq2ps %xmm0, %xmm0
4433 ; CHECK-NEXT:    vaddps %xmm0, %xmm1, %xmm0
4434 ; CHECK-NEXT:    retq
4435   %res = call <4 x float> @llvm.x86.avx512.mask.cvtudq2ps.128(<4 x i32> %x0, <4 x float> %x1, i8 %x2)
4436   %res1 = call <4 x float> @llvm.x86.avx512.mask.cvtudq2ps.128(<4 x i32> %x0, <4 x float> %x1, i8 -1)
4437   %res2 = fadd <4 x float> %res, %res1
4438   ret <4 x float> %res2
4439 }
4440
4441 declare <8 x float> @llvm.x86.avx512.mask.cvtudq2ps.256(<8 x i32>, <8 x float>, i8)
4442
4443 define <8 x float>@test_int_x86_avx512_mask_cvt_udq2ps_256(<8 x i32> %x0, <8 x float> %x1, i8 %x2) {
4444 ; CHECK-LABEL: test_int_x86_avx512_mask_cvt_udq2ps_256:
4445 ; CHECK:       ## BB#0:
4446 ; CHECK-NEXT:    movzbl %dil, %eax
4447 ; CHECK-NEXT:    kmovw %eax, %k1
4448 ; CHECK-NEXT:    vcvtudq2ps %ymm0, %ymm1 {%k1}
4449 ; CHECK-NEXT:    vcvtudq2ps %ymm0, %ymm0
4450 ; CHECK-NEXT:    vaddps %ymm0, %ymm1, %ymm0
4451 ; CHECK-NEXT:    retq
4452   %res = call <8 x float> @llvm.x86.avx512.mask.cvtudq2ps.256(<8 x i32> %x0, <8 x float> %x1, i8 %x2)
4453   %res1 = call <8 x float> @llvm.x86.avx512.mask.cvtudq2ps.256(<8 x i32> %x0, <8 x float> %x1, i8 -1)
4454   %res2 = fadd <8 x float> %res, %res1
4455   ret <8 x float> %res2
4456 }
4457
4458 declare <2 x double> @llvm.x86.avx512.mask.rndscale.pd.128(<2 x double>, i32, <2 x double>, i8)
4459 ; CHECK-LABEL: @test_int_x86_avx512_mask_rndscale_pd_128
4460 ; CHECK-NOT: call
4461 ; CHECK: kmov
4462 ; CHECK: vrndscalepd {{.*}}{%k1}
4463 ; CHECK: vrndscalepd
4464 define <2 x double>@test_int_x86_avx512_mask_rndscale_pd_128(<2 x double> %x0, <2 x double> %x2, i8 %x3) {
4465   %res = call <2 x double> @llvm.x86.avx512.mask.rndscale.pd.128(<2 x double> %x0, i32 4, <2 x double> %x2, i8 %x3)
4466   %res1 = call <2 x double> @llvm.x86.avx512.mask.rndscale.pd.128(<2 x double> %x0, i32 88, <2 x double> %x2, i8 -1)
4467   %res2 = fadd <2 x double> %res, %res1
4468   ret <2 x double> %res2
4469 }
4470
4471 declare <4 x double> @llvm.x86.avx512.mask.rndscale.pd.256(<4 x double>, i32, <4 x double>, i8)
4472 ; CHECK-LABEL: @test_int_x86_avx512_mask_rndscale_pd_256
4473 ; CHECK-NOT: call
4474 ; CHECK: kmov
4475 ; CHECK: vrndscalepd {{.*}}{%k1}
4476 ; CHECK: vrndscalepd
4477 define <4 x double>@test_int_x86_avx512_mask_rndscale_pd_256(<4 x double> %x0, <4 x double> %x2, i8 %x3) {
4478   %res = call <4 x double> @llvm.x86.avx512.mask.rndscale.pd.256(<4 x double> %x0, i32 4, <4 x double> %x2, i8 %x3)
4479   %res1 = call <4 x double> @llvm.x86.avx512.mask.rndscale.pd.256(<4 x double> %x0, i32 88, <4 x double> %x2, i8 -1)
4480   %res2 = fadd <4 x double> %res, %res1
4481   ret <4 x double> %res2
4482 }
4483
4484 declare <4 x float> @llvm.x86.avx512.mask.rndscale.ps.128(<4 x float>, i32, <4 x float>, i8)
4485 ; CHECK-LABEL: @test_int_x86_avx512_mask_rndscale_ps_128
4486 ; CHECK-NOT: call
4487 ; CHECK: kmov
4488 ; CHECK: vrndscaleps {{.*}}{%k1}
4489 ; CHECK: vrndscaleps
4490 define <4 x float>@test_int_x86_avx512_mask_rndscale_ps_128(<4 x float> %x0, <4 x float> %x2, i8 %x3) {
4491   %res = call <4 x float> @llvm.x86.avx512.mask.rndscale.ps.128(<4 x float> %x0, i32 88, <4 x float> %x2, i8 %x3)
4492   %res1 = call <4 x float> @llvm.x86.avx512.mask.rndscale.ps.128(<4 x float> %x0, i32 4, <4 x float> %x2, i8 -1)
4493   %res2 = fadd <4 x float> %res, %res1
4494   ret <4 x float> %res2
4495 }
4496
4497 declare <8 x float> @llvm.x86.avx512.mask.rndscale.ps.256(<8 x float>, i32, <8 x float>, i8)
4498
4499 ; CHECK-LABEL: @test_int_x86_avx512_mask_rndscale_ps_256
4500 ; CHECK-NOT: call
4501 ; CHECK: kmov
4502 ; CHECK: vrndscaleps {{.*}}{%k1}
4503 ; CHECK: vrndscaleps
4504 define <8 x float>@test_int_x86_avx512_mask_rndscale_ps_256(<8 x float> %x0, <8 x float> %x2, i8 %x3) {
4505   %res = call <8 x float> @llvm.x86.avx512.mask.rndscale.ps.256(<8 x float> %x0, i32 5, <8 x float> %x2, i8 %x3)
4506   %res1 = call <8 x float> @llvm.x86.avx512.mask.rndscale.ps.256(<8 x float> %x0, i32 66, <8 x float> %x2, i8 -1)
4507   %res2 = fadd <8 x float> %res, %res1
4508   ret <8 x float> %res2
4509 }
4510
4511 declare <8 x float> @llvm.x86.avx512.mask.shuf.f32x4.256(<8 x float>, <8 x float>, i32, <8 x float>, i8)
4512
4513 define <8 x float>@test_int_x86_avx512_mask_shuf_f32x4_256(<8 x float> %x0, <8 x float> %x1, <8 x float> %x3, i8 %x4) {
4514 ; CHECK-LABEL: test_int_x86_avx512_mask_shuf_f32x4_256:
4515 ; CHECK:       ## BB#0:
4516 ; CHECK-NEXT:    movzbl %dil, %eax
4517 ; CHECK-NEXT:    kmovw %eax, %k1
4518 ; CHECK-NEXT:    vshuff32x4 $22, %ymm1, %ymm0, %ymm2 {%k1}
4519 ; CHECK-NEXT:    vshuff32x4 $22, %ymm1, %ymm0, %ymm0
4520 ; CHECK-NEXT:    vaddps %ymm0, %ymm2, %ymm0
4521 ; CHECK-NEXT:    retq
4522   %res = call <8 x float> @llvm.x86.avx512.mask.shuf.f32x4.256(<8 x float> %x0, <8 x float> %x1, i32 22, <8 x float> %x3, i8 %x4)
4523   %res1 = call <8 x float> @llvm.x86.avx512.mask.shuf.f32x4.256(<8 x float> %x0, <8 x float> %x1, i32 22, <8 x float> %x3, i8 -1)
4524   %res2 = fadd <8 x float> %res, %res1
4525   ret <8 x float> %res2
4526 }
4527
4528 declare <4 x double> @llvm.x86.avx512.mask.shuf.f64x2.256(<4 x double>, <4 x double>, i32, <4 x double>, i8)
4529
4530 define <4 x double>@test_int_x86_avx512_mask_shuf_f64x2_256(<4 x double> %x0, <4 x double> %x1, <4 x double> %x3, i8 %x4) {
4531 ; CHECK-LABEL: test_int_x86_avx512_mask_shuf_f64x2_256:
4532 ; CHECK:       ## BB#0:
4533 ; CHECK-NEXT:    movzbl %dil, %eax
4534 ; CHECK-NEXT:    kmovw %eax, %k1
4535 ; CHECK-NEXT:    vshuff64x2 $22, %ymm1, %ymm0, %ymm2 {%k1}
4536 ; CHECK-NEXT:    vshuff64x2 $22, %ymm1, %ymm0, %ymm0
4537 ; CHECK-NEXT:    vaddpd %ymm0, %ymm2, %ymm0
4538 ; CHECK-NEXT:    retq
4539   %res = call <4 x double> @llvm.x86.avx512.mask.shuf.f64x2.256(<4 x double> %x0, <4 x double> %x1, i32 22, <4 x double> %x3, i8 %x4)
4540   %res1 = call <4 x double> @llvm.x86.avx512.mask.shuf.f64x2.256(<4 x double> %x0, <4 x double> %x1, i32 22, <4 x double> %x3, i8 -1)
4541   %res2 = fadd <4 x double> %res, %res1
4542   ret <4 x double> %res2
4543 }
4544
4545 declare <8 x i32> @llvm.x86.avx512.mask.shuf.i32x4.256(<8 x i32>, <8 x i32>, i32, <8 x i32>, i8)
4546
4547 define <8 x i32>@test_int_x86_avx512_mask_shuf_i32x4_256(<8 x i32> %x0, <8 x i32> %x1, <8 x i32> %x3, i8 %x4) {
4548 ; CHECK-LABEL: test_int_x86_avx512_mask_shuf_i32x4_256:
4549 ; CHECK:       ## BB#0:
4550 ; CHECK-NEXT:    movzbl %dil, %eax
4551 ; CHECK-NEXT:    kmovw %eax, %k1
4552 ; CHECK-NEXT:    vshufi32x4 $22, %ymm1, %ymm0, %ymm2 {%k1}
4553 ; CHECK-NEXT:    vshufi32x4 $22, %ymm1, %ymm0, %ymm0
4554 ; CHECK-NEXT:    vpaddd %ymm0, %ymm2, %ymm0
4555 ; CHECK-NEXT:    retq
4556   %res = call <8 x i32> @llvm.x86.avx512.mask.shuf.i32x4.256(<8 x i32> %x0, <8 x i32> %x1, i32 22, <8 x i32> %x3, i8 %x4)
4557   %res1 = call <8 x i32> @llvm.x86.avx512.mask.shuf.i32x4.256(<8 x i32> %x0, <8 x i32> %x1, i32 22, <8 x i32> %x3, i8 -1)
4558   %res2 = add <8 x i32> %res, %res1
4559   ret <8 x i32> %res2
4560 }
4561
4562 declare <4 x i64> @llvm.x86.avx512.mask.shuf.i64x2.256(<4 x i64>, <4 x i64>, i32, <4 x i64>, i8)
4563
4564 define <4 x i64>@test_int_x86_avx512_mask_shuf_i64x2_256(<4 x i64> %x0, <4 x i64> %x1, <4 x i64> %x3, i8 %x4) {
4565 ; CHECK-LABEL: test_int_x86_avx512_mask_shuf_i64x2_256:
4566 ; CHECK:       ## BB#0:
4567 ; CHECK-NEXT:    movzbl %dil, %eax
4568 ; CHECK-NEXT:    kmovw %eax, %k1
4569 ; CHECK-NEXT:    vshufi64x2 $22, %ymm1, %ymm0, %ymm2 {%k1}
4570 ; CHECK-NEXT:    vshufi64x2 $22, %ymm1, %ymm0, %ymm0
4571 ; CHECK-NEXT:    vpaddq %ymm0, %ymm2, %ymm0
4572 ; CHECK-NEXT:    retq
4573   %res = call <4 x i64> @llvm.x86.avx512.mask.shuf.i64x2.256(<4 x i64> %x0, <4 x i64> %x1, i32 22, <4 x i64> %x3, i8 %x4)
4574   %res1 = call <4 x i64> @llvm.x86.avx512.mask.shuf.i64x2.256(<4 x i64> %x0, <4 x i64> %x1, i32 22, <4 x i64> %x3, i8 -1)
4575   %res2 = add <4 x i64> %res, %res1
4576   ret <4 x i64> %res2
4577 }
4578
4579 declare <4 x float> @llvm.x86.avx512.mask.vextractf32x4.256(<8 x float>, i32, <4 x float>, i8)
4580
4581 define <4 x float>@test_int_x86_avx512_mask_vextractf32x4_256(<8 x float> %x0, <4 x float> %x2, i8 %x3) {
4582 ; CHECK-LABEL: test_int_x86_avx512_mask_vextractf32x4_256:
4583 ; CHECK:       ## BB#0:
4584 ; CHECK-NEXT:    kmovw %edi, %k1
4585 ; CHECK-NEXT:    vextractf32x4 $1, %ymm0, %xmm1 {%k1}
4586 ; CHECK-NEXT:    vextractf32x4 $1, %ymm0, %xmm2 {%k1} {z}
4587 ; CHECK-NEXT:    vextractf32x4 $1, %ymm0, %xmm0
4588 ; CHECK-NEXT:    vaddps %xmm2, %xmm1, %xmm1
4589 ; CHECK-NEXT:    vaddps %xmm1, %xmm0, %xmm0
4590 ; CHECK-NEXT:    retq
4591   %res  = call <4 x float> @llvm.x86.avx512.mask.vextractf32x4.256(<8 x float> %x0, i32 1, <4 x float> %x2, i8 %x3)
4592   %res1 = call <4 x float> @llvm.x86.avx512.mask.vextractf32x4.256(<8 x float> %x0, i32 1, <4 x float> zeroinitializer, i8 %x3)
4593   %res2 = call <4 x float> @llvm.x86.avx512.mask.vextractf32x4.256(<8 x float> %x0, i32 1, <4 x float> zeroinitializer, i8 -1)
4594   %res3 = fadd <4 x float> %res, %res1
4595   %res4 = fadd <4 x float> %res2, %res3
4596   ret <4 x float> %res4
4597 }
4598
4599 declare <2 x double> @llvm.x86.avx512.mask.getmant.pd.128(<2 x double>, i32, <2 x double>, i8)
4600
4601 define <2 x double>@test_int_x86_avx512_mask_getmant_pd_128(<2 x double> %x0, <2 x double> %x2, i8 %x3) {
4602 ; CHECK-LABEL: test_int_x86_avx512_mask_getmant_pd_128:
4603 ; CHECK:       ## BB#0:
4604 ; CHECK-NEXT:    movzbl %dil, %eax
4605 ; CHECK-NEXT:    kmovw %eax, %k1
4606 ; CHECK-NEXT:    vgetmantpd $11, %xmm0, %xmm1 {%k1}
4607 ; CHECK-NEXT:    vgetmantpd $11, %xmm0, %xmm2 {%k1} {z}
4608 ; CHECK-NEXT:    vgetmantpd $11, %xmm0, %xmm0
4609 ; CHECK-NEXT:    vaddpd %xmm0, %xmm1, %xmm0
4610 ; CHECK-NEXT:    vaddpd %xmm0, %xmm2, %xmm0
4611 ; CHECK-NEXT:    retq
4612   %res = call <2 x double> @llvm.x86.avx512.mask.getmant.pd.128(<2 x double> %x0, i32 11, <2 x double> %x2, i8 %x3)
4613   %res2 = call <2 x double> @llvm.x86.avx512.mask.getmant.pd.128(<2 x double> %x0, i32 11, <2 x double> zeroinitializer, i8 %x3)
4614   %res1 = call <2 x double> @llvm.x86.avx512.mask.getmant.pd.128(<2 x double> %x0, i32 11, <2 x double> %x2, i8 -1)
4615   %res3 = fadd <2 x double> %res, %res1
4616   %res4 = fadd <2 x double> %res2, %res3
4617   ret <2 x double> %res4
4618 }
4619
4620 declare <4 x double> @llvm.x86.avx512.mask.getmant.pd.256(<4 x double>, i32, <4 x double>, i8)
4621
4622 define <4 x double>@test_int_x86_avx512_mask_getmant_pd_256(<4 x double> %x0, <4 x double> %x2, i8 %x3) {
4623 ; CHECK-LABEL: test_int_x86_avx512_mask_getmant_pd_256:
4624 ; CHECK:       ## BB#0:
4625 ; CHECK-NEXT:    movzbl %dil, %eax
4626 ; CHECK-NEXT:    kmovw %eax, %k1
4627 ; CHECK-NEXT:    vgetmantpd $11, %ymm0, %ymm1 {%k1}
4628 ; CHECK-NEXT:    vgetmantpd $11, %ymm0, %ymm0
4629 ; CHECK-NEXT:    vaddpd %ymm0, %ymm1, %ymm0
4630 ; CHECK-NEXT:    retq
4631   %res = call <4 x double> @llvm.x86.avx512.mask.getmant.pd.256(<4 x double> %x0, i32 11, <4 x double> %x2, i8 %x3)
4632   %res1 = call <4 x double> @llvm.x86.avx512.mask.getmant.pd.256(<4 x double> %x0, i32 11, <4 x double> %x2, i8 -1)
4633   %res2 = fadd <4 x double> %res, %res1
4634   ret <4 x double> %res2
4635 }
4636
4637 declare <4 x float> @llvm.x86.avx512.mask.getmant.ps.128(<4 x float>, i32, <4 x float>, i8)
4638
4639 define <4 x float>@test_int_x86_avx512_mask_getmant_ps_128(<4 x float> %x0, <4 x float> %x2, i8 %x3) {
4640 ; CHECK-LABEL: test_int_x86_avx512_mask_getmant_ps_128:
4641 ; CHECK:       ## BB#0:
4642 ; CHECK-NEXT:    movzbl %dil, %eax
4643 ; CHECK-NEXT:    kmovw %eax, %k1
4644 ; CHECK-NEXT:    vgetmantps $11, %xmm0, %xmm1 {%k1}
4645 ; CHECK-NEXT:    vgetmantps $11, %xmm0, %xmm0
4646 ; CHECK-NEXT:    vaddps %xmm0, %xmm1, %xmm0
4647 ; CHECK-NEXT:    retq
4648   %res = call <4 x float> @llvm.x86.avx512.mask.getmant.ps.128(<4 x float> %x0, i32 11, <4 x float> %x2, i8 %x3)
4649   %res1 = call <4 x float> @llvm.x86.avx512.mask.getmant.ps.128(<4 x float> %x0, i32 11, <4 x float> %x2, i8 -1)
4650   %res2 = fadd <4 x float> %res, %res1
4651   ret <4 x float> %res2
4652 }
4653
4654 declare <8 x float> @llvm.x86.avx512.mask.getmant.ps.256(<8 x float>, i32, <8 x float>, i8)
4655
4656 define <8 x float>@test_int_x86_avx512_mask_getmant_ps_256(<8 x float> %x0, <8 x float> %x2, i8 %x3) {
4657 ; CHECK-LABEL: test_int_x86_avx512_mask_getmant_ps_256:
4658 ; CHECK:       ## BB#0:
4659 ; CHECK-NEXT:    movzbl %dil, %eax
4660 ; CHECK-NEXT:    kmovw %eax, %k1
4661 ; CHECK-NEXT:    vgetmantps $11, %ymm0, %ymm1 {%k1}
4662 ; CHECK-NEXT:    vgetmantps $11, %ymm0, %ymm0
4663 ; CHECK-NEXT:    vaddps %ymm0, %ymm1, %ymm0
4664 ; CHECK-NEXT:    retq
4665   %res = call <8 x float> @llvm.x86.avx512.mask.getmant.ps.256(<8 x float> %x0, i32 11, <8 x float> %x2, i8 %x3)
4666   %res1 = call <8 x float> @llvm.x86.avx512.mask.getmant.ps.256(<8 x float> %x0, i32 11, <8 x float> %x2, i8 -1)
4667   %res2 = fadd <8 x float> %res, %res1
4668   ret <8 x float> %res2
4669 }
4670
4671 declare <2 x double> @llvm.x86.avx512.mask.shuf.pd.128(<2 x double>, <2 x double>, i32, <2 x double>, i8)
4672
4673 define <2 x double>@test_int_x86_avx512_mask_shuf_pd_128(<2 x double> %x0, <2 x double> %x1, <2 x double> %x3, i8 %x4) {
4674 ; CHECK-LABEL: test_int_x86_avx512_mask_shuf_pd_128:
4675 ; CHECK:       ## BB#0:
4676 ; CHECK-NEXT:    movzbl %dil, %eax
4677 ; CHECK-NEXT:    kmovw %eax, %k1
4678 ; CHECK-NEXT:    vshufpd $22, %xmm1, %xmm0, %xmm2 {%k1}
4679 ; CHECK-NEXT:    vshufpd $22, %xmm1, %xmm0, %xmm3 {%k1} {z}
4680 ; CHECK-NEXT:    vshufpd $22, %xmm1, %xmm0, %xmm0
4681 ; CHECK:         vaddpd %xmm0, %xmm2, %xmm0
4682 ; CHECK-NEXT:    vaddpd %xmm0, %xmm3, %xmm0
4683 ; CHECK-NEXT:    retq
4684   %res = call <2 x double> @llvm.x86.avx512.mask.shuf.pd.128(<2 x double> %x0, <2 x double> %x1, i32 22, <2 x double> %x3, i8 %x4)
4685   %res1 = call <2 x double> @llvm.x86.avx512.mask.shuf.pd.128(<2 x double> %x0, <2 x double> %x1, i32 22, <2 x double> %x3, i8 -1)
4686   %res2 = call <2 x double> @llvm.x86.avx512.mask.shuf.pd.128(<2 x double> %x0, <2 x double> %x1, i32 22, <2 x double> zeroinitializer, i8 %x4)
4687   %res3 = fadd <2 x double> %res, %res1
4688   %res4 = fadd <2 x double> %res2, %res3
4689   ret <2 x double> %res4
4690 }
4691
4692 declare <4 x double> @llvm.x86.avx512.mask.shuf.pd.256(<4 x double>, <4 x double>, i32, <4 x double>, i8)
4693
4694 define <4 x double>@test_int_x86_avx512_mask_shuf_pd_256(<4 x double> %x0, <4 x double> %x1, <4 x double> %x3, i8 %x4) {
4695 ; CHECK-LABEL: test_int_x86_avx512_mask_shuf_pd_256:
4696 ; CHECK:       ## BB#0:
4697 ; CHECK-NEXT:    movzbl %dil, %eax
4698 ; CHECK-NEXT:    kmovw %eax, %k1
4699 ; CHECK-NEXT:    vshufpd $22, %ymm1, %ymm0, %ymm2 {%k1}
4700 ; CHECK-NEXT:    vshufpd $22, %ymm1, %ymm0, %ymm0
4701 ; CHECK:         vaddpd %ymm0, %ymm2, %ymm0
4702 ; CHECK-NEXT:    retq
4703   %res = call <4 x double> @llvm.x86.avx512.mask.shuf.pd.256(<4 x double> %x0, <4 x double> %x1, i32 22, <4 x double> %x3, i8 %x4)
4704   %res1 = call <4 x double> @llvm.x86.avx512.mask.shuf.pd.256(<4 x double> %x0, <4 x double> %x1, i32 22, <4 x double> %x3, i8 -1)
4705   %res2 = fadd <4 x double> %res, %res1
4706   ret <4 x double> %res2
4707 }
4708
4709 declare <4 x float> @llvm.x86.avx512.mask.shuf.ps.128(<4 x float>, <4 x float>, i32, <4 x float>, i8)
4710
4711 define <4 x float>@test_int_x86_avx512_mask_shuf_ps_128(<4 x float> %x0, <4 x float> %x1, <4 x float> %x3, i8 %x4) {
4712 ; CHECK-LABEL: test_int_x86_avx512_mask_shuf_ps_128:
4713 ; CHECK:       ## BB#0:
4714 ; CHECK-NEXT:    movzbl %dil, %eax
4715 ; CHECK-NEXT:    kmovw %eax, %k1
4716 ; CHECK-NEXT:    vshufps $22, %xmm1, %xmm0, %xmm2 {%k1}
4717 ; CHECK-NEXT:    vshufps $22, %xmm1, %xmm0, %xmm0
4718 ; CHECK:         vaddps %xmm0, %xmm2, %xmm0
4719 ; CHECK-NEXT:    retq
4720   %res = call <4 x float> @llvm.x86.avx512.mask.shuf.ps.128(<4 x float> %x0, <4 x float> %x1, i32 22, <4 x float> %x3, i8 %x4)
4721   %res1 = call <4 x float> @llvm.x86.avx512.mask.shuf.ps.128(<4 x float> %x0, <4 x float> %x1, i32 22, <4 x float> %x3, i8 -1)
4722   %res2 = fadd <4 x float> %res, %res1
4723   ret <4 x float> %res2
4724 }
4725
4726 declare <8 x float> @llvm.x86.avx512.mask.shuf.ps.256(<8 x float>, <8 x float>, i32, <8 x float>, i8)
4727
4728 define <8 x float>@test_int_x86_avx512_mask_shuf_ps_256(<8 x float> %x0, <8 x float> %x1, <8 x float> %x3, i8 %x4) {
4729 ; CHECK-LABEL: test_int_x86_avx512_mask_shuf_ps_256:
4730 ; CHECK:       ## BB#0:
4731 ; CHECK-NEXT:    movzbl %dil, %eax
4732 ; CHECK-NEXT:    kmovw %eax, %k1
4733 ; CHECK-NEXT:    vshufps $22, %ymm1, %ymm0, %ymm2 {%k1}
4734 ; CHECK-NEXT:    vshufps $22, %ymm1, %ymm0, %ymm0
4735 ; CHECK:         vaddps %ymm0, %ymm2, %ymm0
4736 ; CHECK-NEXT:    retq
4737   %res = call <8 x float> @llvm.x86.avx512.mask.shuf.ps.256(<8 x float> %x0, <8 x float> %x1, i32 22, <8 x float> %x3, i8 %x4)
4738   %res1 = call <8 x float> @llvm.x86.avx512.mask.shuf.ps.256(<8 x float> %x0, <8 x float> %x1, i32 22, <8 x float> %x3, i8 -1)
4739   %res2 = fadd <8 x float> %res, %res1
4740   ret <8 x float> %res2
4741 }
4742
4743 declare <4 x i32> @llvm.x86.avx512.mask.valign.d.128(<4 x i32>, <4 x i32>, i32, <4 x i32>, i8)
4744
4745 define <4 x i32>@test_int_x86_avx512_mask_valign_d_128(<4 x i32> %x0, <4 x i32> %x1,<4 x i32> %x3, i8 %x4) {
4746 ; CHECK-LABEL: test_int_x86_avx512_mask_valign_d_128:
4747 ; CHECK:       ## BB#0:
4748 ; CHECK-NEXT:    movzbl %dil, %eax
4749 ; CHECK-NEXT:    kmovw %eax, %k1
4750 ; CHECK-NEXT:    valignd $22, %xmm1, %xmm0, %xmm2 {%k1}
4751 ; CHECK-NEXT:    valignd $22, %xmm1, %xmm0, %xmm3 {%k1} {z}
4752 ; CHECK-NEXT:    valignd $22, %xmm1, %xmm0, %xmm0
4753 ; CHECK-NEXT:    vpaddd %xmm0, %xmm2, %xmm0
4754 ; CHECK-NEXT:    vpaddd %xmm3, %xmm0, %xmm0
4755 ; CHECK-NEXT:    retq
4756   %res = call <4 x i32> @llvm.x86.avx512.mask.valign.d.128(<4 x i32> %x0, <4 x i32> %x1, i32 22, <4 x i32> %x3, i8 %x4)
4757   %res1 = call <4 x i32> @llvm.x86.avx512.mask.valign.d.128(<4 x i32> %x0, <4 x i32> %x1, i32 22, <4 x i32> %x3, i8 -1)
4758     %res2 = call <4 x i32> @llvm.x86.avx512.mask.valign.d.128(<4 x i32> %x0, <4 x i32> %x1, i32 22, <4 x i32> zeroinitializer,i8 %x4)
4759   %res3 = add <4 x i32> %res, %res1
4760     %res4 = add <4 x i32> %res3, %res2
4761   ret <4 x i32> %res4
4762 }
4763
4764 declare <8 x i32> @llvm.x86.avx512.mask.valign.d.256(<8 x i32>, <8 x i32>, i32, <8 x i32>, i8)
4765
4766 define <8 x i32>@test_int_x86_avx512_mask_valign_d_256(<8 x i32> %x0, <8 x i32> %x1, <8 x i32> %x3, i8 %x4) {
4767 ; CHECK-LABEL: test_int_x86_avx512_mask_valign_d_256:
4768 ; CHECK:       ## BB#0:
4769 ; CHECK-NEXT:    movzbl %dil, %eax
4770 ; CHECK-NEXT:    kmovw %eax, %k1
4771 ; CHECK-NEXT:    valignd $22, %ymm1, %ymm0, %ymm2 {%k1}
4772 ; CHECK-NEXT:    valignd $22, %ymm1, %ymm0, %ymm0
4773 ; CHECK-NEXT:    vpaddd %ymm0, %ymm2, %ymm0
4774 ; CHECK-NEXT:    retq
4775   %res = call <8 x i32> @llvm.x86.avx512.mask.valign.d.256(<8 x i32> %x0, <8 x i32> %x1, i32 22, <8 x i32> %x3, i8 %x4)
4776   %res1 = call <8 x i32> @llvm.x86.avx512.mask.valign.d.256(<8 x i32> %x0, <8 x i32> %x1, i32 22, <8 x i32> %x3, i8 -1)
4777   %res2 = add <8 x i32> %res, %res1
4778   ret <8 x i32> %res2
4779 }
4780
4781 declare <2 x i64> @llvm.x86.avx512.mask.valign.q.128(<2 x i64>, <2 x i64>, i32, <2 x i64>, i8)
4782
4783 define <2 x i64>@test_int_x86_avx512_mask_valign_q_128(<2 x i64> %x0, <2 x i64> %x1, <2 x i64> %x3, i8 %x4) {
4784 ; CHECK-LABEL: test_int_x86_avx512_mask_valign_q_128:
4785 ; CHECK:       ## BB#0:
4786 ; CHECK-NEXT:    movzbl %dil, %eax
4787 ; CHECK-NEXT:    kmovw %eax, %k1
4788 ; CHECK-NEXT:    valignq $22, %xmm1, %xmm0, %xmm2 {%k1}
4789 ; CHECK-NEXT:    valignq $22, %xmm1, %xmm0, %xmm0
4790 ; CHECK-NEXT:    vpaddq %xmm0, %xmm2, %xmm0
4791 ; CHECK-NEXT:    retq
4792   %res = call <2 x i64> @llvm.x86.avx512.mask.valign.q.128(<2 x i64> %x0, <2 x i64> %x1, i32 22, <2 x i64> %x3, i8 %x4)
4793   %res1 = call <2 x i64> @llvm.x86.avx512.mask.valign.q.128(<2 x i64> %x0, <2 x i64> %x1, i32 22, <2 x i64> %x3, i8 -1)
4794   %res2 = add <2 x i64> %res, %res1
4795   ret <2 x i64> %res2
4796 }
4797
4798 declare <4 x i64> @llvm.x86.avx512.mask.valign.q.256(<4 x i64>, <4 x i64>, i32, <4 x i64>, i8)
4799
4800 define <4 x i64>@test_int_x86_avx512_mask_valign_q_256(<4 x i64> %x0, <4 x i64> %x1, <4 x i64> %x3, i8 %x4) {
4801 ; CHECK-LABEL: test_int_x86_avx512_mask_valign_q_256:
4802 ; CHECK:       ## BB#0:
4803 ; CHECK-NEXT:    movzbl %dil, %eax
4804 ; CHECK-NEXT:    kmovw %eax, %k1
4805 ; CHECK-NEXT:    valignq $22, %ymm1, %ymm0, %ymm2 {%k1}
4806 ; CHECK-NEXT:    valignq $22, %ymm1, %ymm0, %ymm0
4807 ; CHECK-NEXT:    vpaddq %ymm0, %ymm2, %ymm0
4808 ; CHECK-NEXT:    retq
4809   %res = call <4 x i64> @llvm.x86.avx512.mask.valign.q.256(<4 x i64> %x0, <4 x i64> %x1, i32 22, <4 x i64> %x3, i8 %x4)
4810   %res1 = call <4 x i64> @llvm.x86.avx512.mask.valign.q.256(<4 x i64> %x0, <4 x i64> %x1, i32 22, <4 x i64> %x3, i8 -1)
4811   %res2 = add <4 x i64> %res, %res1
4812   ret <4 x i64> %res2
4813 }
4814
4815 declare <4 x double> @llvm.x86.avx512.mask.vpermil.pd.256(<4 x double>, i32, <4 x double>, i8)
4816
4817 define <4 x double>@test_int_x86_avx512_mask_vpermil_pd_256(<4 x double> %x0, <4 x double> %x2, i8 %x3) {
4818 ; CHECK-LABEL: test_int_x86_avx512_mask_vpermil_pd_256:
4819 ; CHECK:       ## BB#0:
4820 ; CHECK-NEXT:    movzbl %dil, %eax
4821 ; CHECK-NEXT:    kmovw %eax, %k1
4822 ; CHECK-NEXT:    vpermilpd $22, %ymm0, %ymm1 {%k1}
4823 ; CHECK-NEXT:    vpermilpd $22, %ymm0, %ymm2 {%k1} {z}
4824 ; CHECK-NEXT:    vpermilpd $22, %ymm0, %ymm0
4825 ; CHECK-NEXT:    vaddpd %ymm2, %ymm1, %ymm1
4826 ; CHECK-NEXT:    vaddpd %ymm1, %ymm0, %ymm0
4827 ; CHECK-NEXT:    retq
4828   %res = call <4 x double> @llvm.x86.avx512.mask.vpermil.pd.256(<4 x double> %x0, i32 22, <4 x double> %x2, i8 %x3)
4829   %res1 = call <4 x double> @llvm.x86.avx512.mask.vpermil.pd.256(<4 x double> %x0, i32 22, <4 x double> zeroinitializer, i8 %x3)
4830   %res2 = call <4 x double> @llvm.x86.avx512.mask.vpermil.pd.256(<4 x double> %x0, i32 22, <4 x double> %x2, i8 -1)
4831   %res3 = fadd <4 x double> %res, %res1
4832   %res4 = fadd <4 x double> %res2, %res3
4833   ret <4 x double> %res4
4834 }
4835
4836 declare <2 x double> @llvm.x86.avx512.mask.vpermil.pd.128(<2 x double>, i32, <2 x double>, i8)
4837
4838 define <2 x double>@test_int_x86_avx512_mask_vpermil_pd_128(<2 x double> %x0, <2 x double> %x2, i8 %x3) {
4839 ; CHECK-LABEL: test_int_x86_avx512_mask_vpermil_pd_128:
4840 ; CHECK:       ## BB#0:
4841 ; CHECK-NEXT:    movzbl %dil, %eax
4842 ; CHECK-NEXT:    kmovw %eax, %k1
4843 ; CHECK-NEXT:    vpermilpd $1, %xmm0, %xmm1 {%k1}
4844 ; CHECK-NEXT:    vpermilpd $1, %xmm0, %xmm2 {%k1} {z}
4845 ; CHECK-NEXT:    vpermilpd $1, %xmm0, %xmm0
4846 ; CHECK-NEXT:    vaddpd %xmm2, %xmm1, %xmm1
4847 ; CHECK-NEXT:    vaddpd %xmm0, %xmm1, %xmm0
4848 ; CHECK-NEXT:    retq
4849   %res = call <2 x double> @llvm.x86.avx512.mask.vpermil.pd.128(<2 x double> %x0, i32 1, <2 x double> %x2, i8 %x3)
4850   %res1 = call <2 x double> @llvm.x86.avx512.mask.vpermil.pd.128(<2 x double> %x0, i32 1, <2 x double> zeroinitializer, i8 %x3)
4851   %res2 = call <2 x double> @llvm.x86.avx512.mask.vpermil.pd.128(<2 x double> %x0, i32 1, <2 x double> %x2, i8 -1)
4852   %res3 = fadd <2 x double> %res, %res1
4853   %res4 = fadd <2 x double> %res3, %res2
4854   ret <2 x double> %res4
4855 }
4856
4857 declare <8 x float> @llvm.x86.avx512.mask.vpermil.ps.256(<8 x float>, i32, <8 x float>, i8)
4858
4859 define <8 x float>@test_int_x86_avx512_mask_vpermil_ps_256(<8 x float> %x0, <8 x float> %x2, i8 %x3) {
4860 ; CHECK-LABEL: test_int_x86_avx512_mask_vpermil_ps_256:
4861 ; CHECK:       ## BB#0:
4862 ; CHECK-NEXT:    movzbl %dil, %eax
4863 ; CHECK-NEXT:    kmovw %eax, %k1
4864 ; CHECK-NEXT:    vpermilps $22, %ymm0, %ymm1 {%k1}
4865 ; CHECK-NEXT:    vpermilps $22, %ymm0, %ymm2 {%k1} {z}
4866 ; CHECK-NEXT:    vpermilps $22, %ymm0, %ymm0
4867 ; CHECK-NEXT:    vaddps %ymm2, %ymm1, %ymm1
4868 ; CHECK-NEXT:    vaddps %ymm0, %ymm1, %ymm0
4869 ; CHECK-NEXT:    retq
4870   %res = call <8 x float> @llvm.x86.avx512.mask.vpermil.ps.256(<8 x float> %x0, i32 22, <8 x float> %x2, i8 %x3)
4871   %res1 = call <8 x float> @llvm.x86.avx512.mask.vpermil.ps.256(<8 x float> %x0, i32 22, <8 x float> zeroinitializer, i8 %x3)
4872   %res2 = call <8 x float> @llvm.x86.avx512.mask.vpermil.ps.256(<8 x float> %x0, i32 22, <8 x float> %x2, i8 -1)
4873   %res3 = fadd <8 x float> %res, %res1
4874   %res4 = fadd <8 x float> %res3, %res2
4875   ret <8 x float> %res4
4876 }
4877
4878 declare <4 x float> @llvm.x86.avx512.mask.vpermil.ps.128(<4 x float>, i32, <4 x float>, i8)
4879
4880 define <4 x float>@test_int_x86_avx512_mask_vpermil_ps_128(<4 x float> %x0, <4 x float> %x2, i8 %x3) {
4881 ; CHECK-LABEL: test_int_x86_avx512_mask_vpermil_ps_128:
4882 ; CHECK:       ## BB#0:
4883 ; CHECK-NEXT:    movzbl %dil, %eax
4884 ; CHECK-NEXT:    kmovw %eax, %k1
4885 ; CHECK-NEXT:    vpermilps $22, %xmm0, %xmm1 {%k1}
4886 ; CHECK-NEXT:    vpermilps $22, %xmm0, %xmm2 {%k1} {z}
4887 ; CHECK-NEXT:    vpermilps $22, %xmm0, %xmm0
4888 ; CHECK-NEXT:    vaddps %xmm2, %xmm1, %xmm1
4889 ; CHECK-NEXT:    vaddps %xmm1, %xmm0, %xmm0
4890 ; CHECK-NEXT:    retq
4891   %res = call <4 x float> @llvm.x86.avx512.mask.vpermil.ps.128(<4 x float> %x0, i32 22, <4 x float> %x2, i8 %x3)
4892   %res1 = call <4 x float> @llvm.x86.avx512.mask.vpermil.ps.128(<4 x float> %x0, i32 22, <4 x float> zeroinitializer, i8 %x3)
4893   %res2 = call <4 x float> @llvm.x86.avx512.mask.vpermil.ps.128(<4 x float> %x0, i32 22, <4 x float> %x2, i8 -1)
4894   %res3 = fadd <4 x float> %res, %res1
4895   %res4 = fadd <4 x float> %res2, %res3
4896   ret <4 x float> %res4
4897 }
4898
4899 declare <4 x double> @llvm.x86.avx512.mask.vpermilvar.pd.256(<4 x double>, <4 x i64>, <4 x double>, i8)
4900
4901 define <4 x double>@test_int_x86_avx512_mask_vpermilvar_pd_256(<4 x double> %x0, <4 x i64> %x1, <4 x double> %x2, i8 %x3) {
4902 ; CHECK-LABEL: test_int_x86_avx512_mask_vpermilvar_pd_256:
4903 ; CHECK:       ## BB#0:
4904 ; CHECK-NEXT:    movzbl %dil, %eax
4905 ; CHECK-NEXT:    kmovw %eax, %k1
4906 ; CHECK-NEXT:    vpermilpd %ymm1, %ymm0, %ymm2 {%k1}
4907 ; CHECK-NEXT:    vpermilpd %ymm1, %ymm0, %ymm3 {%k1} {z}
4908 ; CHECK-NEXT:    vpermilpd %ymm1, %ymm0, %ymm0
4909 ; CHECK-NEXT:    vaddpd %ymm3, %ymm2, %ymm1
4910 ; CHECK-NEXT:    vaddpd %ymm1, %ymm0, %ymm0
4911 ; CHECK-NEXT:    retq
4912   %res = call <4 x double> @llvm.x86.avx512.mask.vpermilvar.pd.256(<4 x double> %x0, <4 x i64> %x1, <4 x double> %x2, i8 %x3)
4913   %res1 = call <4 x double> @llvm.x86.avx512.mask.vpermilvar.pd.256(<4 x double> %x0, <4 x i64> %x1, <4 x double> zeroinitializer, i8 %x3)
4914   %res2 = call <4 x double> @llvm.x86.avx512.mask.vpermilvar.pd.256(<4 x double> %x0, <4 x i64> %x1, <4 x double> %x2, i8 -1)
4915   %res3 = fadd <4 x double> %res, %res1
4916   %res4 = fadd <4 x double> %res2, %res3
4917   ret <4 x double> %res4
4918 }
4919
4920 declare <2 x double> @llvm.x86.avx512.mask.vpermilvar.pd.128(<2 x double>, <2 x i64>, <2 x double>, i8)
4921
4922 define <2 x double>@test_int_x86_avx512_mask_vpermilvar_pd_128(<2 x double> %x0, <2 x i64> %x1, <2 x double> %x2, i8 %x3) {
4923 ; CHECK-LABEL: test_int_x86_avx512_mask_vpermilvar_pd_128:
4924 ; CHECK:       ## BB#0:
4925 ; CHECK-NEXT:    movzbl %dil, %eax
4926 ; CHECK-NEXT:    kmovw %eax, %k1
4927 ; CHECK-NEXT:    vpermilpd %xmm1, %xmm0, %xmm2 {%k1}
4928 ; CHECK-NEXT:    vpermilpd %xmm1, %xmm0, %xmm3 {%k1} {z}
4929 ; CHECK-NEXT:    vpermilpd %xmm1, %xmm0, %xmm0
4930 ; CHECK-NEXT:    vaddpd %xmm3, %xmm2, %xmm1
4931 ; CHECK-NEXT:    vaddpd %xmm0, %xmm1, %xmm0
4932 ; CHECK-NEXT:    retq
4933   %res = call <2 x double> @llvm.x86.avx512.mask.vpermilvar.pd.128(<2 x double> %x0, <2 x i64> %x1, <2 x double> %x2, i8 %x3)
4934   %res1 = call <2 x double> @llvm.x86.avx512.mask.vpermilvar.pd.128(<2 x double> %x0, <2 x i64> %x1, <2 x double> zeroinitializer, i8 %x3)
4935   %res2 = call <2 x double> @llvm.x86.avx512.mask.vpermilvar.pd.128(<2 x double> %x0, <2 x i64> %x1, <2 x double> %x2, i8 -1)
4936   %res3 = fadd <2 x double> %res, %res1
4937   %res4 = fadd <2 x double> %res3, %res2
4938   ret <2 x double> %res4
4939 }
4940
4941 declare <8 x float> @llvm.x86.avx512.mask.vpermilvar.ps.256(<8 x float>, <8 x i32>, <8 x float>, i8)
4942
4943 define <8 x float>@test_int_x86_avx512_mask_vpermilvar_ps_256(<8 x float> %x0, <8 x i32> %x1, <8 x float> %x2, i8 %x3) {
4944 ; CHECK-LABEL: test_int_x86_avx512_mask_vpermilvar_ps_256:
4945 ; CHECK:       ## BB#0:
4946 ; CHECK-NEXT:    movzbl %dil, %eax
4947 ; CHECK-NEXT:    kmovw %eax, %k1
4948 ; CHECK-NEXT:    vpermilps %ymm1, %ymm0, %ymm2 {%k1}
4949 ; CHECK-NEXT:    vpermilps %ymm1, %ymm0, %ymm3 {%k1} {z}
4950 ; CHECK-NEXT:    vpermilps %ymm1, %ymm0, %ymm0
4951 ; CHECK-NEXT:    vaddps %ymm3, %ymm2, %ymm1
4952 ; CHECK-NEXT:    vaddps %ymm0, %ymm1, %ymm0
4953 ; CHECK-NEXT:    retq
4954   %res = call <8 x float> @llvm.x86.avx512.mask.vpermilvar.ps.256(<8 x float> %x0, <8 x i32> %x1, <8 x float> %x2, i8 %x3)
4955   %res1 = call <8 x float> @llvm.x86.avx512.mask.vpermilvar.ps.256(<8 x float> %x0, <8 x i32> %x1, <8 x float> zeroinitializer, i8 %x3)
4956   %res2 = call <8 x float> @llvm.x86.avx512.mask.vpermilvar.ps.256(<8 x float> %x0, <8 x i32> %x1, <8 x float> %x2, i8 -1)
4957   %res3 = fadd <8 x float> %res, %res1
4958   %res4 = fadd <8 x float> %res3, %res2
4959   ret <8 x float> %res4
4960 }
4961
4962 declare <4 x float> @llvm.x86.avx512.mask.vpermilvar.ps.128(<4 x float>, <4 x i32>, <4 x float>, i8)
4963
4964 define <4 x float>@test_int_x86_avx512_mask_vpermilvar_ps_128(<4 x float> %x0, <4 x i32> %x1, <4 x float> %x2, i8 %x3) {
4965 ; CHECK-LABEL: test_int_x86_avx512_mask_vpermilvar_ps_128:
4966 ; CHECK:       ## BB#0:
4967 ; CHECK-NEXT:    movzbl %dil, %eax
4968 ; CHECK-NEXT:    kmovw %eax, %k1
4969 ; CHECK-NEXT:    vpermilps %xmm1, %xmm0, %xmm2 {%k1}
4970 ; CHECK-NEXT:    vpermilps %xmm1, %xmm0, %xmm3 {%k1} {z}
4971 ; CHECK-NEXT:    vpermilps %xmm1, %xmm0, %xmm0
4972 ; CHECK-NEXT:    vaddps %xmm3, %xmm2, %xmm1
4973 ; CHECK-NEXT:    vaddps %xmm1, %xmm0, %xmm0
4974 ; CHECK-NEXT:    retq
4975   %res = call <4 x float> @llvm.x86.avx512.mask.vpermilvar.ps.128(<4 x float> %x0, <4 x i32> %x1, <4 x float> %x2, i8 %x3)
4976   %res1 = call <4 x float> @llvm.x86.avx512.mask.vpermilvar.ps.128(<4 x float> %x0, <4 x i32> %x1, <4 x float> zeroinitializer, i8 %x3)
4977   %res2 = call <4 x float> @llvm.x86.avx512.mask.vpermilvar.ps.128(<4 x float> %x0, <4 x i32> %x1, <4 x float> %x2, i8 -1)
4978   %res3 = fadd <4 x float> %res, %res1
4979   %res4 = fadd <4 x float> %res2, %res3
4980   ret <4 x float> %res4
4981 }
4982
4983 declare <8 x float> @llvm.x86.avx512.mask.insertf32x4.256(<8 x float>, <4 x float>, i32, <8 x float>, i8)
4984
4985 define <8 x float>@test_int_x86_avx512_mask_insertf32x4_256(<8 x float> %x0, <4 x float> %x1, <8 x float> %x3, i8 %x4) {
4986 ; CHECK-LABEL: test_int_x86_avx512_mask_insertf32x4_256:
4987 ; CHECK:       ## BB#0:
4988 ; CHECK-NEXT:    movzbl %dil, %eax
4989 ; CHECK-NEXT:    kmovw %eax, %k1
4990 ; CHECK-NEXT:    vinsertf32x4 $1, %xmm1, %ymm0, %ymm2 {%k1}
4991 ; CHECK-NEXT:    vinsertf32x4 $1, %xmm1, %ymm0, %ymm3 {%k1} {z}
4992 ; CHECK-NEXT:    vinsertf32x4 $1, %xmm1, %ymm0, %ymm0
4993 ; CHECK-NEXT:    vaddps %ymm0, %ymm2, %ymm0
4994 ; CHECK-NEXT:    vaddps %ymm0, %ymm3, %ymm0
4995 ; CHECK-NEXT:    retq
4996   %res = call <8 x float> @llvm.x86.avx512.mask.insertf32x4.256(<8 x float> %x0, <4 x float> %x1, i32 1, <8 x float> %x3, i8 %x4)
4997   %res1 = call <8 x float> @llvm.x86.avx512.mask.insertf32x4.256(<8 x float> %x0, <4 x float> %x1, i32 1, <8 x float> %x3, i8 -1)
4998   %res2 = call <8 x float> @llvm.x86.avx512.mask.insertf32x4.256(<8 x float> %x0, <4 x float> %x1, i32 1, <8 x float> zeroinitializer, i8 %x4)
4999   %res3 = fadd <8 x float> %res, %res1
5000   %res4 = fadd <8 x float> %res2, %res3
5001   ret <8 x float> %res4
5002 }
5003
5004 declare <8 x i32> @llvm.x86.avx512.mask.inserti32x4.256(<8 x i32>, <4 x i32>, i32, <8 x i32>, i8)
5005
5006 define <8 x i32>@test_int_x86_avx512_mask_inserti32x4_256(<8 x i32> %x0, <4 x i32> %x1, <8 x i32> %x3, i8 %x4) {
5007 ; CHECK-LABEL: test_int_x86_avx512_mask_inserti32x4_256:
5008 ; CHECK:       ## BB#0:
5009 ; CHECK-NEXT:    movzbl %dil, %eax
5010 ; CHECK-NEXT:    kmovw %eax, %k1
5011 ; CHECK-NEXT:    vinserti32x4 $1, %xmm1, %ymm0, %ymm2 {%k1}
5012 ; CHECK-NEXT:    vinserti32x4 $1, %xmm1, %ymm0, %ymm3 {%k1} {z}
5013 ; CHECK-NEXT:    vinserti32x4 $1, %xmm1, %ymm0, %ymm0
5014 ; CHECK-NEXT:    vpaddd %ymm0, %ymm2, %ymm0
5015 ; CHECK-NEXT:    vpaddd %ymm0, %ymm3, %ymm0
5016 ; CHECK-NEXT:    retq
5017
5018   %res = call <8 x i32> @llvm.x86.avx512.mask.inserti32x4.256(<8 x i32> %x0, <4 x i32> %x1, i32 1, <8 x i32> %x3, i8 %x4)
5019   %res1 = call <8 x i32> @llvm.x86.avx512.mask.inserti32x4.256(<8 x i32> %x0, <4 x i32> %x1, i32 1, <8 x i32> %x3, i8 -1)
5020   %res2 = call <8 x i32> @llvm.x86.avx512.mask.inserti32x4.256(<8 x i32> %x0, <4 x i32> %x1, i32 1, <8 x i32> zeroinitializer, i8 %x4)
5021   %res3 = add <8 x i32> %res, %res1
5022   %res4 = add <8 x i32> %res2, %res3
5023   ret <8 x i32> %res4
5024 }