1// RUN: %clang_cc1 %s -O0 -triple=x86_64-apple-darwin -ffreestanding -target-feature +avx512bw -target-feature +avx512vl -emit-llvm -o - -Werror | FileCheck %s 2 3#include <immintrin.h> 4 5__mmask32 test_mm256_cmpeq_epi8_mask(__m256i __a, __m256i __b) { 6 // CHECK-LABEL: @test_mm256_cmpeq_epi8_mask 7 // CHECK: @llvm.x86.avx512.mask.pcmpeq.b.256 8 return (__mmask32)_mm256_cmpeq_epi8_mask(__a, __b); 9} 10 11__mmask32 test_mm256_mask_cmpeq_epi8_mask(__mmask32 __u, __m256i __a, __m256i __b) { 12 // CHECK-LABEL: @test_mm256_mask_cmpeq_epi8_mask 13 // CHECK: @llvm.x86.avx512.mask.pcmpeq.b.256 14 return (__mmask32)_mm256_mask_cmpeq_epi8_mask(__u, __a, __b); 15} 16 17__mmask16 test_mm_cmpeq_epi8_mask(__m128i __a, __m128i __b) { 18 // CHECK-LABEL: @test_mm_cmpeq_epi8_mask 19 // CHECK: @llvm.x86.avx512.mask.pcmpeq.b.128 20 return (__mmask16)_mm_cmpeq_epi8_mask(__a, __b); 21} 22 23__mmask16 test_mm_mask_cmpeq_epi8_mask(__mmask16 __u, __m128i __a, __m128i __b) { 24 // CHECK-LABEL: @test_mm_mask_cmpeq_epi8_mask 25 // CHECK: @llvm.x86.avx512.mask.pcmpeq.b.128 26 return (__mmask16)_mm_mask_cmpeq_epi8_mask(__u, __a, __b); 27} 28 29__mmask16 test_mm256_cmpeq_epi16_mask(__m256i __a, __m256i __b) { 30 // CHECK-LABEL: @test_mm256_cmpeq_epi16_mask 31 // CHECK: @llvm.x86.avx512.mask.pcmpeq.w.256 32 return (__mmask16)_mm256_cmpeq_epi16_mask(__a, __b); 33} 34 35__mmask16 test_mm256_mask_cmpeq_epi16_mask(__mmask16 __u, __m256i __a, __m256i __b) { 36 // CHECK-LABEL: @test_mm256_mask_cmpeq_epi16_mask 37 // CHECK: @llvm.x86.avx512.mask.pcmpeq.w.256 38 return (__mmask16)_mm256_mask_cmpeq_epi16_mask(__u, __a, __b); 39} 40 41__mmask8 test_mm_cmpeq_epi16_mask(__m128i __a, __m128i __b) { 42 // CHECK-LABEL: @test_mm_cmpeq_epi16_mask 43 // CHECK: @llvm.x86.avx512.mask.pcmpeq.w.128 44 return (__mmask8)_mm_cmpeq_epi16_mask(__a, __b); 45} 46 47__mmask8 test_mm_mask_cmpeq_epi16_mask(__mmask8 __u, __m128i __a, __m128i __b) { 48 // CHECK-LABEL: @test_mm_mask_cmpeq_epi16_mask 49 // CHECK: @llvm.x86.avx512.mask.pcmpeq.w.128 50 return (__mmask8)_mm_mask_cmpeq_epi16_mask(__u, __a, __b); 51} 52 53__mmask32 test_mm256_cmpgt_epi8_mask(__m256i __a, __m256i __b) { 54 // CHECK-LABEL: @test_mm256_cmpgt_epi8_mask 55 // CHECK: @llvm.x86.avx512.mask.pcmpgt.b.256 56 return (__mmask32)_mm256_cmpgt_epi8_mask(__a, __b); 57} 58 59__mmask32 test_mm256_mask_cmpgt_epi8_mask(__mmask32 __u, __m256i __a, __m256i __b) { 60 // CHECK-LABEL: @test_mm256_mask_cmpgt_epi8_mask 61 // CHECK: @llvm.x86.avx512.mask.pcmpgt.b.256 62 return (__mmask32)_mm256_mask_cmpgt_epi8_mask(__u, __a, __b); 63} 64 65__mmask16 test_mm_cmpgt_epi8_mask(__m128i __a, __m128i __b) { 66 // CHECK-LABEL: @test_mm_cmpgt_epi8_mask 67 // CHECK: @llvm.x86.avx512.mask.pcmpgt.b.128 68 return (__mmask16)_mm_cmpgt_epi8_mask(__a, __b); 69} 70 71__mmask16 test_mm_mask_cmpgt_epi8_mask(__mmask16 __u, __m128i __a, __m128i __b) { 72 // CHECK-LABEL: @test_mm_mask_cmpgt_epi8_mask 73 // CHECK: @llvm.x86.avx512.mask.pcmpgt.b.128 74 return (__mmask16)_mm_mask_cmpgt_epi8_mask(__u, __a, __b); 75} 76 77__mmask16 test_mm256_cmpgt_epi16_mask(__m256i __a, __m256i __b) { 78 // CHECK-LABEL: @test_mm256_cmpgt_epi16_mask 79 // CHECK: @llvm.x86.avx512.mask.pcmpgt.w.256 80 return (__mmask16)_mm256_cmpgt_epi16_mask(__a, __b); 81} 82 83__mmask16 test_mm256_mask_cmpgt_epi16_mask(__mmask16 __u, __m256i __a, __m256i __b) { 84 // CHECK-LABEL: @test_mm256_mask_cmpgt_epi16_mask 85 // CHECK: @llvm.x86.avx512.mask.pcmpgt.w.256 86 return (__mmask16)_mm256_mask_cmpgt_epi16_mask(__u, __a, __b); 87} 88 89__mmask8 test_mm_cmpgt_epi16_mask(__m128i __a, __m128i __b) { 90 // CHECK-LABEL: @test_mm_cmpgt_epi16_mask 91 // CHECK: @llvm.x86.avx512.mask.pcmpgt.w.128 92 return (__mmask8)_mm_cmpgt_epi16_mask(__a, __b); 93} 94 95__mmask8 test_mm_mask_cmpgt_epi16_mask(__mmask8 __u, __m128i __a, __m128i __b) { 96 // CHECK-LABEL: @test_mm_mask_cmpgt_epi16_mask 97 // CHECK: @llvm.x86.avx512.mask.pcmpgt.w.128 98 return (__mmask8)_mm_mask_cmpgt_epi16_mask(__u, __a, __b); 99} 100 101__mmask16 test_mm_cmpeq_epu8_mask(__m128i __a, __m128i __b) { 102 // CHECK-LABEL: @test_mm_cmpeq_epu8_mask 103 // CHECK: @llvm.x86.avx512.mask.ucmp.b.128(<16 x i8> {{.*}}, <16 x i8> {{.*}}, i8 0, i16 -1) 104 return (__mmask64)_mm_cmpeq_epu8_mask(__a, __b); 105} 106 107__mmask16 test_mm_mask_cmpeq_epu8_mask(__mmask64 __u, __m128i __a, __m128i __b) { 108 // CHECK-LABEL: @test_mm_mask_cmpeq_epu8_mask 109 // CHECK: @llvm.x86.avx512.mask.ucmp.b.128(<16 x i8> {{.*}}, <16 x i8> {{.*}}, i8 0, i16 {{.*}}) 110 return (__mmask64)_mm_mask_cmpeq_epu8_mask(__u, __a, __b); 111} 112 113__mmask8 test_mm_cmpeq_epu16_mask(__m128i __a, __m128i __b) { 114 // CHECK-LABEL: @test_mm_cmpeq_epu16_mask 115 // CHECK: @llvm.x86.avx512.mask.ucmp.w.128(<8 x i16> {{.*}}, <8 x i16> {{.*}}, i8 0, i8 -1) 116 return (__mmask32)_mm_cmpeq_epu16_mask(__a, __b); 117} 118 119__mmask8 test_mm_mask_cmpeq_epu16_mask(__mmask32 __u, __m128i __a, __m128i __b) { 120 // CHECK-LABEL: @test_mm_mask_cmpeq_epu16_mask 121 // CHECK: @llvm.x86.avx512.mask.ucmp.w.128(<8 x i16> {{.*}}, <8 x i16> {{.*}}, i8 0, i8 {{.*}}) 122 return (__mmask32)_mm_mask_cmpeq_epu16_mask(__u, __a, __b); 123} 124 125__mmask32 test_mm256_cmpeq_epu8_mask(__m256i __a, __m256i __b) { 126 // CHECK-LABEL: @test_mm256_cmpeq_epu8_mask 127 // CHECK: @llvm.x86.avx512.mask.ucmp.b.256(<32 x i8> {{.*}}, <32 x i8> {{.*}}, i8 0, i32 -1) 128 return (__mmask64)_mm256_cmpeq_epu8_mask(__a, __b); 129} 130 131__mmask32 test_mm256_mask_cmpeq_epu8_mask(__mmask64 __u, __m256i __a, __m256i __b) { 132 // CHECK-LABEL: @test_mm256_mask_cmpeq_epu8_mask 133 // CHECK: @llvm.x86.avx512.mask.ucmp.b.256(<32 x i8> {{.*}}, <32 x i8> {{.*}}, i8 0, i32 {{.*}}) 134 return (__mmask64)_mm256_mask_cmpeq_epu8_mask(__u, __a, __b); 135} 136 137__mmask16 test_mm256_cmpeq_epu16_mask(__m256i __a, __m256i __b) { 138 // CHECK-LABEL: @test_mm256_cmpeq_epu16_mask 139 // CHECK: @llvm.x86.avx512.mask.ucmp.w.256(<16 x i16> {{.*}}, <16 x i16> {{.*}}, i8 0, i16 -1) 140 return (__mmask32)_mm256_cmpeq_epu16_mask(__a, __b); 141} 142 143__mmask16 test_mm256_mask_cmpeq_epu16_mask(__mmask32 __u, __m256i __a, __m256i __b) { 144 // CHECK-LABEL: @test_mm256_mask_cmpeq_epu16_mask 145 // CHECK: @llvm.x86.avx512.mask.ucmp.w.256(<16 x i16> {{.*}}, <16 x i16> {{.*}}, i8 0, i16 {{.*}}) 146 return (__mmask32)_mm256_mask_cmpeq_epu16_mask(__u, __a, __b); 147} 148 149__mmask16 test_mm_cmpgt_epu8_mask(__m128i __a, __m128i __b) { 150 // CHECK-LABEL: @test_mm_cmpgt_epu8_mask 151 // CHECK: @llvm.x86.avx512.mask.ucmp.b.128(<16 x i8> {{.*}}, <16 x i8> {{.*}}, i8 6, i16 -1) 152 return (__mmask64)_mm_cmpgt_epu8_mask(__a, __b); 153} 154 155__mmask16 test_mm_mask_cmpgt_epu8_mask(__mmask64 __u, __m128i __a, __m128i __b) { 156 // CHECK-LABEL: @test_mm_mask_cmpgt_epu8_mask 157 // CHECK: @llvm.x86.avx512.mask.ucmp.b.128(<16 x i8> {{.*}}, <16 x i8> {{.*}}, i8 6, i16 {{.*}}) 158 return (__mmask64)_mm_mask_cmpgt_epu8_mask(__u, __a, __b); 159} 160 161__mmask8 test_mm_cmpgt_epu16_mask(__m128i __a, __m128i __b) { 162 // CHECK-LABEL: @test_mm_cmpgt_epu16_mask 163 // CHECK: @llvm.x86.avx512.mask.ucmp.w.128(<8 x i16> {{.*}}, <8 x i16> {{.*}}, i8 6, i8 -1) 164 return (__mmask32)_mm_cmpgt_epu16_mask(__a, __b); 165} 166 167__mmask8 test_mm_mask_cmpgt_epu16_mask(__mmask32 __u, __m128i __a, __m128i __b) { 168 // CHECK-LABEL: @test_mm_mask_cmpgt_epu16_mask 169 // CHECK: @llvm.x86.avx512.mask.ucmp.w.128(<8 x i16> {{.*}}, <8 x i16> {{.*}}, i8 6, i8 {{.*}}) 170 return (__mmask32)_mm_mask_cmpgt_epu16_mask(__u, __a, __b); 171} 172 173__mmask32 test_mm256_cmpgt_epu8_mask(__m256i __a, __m256i __b) { 174 // CHECK-LABEL: @test_mm256_cmpgt_epu8_mask 175 // CHECK: @llvm.x86.avx512.mask.ucmp.b.256(<32 x i8> {{.*}}, <32 x i8> {{.*}}, i8 6, i32 -1) 176 return (__mmask64)_mm256_cmpgt_epu8_mask(__a, __b); 177} 178 179__mmask32 test_mm256_mask_cmpgt_epu8_mask(__mmask64 __u, __m256i __a, __m256i __b) { 180 // CHECK-LABEL: @test_mm256_mask_cmpgt_epu8_mask 181 // CHECK: @llvm.x86.avx512.mask.ucmp.b.256(<32 x i8> {{.*}}, <32 x i8> {{.*}}, i8 6, i32 {{.*}}) 182 return (__mmask64)_mm256_mask_cmpgt_epu8_mask(__u, __a, __b); 183} 184 185__mmask16 test_mm256_cmpgt_epu16_mask(__m256i __a, __m256i __b) { 186 // CHECK-LABEL: @test_mm256_cmpgt_epu16_mask 187 // CHECK: @llvm.x86.avx512.mask.ucmp.w.256(<16 x i16> {{.*}}, <16 x i16> {{.*}}, i8 6, i16 -1) 188 return (__mmask32)_mm256_cmpgt_epu16_mask(__a, __b); 189} 190 191__mmask16 test_mm256_mask_cmpgt_epu16_mask(__mmask32 __u, __m256i __a, __m256i __b) { 192 // CHECK-LABEL: @test_mm256_mask_cmpgt_epu16_mask 193 // CHECK: @llvm.x86.avx512.mask.ucmp.w.256(<16 x i16> {{.*}}, <16 x i16> {{.*}}, i8 6, i16 {{.*}}) 194 return (__mmask32)_mm256_mask_cmpgt_epu16_mask(__u, __a, __b); 195} 196 197__mmask16 test_mm_cmpge_epi8_mask(__m128i __a, __m128i __b) { 198 // CHECK-LABEL: @test_mm_cmpge_epi8_mask 199 // CHECK: @llvm.x86.avx512.mask.cmp.b.128(<16 x i8> {{.*}}, <16 x i8> {{.*}}, i8 5, i16 -1) 200 return (__mmask64)_mm_cmpge_epi8_mask(__a, __b); 201} 202 203__mmask16 test_mm_mask_cmpge_epi8_mask(__mmask64 __u, __m128i __a, __m128i __b) { 204 // CHECK-LABEL: @test_mm_mask_cmpge_epi8_mask 205 // CHECK: @llvm.x86.avx512.mask.cmp.b.128(<16 x i8> {{.*}}, <16 x i8> {{.*}}, i8 5, i16 {{.*}}) 206 return (__mmask64)_mm_mask_cmpge_epi8_mask(__u, __a, __b); 207} 208 209__mmask16 test_mm_cmpge_epu8_mask(__m128i __a, __m128i __b) { 210 // CHECK-LABEL: @test_mm_cmpge_epu8_mask 211 // CHECK: @llvm.x86.avx512.mask.ucmp.b.128(<16 x i8> {{.*}}, <16 x i8> {{.*}}, i8 5, i16 -1) 212 return (__mmask64)_mm_cmpge_epu8_mask(__a, __b); 213} 214 215__mmask16 test_mm_mask_cmpge_epu8_mask(__mmask64 __u, __m128i __a, __m128i __b) { 216 // CHECK-LABEL: @test_mm_mask_cmpge_epu8_mask 217 // CHECK: @llvm.x86.avx512.mask.ucmp.b.128(<16 x i8> {{.*}}, <16 x i8> {{.*}}, i8 5, i16 {{.*}}) 218 return (__mmask64)_mm_mask_cmpge_epu8_mask(__u, __a, __b); 219} 220 221__mmask8 test_mm_cmpge_epi16_mask(__m128i __a, __m128i __b) { 222 // CHECK-LABEL: @test_mm_cmpge_epi16_mask 223 // CHECK: @llvm.x86.avx512.mask.cmp.w.128(<8 x i16> {{.*}}, <8 x i16> {{.*}}, i8 5, i8 -1) 224 return (__mmask32)_mm_cmpge_epi16_mask(__a, __b); 225} 226 227__mmask8 test_mm_mask_cmpge_epi16_mask(__mmask32 __u, __m128i __a, __m128i __b) { 228 // CHECK-LABEL: @test_mm_mask_cmpge_epi16_mask 229 // CHECK: @llvm.x86.avx512.mask.cmp.w.128(<8 x i16> {{.*}}, <8 x i16> {{.*}}, i8 5, i8 {{.*}}) 230 return (__mmask32)_mm_mask_cmpge_epi16_mask(__u, __a, __b); 231} 232 233__mmask8 test_mm_cmpge_epu16_mask(__m128i __a, __m128i __b) { 234 // CHECK-LABEL: @test_mm_cmpge_epu16_mask 235 // CHECK: @llvm.x86.avx512.mask.ucmp.w.128(<8 x i16> {{.*}}, <8 x i16> {{.*}}, i8 5, i8 -1) 236 return (__mmask32)_mm_cmpge_epu16_mask(__a, __b); 237} 238 239__mmask8 test_mm_mask_cmpge_epu16_mask(__mmask32 __u, __m128i __a, __m128i __b) { 240 // CHECK-LABEL: @test_mm_mask_cmpge_epu16_mask 241 // CHECK: @llvm.x86.avx512.mask.ucmp.w.128(<8 x i16> {{.*}}, <8 x i16> {{.*}}, i8 5, i8 {{.*}}) 242 return (__mmask32)_mm_mask_cmpge_epu16_mask(__u, __a, __b); 243} 244 245__mmask32 test_mm256_cmpge_epi8_mask(__m256i __a, __m256i __b) { 246 // CHECK-LABEL: @test_mm256_cmpge_epi8_mask 247 // CHECK: @llvm.x86.avx512.mask.cmp.b.256(<32 x i8> {{.*}}, <32 x i8> {{.*}}, i8 5, i32 -1) 248 return (__mmask64)_mm256_cmpge_epi8_mask(__a, __b); 249} 250 251__mmask32 test_mm256_mask_cmpge_epi8_mask(__mmask64 __u, __m256i __a, __m256i __b) { 252 // CHECK-LABEL: @test_mm256_mask_cmpge_epi8_mask 253 // CHECK: @llvm.x86.avx512.mask.cmp.b.256(<32 x i8> {{.*}}, <32 x i8> {{.*}}, i8 5, i32 {{.*}}) 254 return (__mmask64)_mm256_mask_cmpge_epi8_mask(__u, __a, __b); 255} 256 257__mmask32 test_mm256_cmpge_epu8_mask(__m256i __a, __m256i __b) { 258 // CHECK-LABEL: @test_mm256_cmpge_epu8_mask 259 // CHECK: @llvm.x86.avx512.mask.ucmp.b.256(<32 x i8> {{.*}}, <32 x i8> {{.*}}, i8 5, i32 -1) 260 return (__mmask64)_mm256_cmpge_epu8_mask(__a, __b); 261} 262 263__mmask32 test_mm256_mask_cmpge_epu8_mask(__mmask64 __u, __m256i __a, __m256i __b) { 264 // CHECK-LABEL: @test_mm256_mask_cmpge_epu8_mask 265 // CHECK: @llvm.x86.avx512.mask.ucmp.b.256(<32 x i8> {{.*}}, <32 x i8> {{.*}}, i8 5, i32 {{.*}}) 266 return (__mmask64)_mm256_mask_cmpge_epu8_mask(__u, __a, __b); 267} 268 269__mmask16 test_mm256_cmpge_epi16_mask(__m256i __a, __m256i __b) { 270 // CHECK-LABEL: @test_mm256_cmpge_epi16_mask 271 // CHECK: @llvm.x86.avx512.mask.cmp.w.256(<16 x i16> {{.*}}, <16 x i16> {{.*}}, i8 5, i16 -1) 272 return (__mmask32)_mm256_cmpge_epi16_mask(__a, __b); 273} 274 275__mmask16 test_mm256_mask_cmpge_epi16_mask(__mmask32 __u, __m256i __a, __m256i __b) { 276 // CHECK-LABEL: @test_mm256_mask_cmpge_epi16_mask 277 // CHECK: @llvm.x86.avx512.mask.cmp.w.256(<16 x i16> {{.*}}, <16 x i16> {{.*}}, i8 5, i16 {{.*}}) 278 return (__mmask32)_mm256_mask_cmpge_epi16_mask(__u, __a, __b); 279} 280 281__mmask16 test_mm256_cmpge_epu16_mask(__m256i __a, __m256i __b) { 282 // CHECK-LABEL: @test_mm256_cmpge_epu16_mask 283 // CHECK: @llvm.x86.avx512.mask.ucmp.w.256(<16 x i16> {{.*}}, <16 x i16> {{.*}}, i8 5, i16 -1) 284 return (__mmask32)_mm256_cmpge_epu16_mask(__a, __b); 285} 286 287__mmask16 test_mm256_mask_cmpge_epu16_mask(__mmask32 __u, __m256i __a, __m256i __b) { 288 // CHECK-LABEL: @test_mm256_mask_cmpge_epu16_mask 289 // CHECK: @llvm.x86.avx512.mask.ucmp.w.256(<16 x i16> {{.*}}, <16 x i16> {{.*}}, i8 5, i16 {{.*}}) 290 return (__mmask32)_mm256_mask_cmpge_epu16_mask(__u, __a, __b); 291} 292 293__mmask16 test_mm_cmple_epi8_mask(__m128i __a, __m128i __b) { 294 // CHECK-LABEL: @test_mm_cmple_epi8_mask 295 // CHECK: @llvm.x86.avx512.mask.cmp.b.128(<16 x i8> {{.*}}, <16 x i8> {{.*}}, i8 2, i16 -1) 296 return (__mmask64)_mm_cmple_epi8_mask(__a, __b); 297} 298 299__mmask16 test_mm_mask_cmple_epi8_mask(__mmask64 __u, __m128i __a, __m128i __b) { 300 // CHECK-LABEL: @test_mm_mask_cmple_epi8_mask 301 // CHECK: @llvm.x86.avx512.mask.cmp.b.128(<16 x i8> {{.*}}, <16 x i8> {{.*}}, i8 2, i16 {{.*}}) 302 return (__mmask64)_mm_mask_cmple_epi8_mask(__u, __a, __b); 303} 304 305__mmask16 test_mm_cmple_epu8_mask(__m128i __a, __m128i __b) { 306 // CHECK-LABEL: @test_mm_cmple_epu8_mask 307 // CHECK: @llvm.x86.avx512.mask.ucmp.b.128(<16 x i8> {{.*}}, <16 x i8> {{.*}}, i8 2, i16 -1) 308 return (__mmask64)_mm_cmple_epu8_mask(__a, __b); 309} 310 311__mmask16 test_mm_mask_cmple_epu8_mask(__mmask64 __u, __m128i __a, __m128i __b) { 312 // CHECK-LABEL: @test_mm_mask_cmple_epu8_mask 313 // CHECK: @llvm.x86.avx512.mask.ucmp.b.128(<16 x i8> {{.*}}, <16 x i8> {{.*}}, i8 2, i16 {{.*}}) 314 return (__mmask64)_mm_mask_cmple_epu8_mask(__u, __a, __b); 315} 316 317__mmask8 test_mm_cmple_epi16_mask(__m128i __a, __m128i __b) { 318 // CHECK-LABEL: @test_mm_cmple_epi16_mask 319 // CHECK: @llvm.x86.avx512.mask.cmp.w.128(<8 x i16> {{.*}}, <8 x i16> {{.*}}, i8 2, i8 -1) 320 return (__mmask32)_mm_cmple_epi16_mask(__a, __b); 321} 322 323__mmask8 test_mm_mask_cmple_epi16_mask(__mmask32 __u, __m128i __a, __m128i __b) { 324 // CHECK-LABEL: @test_mm_mask_cmple_epi16_mask 325 // CHECK: @llvm.x86.avx512.mask.cmp.w.128(<8 x i16> {{.*}}, <8 x i16> {{.*}}, i8 2, i8 {{.*}}) 326 return (__mmask32)_mm_mask_cmple_epi16_mask(__u, __a, __b); 327} 328 329__mmask8 test_mm_cmple_epu16_mask(__m128i __a, __m128i __b) { 330 // CHECK-LABEL: @test_mm_cmple_epu16_mask 331 // CHECK: @llvm.x86.avx512.mask.ucmp.w.128(<8 x i16> {{.*}}, <8 x i16> {{.*}}, i8 2, i8 -1) 332 return (__mmask32)_mm_cmple_epu16_mask(__a, __b); 333} 334 335__mmask8 test_mm_mask_cmple_epu16_mask(__mmask32 __u, __m128i __a, __m128i __b) { 336 // CHECK-LABEL: @test_mm_mask_cmple_epu16_mask 337 // CHECK: @llvm.x86.avx512.mask.ucmp.w.128(<8 x i16> {{.*}}, <8 x i16> {{.*}}, i8 2, i8 {{.*}}) 338 return (__mmask32)_mm_mask_cmple_epu16_mask(__u, __a, __b); 339} 340 341__mmask32 test_mm256_cmple_epi8_mask(__m256i __a, __m256i __b) { 342 // CHECK-LABEL: @test_mm256_cmple_epi8_mask 343 // CHECK: @llvm.x86.avx512.mask.cmp.b.256(<32 x i8> {{.*}}, <32 x i8> {{.*}}, i8 2, i32 -1) 344 return (__mmask64)_mm256_cmple_epi8_mask(__a, __b); 345} 346 347__mmask32 test_mm256_mask_cmple_epi8_mask(__mmask64 __u, __m256i __a, __m256i __b) { 348 // CHECK-LABEL: @test_mm256_mask_cmple_epi8_mask 349 // CHECK: @llvm.x86.avx512.mask.cmp.b.256(<32 x i8> {{.*}}, <32 x i8> {{.*}}, i8 2, i32 {{.*}}) 350 return (__mmask64)_mm256_mask_cmple_epi8_mask(__u, __a, __b); 351} 352 353__mmask32 test_mm256_cmple_epu8_mask(__m256i __a, __m256i __b) { 354 // CHECK-LABEL: @test_mm256_cmple_epu8_mask 355 // CHECK: @llvm.x86.avx512.mask.ucmp.b.256(<32 x i8> {{.*}}, <32 x i8> {{.*}}, i8 2, i32 -1) 356 return (__mmask64)_mm256_cmple_epu8_mask(__a, __b); 357} 358 359__mmask32 test_mm256_mask_cmple_epu8_mask(__mmask64 __u, __m256i __a, __m256i __b) { 360 // CHECK-LABEL: @test_mm256_mask_cmple_epu8_mask 361 // CHECK: @llvm.x86.avx512.mask.ucmp.b.256(<32 x i8> {{.*}}, <32 x i8> {{.*}}, i8 2, i32 {{.*}}) 362 return (__mmask64)_mm256_mask_cmple_epu8_mask(__u, __a, __b); 363} 364 365__mmask16 test_mm256_cmple_epi16_mask(__m256i __a, __m256i __b) { 366 // CHECK-LABEL: @test_mm256_cmple_epi16_mask 367 // CHECK: @llvm.x86.avx512.mask.cmp.w.256(<16 x i16> {{.*}}, <16 x i16> {{.*}}, i8 2, i16 -1) 368 return (__mmask32)_mm256_cmple_epi16_mask(__a, __b); 369} 370 371__mmask16 test_mm256_mask_cmple_epi16_mask(__mmask32 __u, __m256i __a, __m256i __b) { 372 // CHECK-LABEL: @test_mm256_mask_cmple_epi16_mask 373 // CHECK: @llvm.x86.avx512.mask.cmp.w.256(<16 x i16> {{.*}}, <16 x i16> {{.*}}, i8 2, i16 {{.*}}) 374 return (__mmask32)_mm256_mask_cmple_epi16_mask(__u, __a, __b); 375} 376 377__mmask16 test_mm256_cmple_epu16_mask(__m256i __a, __m256i __b) { 378 // CHECK-LABEL: @test_mm256_cmple_epu16_mask 379 // CHECK: @llvm.x86.avx512.mask.ucmp.w.256(<16 x i16> {{.*}}, <16 x i16> {{.*}}, i8 2, i16 -1) 380 return (__mmask32)_mm256_cmple_epu16_mask(__a, __b); 381} 382 383__mmask16 test_mm256_mask_cmple_epu16_mask(__mmask32 __u, __m256i __a, __m256i __b) { 384 // CHECK-LABEL: @test_mm256_mask_cmple_epu16_mask 385 // CHECK: @llvm.x86.avx512.mask.ucmp.w.256(<16 x i16> {{.*}}, <16 x i16> {{.*}}, i8 2, i16 {{.*}}) 386 return (__mmask32)_mm256_mask_cmple_epu16_mask(__u, __a, __b); 387} 388 389__mmask16 test_mm_cmplt_epi8_mask(__m128i __a, __m128i __b) { 390 // CHECK-LABEL: @test_mm_cmplt_epi8_mask 391 // CHECK: @llvm.x86.avx512.mask.cmp.b.128(<16 x i8> {{.*}}, <16 x i8> {{.*}}, i8 1, i16 -1) 392 return (__mmask64)_mm_cmplt_epi8_mask(__a, __b); 393} 394 395__mmask16 test_mm_mask_cmplt_epi8_mask(__mmask64 __u, __m128i __a, __m128i __b) { 396 // CHECK-LABEL: @test_mm_mask_cmplt_epi8_mask 397 // CHECK: @llvm.x86.avx512.mask.cmp.b.128(<16 x i8> {{.*}}, <16 x i8> {{.*}}, i8 1, i16 {{.*}}) 398 return (__mmask64)_mm_mask_cmplt_epi8_mask(__u, __a, __b); 399} 400 401__mmask16 test_mm_cmplt_epu8_mask(__m128i __a, __m128i __b) { 402 // CHECK-LABEL: @test_mm_cmplt_epu8_mask 403 // CHECK: @llvm.x86.avx512.mask.ucmp.b.128(<16 x i8> {{.*}}, <16 x i8> {{.*}}, i8 1, i16 -1) 404 return (__mmask64)_mm_cmplt_epu8_mask(__a, __b); 405} 406 407__mmask16 test_mm_mask_cmplt_epu8_mask(__mmask64 __u, __m128i __a, __m128i __b) { 408 // CHECK-LABEL: @test_mm_mask_cmplt_epu8_mask 409 // CHECK: @llvm.x86.avx512.mask.ucmp.b.128(<16 x i8> {{.*}}, <16 x i8> {{.*}}, i8 1, i16 {{.*}}) 410 return (__mmask64)_mm_mask_cmplt_epu8_mask(__u, __a, __b); 411} 412 413__mmask8 test_mm_cmplt_epi16_mask(__m128i __a, __m128i __b) { 414 // CHECK-LABEL: @test_mm_cmplt_epi16_mask 415 // CHECK: @llvm.x86.avx512.mask.cmp.w.128(<8 x i16> {{.*}}, <8 x i16> {{.*}}, i8 1, i8 -1) 416 return (__mmask32)_mm_cmplt_epi16_mask(__a, __b); 417} 418 419__mmask8 test_mm_mask_cmplt_epi16_mask(__mmask32 __u, __m128i __a, __m128i __b) { 420 // CHECK-LABEL: @test_mm_mask_cmplt_epi16_mask 421 // CHECK: @llvm.x86.avx512.mask.cmp.w.128(<8 x i16> {{.*}}, <8 x i16> {{.*}}, i8 1, i8 {{.*}}) 422 return (__mmask32)_mm_mask_cmplt_epi16_mask(__u, __a, __b); 423} 424 425__mmask8 test_mm_cmplt_epu16_mask(__m128i __a, __m128i __b) { 426 // CHECK-LABEL: @test_mm_cmplt_epu16_mask 427 // CHECK: @llvm.x86.avx512.mask.ucmp.w.128(<8 x i16> {{.*}}, <8 x i16> {{.*}}, i8 1, i8 -1) 428 return (__mmask32)_mm_cmplt_epu16_mask(__a, __b); 429} 430 431__mmask8 test_mm_mask_cmplt_epu16_mask(__mmask32 __u, __m128i __a, __m128i __b) { 432 // CHECK-LABEL: @test_mm_mask_cmplt_epu16_mask 433 // CHECK: @llvm.x86.avx512.mask.ucmp.w.128(<8 x i16> {{.*}}, <8 x i16> {{.*}}, i8 1, i8 {{.*}}) 434 return (__mmask32)_mm_mask_cmplt_epu16_mask(__u, __a, __b); 435} 436 437__mmask32 test_mm256_cmplt_epi8_mask(__m256i __a, __m256i __b) { 438 // CHECK-LABEL: @test_mm256_cmplt_epi8_mask 439 // CHECK: @llvm.x86.avx512.mask.cmp.b.256(<32 x i8> {{.*}}, <32 x i8> {{.*}}, i8 1, i32 -1) 440 return (__mmask64)_mm256_cmplt_epi8_mask(__a, __b); 441} 442 443__mmask32 test_mm256_mask_cmplt_epi8_mask(__mmask64 __u, __m256i __a, __m256i __b) { 444 // CHECK-LABEL: @test_mm256_mask_cmplt_epi8_mask 445 // CHECK: @llvm.x86.avx512.mask.cmp.b.256(<32 x i8> {{.*}}, <32 x i8> {{.*}}, i8 1, i32 {{.*}}) 446 return (__mmask64)_mm256_mask_cmplt_epi8_mask(__u, __a, __b); 447} 448 449__mmask32 test_mm256_cmplt_epu8_mask(__m256i __a, __m256i __b) { 450 // CHECK-LABEL: @test_mm256_cmplt_epu8_mask 451 // CHECK: @llvm.x86.avx512.mask.ucmp.b.256(<32 x i8> {{.*}}, <32 x i8> {{.*}}, i8 1, i32 -1) 452 return (__mmask64)_mm256_cmplt_epu8_mask(__a, __b); 453} 454 455__mmask32 test_mm256_mask_cmplt_epu8_mask(__mmask64 __u, __m256i __a, __m256i __b) { 456 // CHECK-LABEL: @test_mm256_mask_cmplt_epu8_mask 457 // CHECK: @llvm.x86.avx512.mask.ucmp.b.256(<32 x i8> {{.*}}, <32 x i8> {{.*}}, i8 1, i32 {{.*}}) 458 return (__mmask64)_mm256_mask_cmplt_epu8_mask(__u, __a, __b); 459} 460 461__mmask16 test_mm256_cmplt_epi16_mask(__m256i __a, __m256i __b) { 462 // CHECK-LABEL: @test_mm256_cmplt_epi16_mask 463 // CHECK: @llvm.x86.avx512.mask.cmp.w.256(<16 x i16> {{.*}}, <16 x i16> {{.*}}, i8 1, i16 -1) 464 return (__mmask32)_mm256_cmplt_epi16_mask(__a, __b); 465} 466 467__mmask16 test_mm256_mask_cmplt_epi16_mask(__mmask32 __u, __m256i __a, __m256i __b) { 468 // CHECK-LABEL: @test_mm256_mask_cmplt_epi16_mask 469 // CHECK: @llvm.x86.avx512.mask.cmp.w.256(<16 x i16> {{.*}}, <16 x i16> {{.*}}, i8 1, i16 {{.*}}) 470 return (__mmask32)_mm256_mask_cmplt_epi16_mask(__u, __a, __b); 471} 472 473__mmask16 test_mm256_cmplt_epu16_mask(__m256i __a, __m256i __b) { 474 // CHECK-LABEL: @test_mm256_cmplt_epu16_mask 475 // CHECK: @llvm.x86.avx512.mask.ucmp.w.256(<16 x i16> {{.*}}, <16 x i16> {{.*}}, i8 1, i16 -1) 476 return (__mmask32)_mm256_cmplt_epu16_mask(__a, __b); 477} 478 479__mmask16 test_mm256_mask_cmplt_epu16_mask(__mmask32 __u, __m256i __a, __m256i __b) { 480 // CHECK-LABEL: @test_mm256_mask_cmplt_epu16_mask 481 // CHECK: @llvm.x86.avx512.mask.ucmp.w.256(<16 x i16> {{.*}}, <16 x i16> {{.*}}, i8 1, i16 {{.*}}) 482 return (__mmask32)_mm256_mask_cmplt_epu16_mask(__u, __a, __b); 483} 484 485__mmask16 test_mm_cmpneq_epi8_mask(__m128i __a, __m128i __b) { 486 // CHECK-LABEL: @test_mm_cmpneq_epi8_mask 487 // CHECK: @llvm.x86.avx512.mask.cmp.b.128(<16 x i8> {{.*}}, <16 x i8> {{.*}}, i8 4, i16 -1) 488 return (__mmask64)_mm_cmpneq_epi8_mask(__a, __b); 489} 490 491__mmask16 test_mm_mask_cmpneq_epi8_mask(__mmask64 __u, __m128i __a, __m128i __b) { 492 // CHECK-LABEL: @test_mm_mask_cmpneq_epi8_mask 493 // CHECK: @llvm.x86.avx512.mask.cmp.b.128(<16 x i8> {{.*}}, <16 x i8> {{.*}}, i8 4, i16 {{.*}}) 494 return (__mmask64)_mm_mask_cmpneq_epi8_mask(__u, __a, __b); 495} 496 497__mmask16 test_mm_cmpneq_epu8_mask(__m128i __a, __m128i __b) { 498 // CHECK-LABEL: @test_mm_cmpneq_epu8_mask 499 // CHECK: @llvm.x86.avx512.mask.ucmp.b.128(<16 x i8> {{.*}}, <16 x i8> {{.*}}, i8 4, i16 -1) 500 return (__mmask64)_mm_cmpneq_epu8_mask(__a, __b); 501} 502 503__mmask16 test_mm_mask_cmpneq_epu8_mask(__mmask64 __u, __m128i __a, __m128i __b) { 504 // CHECK-LABEL: @test_mm_mask_cmpneq_epu8_mask 505 // CHECK: @llvm.x86.avx512.mask.ucmp.b.128(<16 x i8> {{.*}}, <16 x i8> {{.*}}, i8 4, i16 {{.*}}) 506 return (__mmask64)_mm_mask_cmpneq_epu8_mask(__u, __a, __b); 507} 508 509__mmask8 test_mm_cmpneq_epi16_mask(__m128i __a, __m128i __b) { 510 // CHECK-LABEL: @test_mm_cmpneq_epi16_mask 511 // CHECK: @llvm.x86.avx512.mask.cmp.w.128(<8 x i16> {{.*}}, <8 x i16> {{.*}}, i8 4, i8 -1) 512 return (__mmask32)_mm_cmpneq_epi16_mask(__a, __b); 513} 514 515__mmask8 test_mm_mask_cmpneq_epi16_mask(__mmask32 __u, __m128i __a, __m128i __b) { 516 // CHECK-LABEL: @test_mm_mask_cmpneq_epi16_mask 517 // CHECK: @llvm.x86.avx512.mask.cmp.w.128(<8 x i16> {{.*}}, <8 x i16> {{.*}}, i8 4, i8 {{.*}}) 518 return (__mmask32)_mm_mask_cmpneq_epi16_mask(__u, __a, __b); 519} 520 521__mmask8 test_mm_cmpneq_epu16_mask(__m128i __a, __m128i __b) { 522 // CHECK-LABEL: @test_mm_cmpneq_epu16_mask 523 // CHECK: @llvm.x86.avx512.mask.ucmp.w.128(<8 x i16> {{.*}}, <8 x i16> {{.*}}, i8 4, i8 -1) 524 return (__mmask32)_mm_cmpneq_epu16_mask(__a, __b); 525} 526 527__mmask8 test_mm_mask_cmpneq_epu16_mask(__mmask32 __u, __m128i __a, __m128i __b) { 528 // CHECK-LABEL: @test_mm_mask_cmpneq_epu16_mask 529 // CHECK: @llvm.x86.avx512.mask.ucmp.w.128(<8 x i16> {{.*}}, <8 x i16> {{.*}}, i8 4, i8 {{.*}}) 530 return (__mmask32)_mm_mask_cmpneq_epu16_mask(__u, __a, __b); 531} 532 533__mmask32 test_mm256_cmpneq_epi8_mask(__m256i __a, __m256i __b) { 534 // CHECK-LABEL: @test_mm256_cmpneq_epi8_mask 535 // CHECK: @llvm.x86.avx512.mask.cmp.b.256(<32 x i8> {{.*}}, <32 x i8> {{.*}}, i8 4, i32 -1) 536 return (__mmask64)_mm256_cmpneq_epi8_mask(__a, __b); 537} 538 539__mmask32 test_mm256_mask_cmpneq_epi8_mask(__mmask64 __u, __m256i __a, __m256i __b) { 540 // CHECK-LABEL: @test_mm256_mask_cmpneq_epi8_mask 541 // CHECK: @llvm.x86.avx512.mask.cmp.b.256(<32 x i8> {{.*}}, <32 x i8> {{.*}}, i8 4, i32 {{.*}}) 542 return (__mmask64)_mm256_mask_cmpneq_epi8_mask(__u, __a, __b); 543} 544 545__mmask32 test_mm256_cmpneq_epu8_mask(__m256i __a, __m256i __b) { 546 // CHECK-LABEL: @test_mm256_cmpneq_epu8_mask 547 // CHECK: @llvm.x86.avx512.mask.ucmp.b.256(<32 x i8> {{.*}}, <32 x i8> {{.*}}, i8 4, i32 -1) 548 return (__mmask64)_mm256_cmpneq_epu8_mask(__a, __b); 549} 550 551__mmask32 test_mm256_mask_cmpneq_epu8_mask(__mmask64 __u, __m256i __a, __m256i __b) { 552 // CHECK-LABEL: @test_mm256_mask_cmpneq_epu8_mask 553 // CHECK: @llvm.x86.avx512.mask.ucmp.b.256(<32 x i8> {{.*}}, <32 x i8> {{.*}}, i8 4, i32 {{.*}}) 554 return (__mmask64)_mm256_mask_cmpneq_epu8_mask(__u, __a, __b); 555} 556 557__mmask16 test_mm256_cmpneq_epi16_mask(__m256i __a, __m256i __b) { 558 // CHECK-LABEL: @test_mm256_cmpneq_epi16_mask 559 // CHECK: @llvm.x86.avx512.mask.cmp.w.256(<16 x i16> {{.*}}, <16 x i16> {{.*}}, i8 4, i16 -1) 560 return (__mmask32)_mm256_cmpneq_epi16_mask(__a, __b); 561} 562 563__mmask16 test_mm256_mask_cmpneq_epi16_mask(__mmask32 __u, __m256i __a, __m256i __b) { 564 // CHECK-LABEL: @test_mm256_mask_cmpneq_epi16_mask 565 // CHECK: @llvm.x86.avx512.mask.cmp.w.256(<16 x i16> {{.*}}, <16 x i16> {{.*}}, i8 4, i16 {{.*}}) 566 return (__mmask32)_mm256_mask_cmpneq_epi16_mask(__u, __a, __b); 567} 568 569__mmask16 test_mm256_cmpneq_epu16_mask(__m256i __a, __m256i __b) { 570 // CHECK-LABEL: @test_mm256_cmpneq_epu16_mask 571 // CHECK: @llvm.x86.avx512.mask.ucmp.w.256(<16 x i16> {{.*}}, <16 x i16> {{.*}}, i8 4, i16 -1) 572 return (__mmask32)_mm256_cmpneq_epu16_mask(__a, __b); 573} 574 575__mmask16 test_mm256_mask_cmpneq_epu16_mask(__mmask32 __u, __m256i __a, __m256i __b) { 576 // CHECK-LABEL: @test_mm256_mask_cmpneq_epu16_mask 577 // CHECK: @llvm.x86.avx512.mask.ucmp.w.256(<16 x i16> {{.*}}, <16 x i16> {{.*}}, i8 4, i16 {{.*}}) 578 return (__mmask32)_mm256_mask_cmpneq_epu16_mask(__u, __a, __b); 579} 580 581__mmask16 test_mm_cmp_epi8_mask(__m128i __a, __m128i __b) { 582 // CHECK-LABEL: @test_mm_cmp_epi8_mask 583 // CHECK: @llvm.x86.avx512.mask.cmp.b.128(<16 x i8> {{.*}}, <16 x i8> {{.*}}, i8 7, i16 -1) 584 return (__mmask64)_mm_cmp_epi8_mask(__a, __b, 7); 585} 586 587__mmask16 test_mm_mask_cmp_epi8_mask(__mmask64 __u, __m128i __a, __m128i __b) { 588 // CHECK-LABEL: @test_mm_mask_cmp_epi8_mask 589 // CHECK: @llvm.x86.avx512.mask.cmp.b.128(<16 x i8> {{.*}}, <16 x i8> {{.*}}, i8 7, i16 {{.*}}) 590 return (__mmask64)_mm_mask_cmp_epi8_mask(__u, __a, __b, 7); 591} 592 593__mmask16 test_mm_cmp_epu8_mask(__m128i __a, __m128i __b) { 594 // CHECK-LABEL: @test_mm_cmp_epu8_mask 595 // CHECK: @llvm.x86.avx512.mask.ucmp.b.128(<16 x i8> {{.*}}, <16 x i8> {{.*}}, i8 7, i16 -1) 596 return (__mmask64)_mm_cmp_epu8_mask(__a, __b, 7); 597} 598 599__mmask16 test_mm_mask_cmp_epu8_mask(__mmask64 __u, __m128i __a, __m128i __b) { 600 // CHECK-LABEL: @test_mm_mask_cmp_epu8_mask 601 // CHECK: @llvm.x86.avx512.mask.ucmp.b.128(<16 x i8> {{.*}}, <16 x i8> {{.*}}, i8 7, i16 {{.*}}) 602 return (__mmask64)_mm_mask_cmp_epu8_mask(__u, __a, __b, 7); 603} 604 605__mmask8 test_mm_cmp_epi16_mask(__m128i __a, __m128i __b) { 606 // CHECK-LABEL: @test_mm_cmp_epi16_mask 607 // CHECK: @llvm.x86.avx512.mask.cmp.w.128(<8 x i16> {{.*}}, <8 x i16> {{.*}}, i8 7, i8 -1) 608 return (__mmask32)_mm_cmp_epi16_mask(__a, __b, 7); 609} 610 611__mmask8 test_mm_mask_cmp_epi16_mask(__mmask32 __u, __m128i __a, __m128i __b) { 612 // CHECK-LABEL: @test_mm_mask_cmp_epi16_mask 613 // CHECK: @llvm.x86.avx512.mask.cmp.w.128(<8 x i16> {{.*}}, <8 x i16> {{.*}}, i8 7, i8 {{.*}}) 614 return (__mmask32)_mm_mask_cmp_epi16_mask(__u, __a, __b, 7); 615} 616 617__mmask8 test_mm_cmp_epu16_mask(__m128i __a, __m128i __b) { 618 // CHECK-LABEL: @test_mm_cmp_epu16_mask 619 // CHECK: @llvm.x86.avx512.mask.ucmp.w.128(<8 x i16> {{.*}}, <8 x i16> {{.*}}, i8 7, i8 -1) 620 return (__mmask32)_mm_cmp_epu16_mask(__a, __b, 7); 621} 622 623__mmask8 test_mm_mask_cmp_epu16_mask(__mmask32 __u, __m128i __a, __m128i __b) { 624 // CHECK-LABEL: @test_mm_mask_cmp_epu16_mask 625 // CHECK: @llvm.x86.avx512.mask.ucmp.w.128(<8 x i16> {{.*}}, <8 x i16> {{.*}}, i8 7, i8 {{.*}}) 626 return (__mmask32)_mm_mask_cmp_epu16_mask(__u, __a, __b, 7); 627} 628 629__mmask32 test_mm256_cmp_epi8_mask(__m256i __a, __m256i __b) { 630 // CHECK-LABEL: @test_mm256_cmp_epi8_mask 631 // CHECK: @llvm.x86.avx512.mask.cmp.b.256(<32 x i8> {{.*}}, <32 x i8> {{.*}}, i8 7, i32 -1) 632 return (__mmask64)_mm256_cmp_epi8_mask(__a, __b, 7); 633} 634 635__mmask32 test_mm256_mask_cmp_epi8_mask(__mmask64 __u, __m256i __a, __m256i __b) { 636 // CHECK-LABEL: @test_mm256_mask_cmp_epi8_mask 637 // CHECK: @llvm.x86.avx512.mask.cmp.b.256(<32 x i8> {{.*}}, <32 x i8> {{.*}}, i8 7, i32 {{.*}}) 638 return (__mmask64)_mm256_mask_cmp_epi8_mask(__u, __a, __b, 7); 639} 640 641__mmask32 test_mm256_cmp_epu8_mask(__m256i __a, __m256i __b) { 642 // CHECK-LABEL: @test_mm256_cmp_epu8_mask 643 // CHECK: @llvm.x86.avx512.mask.ucmp.b.256(<32 x i8> {{.*}}, <32 x i8> {{.*}}, i8 7, i32 -1) 644 return (__mmask64)_mm256_cmp_epu8_mask(__a, __b, 7); 645} 646 647__mmask32 test_mm256_mask_cmp_epu8_mask(__mmask64 __u, __m256i __a, __m256i __b) { 648 // CHECK-LABEL: @test_mm256_mask_cmp_epu8_mask 649 // CHECK: @llvm.x86.avx512.mask.ucmp.b.256(<32 x i8> {{.*}}, <32 x i8> {{.*}}, i8 7, i32 {{.*}}) 650 return (__mmask64)_mm256_mask_cmp_epu8_mask(__u, __a, __b, 7); 651} 652 653__mmask16 test_mm256_cmp_epi16_mask(__m256i __a, __m256i __b) { 654 // CHECK-LABEL: @test_mm256_cmp_epi16_mask 655 // CHECK: @llvm.x86.avx512.mask.cmp.w.256(<16 x i16> {{.*}}, <16 x i16> {{.*}}, i8 7, i16 -1) 656 return (__mmask32)_mm256_cmp_epi16_mask(__a, __b, 7); 657} 658 659__mmask16 test_mm256_mask_cmp_epi16_mask(__mmask32 __u, __m256i __a, __m256i __b) { 660 // CHECK-LABEL: @test_mm256_mask_cmp_epi16_mask 661 // CHECK: @llvm.x86.avx512.mask.cmp.w.256(<16 x i16> {{.*}}, <16 x i16> {{.*}}, i8 7, i16 {{.*}}) 662 return (__mmask32)_mm256_mask_cmp_epi16_mask(__u, __a, __b, 7); 663} 664 665__mmask16 test_mm256_cmp_epu16_mask(__m256i __a, __m256i __b) { 666 // CHECK-LABEL: @test_mm256_cmp_epu16_mask 667 // CHECK: @llvm.x86.avx512.mask.ucmp.w.256(<16 x i16> {{.*}}, <16 x i16> {{.*}}, i8 7, i16 -1) 668 return (__mmask32)_mm256_cmp_epu16_mask(__a, __b, 7); 669} 670 671__mmask16 test_mm256_mask_cmp_epu16_mask(__mmask32 __u, __m256i __a, __m256i __b) { 672 // CHECK-LABEL: @test_mm256_mask_cmp_epu16_mask 673 // CHECK: @llvm.x86.avx512.mask.ucmp.w.256(<16 x i16> {{.*}}, <16 x i16> {{.*}}, i8 7, i16 {{.*}}) 674 return (__mmask32)_mm256_mask_cmp_epu16_mask(__u, __a, __b, 7); 675} 676