[X86] test/testn intrinsics lowering to IR. clang side

[uriel.k]

Summary

Changed Header files of the intrinsics fro lowering test and testn intrinsics to IR code.
Removed test and testn builtins from clang

this is the clang side, the llvm side revision is D38736.

[craig.topper]

lib/Headers/avx512bwintrin.h

2107

Can you align this with the opening paren on the line above? Same with all the other functions below.

[craig.topper]

lib/Headers/avx512vlbwintrin.h

2798

Sorry I didn't catch this before, but can you use _MM_CMPINT_NE and _MM_CMPINT_EQ instead of '4' and '0' in all of these? Then no one has to guess what 4 and 0 means.

[craig.topper]

lib/Headers/avx512vlbwintrin.h

2798

Better yet, use _mm512_cmpneq_epi32_mask, __mm512_cmpeq_epi32_mask and friends

[uriel.k]

lib/Headers/avx512vlbwintrin.h

2798

For strange reason this line moved and is not aligned with the open paren above it. If there are no other corrections I'll fix it before the commit.

[uriel.k]

lib/Headers/avx512vlbwintrin.h

2798

I meant of course for all the lines that moved

[craig.topper]

LGTM

include/clang/Basic/BuiltinsX86.def

 TARGET_BUILTIN(__builtin_ia32_pmaxud512_mask, "V16iV16iV16iV16iUs", "", "avx512f")
 TARGET_BUILTIN(__builtin_ia32_pmaxuq512_mask, "V8LLiV8LLiV8LLiV8LLiUc", "", "avx512f")
 TARGET_BUILTIN(__builtin_ia32_pminsd512_mask, "V16iV16iV16iV16iUs", "", "avx512f")
 TARGET_BUILTIN(__builtin_ia32_pminsq512_mask, "V8LLiV8LLiV8LLiV8LLiUc", "", "avx512f")
 TARGET_BUILTIN(__builtin_ia32_pminud512_mask, "V16iV16iV16iV16iUs", "", "avx512f")
 TARGET_BUILTIN(__builtin_ia32_pminuq512_mask, "V8LLiV8LLiV8LLiV8LLiUc", "", "avx512f")
 TARGET_BUILTIN(__builtin_ia32_pmuldq512, "V8LLiV16iV16i", "", "avx512f")
 TARGET_BUILTIN(__builtin_ia32_pmuludq512, "V8LLiV16iV16i", "", "avx512f")
-TARGET_BUILTIN(__builtin_ia32_ptestmd512, "UsV16iV16iUs", "", "avx512f")
-TARGET_BUILTIN(__builtin_ia32_ptestmq512, "UcV8LLiV8LLiUc", "", "avx512f")
 TARGET_BUILTIN(__builtin_ia32_loaddqusi512_mask, "V16iiC*V16iUs", "", "avx512f")
 TARGET_BUILTIN(__builtin_ia32_loaddqudi512_mask, "V8LLiLLiC*V8LLiUc", "", "avx512f")
 TARGET_BUILTIN(__builtin_ia32_loadups512_mask, "V16ffC*V16fUs", "", "avx512f")
 TARGET_BUILTIN(__builtin_ia32_loadaps512_mask, "V16fV16fC*V16fUs", "", "avx512f")
 TARGET_BUILTIN(__builtin_ia32_loadupd512_mask, "V8ddC*V8dUc", "", "avx512f")
 TARGET_BUILTIN(__builtin_ia32_loadapd512_mask, "V8dV8dC*V8dUc", "", "avx512f")
 TARGET_BUILTIN(__builtin_ia32_storedqudi512_mask, "vLLi*V8LLiUc", "", "avx512f")
 TARGET_BUILTIN(__builtin_ia32_storedqusi512_mask, "vi*V16iUs", "", "avx512f")

 TARGET_BUILTIN(__builtin_ia32_vpermi2varps512_mask, "V16fV16fV16iV16fUs","","avx512f")
 TARGET_BUILTIN(__builtin_ia32_vpermi2varq512_mask, "V8LLiV8LLiV8LLiV8LLiUc","","avx512f")
 TARGET_BUILTIN(__builtin_ia32_vpermilvarpd512, "V8dV8dV8LLi","","avx512f")
 TARGET_BUILTIN(__builtin_ia32_vpermilvarps512, "V16fV16fV16i","","avx512f")
 TARGET_BUILTIN(__builtin_ia32_vpermt2vard512_maskz, "V16iV16iV16iV16iUs","","avx512f")
 TARGET_BUILTIN(__builtin_ia32_vpermt2varpd512_maskz, "V8dV8LLiV8dV8dUc","","avx512f")
 TARGET_BUILTIN(__builtin_ia32_vpermt2varps512_maskz, "V16fV16iV16fV16fUs","","avx512f")
 TARGET_BUILTIN(__builtin_ia32_vpermt2varq512_maskz, "V8LLiV8LLiV8LLiV8LLiUc","","avx512f")
-TARGET_BUILTIN(__builtin_ia32_ptestmb512, "ULLiV64cV64cULLi","","avx512bw")
-TARGET_BUILTIN(__builtin_ia32_ptestmw512, "UiV32sV32sUi","","avx512bw")
-TARGET_BUILTIN(__builtin_ia32_ptestnmb512, "ULLiV64cV64cULLi","","avx512bw")
-TARGET_BUILTIN(__builtin_ia32_ptestnmw512, "UiV32sV32sUi","","avx512bw")
-TARGET_BUILTIN(__builtin_ia32_ptestmb128, "UsV16cV16cUs","","avx512bw,avx512vl")
-TARGET_BUILTIN(__builtin_ia32_ptestmb256, "UiV32cV32cUi","","avx512bw,avx512vl")
-TARGET_BUILTIN(__builtin_ia32_ptestmw128, "UcV8sV8sUc","","avx512bw,avx512vl")
-TARGET_BUILTIN(__builtin_ia32_ptestmw256, "UsV16sV16sUs","","avx512bw,avx512vl")
-TARGET_BUILTIN(__builtin_ia32_ptestnmb128, "UsV16cV16cUs","","avx512bw,avx512vl")
-TARGET_BUILTIN(__builtin_ia32_ptestnmb256, "UiV32cV32cUi","","avx512bw,avx512vl")
-TARGET_BUILTIN(__builtin_ia32_ptestnmw128, "UcV8sV8sUc","","avx512bw,avx512vl")
-TARGET_BUILTIN(__builtin_ia32_ptestnmw256, "UsV16sV16sUs","","avx512bw,avx512vl")
-TARGET_BUILTIN(__builtin_ia32_ptestmd128, "UcV4iV4iUc","","avx512vl")
-TARGET_BUILTIN(__builtin_ia32_ptestmd256, "UcV8iV8iUc","","avx512vl")
-TARGET_BUILTIN(__builtin_ia32_ptestmq128, "UcV2LLiV2LLiUc","","avx512vl")
-TARGET_BUILTIN(__builtin_ia32_ptestmq256, "UcV4LLiV4LLiUc","","avx512vl")
-TARGET_BUILTIN(__builtin_ia32_ptestnmd128, "UcV4iV4iUc","","avx512vl")
-TARGET_BUILTIN(__builtin_ia32_ptestnmd256, "UcV8iV8iUc","","avx512vl")
-TARGET_BUILTIN(__builtin_ia32_ptestnmq128, "UcV2LLiV2LLiUc","","avx512vl")
-TARGET_BUILTIN(__builtin_ia32_ptestnmq256, "UcV4LLiV4LLiUc","","avx512vl")
-TARGET_BUILTIN(__builtin_ia32_ptestnmd512, "UsV16iV16iUs","","avx512f")
-TARGET_BUILTIN(__builtin_ia32_ptestnmq512, "UcV8LLiV8LLiUc","","avx512f")
 TARGET_BUILTIN(__builtin_ia32_rndscalesd_round_mask, "V2dV2dV2dV2dUcIiIi","","avx512f")
 TARGET_BUILTIN(__builtin_ia32_rndscaless_round_mask, "V4fV4fV4fV4fUcIiIi","","avx512f")
 TARGET_BUILTIN(__builtin_ia32_scalefpd512_mask, "V8dV8dV8dV8dUcIi","","avx512f")
 TARGET_BUILTIN(__builtin_ia32_scalefps512_mask, "V16fV16fV16fV16fUsIi","","avx512f")
 TARGET_BUILTIN(__builtin_ia32_scalefsd_round_mask, "V2dV2dV2dV2dUcIi","","avx512f")
 TARGET_BUILTIN(__builtin_ia32_scalefss_round_mask, "V4fV4fV4fV4fUcIi","","avx512f")
 TARGET_BUILTIN(__builtin_ia32_psradi512, "V16iV16ii","","avx512f")
 TARGET_BUILTIN(__builtin_ia32_psraqi512, "V8LLiV8LLii","","avx512f")

lib/Headers/avx512bwintrin.h

 _mm512_mask_storeu_epi8 (void *__P, __mmask64 __U, __m512i __A)
 {
   __builtin_ia32_storedquqi512_mask ((__v64qi *) __P,
              (__v64qi) __A,
              (__mmask64) __U);
 }
 
 static __inline__ __mmask64 __DEFAULT_FN_ATTRS
-_mm512_test_epi8_mask (__m512i __A, __m512i __B)
-{
-  return (__mmask64) __builtin_ia32_ptestmb512 ((__v64qi) __A,
-            (__v64qi) __B,
-            (__mmask64) -1);
+_mm512_test_epi8_mask(__m512i __A, __m512i __B) {
+  return _mm512_cmp_epi8_mask(_mm512_and_epi32(__A, __B), _mm512_setzero_qi(),
+                              4);
 }
 
 static __inline__ __mmask64 __DEFAULT_FN_ATTRS
-_mm512_mask_test_epi8_mask (__mmask64 __U, __m512i __A, __m512i __B)
-{
-  return (__mmask64) __builtin_ia32_ptestmb512 ((__v64qi) __A,
-            (__v64qi) __B, __U);
+_mm512_mask_test_epi8_mask(__mmask64 __U, __m512i __A, __m512i __B) {
+  return _mm512_mask_cmp_epi8_mask(__U, _mm512_and_epi32(__A, __B),
+                                   _mm512_setzero_qi(), 4);
 }
 
 static __inline__ __mmask32 __DEFAULT_FN_ATTRS
-_mm512_test_epi16_mask (__m512i __A, __m512i __B)
-{
-  return (__mmask32) __builtin_ia32_ptestmw512 ((__v32hi) __A,
-            (__v32hi) __B,
-            (__mmask32) -1);
+_mm512_test_epi16_mask(__m512i __A, __m512i __B) {
+  return _mm512_cmp_epi16_mask(_mm512_and_epi32(__A, __B), _mm512_setzero_qi(),
+                               4);
 }
 
 static __inline__ __mmask32 __DEFAULT_FN_ATTRS
-_mm512_mask_test_epi16_mask (__mmask32 __U, __m512i __A, __m512i __B)
-{
-  return (__mmask32) __builtin_ia32_ptestmw512 ((__v32hi) __A,
-            (__v32hi) __B, __U);
+_mm512_mask_test_epi16_mask(__mmask32 __U, __m512i __A, __m512i __B) {
+  return _mm512_mask_cmp_epi16_mask(__U, _mm512_and_epi32(__A, __B),
+                                    _mm512_setzero_qi(), 4);
 }
 
 static __inline__ __mmask64 __DEFAULT_FN_ATTRS
-_mm512_testn_epi8_mask (__m512i __A, __m512i __B)
-{
-  return (__mmask64) __builtin_ia32_ptestnmb512 ((__v64qi) __A,
-             (__v64qi) __B,
-             (__mmask64) -1);
+_mm512_testn_epi8_mask(__m512i __A, __m512i __B) {
+  return _mm512_cmp_epi8_mask(_mm512_and_epi32(__A, __B), _mm512_setzero_qi(),
+                              0);
 }
 
 static __inline__ __mmask64 __DEFAULT_FN_ATTRS
-_mm512_mask_testn_epi8_mask (__mmask64 __U, __m512i __A, __m512i __B)
-{
-  return (__mmask64) __builtin_ia32_ptestnmb512 ((__v64qi) __A,
-             (__v64qi) __B, __U);
+_mm512_mask_testn_epi8_mask(__mmask64 __U, __m512i __A, __m512i __B) {
+  return _mm512_mask_cmp_epi8_mask(__U, _mm512_and_epi32(__A, __B),
+                                   _mm512_setzero_qi(), 0);
 }
 
 static __inline__ __mmask32 __DEFAULT_FN_ATTRS
-_mm512_testn_epi16_mask (__m512i __A, __m512i __B)
-{
-  return (__mmask32) __builtin_ia32_ptestnmw512 ((__v32hi) __A,
-             (__v32hi) __B,
-             (__mmask32) -1);
+_mm512_testn_epi16_mask(__m512i __A, __m512i __B) {
+  return _mm512_cmp_epi16_mask(_mm512_and_epi32(__A, __B), _mm512_setzero_qi(),
+                               0);
 }
 
 static __inline__ __mmask32 __DEFAULT_FN_ATTRS
-_mm512_mask_testn_epi16_mask (__mmask32 __U, __m512i __A, __m512i __B)
-{
-  return (__mmask32) __builtin_ia32_ptestnmw512 ((__v32hi) __A,
-             (__v32hi) __B, __U);
+_mm512_mask_testn_epi16_mask(__mmask32 __U, __m512i __A, __m512i __B) {
+  return _mm512_mask_cmp_epi16_mask(__U, _mm512_and_epi32(__A, __B),
+                                    _mm512_setzero_qi(), 0);
 }
 
 static __inline__ __mmask64 __DEFAULT_FN_ATTRS
 _mm512_movepi8_mask (__m512i __A)
 {
   return (__mmask64) __builtin_ia32_cvtb2mask512 ((__v64qi) __A);
 }
 

lib/Headers/avx512fintrin.h

 static __inline__ __m512i __DEFAULT_FN_ATTRS
 _mm512_maskz_unpacklo_epi64 (__mmask8 __U, __m512i __A, __m512i __B)
 {
   return (__m512i)__builtin_ia32_selectq_512((__mmask8) __U,
                                         (__v8di)_mm512_unpacklo_epi64(__A, __B),
                                         (__v8di)_mm512_setzero_si512());
 }
 
-/* Bit Test */
-
-static __inline __mmask16 __DEFAULT_FN_ATTRS
-_mm512_test_epi32_mask(__m512i __A, __m512i __B)
-{
-  return (__mmask16) __builtin_ia32_ptestmd512 ((__v16si) __A,
-            (__v16si) __B,
-            (__mmask16) -1);
-}
-
-static __inline__ __mmask16 __DEFAULT_FN_ATTRS
-_mm512_mask_test_epi32_mask (__mmask16 __U, __m512i __A, __m512i __B)
-{
-  return (__mmask16) __builtin_ia32_ptestmd512 ((__v16si) __A,
-                 (__v16si) __B, __U);
-}
-
-static __inline __mmask8 __DEFAULT_FN_ATTRS
-_mm512_test_epi64_mask(__m512i __A, __m512i __B)
-{
-  return (__mmask8) __builtin_ia32_ptestmq512 ((__v8di) __A,
-                 (__v8di) __B,
-                 (__mmask8) -1);
-}
-
-static __inline__ __mmask8 __DEFAULT_FN_ATTRS
-_mm512_mask_test_epi64_mask (__mmask8 __U, __m512i __A, __m512i __B)
-{
-  return (__mmask8) __builtin_ia32_ptestmq512 ((__v8di) __A, (__v8di) __B, __U);
-}
-
 
 /* SIMD load ops */
 
 static __inline __m512i __DEFAULT_FN_ATTRS
 _mm512_loadu_si512 (void const *__P)
 {
   return (__m512i) __builtin_ia32_loaddqusi512_mask ((const int *) __P,
                   (__v16si)

 {
   return (__m512) __builtin_ia32_vpermt2varps512_maskz ((__v16si) __I
                                                         /* idx */ ,
                                                         (__v16sf) __A,
                                                         (__v16sf) __B,
                                                         (__mmask16) __U);
 }
 
-static __inline__ __mmask16 __DEFAULT_FN_ATTRS
-_mm512_testn_epi32_mask (__m512i __A, __m512i __B)
-{
-  return (__mmask16) __builtin_ia32_ptestnmd512 ((__v16si) __A,
-             (__v16si) __B,
-             (__mmask16) -1);
-}
-
-static __inline__ __mmask16 __DEFAULT_FN_ATTRS
-_mm512_mask_testn_epi32_mask (__mmask16 __U, __m512i __A, __m512i __B)
-{
-  return (__mmask16) __builtin_ia32_ptestnmd512 ((__v16si) __A,
-             (__v16si) __B, __U);
-}
-
-static __inline__ __mmask8 __DEFAULT_FN_ATTRS
-_mm512_testn_epi64_mask (__m512i __A, __m512i __B)
-{
-  return (__mmask8) __builtin_ia32_ptestnmq512 ((__v8di) __A,
-            (__v8di) __B,
-            (__mmask8) -1);
-}
-
-static __inline__ __mmask8 __DEFAULT_FN_ATTRS
-_mm512_mask_testn_epi64_mask (__mmask8 __U, __m512i __A, __m512i __B)
-{
-  return (__mmask8) __builtin_ia32_ptestnmq512 ((__v8di) __A,
-            (__v8di) __B, __U);
-}
 
 #define _mm512_cvtt_roundpd_epu32(A, R) __extension__ ({ \
   (__m256i)__builtin_ia32_cvttpd2udq512_mask((__v8df)(__m512d)(A), \
                                              (__v8si)_mm256_undefined_si256(), \
                                              (__mmask8)-1, (int)(R)); })
 
 #define _mm512_mask_cvtt_roundpd_epu32(W, U, A, R) __extension__ ({ \
   (__m256i)__builtin_ia32_cvttpd2udq512_mask((__v8df)(__m512d)(A), \
(__mmask8)__builtin_ia32_cmpsd_mask((__v2df)(__m128d)(X), \
                                       _MM_FROUND_CUR_DIRECTION); })
 
 #define _mm_mask_cmp_sd_mask(M, X, Y, P) __extension__ ({ \
   (__mmask8)__builtin_ia32_cmpsd_mask((__v2df)(__m128d)(X), \
                                       (__v2df)(__m128d)(Y), (int)(P), \
                                       (__mmask8)(M), \
                                       _MM_FROUND_CUR_DIRECTION); })
 
+/* Bit Test */
+
+static __inline __mmask16 __DEFAULT_FN_ATTRS
+_mm512_test_epi32_mask(__m512i __A, __m512i __B) {
+  return _mm512_cmp_epi32_mask(_mm512_and_epi32(__A, __B),
+                               _mm512_setzero_epi32(), 4);
+}
+
+static __inline__ __mmask16 __DEFAULT_FN_ATTRS
+_mm512_mask_test_epi32_mask(__mmask16 __U, __m512i __A, __m512i __B) {
+  return _mm512_mask_cmp_epi32_mask(__U, _mm512_and_epi32(__A, __B),
+                                    _mm512_setzero_epi32(), 4);
+}
+
+static __inline __mmask8 __DEFAULT_FN_ATTRS
+_mm512_test_epi64_mask(__m512i __A, __m512i __B) {
+  return _mm512_cmp_epi64_mask(_mm512_and_epi32(__A, __B),
+                               _mm512_setzero_epi32(), 4);
+}
+
+static __inline__ __mmask8 __DEFAULT_FN_ATTRS
+_mm512_mask_test_epi64_mask(__mmask8 __U, __m512i __A, __m512i __B) {
+  return _mm512_mask_cmp_epi64_mask(__U, _mm512_and_epi32(__A, __B),
+                                    _mm512_setzero_epi32(), 4);
+}
+
+static __inline__ __mmask16 __DEFAULT_FN_ATTRS
+_mm512_testn_epi32_mask(__m512i __A, __m512i __B) {
+  return _mm512_cmp_epi32_mask(_mm512_and_epi32(__A, __B),
+                               _mm512_setzero_epi32(), 0);
+}
+
+static __inline__ __mmask16 __DEFAULT_FN_ATTRS
+_mm512_mask_testn_epi32_mask(__mmask16 __U, __m512i __A, __m512i __B) {
+  return _mm512_mask_cmp_epi32_mask(__U, _mm512_and_epi32(__A, __B),
+                                    _mm512_setzero_epi32(), 0);
+}
+
+static __inline__ __mmask8 __DEFAULT_FN_ATTRS
+_mm512_testn_epi64_mask(__m512i __A, __m512i __B) {
+  return _mm512_cmp_epi64_mask(_mm512_and_epi32(__A, __B),
+                               _mm512_setzero_epi32(), 0);
+}
+
+static __inline__ __mmask8 __DEFAULT_FN_ATTRS
+_mm512_mask_testn_epi64_mask(__mmask8 __U, __m512i __A, __m512i __B) {
+  return _mm512_mask_cmp_epi64_mask(__U, _mm512_and_epi32(__A, __B),
+                                    _mm512_setzero_epi32(), 0);
+}
+
 static __inline__ __m512 __DEFAULT_FN_ATTRS
 _mm512_movehdup_ps (__m512 __A)
 {
   return (__m512)__builtin_shufflevector((__v16sf)__A, (__v16sf)__A,
                          1, 1, 3, 3, 5, 5, 7, 7, 9, 9, 11, 11, 13, 13, 15, 15);
 }
 
 static __inline__ __m512 __DEFAULT_FN_ATTRS

lib/Headers/avx512vlbwintrin.h

 static __inline__ void __DEFAULT_FN_ATTRS
 _mm256_mask_storeu_epi8 (void *__P, __mmask32 __U, __m256i __A)
 {
   __builtin_ia32_storedquqi256_mask ((__v32qi *) __P,
              (__v32qi) __A,
              (__mmask32) __U);
 }
 
-static __inline__ __mmask16 __DEFAULT_FN_ATTRS
-_mm_test_epi8_mask (__m128i __A, __m128i __B)
-{
-  return (__mmask16) __builtin_ia32_ptestmb128 ((__v16qi) __A,
-            (__v16qi) __B,
-            (__mmask16) -1);
+static __inline__ __mmask16 __DEFAULT_FN_ATTRS _mm_test_epi8_mask(__m128i __A,
+                                                                  __m128i __B) {
+  return _mm_cmp_epi8_mask(_mm_and_si128(__A, __B), _mm_setzero_hi(), 4);
 }
 
 static __inline__ __mmask16 __DEFAULT_FN_ATTRS
-_mm_mask_test_epi8_mask (__mmask16 __U, __m128i __A, __m128i __B)
-{
-  return (__mmask16) __builtin_ia32_ptestmb128 ((__v16qi) __A,
-            (__v16qi) __B, __U);
+_mm_mask_test_epi8_mask(__mmask16 __U, __m128i __A, __m128i __B) {
+  return _mm_mask_cmp_epi8_mask(__U, _mm_and_si128(__A, __B), _mm_setzero_hi(),
+                                4);
 }
 
 static __inline__ __mmask32 __DEFAULT_FN_ATTRS
-_mm256_test_epi8_mask (__m256i __A, __m256i __B)
-{
-  return (__mmask32) __builtin_ia32_ptestmb256 ((__v32qi) __A,
-            (__v32qi) __B,
-            (__mmask32) -1);
+_mm256_test_epi8_mask(__m256i __A, __m256i __B) {
+  return _mm256_cmp_epi8_mask(_mm256_and_si256(__A, __B),
+                              _mm256_setzero_si256(), 4);
 }
 
 static __inline__ __mmask32 __DEFAULT_FN_ATTRS
-_mm256_mask_test_epi8_mask (__mmask32 __U, __m256i __A, __m256i __B)
-{
-  return (__mmask32) __builtin_ia32_ptestmb256 ((__v32qi) __A,
-            (__v32qi) __B, __U);
+_mm256_mask_test_epi8_mask(__mmask32 __U, __m256i __A, __m256i __B) {
+  return _mm256_mask_cmp_epi8_mask(__U, _mm256_and_si256(__A, __B),
+                                   _mm256_setzero_si256(), 4);
 }
 
-static __inline__ __mmask8 __DEFAULT_FN_ATTRS
-_mm_test_epi16_mask (__m128i __A, __m128i __B)
-{
-  return (__mmask8) __builtin_ia32_ptestmw128 ((__v8hi) __A,
-                 (__v8hi) __B,
-                 (__mmask8) -1);
+static __inline__ __mmask8 __DEFAULT_FN_ATTRS _mm_test_epi16_mask(__m128i __A,
+                                                                  __m128i __B) {
+  return _mm_cmp_epi16_mask(_mm_and_si128(__A, __B), _mm_setzero_hi(), 4);
 }
 
 static __inline__ __mmask8 __DEFAULT_FN_ATTRS
-_mm_mask_test_epi16_mask (__mmask8 __U, __m128i __A, __m128i __B)
-{
-  return (__mmask8) __builtin_ia32_ptestmw128 ((__v8hi) __A,
-                 (__v8hi) __B, __U);
+_mm_mask_test_epi16_mask(__mmask8 __U, __m128i __A, __m128i __B) {
+  return _mm_mask_cmp_epi16_mask(__U, _mm_and_si128(__A, __B), _mm_setzero_hi(),
+                                 4);
 }
 
 static __inline__ __mmask16 __DEFAULT_FN_ATTRS
-_mm256_test_epi16_mask (__m256i __A, __m256i __B)
-{
-  return (__mmask16) __builtin_ia32_ptestmw256 ((__v16hi) __A,
-            (__v16hi) __B,
-            (__mmask16) -1);
+_mm256_test_epi16_mask(__m256i __A, __m256i __B) {
+  return _mm256_cmp_epi16_mask(_mm256_and_si256(__A, __B),
+                               _mm256_setzero_si256(), 4);
 }
 
 static __inline__ __mmask16 __DEFAULT_FN_ATTRS
-_mm256_mask_test_epi16_mask (__mmask16 __U, __m256i __A, __m256i __B)
-{
-  return (__mmask16) __builtin_ia32_ptestmw256 ((__v16hi) __A,
-            (__v16hi) __B, __U);
+_mm256_mask_test_epi16_mask(__mmask16 __U, __m256i __A, __m256i __B) {
+  return _mm256_mask_cmp_epi16_mask(__U, _mm256_and_si256(__A, __B),
+                                    _mm256_setzero_si256(), 4);
 }
 
 static __inline__ __mmask16 __DEFAULT_FN_ATTRS
-_mm_testn_epi8_mask (__m128i __A, __m128i __B)
-{
-  return (__mmask16) __builtin_ia32_ptestnmb128 ((__v16qi) __A,
-             (__v16qi) __B,
-             (__mmask16) -1);
+_mm_testn_epi8_mask(__m128i __A, __m128i __B) {
+  return _mm_cmp_epi8_mask(_mm_and_si128(__A, __B), _mm_setzero_hi(), 0);
 }
 
 static __inline__ __mmask16 __DEFAULT_FN_ATTRS
-_mm_mask_testn_epi8_mask (__mmask16 __U, __m128i __A, __m128i __B)
-{
-  return (__mmask16) __builtin_ia32_ptestnmb128 ((__v16qi) __A,
-             (__v16qi) __B, __U);
+_mm_mask_testn_epi8_mask(__mmask16 __U, __m128i __A, __m128i __B) {
+  return _mm_mask_cmp_epi8_mask(__U, _mm_and_si128(__A, __B), _mm_setzero_hi(),
+                                0);
 }
 
 static __inline__ __mmask32 __DEFAULT_FN_ATTRS
-_mm256_testn_epi8_mask (__m256i __A, __m256i __B)
-{
-  return (__mmask32) __builtin_ia32_ptestnmb256 ((__v32qi) __A,
-             (__v32qi) __B,
-             (__mmask32) -1);
+_mm256_testn_epi8_mask(__m256i __A, __m256i __B) {
+  return _mm256_cmp_epi8_mask(_mm256_and_si256(__A, __B),
+                              _mm256_setzero_si256(), 0);
 }
 
 static __inline__ __mmask32 __DEFAULT_FN_ATTRS
-_mm256_mask_testn_epi8_mask (__mmask32 __U, __m256i __A, __m256i __B)
-{
-  return (__mmask32) __builtin_ia32_ptestnmb256 ((__v32qi) __A,
-             (__v32qi) __B, __U);
+_mm256_mask_testn_epi8_mask(__mmask32 __U, __m256i __A, __m256i __B) {
+  return _mm256_mask_cmp_epi8_mask(__U, _mm256_and_si256(__A, __B),
+                                   _mm256_setzero_si256(), 0);
 }
 
 static __inline__ __mmask8 __DEFAULT_FN_ATTRS
-_mm_testn_epi16_mask (__m128i __A, __m128i __B)
-{
-  return (__mmask8) __builtin_ia32_ptestnmw128 ((__v8hi) __A,
-            (__v8hi) __B,
-            (__mmask8) -1);
+_mm_testn_epi16_mask(__m128i __A, __m128i __B) {
+  return _mm_cmp_epi16_mask(_mm_and_si128(__A, __B), _mm_setzero_hi(), 0);
 }
 
 static __inline__ __mmask8 __DEFAULT_FN_ATTRS
-_mm_mask_testn_epi16_mask (__mmask8 __U, __m128i __A, __m128i __B)
-{
-  return (__mmask8) __builtin_ia32_ptestnmw128 ((__v8hi) __A,
-            (__v8hi) __B, __U);
+_mm_mask_testn_epi16_mask(__mmask8 __U, __m128i __A, __m128i __B) {
+  return _mm_mask_cmp_epi16_mask(__U, _mm_and_si128(__A, __B), _mm_setzero_hi(),
+                                 0);
 }
 
 static __inline__ __mmask16 __DEFAULT_FN_ATTRS
-_mm256_testn_epi16_mask (__m256i __A, __m256i __B)
-{
-  return (__mmask16) __builtin_ia32_ptestnmw256 ((__v16hi) __A,
-             (__v16hi) __B,
-             (__mmask16) -1);
+_mm256_testn_epi16_mask(__m256i __A, __m256i __B) {
+  return _mm256_cmp_epi16_mask(_mm256_and_si256(__A, __B),
+                               _mm256_setzero_si256(), 0);
 }
 
 static __inline__ __mmask16 __DEFAULT_FN_ATTRS
-_mm256_mask_testn_epi16_mask (__mmask16 __U, __m256i __A, __m256i __B)
-{
-  return (__mmask16) __builtin_ia32_ptestnmw256 ((__v16hi) __A,
-             (__v16hi) __B, __U);
+_mm256_mask_testn_epi16_mask(__mmask16 __U, __m256i __A, __m256i __B) {
+  return _mm256_mask_cmp_epi16_mask(__U, _mm256_and_si256(__A, __B),
+                                    _mm256_setzero_si256(), 0);
 }
 
 static __inline__ __mmask16 __DEFAULT_FN_ATTRS
 _mm_movepi8_mask (__m128i __A)
 {
   return (__mmask16) __builtin_ia32_cvtb2mask128 ((__v16qi) __A);
 }
 

lib/Headers/avx512vlintrin.h

 static __inline__ __m256 __DEFAULT_FN_ATTRS
 _mm256_maskz_permutevar_ps(__mmask8 __U, __m256 __A, __m256i __C)
 {
   return (__m256)__builtin_ia32_selectps_256((__mmask8)__U,
                                           (__v8sf)_mm256_permutevar_ps(__A, __C),
                                           (__v8sf)_mm256_setzero_ps());
 }
 
-static __inline__ __mmask8 __DEFAULT_FN_ATTRS
-_mm_test_epi32_mask (__m128i __A, __m128i __B)
-{
-  return (__mmask8) __builtin_ia32_ptestmd128 ((__v4si) __A,
-                 (__v4si) __B,
-                 (__mmask8) -1);
+static __inline__ __mmask8 __DEFAULT_FN_ATTRS _mm_test_epi32_mask(__m128i __A,
+                                                                  __m128i __B) {
+  return _mm_cmp_epi32_mask(_mm_and_si128(__A, __B), _mm_setzero_di(), 4);
 }
 
 static __inline__ __mmask8 __DEFAULT_FN_ATTRS
-_mm_mask_test_epi32_mask (__mmask8 __U, __m128i __A, __m128i __B)
-{
-  return (__mmask8) __builtin_ia32_ptestmd128 ((__v4si) __A,
-                 (__v4si) __B, __U);
+_mm_mask_test_epi32_mask(__mmask8 __U, __m128i __A, __m128i __B) {
+  return _mm_mask_cmp_epi32_mask(__U, _mm_and_si128(__A, __B), _mm_setzero_di(),
+                                 4);
 }
 
 static __inline__ __mmask8 __DEFAULT_FN_ATTRS
-_mm256_test_epi32_mask (__m256i __A, __m256i __B)
-{
-  return (__mmask8) __builtin_ia32_ptestmd256 ((__v8si) __A,
-                 (__v8si) __B,
-                 (__mmask8) -1);
+_mm256_test_epi32_mask(__m256i __A, __m256i __B) {
+  return _mm256_cmp_epi32_mask(_mm256_and_si256(__A, __B),
+                               _mm256_setzero_si256(), 4);
 }
 
 static __inline__ __mmask8 __DEFAULT_FN_ATTRS
-_mm256_mask_test_epi32_mask (__mmask8 __U, __m256i __A, __m256i __B)
-{
-  return (__mmask8) __builtin_ia32_ptestmd256 ((__v8si) __A,
-                 (__v8si) __B, __U);
+_mm256_mask_test_epi32_mask(__mmask8 __U, __m256i __A, __m256i __B) {
+  return _mm256_mask_cmp_epi32_mask(__U, _mm256_and_si256(__A, __B),
+                                    _mm256_setzero_si256(), 4);
 }
 
-static __inline__ __mmask8 __DEFAULT_FN_ATTRS
-_mm_test_epi64_mask (__m128i __A, __m128i __B)
-{
-  return (__mmask8) __builtin_ia32_ptestmq128 ((__v2di) __A,
-                 (__v2di) __B,
-                 (__mmask8) -1);
+static __inline__ __mmask8 __DEFAULT_FN_ATTRS _mm_test_epi64_mask(__m128i __A,
+                                                                  __m128i __B) {
+  return _mm_cmp_epi64_mask(_mm_and_si128(__A, __B), _mm_setzero_di(), 4);
 }
 
 static __inline__ __mmask8 __DEFAULT_FN_ATTRS
-_mm_mask_test_epi64_mask (__mmask8 __U, __m128i __A, __m128i __B)
-{
-  return (__mmask8) __builtin_ia32_ptestmq128 ((__v2di) __A,
-                 (__v2di) __B, __U);
+_mm_mask_test_epi64_mask(__mmask8 __U, __m128i __A, __m128i __B) {
+  return _mm_mask_cmp_epi64_mask(__U, _mm_and_si128(__A, __B), _mm_setzero_di(),
+                                 4);
 }
 
 static __inline__ __mmask8 __DEFAULT_FN_ATTRS
-_mm256_test_epi64_mask (__m256i __A, __m256i __B)
-{
-  return (__mmask8) __builtin_ia32_ptestmq256 ((__v4di) __A,
-                 (__v4di) __B,
-                 (__mmask8) -1);
+_mm256_test_epi64_mask(__m256i __A, __m256i __B) {
+  return _mm256_cmp_epi64_mask(_mm256_and_si256(__A, __B),
+                               _mm256_setzero_si256(), 4);
 }
 
 static __inline__ __mmask8 __DEFAULT_FN_ATTRS
-_mm256_mask_test_epi64_mask (__mmask8 __U, __m256i __A, __m256i __B)
-{
-  return (__mmask8) __builtin_ia32_ptestmq256 ((__v4di) __A,
-                 (__v4di) __B, __U);
+_mm256_mask_test_epi64_mask(__mmask8 __U, __m256i __A, __m256i __B) {
+  return _mm256_mask_cmp_epi64_mask(__U, _mm256_and_si256(__A, __B),
+                                    _mm256_setzero_si256(), 4);
 }
 
 static __inline__ __mmask8 __DEFAULT_FN_ATTRS
-_mm_testn_epi32_mask (__m128i __A, __m128i __B)
-{
-  return (__mmask8) __builtin_ia32_ptestnmd128 ((__v4si) __A,
-            (__v4si) __B,
-            (__mmask8) -1);
+_mm_testn_epi32_mask(__m128i __A, __m128i __B) {
+  return _mm_cmp_epi32_mask(_mm_and_si128(__A, __B), _mm_setzero_di(), 0);
 }
 
 static __inline__ __mmask8 __DEFAULT_FN_ATTRS
-_mm_mask_testn_epi32_mask (__mmask8 __U, __m128i __A, __m128i __B)
-{
-  return (__mmask8) __builtin_ia32_ptestnmd128 ((__v4si) __A,
-            (__v4si) __B, __U);
+_mm_mask_testn_epi32_mask(__mmask8 __U, __m128i __A, __m128i __B) {
+  return _mm_mask_cmp_epi32_mask(__U, _mm_and_si128(__A, __B), _mm_setzero_di(),
+                                 0);
 }
 
 static __inline__ __mmask8 __DEFAULT_FN_ATTRS
-_mm256_testn_epi32_mask (__m256i __A, __m256i __B)
-{
-  return (__mmask8) __builtin_ia32_ptestnmd256 ((__v8si) __A,
-            (__v8si) __B,
-            (__mmask8) -1);
+_mm256_testn_epi32_mask(__m256i __A, __m256i __B) {
+  return _mm256_cmp_epi32_mask(_mm256_and_si256(__A, __B),
+                               _mm256_setzero_si256(), 0);
 }
 
 static __inline__ __mmask8 __DEFAULT_FN_ATTRS
-_mm256_mask_testn_epi32_mask (__mmask8 __U, __m256i __A, __m256i __B)
-{
-  return (__mmask8) __builtin_ia32_ptestnmd256 ((__v8si) __A,
-            (__v8si) __B, __U);
+_mm256_mask_testn_epi32_mask(__mmask8 __U, __m256i __A, __m256i __B) {
+  return _mm256_mask_cmp_epi32_mask(__U, _mm256_and_si256(__A, __B),
+                                    _mm256_setzero_si256(), 0);
 }
 
 static __inline__ __mmask8 __DEFAULT_FN_ATTRS
-_mm_testn_epi64_mask (__m128i __A, __m128i __B)
-{
-  return (__mmask8) __builtin_ia32_ptestnmq128 ((__v2di) __A,
-            (__v2di) __B,
-            (__mmask8) -1);
+_mm_testn_epi64_mask(__m128i __A, __m128i __B) {
+  return _mm_cmp_epi64_mask(_mm_and_si128(__A, __B), _mm_setzero_di(), 0);
 }
 
 static __inline__ __mmask8 __DEFAULT_FN_ATTRS
-_mm_mask_testn_epi64_mask (__mmask8 __U, __m128i __A, __m128i __B)
-{
-  return (__mmask8) __builtin_ia32_ptestnmq128 ((__v2di) __A,
-            (__v2di) __B, __U);
+_mm_mask_testn_epi64_mask(__mmask8 __U, __m128i __A, __m128i __B) {
+  return _mm_mask_cmp_epi64_mask(__U, _mm_and_si128(__A, __B), _mm_setzero_di(),
+                                 0);
 }
 
 static __inline__ __mmask8 __DEFAULT_FN_ATTRS
-_mm256_testn_epi64_mask (__m256i __A, __m256i __B)
-{
-  return (__mmask8) __builtin_ia32_ptestnmq256 ((__v4di) __A,
-            (__v4di) __B,
-            (__mmask8) -1);
+_mm256_testn_epi64_mask(__m256i __A, __m256i __B) {
+  return _mm256_cmp_epi64_mask(_mm256_and_si256(__A, __B),
+                               _mm256_setzero_si256(), 0);
 }
 
 static __inline__ __mmask8 __DEFAULT_FN_ATTRS
-_mm256_mask_testn_epi64_mask (__mmask8 __U, __m256i __A, __m256i __B)
-{
-  return (__mmask8) __builtin_ia32_ptestnmq256 ((__v4di) __A,
-            (__v4di) __B, __U);
+_mm256_mask_testn_epi64_mask(__mmask8 __U, __m256i __A, __m256i __B) {
+  return _mm256_mask_cmp_epi64_mask(__U, _mm256_and_si256(__A, __B),
+                                    _mm256_setzero_si256(), 0);
 }
 
-
-
 static __inline__ __m128i __DEFAULT_FN_ATTRS
 _mm_mask_unpackhi_epi32(__m128i __W, __mmask8 __U, __m128i __A, __m128i __B)
 {
   return (__m128i)__builtin_ia32_selectd_128((__mmask8)__U,
                                            (__v4si)_mm_unpackhi_epi32(__A, __B),
                                            (__v4si)__W);
 }
 

test/CodeGen/avx512bw-builtins.c

 }
 void test_mm512_mask_storeu_epi16(void *__P, __mmask32 __U, __m512i __A) {
   // CHECK-LABEL: @test_mm512_mask_storeu_epi16
   // CHECK: @llvm.masked.store.v32i16.p0v32i16(<32 x i16> %{{.*}}, <32 x i16>* %{{.*}}, i32 1, <32 x i1> %{{.*}})
   return _mm512_mask_storeu_epi16(__P, __U, __A); 
 }
 __mmask64 test_mm512_test_epi8_mask(__m512i __A, __m512i __B) {
   // CHECK-LABEL: @test_mm512_test_epi8_mask
-  // CHECK: @llvm.x86.avx512.ptestm.b.512
+  // CHECK: and <16 x i32> %{{.*}}, %{{.*}}
+  // CHECK: icmp ne <64 x i8> %{{.*}}, %{{.*}}
   return _mm512_test_epi8_mask(__A, __B); 
 }
 
 void test_mm512_mask_storeu_epi8(void *__P, __mmask64 __U, __m512i __A) {
   // CHECK-LABEL: @test_mm512_mask_storeu_epi8
   // CHECK: @llvm.masked.store.v64i8.p0v64i8(<64 x i8> %{{.*}}, <64 x i8>* %{{.*}}, i32 1, <64 x i1> %{{.*}})
   return _mm512_mask_storeu_epi8(__P, __U, __A); 
 }
 __mmask64 test_mm512_mask_test_epi8_mask(__mmask64 __U, __m512i __A, __m512i __B) {
   // CHECK-LABEL: @test_mm512_mask_test_epi8_mask
-  // CHECK: @llvm.x86.avx512.ptestm.b.512
+  // CHECK: and <16 x i32> %{{.*}}, %{{.*}}
+  // CHECK: icmp ne <64 x i8> %{{.*}}, %{{.*}}
+  // CHECK: and <64 x i1> %{{.*}}, %{{.*}}
   return _mm512_mask_test_epi8_mask(__U, __A, __B); 
 }
 
 __mmask32 test_mm512_test_epi16_mask(__m512i __A, __m512i __B) {
   // CHECK-LABEL: @test_mm512_test_epi16_mask
-  // CHECK: @llvm.x86.avx512.ptestm.w.
+  // CHECK: and <16 x i32> %{{.*}}, %{{.*}}
+  // CHECK: icmp ne <32 x i16> %{{.*}}, %{{.*}}
   return _mm512_test_epi16_mask(__A, __B); 
 }
 
 __mmask32 test_mm512_mask_test_epi16_mask(__mmask32 __U, __m512i __A, __m512i __B) {
   // CHECK-LABEL: @test_mm512_mask_test_epi16_mask
-  // CHECK: @llvm.x86.avx512.ptestm.w.
+  // CHECK: and <16 x i32> %{{.*}}, %{{.*}}
+  // CHECK: icmp ne <32 x i16> %{{.*}}, %{{.*}}
+  // CHECK: and <32 x i1> %{{.*}}, %{{.*}}
   return _mm512_mask_test_epi16_mask(__U, __A, __B); 
 }
 
 __mmask64 test_mm512_testn_epi8_mask(__m512i __A, __m512i __B) {
   // CHECK-LABEL: @test_mm512_testn_epi8_mask
-  // CHECK: @llvm.x86.avx512.ptestnm.b.
+  // CHECK: and <16 x i32> %{{.*}}, %{{.*}}
+  // CHECK: icmp eq <64 x i8> %{{.*}}, %{{.*}}
   return _mm512_testn_epi8_mask(__A, __B); 
 }
 
 __mmask64 test_mm512_mask_testn_epi8_mask(__mmask64 __U, __m512i __A, __m512i __B) {
   // CHECK-LABEL: @test_mm512_mask_testn_epi8_mask
-  // CHECK: @llvm.x86.avx512.ptestnm.b.
+  // CHECK: and <16 x i32> %{{.*}}, %{{.*}}
+  // CHECK: icmp eq <64 x i8> %{{.*}}, %{{.*}}
+  // CHECK: and <64 x i1> %{{.*}}, %{{.*}}
   return _mm512_mask_testn_epi8_mask(__U, __A, __B); 
 }
 
 __mmask32 test_mm512_testn_epi16_mask(__m512i __A, __m512i __B) {
   // CHECK-LABEL: @test_mm512_testn_epi16_mask
-  // CHECK: @llvm.x86.avx512.ptestnm.w.
+  // CHECK: and <16 x i32> %{{.*}}, %{{.*}}
+  // CHECK: icmp eq <32 x i16> %{{.*}}, %{{.*}}
   return _mm512_testn_epi16_mask(__A, __B); 
 }
 
 __mmask32 test_mm512_mask_testn_epi16_mask(__mmask32 __U, __m512i __A, __m512i __B) {
   // CHECK-LABEL: @test_mm512_mask_testn_epi16_mask
-  // CHECK: @llvm.x86.avx512.ptestnm.w.
+  // CHECK: and <16 x i32> %{{.*}}, %{{.*}}
+  // CHECK: icmp eq <32 x i16> %{{.*}}, %{{.*}}
+  // CHECK: and <32 x i1> %{{.*}}, %{{.*}}
   return _mm512_mask_testn_epi16_mask(__U, __A, __B); 
 }
 
 __mmask64 test_mm512_movepi8_mask(__m512i __A) {
   // CHECK-LABEL: @test_mm512_movepi8_mask
   // CHECK: @llvm.x86.avx512.cvtb2mask.512
   return _mm512_movepi8_mask(__A); 
 }

test/CodeGen/avx512f-builtins.c

 
 __m512i test_mm512_maskz_permutex2var_epi64(__mmask8 __U, __m512i __A, __m512i __I, __m512i __B) {
   // CHECK-LABEL: @test_mm512_maskz_permutex2var_epi64
   // CHECK: @llvm.x86.avx512.maskz.vpermt2var.q.512
   return _mm512_maskz_permutex2var_epi64(__U, __A, __I, __B);
 }
 __mmask16 test_mm512_testn_epi32_mask(__m512i __A, __m512i __B) {
   // CHECK-LABEL: @test_mm512_testn_epi32_mask
-  // CHECK: @llvm.x86.avx512.ptestnm.d.512
+  // CHECK: and <16 x i32> %{{.*}}, %{{.*}}
+  // CHECK: icmp eq <16 x i32> %{{.*}}, %{{.*}}
   return _mm512_testn_epi32_mask(__A, __B); 
 }
 
 __mmask16 test_mm512_mask_testn_epi32_mask(__mmask16 __U, __m512i __A, __m512i __B) {
   // CHECK-LABEL: @test_mm512_mask_testn_epi32_mask
-  // CHECK: @llvm.x86.avx512.ptestnm.d.512
+  // CHECK: and <16 x i32> %{{.*}}, %{{.*}}
+  // CHECK: icmp eq <16 x i32> %{{.*}}, %{{.*}}
+  // CHECK: and <16 x i1> %{{.*}}, %{{.*}}
   return _mm512_mask_testn_epi32_mask(__U, __A, __B); 
 }
 
 __mmask8 test_mm512_testn_epi64_mask(__m512i __A, __m512i __B) {
   // CHECK-LABEL: @test_mm512_testn_epi64_mask
-  // CHECK: @llvm.x86.avx512.ptestnm.q.512
+  // CHECK: and <16 x i32> %{{.*}}, %{{.*}}
+  // CHECK: icmp eq <8 x i64> %{{.*}}, %{{.*}}
   return _mm512_testn_epi64_mask(__A, __B); 
 }
 
 __mmask8 test_mm512_mask_testn_epi64_mask(__mmask8 __U, __m512i __A, __m512i __B) {
   // CHECK-LABEL: @test_mm512_mask_testn_epi64_mask
-  // CHECK: @llvm.x86.avx512.ptestnm.q.512
+  // CHECK: and <16 x i32> %{{.*}}, %{{.*}}
+  // CHECK: icmp eq <8 x i64> %{{.*}}, %{{.*}}
+  // CHECK: and <8 x i1> %{{.*}}, %{{.*}}
   return _mm512_mask_testn_epi64_mask(__U, __A, __B); 
 }
 
 __mmask16 test_mm512_mask_test_epi32_mask (__mmask16 __U, __m512i __A, __m512i __B)
 {
   // CHECK-LABEL: @test_mm512_mask_test_epi32_mask 
-  // CHECK: @llvm.x86.avx512.ptestm.d.512
+  // CHECK: and <16 x i32> %{{.*}}, %{{.*}}
+  // CHECK: icmp ne <16 x i32> %{{.*}}, %{{.*}}
   return _mm512_mask_test_epi32_mask (__U,__A,__B);
 }
 
 __mmask8 test_mm512_mask_test_epi64_mask (__mmask8 __U, __m512i __A, __m512i __B)
 {
   // CHECK-LABEL: @test_mm512_mask_test_epi64_mask 
-  // CHECK: @llvm.x86.avx512.ptestm.q.512
+  // CHECK: and <16 x i32> %{{.*}}, %{{.*}}
+  // CHECK: icmp ne <8 x i64> %{{.*}}, %{{.*}}
+  // CHECK: and <8 x i1> %{{.*}}, %{{.*}}
   return _mm512_mask_test_epi64_mask (__U,__A,__B);
 }
 
 __m512i test_mm512_maskz_unpackhi_epi32(__mmask16 __U, __m512i __A, __m512i __B) {
   // CHECK-LABEL: @test_mm512_maskz_unpackhi_epi32
   // CHECK: shufflevector <16 x i32> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> <i32 2, i32 18, i32 3, i32 19, i32 6, i32 22, i32 7, i32 23, i32 10, i32 26, i32 11, i32 27, i32 14, i32 30, i32 15, i32 31>
   // CHECK: select <16 x i1> %{{.*}}, <16 x i32> %{{.*}}, <16 x i32> %{{.*}}
   return _mm512_maskz_unpackhi_epi32(__U, __A, __B); 

test/CodeGen/avx512vl-builtins.c

__m256 test_mm256_maskz_permutevar_ps(__mmask8 __U, __m256 __A, __m256i __C) {
   // CHECK-LABEL: @test_mm256_maskz_permutevar_ps
   // CHECK: @llvm.x86.avx.vpermilvar.ps.256
   // CHECK: select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}}
   return _mm256_maskz_permutevar_ps(__U, __A, __C); 
 }
 
 __mmask8 test_mm_test_epi32_mask(__m128i __A, __m128i __B) {
   // CHECK-LABEL: @test_mm_test_epi32_mask
-  // CHECK: @llvm.x86.avx512.ptestm.d.128
+  // CHECK: and <2 x i64> %{{.*}}, %{{.*}}
+  // CHECK: icmp ne <4 x i32> %{{.*}}, %{{.*}}
   return _mm_test_epi32_mask(__A, __B); 
 }
 
 __mmask8 test_mm_mask_test_epi32_mask(__mmask8 __U, __m128i __A, __m128i __B) {
   // CHECK-LABEL: @test_mm_mask_test_epi32_mask
-  // CHECK: @llvm.x86.avx512.ptestm.d.128
+  // CHECK: and <2 x i64> %{{.*}}, %{{.*}}
+  // CHECK: icmp ne <4 x i32> %{{.*}}, %{{.*}}
+  // CHECK: and <4 x i1> %{{.*}}, %{{.*}}
   return _mm_mask_test_epi32_mask(__U, __A, __B); 
 }
 
 __mmask8 test_mm256_test_epi32_mask(__m256i __A, __m256i __B) {
   // CHECK-LABEL: @test_mm256_test_epi32_mask
-  // CHECK: @llvm.x86.avx512.ptestm.d.256
+  // CHECK: and <4 x i64> %{{.*}}, %{{.*}}
+  // CHECK: icmp ne <8 x i32> %{{.*}}, %{{.*}}
   return _mm256_test_epi32_mask(__A, __B); 
 }
 
 __mmask8 test_mm256_mask_test_epi32_mask(__mmask8 __U, __m256i __A, __m256i __B) {
   // CHECK-LABEL: @test_mm256_mask_test_epi32_mask
-  // CHECK: @llvm.x86.avx512.ptestm.d.256
+  // CHECK: and <4 x i64> %{{.*}}, %{{.*}}
+  // CHECK: icmp ne <8 x i32> %{{.*}}, %{{.*}}
+  // CHECK: and <8 x i1> %{{.*}}, %{{.*}}
   return _mm256_mask_test_epi32_mask(__U, __A, __B); 
 }
 
 __mmask8 test_mm_test_epi64_mask(__m128i __A, __m128i __B) {
   // CHECK-LABEL: @test_mm_test_epi64_mask
-  // CHECK: @llvm.x86.avx512.ptestm.q.128
+  // CHECK: and <2 x i64> %{{.*}}, %{{.*}}
+  // CHECK: icmp ne <2 x i64> %{{.*}}, %{{.*}}
   return _mm_test_epi64_mask(__A, __B); 
 }
 
 __mmask8 test_mm_mask_test_epi64_mask(__mmask8 __U, __m128i __A, __m128i __B) {
   // CHECK-LABEL: @test_mm_mask_test_epi64_mask
-  // CHECK: @llvm.x86.avx512.ptestm.q.128
+  // CHECK: and <2 x i64> %{{.*}}, %{{.*}}
+  // CHECK: icmp ne <2 x i64> %{{.*}}, %{{.*}}
+  // CHECK: and <2 x i1> %{{.*}}, %{{.*}}
   return _mm_mask_test_epi64_mask(__U, __A, __B); 
 }
 
 __mmask8 test_mm256_test_epi64_mask(__m256i __A, __m256i __B) {
   // CHECK-LABEL: @test_mm256_test_epi64_mask
-  // CHECK: @llvm.x86.avx512.ptestm.q.256
+  // CHECK: and <4 x i64> %{{.*}}, %{{.*}}
+  // CHECK: icmp ne <4 x i64> %{{.*}}, %{{.*}}
   return _mm256_test_epi64_mask(__A, __B); 
 }
 
 __mmask8 test_mm256_mask_test_epi64_mask(__mmask8 __U, __m256i __A, __m256i __B) {
   // CHECK-LABEL: @test_mm256_mask_test_epi64_mask
-  // CHECK: @llvm.x86.avx512.ptestm.q.256
+  // CHECK: and <4 x i64> %{{.*}}, %{{.*}}
+  // CHECK: icmp ne <4 x i64> %{{.*}}, %{{.*}}
+  // CHECK: and <4 x i1> %{{.*}}, %{{.*}}
   return _mm256_mask_test_epi64_mask(__U, __A, __B); 
 }
 
 __mmask8 test_mm_testn_epi32_mask(__m128i __A, __m128i __B) {
   // CHECK-LABEL: @test_mm_testn_epi32_mask
-  // CHECK: @llvm.x86.avx512.ptestnm.d.128
+  // CHECK: and <2 x i64> %{{.*}}, %{{.*}}
+  // CHECK: icmp eq <4 x i32> %{{.*}}, %{{.*}}
   return _mm_testn_epi32_mask(__A, __B); 
 }
 
 __mmask8 test_mm_mask_testn_epi32_mask(__mmask8 __U, __m128i __A, __m128i __B) {
   // CHECK-LABEL: @test_mm_mask_testn_epi32_mask
-  // CHECK: @llvm.x86.avx512.ptestnm.d.128
+  // CHECK: and <2 x i64> %{{.*}}, %{{.*}}
+  // CHECK: icmp eq <4 x i32> %{{.*}}, %{{.*}}
+  // CHECK: and <4 x i1> %{{.*}}, %{{.*}}
   return _mm_mask_testn_epi32_mask(__U, __A, __B); 
 }
 
 __mmask8 test_mm256_testn_epi32_mask(__m256i __A, __m256i __B) {
   // CHECK-LABEL: @test_mm256_testn_epi32_mask
-  // CHECK: @llvm.x86.avx512.ptestnm.d.256
+  // CHECK: and <4 x i64> %{{.*}}, %{{.*}}
+  // CHECK: icmp eq <8 x i32> %{{.*}}, %{{.*}}
   return _mm256_testn_epi32_mask(__A, __B); 
 }
 
 __mmask8 test_mm256_mask_testn_epi32_mask(__mmask8 __U, __m256i __A, __m256i __B) {
   // CHECK-LABEL: @test_mm256_mask_testn_epi32_mask
-  // CHECK: @llvm.x86.avx512.ptestnm.d.256
+  // CHECK: and <4 x i64> %{{.*}}, %{{.*}}
+  // CHECK: icmp eq <8 x i32> %{{.*}}, %{{.*}}
+  // CHECK: and <8 x i1> %{{.*}}, %{{.*}}
   return _mm256_mask_testn_epi32_mask(__U, __A, __B); 
 }
 
 __mmask8 test_mm_testn_epi64_mask(__m128i __A, __m128i __B) {
   // CHECK-LABEL: @test_mm_testn_epi64_mask
-  // CHECK: @llvm.x86.avx512.ptestnm.q.128
+  // CHECK: and <2 x i64> %{{.*}}, %{{.*}}
+  // CHECK: icmp eq <2 x i64> %{{.*}}, %{{.*}}
   return _mm_testn_epi64_mask(__A, __B); 
 }
 
 __mmask8 test_mm_mask_testn_epi64_mask(__mmask8 __U, __m128i __A, __m128i __B) {
   // CHECK-LABEL: @test_mm_mask_testn_epi64_mask
-  // CHECK: @llvm.x86.avx512.ptestnm.q.128
+  // CHECK: and <2 x i64> %{{.*}}, %{{.*}}
+  // CHECK: icmp eq <2 x i64> %{{.*}}, %{{.*}}
+  // CHECK: and <2 x i1> %{{.*}}, %{{.*}}
   return _mm_mask_testn_epi64_mask(__U, __A, __B); 
 }
 
 __mmask8 test_mm256_testn_epi64_mask(__m256i __A, __m256i __B) {
   // CHECK-LABEL: @test_mm256_testn_epi64_mask
-  // CHECK: @llvm.x86.avx512.ptestnm.q.256
+  // CHECK: and <4 x i64> %{{.*}}, %{{.*}}
+  // CHECK: icmp eq <4 x i64> %{{.*}}, %{{.*}}
   return _mm256_testn_epi64_mask(__A, __B); 
 }
 
 __mmask8 test_mm256_mask_testn_epi64_mask(__mmask8 __U, __m256i __A, __m256i __B) {
   // CHECK-LABEL: @test_mm256_mask_testn_epi64_mask
-  // CHECK: @llvm.x86.avx512.ptestnm.q.256
+  // CHECK: and <4 x i64> %{{.*}}, %{{.*}}
+  // CHECK: icmp eq <4 x i64> %{{.*}}, %{{.*}}
+  // CHECK: and <4 x i1> %{{.*}}, %{{.*}}
   return _mm256_mask_testn_epi64_mask(__U, __A, __B); 
 }
+
 __m128i test_mm_mask_unpackhi_epi32(__m128i __W, __mmask8 __U, __m128i __A, __m128i __B) {
   // CHECK-LABEL: @test_mm_mask_unpackhi_epi32
   // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> <i32 2, i32 6, i32 3, i32 7>
   // CHECK: select <4 x i1> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}
   return _mm_mask_unpackhi_epi32(__W, __U, __A, __B); 
 }
 
 __m128i test_mm_maskz_unpackhi_epi32(__mmask8 __U, __m128i __A, __m128i __B) {

test/CodeGen/avx512vlbw-builtins.c

 
 void test_mm256_mask_storeu_epi8(void *__P, __mmask32 __U, __m256i __A) {
   // CHECK-LABEL: @test_mm256_mask_storeu_epi8
   // CHECK: @llvm.masked.store.v32i8.p0v32i8(<32 x i8> %{{.*}}, <32 x i8>* %{{.*}}, i32 1, <32 x i1> %{{.*}})
   return _mm256_mask_storeu_epi8(__P, __U, __A); 
 }
 __mmask16 test_mm_test_epi8_mask(__m128i __A, __m128i __B) {
   // CHECK-LABEL: @test_mm_test_epi8_mask
-  // CHECK: @llvm.x86.avx512.ptestm.b.128
+  // CHECK: and <2 x i64> %{{.*}}, %{{.*}}
+  // CHECK: icmp ne <16 x i8> %{{.*}}, %{{.*}}
   return _mm_test_epi8_mask(__A, __B); 
 }
 
 __mmask16 test_mm_mask_test_epi8_mask(__mmask16 __U, __m128i __A, __m128i __B) {
   // CHECK-LABEL: @test_mm_mask_test_epi8_mask
-  // CHECK: @llvm.x86.avx512.ptestm.b.128
+  // CHECK: and <2 x i64> %{{.*}}, %{{.*}}
+  // CHECK: icmp ne <16 x i8> %{{.*}}, %{{.*}}
+  // CHECK: and <16 x i1> %{{.*}}, %{{.*}}
   return _mm_mask_test_epi8_mask(__U, __A, __B); 
 }
 
 __mmask32 test_mm256_test_epi8_mask(__m256i __A, __m256i __B) {
   // CHECK-LABEL: @test_mm256_test_epi8_mask
-  // CHECK: @llvm.x86.avx512.ptestm.b.256
+  // CHECK: and <4 x i64> %{{.*}}, %{{.*}}
+  // CHECK: icmp ne <32 x i8> %{{.*}}, %{{.*}}
   return _mm256_test_epi8_mask(__A, __B); 
 }
 
 __mmask32 test_mm256_mask_test_epi8_mask(__mmask32 __U, __m256i __A, __m256i __B) {
   // CHECK-LABEL: @test_mm256_mask_test_epi8_mask
-  // CHECK: @llvm.x86.avx512.ptestm.b.256
+  // CHECK: and <4 x i64> %{{.*}}, %{{.*}}
+  // CHECK: icmp ne <32 x i8> %{{.*}}, %{{.*}}
+  // CHECK: and <32 x i1> %{{.*}}, %{{.*}}
   return _mm256_mask_test_epi8_mask(__U, __A, __B); 
 }
 
 __mmask8 test_mm_test_epi16_mask(__m128i __A, __m128i __B) {
   // CHECK-LABEL: @test_mm_test_epi16_mask
-  // CHECK: @llvm.x86.avx512.ptestm.w.128
+  // CHECK: and <2 x i64> %{{.*}}, %{{.*}}
+  // CHECK: icmp ne <8 x i16> %{{.*}}, %{{.*}}
   return _mm_test_epi16_mask(__A, __B); 
 }
 
 __mmask8 test_mm_mask_test_epi16_mask(__mmask8 __U, __m128i __A, __m128i __B) {
   // CHECK-LABEL: @test_mm_mask_test_epi16_mask
-  // CHECK: @llvm.x86.avx512.ptestm.w.128
+  // CHECK: and <2 x i64> %{{.*}}, %{{.*}}
+  // CHECK: icmp ne <8 x i16> %{{.*}}, %{{.*}}
+  // CHECK: and <8 x i1> %{{.*}}, %{{.*}}
   return _mm_mask_test_epi16_mask(__U, __A, __B); 
 }
 
 __mmask16 test_mm256_test_epi16_mask(__m256i __A, __m256i __B) {
   // CHECK-LABEL: @test_mm256_test_epi16_mask
-  // CHECK: @llvm.x86.avx512.ptestm.w.256
+  // CHECK: and <4 x i64> %{{.*}}, %{{.*}}
+  // CHECK: icmp ne <16 x i16> %{{.*}}, %{{.*}}
   return _mm256_test_epi16_mask(__A, __B); 
 }
 
 __mmask16 test_mm256_mask_test_epi16_mask(__mmask16 __U, __m256i __A, __m256i __B) {
   // CHECK-LABEL: @test_mm256_mask_test_epi16_mask
-  // CHECK: @llvm.x86.avx512.ptestm.w.256
+  // CHECK: and <4 x i64> %{{.*}}, %{{.*}}
+  // CHECK: icmp ne <16 x i16> %{{.*}}, %{{.*}}
+  // CHECK: and <16 x i1> %{{.*}}, %{{.*}}
   return _mm256_mask_test_epi16_mask(__U, __A, __B); 
 }
 
 __mmask16 test_mm_testn_epi8_mask(__m128i __A, __m128i __B) {
   // CHECK-LABEL: @test_mm_testn_epi8_mask
-  // CHECK: @llvm.x86.avx512.ptestnm.b.128
+  // CHECK: and <2 x i64> %{{.*}}, %{{.*}}
+  // CHECK: icmp eq <16 x i8> %{{.*}}, %{{.*}}
   return _mm_testn_epi8_mask(__A, __B); 
 }
 
 __mmask16 test_mm_mask_testn_epi8_mask(__mmask16 __U, __m128i __A, __m128i __B) {
   // CHECK-LABEL: @test_mm_mask_testn_epi8_mask
-  // CHECK: @llvm.x86.avx512.ptestnm.b.128
+  // CHECK: and <2 x i64> %{{.*}}, %{{.*}}
+  // CHECK: icmp eq <16 x i8> %{{.*}}, %{{.*}}
+  // CHECK: and <16 x i1> %{{.*}}, %{{.*}}
   return _mm_mask_testn_epi8_mask(__U, __A, __B); 
 }
 
 __mmask32 test_mm256_testn_epi8_mask(__m256i __A, __m256i __B) {
   // CHECK-LABEL: @test_mm256_testn_epi8_mask
-  // CHECK: @llvm.x86.avx512.ptestnm.b.256
+  // CHECK: and <4 x i64> %{{.*}}, %{{.*}}
+  // CHECK: icmp eq <32 x i8> %{{.*}}, %{{.*}}
   return _mm256_testn_epi8_mask(__A, __B); 
 }
 
 __mmask32 test_mm256_mask_testn_epi8_mask(__mmask32 __U, __m256i __A, __m256i __B) {
   // CHECK-LABEL: @test_mm256_mask_testn_epi8_mask
-  // CHECK: @llvm.x86.avx512.ptestnm.b.256
+  // CHECK: and <4 x i64> %{{.*}}, %{{.*}}
+  // CHECK: icmp eq <32 x i8> %{{.*}}, %{{.*}}
+  // CHECK: and <32 x i1> %{{.*}}, %{{.*}}
   return _mm256_mask_testn_epi8_mask(__U, __A, __B); 
 }
 
 __mmask8 test_mm_testn_epi16_mask(__m128i __A, __m128i __B) {
   // CHECK-LABEL: @test_mm_testn_epi16_mask
-  // CHECK: @llvm.x86.avx512.ptestnm.w.128
+  // CHECK: and <2 x i64> %{{.*}}, %{{.*}}
+  // CHECK: icmp eq <8 x i16> %{{.*}}, %{{.*}}
   return _mm_testn_epi16_mask(__A, __B); 
 }
 
 __mmask8 test_mm_mask_testn_epi16_mask(__mmask8 __U, __m128i __A, __m128i __B) {
   // CHECK-LABEL: @test_mm_mask_testn_epi16_mask
-  // CHECK: @llvm.x86.avx512.ptestnm.w.128
+  // CHECK: and <2 x i64> %{{.*}}, %{{.*}}
+  // CHECK: icmp eq <8 x i16> %{{.*}}, %{{.*}}
+  // CHECK: and <8 x i1> %{{.*}}, %{{.*}}
   return _mm_mask_testn_epi16_mask(__U, __A, __B); 
 }
 
 __mmask16 test_mm256_testn_epi16_mask(__m256i __A, __m256i __B) {
   // CHECK-LABEL: @test_mm256_testn_epi16_mask
-  // CHECK: @llvm.x86.avx512.ptestnm.w.256
+  // CHECK: and <4 x i64> %{{.*}}, %{{.*}}
+  // CHECK: icmp eq <16 x i16> %{{.*}}, %{{.*}}
   return _mm256_testn_epi16_mask(__A, __B); 
 }
 
 __mmask16 test_mm256_mask_testn_epi16_mask(__mmask16 __U, __m256i __A, __m256i __B) {
   // CHECK-LABEL: @test_mm256_mask_testn_epi16_mask
-  // CHECK: @llvm.x86.avx512.ptestnm.w.256
+  // CHECK: and <4 x i64> %{{.*}}, %{{.*}}
+  // CHECK: icmp eq <16 x i16> %{{.*}}, %{{.*}}
+  // CHECK: and <16 x i1> %{{.*}}, %{{.*}}
   return _mm256_mask_testn_epi16_mask(__U, __A, __B); 
 }
 
 __mmask16 test_mm_movepi8_mask(__m128i __A) {
   // CHECK-LABEL: @test_mm_movepi8_mask
   // CHECK: @llvm.x86.avx512.cvtb2mask.128
   return _mm_movepi8_mask(__A); 
 }