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 }