1// RUN: %clang_cc1 %s -O0 -triple=x86_64-apple-darwin -ffreestanding -target-feature +avx512f -target-feature +avx512vl -emit-llvm -o - -Werror | FileCheck %s 2 3#include <immintrin.h> 4 5__mmask8 test_mm256_cmpeq_epi32_mask(__m256i __a, __m256i __b) { 6 // CHECK-LABEL: @test_mm256_cmpeq_epi32_mask 7 // CHECK: @llvm.x86.avx512.mask.pcmpeq.d.256 8 return (__mmask8)_mm256_cmpeq_epi32_mask(__a, __b); 9} 10 11__mmask8 test_mm256_mask_cmpeq_epi32_mask(__mmask8 __u, __m256i __a, __m256i __b) { 12 // CHECK-LABEL: @test_mm256_mask_cmpeq_epi32_mask 13 // CHECK: @llvm.x86.avx512.mask.pcmpeq.d.256 14 return (__mmask8)_mm256_mask_cmpeq_epi32_mask(__u, __a, __b); 15} 16 17__mmask8 test_mm_cmpeq_epi32_mask(__m128i __a, __m128i __b) { 18 // CHECK-LABEL: @test_mm_cmpeq_epi32_mask 19 // CHECK: @llvm.x86.avx512.mask.pcmpeq.d.128 20 return (__mmask8)_mm_cmpeq_epi32_mask(__a, __b); 21} 22 23__mmask8 test_mm_mask_cmpeq_epi32_mask(__mmask8 __u, __m128i __a, __m128i __b) { 24 // CHECK-LABEL: @test_mm_mask_cmpeq_epi32_mask 25 // CHECK: @llvm.x86.avx512.mask.pcmpeq.d.128 26 return (__mmask8)_mm_mask_cmpeq_epi32_mask(__u, __a, __b); 27} 28 29__mmask8 test_mm256_cmpeq_epi64_mask(__m256i __a, __m256i __b) { 30 // CHECK-LABEL: @test_mm256_cmpeq_epi64_mask 31 // CHECK: @llvm.x86.avx512.mask.pcmpeq.q.256 32 return (__mmask8)_mm256_cmpeq_epi64_mask(__a, __b); 33} 34 35__mmask8 test_mm256_mask_cmpeq_epi64_mask(__mmask8 __u, __m256i __a, __m256i __b) { 36 // CHECK-LABEL: @test_mm256_mask_cmpeq_epi64_mask 37 // CHECK: @llvm.x86.avx512.mask.pcmpeq.q.256 38 return (__mmask8)_mm256_mask_cmpeq_epi64_mask(__u, __a, __b); 39} 40 41__mmask8 test_mm_cmpeq_epi64_mask(__m128i __a, __m128i __b) { 42 // CHECK-LABEL: @test_mm_cmpeq_epi64_mask 43 // CHECK: @llvm.x86.avx512.mask.pcmpeq.q.128 44 return (__mmask8)_mm_cmpeq_epi64_mask(__a, __b); 45} 46 47__mmask8 test_mm_mask_cmpeq_epi64_mask(__mmask8 __u, __m128i __a, __m128i __b) { 48 // CHECK-LABEL: @test_mm_mask_cmpeq_epi64_mask 49 // CHECK: @llvm.x86.avx512.mask.pcmpeq.q.128 50 return (__mmask8)_mm_mask_cmpeq_epi64_mask(__u, __a, __b); 51} 52 53__mmask8 test_mm256_cmpgt_epi32_mask(__m256i __a, __m256i __b) { 54 // CHECK-LABEL: @test_mm256_cmpgt_epi32_mask 55 // CHECK: @llvm.x86.avx512.mask.pcmpgt.d.256 56 return (__mmask8)_mm256_cmpgt_epi32_mask(__a, __b); 57} 58 59__mmask8 test_mm256_mask_cmpgt_epi32_mask(__mmask8 __u, __m256i __a, __m256i __b) { 60 // CHECK-LABEL: @test_mm256_mask_cmpgt_epi32_mask 61 // CHECK: @llvm.x86.avx512.mask.pcmpgt.d.256 62 return (__mmask8)_mm256_mask_cmpgt_epi32_mask(__u, __a, __b); 63} 64 65__mmask8 test_mm_cmpgt_epi32_mask(__m128i __a, __m128i __b) { 66 // CHECK-LABEL: @test_mm_cmpgt_epi32_mask 67 // CHECK: @llvm.x86.avx512.mask.pcmpgt.d.128 68 return (__mmask8)_mm_cmpgt_epi32_mask(__a, __b); 69} 70 71__mmask8 test_mm_mask_cmpgt_epi32_mask(__mmask8 __u, __m128i __a, __m128i __b) { 72 // CHECK-LABEL: @test_mm_mask_cmpgt_epi32_mask 73 // CHECK: @llvm.x86.avx512.mask.pcmpgt.d.128 74 return (__mmask8)_mm_mask_cmpgt_epi32_mask(__u, __a, __b); 75} 76 77__mmask8 test_mm256_cmpgt_epi64_mask(__m256i __a, __m256i __b) { 78 // CHECK-LABEL: @test_mm256_cmpgt_epi64_mask 79 // CHECK: @llvm.x86.avx512.mask.pcmpgt.q.256 80 return (__mmask8)_mm256_cmpgt_epi64_mask(__a, __b); 81} 82 83__mmask8 test_mm256_mask_cmpgt_epi64_mask(__mmask8 __u, __m256i __a, __m256i __b) { 84 // CHECK-LABEL: @test_mm256_mask_cmpgt_epi64_mask 85 // CHECK: @llvm.x86.avx512.mask.pcmpgt.q.256 86 return (__mmask8)_mm256_mask_cmpgt_epi64_mask(__u, __a, __b); 87} 88 89__mmask8 test_mm_cmpgt_epi64_mask(__m128i __a, __m128i __b) { 90 // CHECK-LABEL: @test_mm_cmpgt_epi64_mask 91 // CHECK: @llvm.x86.avx512.mask.pcmpgt.q.128 92 return (__mmask8)_mm_cmpgt_epi64_mask(__a, __b); 93} 94 95__mmask8 test_mm_mask_cmpgt_epi64_mask(__mmask8 __u, __m128i __a, __m128i __b) { 96 // CHECK-LABEL: @test_mm_mask_cmpgt_epi64_mask 97 // CHECK: @llvm.x86.avx512.mask.pcmpgt.q.128 98 return (__mmask8)_mm_mask_cmpgt_epi64_mask(__u, __a, __b); 99} 100 101__mmask8 test_mm_cmpeq_epu32_mask(__m128i __a, __m128i __b) { 102 // CHECK-LABEL: @test_mm_cmpeq_epu32_mask 103 // CHECK: @llvm.x86.avx512.mask.ucmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i8 0, i8 -1) 104 return (__mmask8)_mm_cmpeq_epu32_mask(__a, __b); 105} 106 107__mmask8 test_mm_mask_cmpeq_epu32_mask(__mmask8 __u, __m128i __a, __m128i __b) { 108 // CHECK-LABEL: @test_mm_mask_cmpeq_epu32_mask 109 // CHECK: @llvm.x86.avx512.mask.ucmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i8 0, i8 {{.*}}) 110 return (__mmask8)_mm_mask_cmpeq_epu32_mask(__u, __a, __b); 111} 112 113__mmask8 test_mm_cmpeq_epu64_mask(__m128i __a, __m128i __b) { 114 // CHECK-LABEL: @test_mm_cmpeq_epu64_mask 115 // CHECK: @llvm.x86.avx512.mask.ucmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i8 0, i8 -1) 116 return (__mmask8)_mm_cmpeq_epu64_mask(__a, __b); 117} 118 119__mmask8 test_mm_mask_cmpeq_epu64_mask(__mmask8 __u, __m128i __a, __m128i __b) { 120 // CHECK-LABEL: @test_mm_mask_cmpeq_epu64_mask 121 // CHECK: @llvm.x86.avx512.mask.ucmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i8 0, i8 {{.*}}) 122 return (__mmask8)_mm_mask_cmpeq_epu64_mask(__u, __a, __b); 123} 124 125__mmask8 test_mm_cmpge_epi32_mask(__m128i __a, __m128i __b) { 126 // CHECK-LABEL: @test_mm_cmpge_epi32_mask 127 // CHECK: @llvm.x86.avx512.mask.cmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i8 5, i8 -1) 128 return (__mmask8)_mm_cmpge_epi32_mask(__a, __b); 129} 130 131__mmask8 test_mm_mask_cmpge_epi32_mask(__mmask8 __u, __m128i __a, __m128i __b) { 132 // CHECK-LABEL: @test_mm_mask_cmpge_epi32_mask 133 // CHECK: @llvm.x86.avx512.mask.cmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i8 5, i8 {{.*}}) 134 return (__mmask8)_mm_mask_cmpge_epi32_mask(__u, __a, __b); 135} 136 137__mmask8 test_mm_cmpge_epi64_mask(__m128i __a, __m128i __b) { 138 // CHECK-LABEL: @test_mm_cmpge_epi64_mask 139 // CHECK: @llvm.x86.avx512.mask.cmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i8 5, i8 -1) 140 return (__mmask8)_mm_cmpge_epi64_mask(__a, __b); 141} 142 143__mmask8 test_mm_mask_cmpge_epi64_mask(__mmask8 __u, __m128i __a, __m128i __b) { 144 // CHECK-LABEL: @test_mm_mask_cmpge_epi64_mask 145 // CHECK: @llvm.x86.avx512.mask.cmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i8 5, i8 {{.*}}) 146 return (__mmask8)_mm_mask_cmpge_epi64_mask(__u, __a, __b); 147} 148 149__mmask8 test_mm256_cmpge_epi32_mask(__m256i __a, __m256i __b) { 150 // CHECK-LABEL: @test_mm256_cmpge_epi32_mask 151 // CHECK: @llvm.x86.avx512.mask.cmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i8 5, i8 -1) 152 return (__mmask8)_mm256_cmpge_epi32_mask(__a, __b); 153} 154 155__mmask8 test_mm256_mask_cmpge_epi32_mask(__mmask8 __u, __m256i __a, __m256i __b) { 156 // CHECK-LABEL: @test_mm256_mask_cmpge_epi32_mask 157 // CHECK: @llvm.x86.avx512.mask.cmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i8 5, i8 {{.*}}) 158 return (__mmask8)_mm256_mask_cmpge_epi32_mask(__u, __a, __b); 159} 160 161__mmask8 test_mm256_cmpge_epi64_mask(__m256i __a, __m256i __b) { 162 // CHECK-LABEL: @test_mm256_cmpge_epi64_mask 163 // CHECK: @llvm.x86.avx512.mask.cmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i8 5, i8 -1) 164 return (__mmask8)_mm256_cmpge_epi64_mask(__a, __b); 165} 166 167__mmask8 test_mm256_mask_cmpge_epi64_mask(__mmask8 __u, __m256i __a, __m256i __b) { 168 // CHECK-LABEL: @test_mm256_mask_cmpge_epi64_mask 169 // CHECK: @llvm.x86.avx512.mask.cmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i8 5, i8 {{.*}}) 170 return (__mmask8)_mm256_mask_cmpge_epi64_mask(__u, __a, __b); 171} 172 173__mmask8 test_mm_cmpge_epu32_mask(__m128i __a, __m128i __b) { 174 // CHECK-LABEL: @test_mm_cmpge_epu32_mask 175 // CHECK: @llvm.x86.avx512.mask.ucmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i8 5, i8 -1) 176 return (__mmask8)_mm_cmpge_epu32_mask(__a, __b); 177} 178 179__mmask8 test_mm_mask_cmpge_epu32_mask(__mmask8 __u, __m128i __a, __m128i __b) { 180 // CHECK-LABEL: @test_mm_mask_cmpge_epu32_mask 181 // CHECK: @llvm.x86.avx512.mask.ucmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i8 5, i8 {{.*}}) 182 return (__mmask8)_mm_mask_cmpge_epu32_mask(__u, __a, __b); 183} 184 185__mmask8 test_mm_cmpge_epu64_mask(__m128i __a, __m128i __b) { 186 // CHECK-LABEL: @test_mm_cmpge_epu64_mask 187 // CHECK: @llvm.x86.avx512.mask.ucmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i8 5, i8 -1) 188 return (__mmask8)_mm_cmpge_epu64_mask(__a, __b); 189} 190 191__mmask8 test_mm_mask_cmpge_epu64_mask(__mmask8 __u, __m128i __a, __m128i __b) { 192 // CHECK-LABEL: @test_mm_mask_cmpge_epu64_mask 193 // CHECK: @llvm.x86.avx512.mask.ucmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i8 5, i8 {{.*}}) 194 return (__mmask8)_mm_mask_cmpge_epu64_mask(__u, __a, __b); 195} 196 197__mmask8 test_mm256_cmpge_epu32_mask(__m256i __a, __m256i __b) { 198 // CHECK-LABEL: @test_mm256_cmpge_epu32_mask 199 // CHECK: @llvm.x86.avx512.mask.ucmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i8 5, i8 -1) 200 return (__mmask8)_mm256_cmpge_epu32_mask(__a, __b); 201} 202 203__mmask8 test_mm256_mask_cmpge_epu32_mask(__mmask8 __u, __m256i __a, __m256i __b) { 204 // CHECK-LABEL: @test_mm256_mask_cmpge_epu32_mask 205 // CHECK: @llvm.x86.avx512.mask.ucmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i8 5, i8 {{.*}}) 206 return (__mmask8)_mm256_mask_cmpge_epu32_mask(__u, __a, __b); 207} 208 209__mmask8 test_mm256_cmpge_epu64_mask(__m256i __a, __m256i __b) { 210 // CHECK-LABEL: @test_mm256_cmpge_epu64_mask 211 // CHECK: @llvm.x86.avx512.mask.ucmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i8 5, i8 -1) 212 return (__mmask8)_mm256_cmpge_epu64_mask(__a, __b); 213} 214 215__mmask8 test_mm256_mask_cmpge_epu64_mask(__mmask8 __u, __m256i __a, __m256i __b) { 216 // CHECK-LABEL: @test_mm256_mask_cmpge_epu64_mask 217 // CHECK: @llvm.x86.avx512.mask.ucmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i8 5, i8 {{.*}}) 218 return (__mmask8)_mm256_mask_cmpge_epu64_mask(__u, __a, __b); 219} 220 221__mmask8 test_mm_cmpgt_epu32_mask(__m128i __a, __m128i __b) { 222 // CHECK-LABEL: @test_mm_cmpgt_epu32_mask 223 // CHECK: @llvm.x86.avx512.mask.ucmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i8 6, i8 -1) 224 return (__mmask8)_mm_cmpgt_epu32_mask(__a, __b); 225} 226 227__mmask8 test_mm_mask_cmpgt_epu32_mask(__mmask8 __u, __m128i __a, __m128i __b) { 228 // CHECK-LABEL: @test_mm_mask_cmpgt_epu32_mask 229 // CHECK: @llvm.x86.avx512.mask.ucmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i8 6, i8 {{.*}}) 230 return (__mmask8)_mm_mask_cmpgt_epu32_mask(__u, __a, __b); 231} 232 233__mmask8 test_mm_cmpgt_epu64_mask(__m128i __a, __m128i __b) { 234 // CHECK-LABEL: @test_mm_cmpgt_epu64_mask 235 // CHECK: @llvm.x86.avx512.mask.ucmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i8 6, i8 -1) 236 return (__mmask8)_mm_cmpgt_epu64_mask(__a, __b); 237} 238 239__mmask8 test_mm_mask_cmpgt_epu64_mask(__mmask8 __u, __m128i __a, __m128i __b) { 240 // CHECK-LABEL: @test_mm_mask_cmpgt_epu64_mask 241 // CHECK: @llvm.x86.avx512.mask.ucmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i8 6, i8 {{.*}}) 242 return (__mmask8)_mm_mask_cmpgt_epu64_mask(__u, __a, __b); 243} 244 245__mmask8 test_mm256_cmpgt_epu32_mask(__m256i __a, __m256i __b) { 246 // CHECK-LABEL: @test_mm256_cmpgt_epu32_mask 247 // CHECK: @llvm.x86.avx512.mask.ucmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i8 6, i8 -1) 248 return (__mmask8)_mm256_cmpgt_epu32_mask(__a, __b); 249} 250 251__mmask8 test_mm256_mask_cmpgt_epu32_mask(__mmask8 __u, __m256i __a, __m256i __b) { 252 // CHECK-LABEL: @test_mm256_mask_cmpgt_epu32_mask 253 // CHECK: @llvm.x86.avx512.mask.ucmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i8 6, i8 {{.*}}) 254 return (__mmask8)_mm256_mask_cmpgt_epu32_mask(__u, __a, __b); 255} 256 257__mmask8 test_mm256_cmpgt_epu64_mask(__m256i __a, __m256i __b) { 258 // CHECK-LABEL: @test_mm256_cmpgt_epu64_mask 259 // CHECK: @llvm.x86.avx512.mask.ucmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i8 6, i8 -1) 260 return (__mmask8)_mm256_cmpgt_epu64_mask(__a, __b); 261} 262 263__mmask8 test_mm256_mask_cmpgt_epu64_mask(__mmask8 __u, __m256i __a, __m256i __b) { 264 // CHECK-LABEL: @test_mm256_mask_cmpgt_epu64_mask 265 // CHECK: @llvm.x86.avx512.mask.ucmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i8 6, i8 {{.*}}) 266 return (__mmask8)_mm256_mask_cmpgt_epu64_mask(__u, __a, __b); 267} 268 269__mmask8 test_mm_cmple_epi32_mask(__m128i __a, __m128i __b) { 270 // CHECK-LABEL: @test_mm_cmple_epi32_mask 271 // CHECK: @llvm.x86.avx512.mask.cmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i8 2, i8 -1) 272 return (__mmask8)_mm_cmple_epi32_mask(__a, __b); 273} 274 275__mmask8 test_mm_mask_cmple_epi32_mask(__mmask8 __u, __m128i __a, __m128i __b) { 276 // CHECK-LABEL: @test_mm_mask_cmple_epi32_mask 277 // CHECK: @llvm.x86.avx512.mask.cmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i8 2, i8 {{.*}}) 278 return (__mmask8)_mm_mask_cmple_epi32_mask(__u, __a, __b); 279} 280 281__mmask8 test_mm_cmple_epi64_mask(__m128i __a, __m128i __b) { 282 // CHECK-LABEL: @test_mm_cmple_epi64_mask 283 // CHECK: @llvm.x86.avx512.mask.cmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i8 2, i8 -1) 284 return (__mmask8)_mm_cmple_epi64_mask(__a, __b); 285} 286 287__mmask8 test_mm_mask_cmple_epi64_mask(__mmask8 __u, __m128i __a, __m128i __b) { 288 // CHECK-LABEL: @test_mm_mask_cmple_epi64_mask 289 // CHECK: @llvm.x86.avx512.mask.cmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i8 2, i8 {{.*}}) 290 return (__mmask8)_mm_mask_cmple_epi64_mask(__u, __a, __b); 291} 292 293__mmask8 test_mm256_cmple_epi32_mask(__m256i __a, __m256i __b) { 294 // CHECK-LABEL: @test_mm256_cmple_epi32_mask 295 // CHECK: @llvm.x86.avx512.mask.cmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i8 2, i8 -1) 296 return (__mmask8)_mm256_cmple_epi32_mask(__a, __b); 297} 298 299__mmask8 test_mm256_mask_cmple_epi32_mask(__mmask8 __u, __m256i __a, __m256i __b) { 300 // CHECK-LABEL: @test_mm256_mask_cmple_epi32_mask 301 // CHECK: @llvm.x86.avx512.mask.cmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i8 2, i8 {{.*}}) 302 return (__mmask8)_mm256_mask_cmple_epi32_mask(__u, __a, __b); 303} 304 305__mmask8 test_mm256_cmple_epi64_mask(__m256i __a, __m256i __b) { 306 // CHECK-LABEL: @test_mm256_cmple_epi64_mask 307 // CHECK: @llvm.x86.avx512.mask.cmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i8 2, i8 -1) 308 return (__mmask8)_mm256_cmple_epi64_mask(__a, __b); 309} 310 311__mmask8 test_mm256_mask_cmple_epi64_mask(__mmask8 __u, __m256i __a, __m256i __b) { 312 // CHECK-LABEL: @test_mm256_mask_cmple_epi64_mask 313 // CHECK: @llvm.x86.avx512.mask.cmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i8 2, i8 {{.*}}) 314 return (__mmask8)_mm256_mask_cmple_epi64_mask(__u, __a, __b); 315} 316 317__mmask8 test_mm_cmple_epu32_mask(__m128i __a, __m128i __b) { 318 // CHECK-LABEL: @test_mm_cmple_epu32_mask 319 // CHECK: @llvm.x86.avx512.mask.ucmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i8 2, i8 -1) 320 return (__mmask8)_mm_cmple_epu32_mask(__a, __b); 321} 322 323__mmask8 test_mm_mask_cmple_epu32_mask(__mmask8 __u, __m128i __a, __m128i __b) { 324 // CHECK-LABEL: @test_mm_mask_cmple_epu32_mask 325 // CHECK: @llvm.x86.avx512.mask.ucmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i8 2, i8 {{.*}}) 326 return (__mmask8)_mm_mask_cmple_epu32_mask(__u, __a, __b); 327} 328 329__mmask8 test_mm_cmple_epu64_mask(__m128i __a, __m128i __b) { 330 // CHECK-LABEL: @test_mm_cmple_epu64_mask 331 // CHECK: @llvm.x86.avx512.mask.ucmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i8 2, i8 -1) 332 return (__mmask8)_mm_cmple_epu64_mask(__a, __b); 333} 334 335__mmask8 test_mm_mask_cmple_epu64_mask(__mmask8 __u, __m128i __a, __m128i __b) { 336 // CHECK-LABEL: @test_mm_mask_cmple_epu64_mask 337 // CHECK: @llvm.x86.avx512.mask.ucmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i8 2, i8 {{.*}}) 338 return (__mmask8)_mm_mask_cmple_epu64_mask(__u, __a, __b); 339} 340 341__mmask8 test_mm256_cmple_epu32_mask(__m256i __a, __m256i __b) { 342 // CHECK-LABEL: @test_mm256_cmple_epu32_mask 343 // CHECK: @llvm.x86.avx512.mask.ucmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i8 2, i8 -1) 344 return (__mmask8)_mm256_cmple_epu32_mask(__a, __b); 345} 346 347__mmask8 test_mm256_mask_cmple_epu32_mask(__mmask8 __u, __m256i __a, __m256i __b) { 348 // CHECK-LABEL: @test_mm256_mask_cmple_epu32_mask 349 // CHECK: @llvm.x86.avx512.mask.ucmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i8 2, i8 {{.*}}) 350 return (__mmask8)_mm256_mask_cmple_epu32_mask(__u, __a, __b); 351} 352 353__mmask8 test_mm256_cmple_epu64_mask(__m256i __a, __m256i __b) { 354 // CHECK-LABEL: @test_mm256_cmple_epu64_mask 355 // CHECK: @llvm.x86.avx512.mask.ucmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i8 2, i8 -1) 356 return (__mmask8)_mm256_cmple_epu64_mask(__a, __b); 357} 358 359__mmask8 test_mm256_mask_cmple_epu64_mask(__mmask8 __u, __m256i __a, __m256i __b) { 360 // CHECK-LABEL: @test_mm256_mask_cmple_epu64_mask 361 // CHECK: @llvm.x86.avx512.mask.ucmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i8 2, i8 {{.*}}) 362 return (__mmask8)_mm256_mask_cmple_epu64_mask(__u, __a, __b); 363} 364 365__mmask8 test_mm_cmplt_epi32_mask(__m128i __a, __m128i __b) { 366 // CHECK-LABEL: @test_mm_cmplt_epi32_mask 367 // CHECK: @llvm.x86.avx512.mask.cmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i8 1, i8 -1) 368 return (__mmask8)_mm_cmplt_epi32_mask(__a, __b); 369} 370 371__mmask8 test_mm_mask_cmplt_epi32_mask(__mmask8 __u, __m128i __a, __m128i __b) { 372 // CHECK-LABEL: @test_mm_mask_cmplt_epi32_mask 373 // CHECK: @llvm.x86.avx512.mask.cmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i8 1, i8 {{.*}}) 374 return (__mmask8)_mm_mask_cmplt_epi32_mask(__u, __a, __b); 375} 376 377__mmask8 test_mm_cmplt_epi64_mask(__m128i __a, __m128i __b) { 378 // CHECK-LABEL: @test_mm_cmplt_epi64_mask 379 // CHECK: @llvm.x86.avx512.mask.cmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i8 1, i8 -1) 380 return (__mmask8)_mm_cmplt_epi64_mask(__a, __b); 381} 382 383__mmask8 test_mm_mask_cmplt_epi64_mask(__mmask8 __u, __m128i __a, __m128i __b) { 384 // CHECK-LABEL: @test_mm_mask_cmplt_epi64_mask 385 // CHECK: @llvm.x86.avx512.mask.cmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i8 1, i8 {{.*}}) 386 return (__mmask8)_mm_mask_cmplt_epi64_mask(__u, __a, __b); 387} 388 389__mmask8 test_mm256_cmplt_epi32_mask(__m256i __a, __m256i __b) { 390 // CHECK-LABEL: @test_mm256_cmplt_epi32_mask 391 // CHECK: @llvm.x86.avx512.mask.cmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i8 1, i8 -1) 392 return (__mmask8)_mm256_cmplt_epi32_mask(__a, __b); 393} 394 395__mmask8 test_mm256_mask_cmplt_epi32_mask(__mmask8 __u, __m256i __a, __m256i __b) { 396 // CHECK-LABEL: @test_mm256_mask_cmplt_epi32_mask 397 // CHECK: @llvm.x86.avx512.mask.cmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i8 1, i8 {{.*}}) 398 return (__mmask8)_mm256_mask_cmplt_epi32_mask(__u, __a, __b); 399} 400 401__mmask8 test_mm256_cmplt_epi64_mask(__m256i __a, __m256i __b) { 402 // CHECK-LABEL: @test_mm256_cmplt_epi64_mask 403 // CHECK: @llvm.x86.avx512.mask.cmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i8 1, i8 -1) 404 return (__mmask8)_mm256_cmplt_epi64_mask(__a, __b); 405} 406 407__mmask8 test_mm256_mask_cmplt_epi64_mask(__mmask8 __u, __m256i __a, __m256i __b) { 408 // CHECK-LABEL: @test_mm256_mask_cmplt_epi64_mask 409 // CHECK: @llvm.x86.avx512.mask.cmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i8 1, i8 {{.*}}) 410 return (__mmask8)_mm256_mask_cmplt_epi64_mask(__u, __a, __b); 411} 412 413__mmask8 test_mm_cmplt_epu32_mask(__m128i __a, __m128i __b) { 414 // CHECK-LABEL: @test_mm_cmplt_epu32_mask 415 // CHECK: @llvm.x86.avx512.mask.ucmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i8 1, i8 -1) 416 return (__mmask8)_mm_cmplt_epu32_mask(__a, __b); 417} 418 419__mmask8 test_mm_mask_cmplt_epu32_mask(__mmask8 __u, __m128i __a, __m128i __b) { 420 // CHECK-LABEL: @test_mm_mask_cmplt_epu32_mask 421 // CHECK: @llvm.x86.avx512.mask.ucmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i8 1, i8 {{.*}}) 422 return (__mmask8)_mm_mask_cmplt_epu32_mask(__u, __a, __b); 423} 424 425__mmask8 test_mm_cmplt_epu64_mask(__m128i __a, __m128i __b) { 426 // CHECK-LABEL: @test_mm_cmplt_epu64_mask 427 // CHECK: @llvm.x86.avx512.mask.ucmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i8 1, i8 -1) 428 return (__mmask8)_mm_cmplt_epu64_mask(__a, __b); 429} 430 431__mmask8 test_mm_mask_cmplt_epu64_mask(__mmask8 __u, __m128i __a, __m128i __b) { 432 // CHECK-LABEL: @test_mm_mask_cmplt_epu64_mask 433 // CHECK: @llvm.x86.avx512.mask.ucmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i8 1, i8 {{.*}}) 434 return (__mmask8)_mm_mask_cmplt_epu64_mask(__u, __a, __b); 435} 436 437__mmask8 test_mm256_cmplt_epu32_mask(__m256i __a, __m256i __b) { 438 // CHECK-LABEL: @test_mm256_cmplt_epu32_mask 439 // CHECK: @llvm.x86.avx512.mask.ucmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i8 1, i8 -1) 440 return (__mmask8)_mm256_cmplt_epu32_mask(__a, __b); 441} 442 443__mmask8 test_mm256_mask_cmplt_epu32_mask(__mmask8 __u, __m256i __a, __m256i __b) { 444 // CHECK-LABEL: @test_mm256_mask_cmplt_epu32_mask 445 // CHECK: @llvm.x86.avx512.mask.ucmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i8 1, i8 {{.*}}) 446 return (__mmask8)_mm256_mask_cmplt_epu32_mask(__u, __a, __b); 447} 448 449__mmask8 test_mm256_cmplt_epu64_mask(__m256i __a, __m256i __b) { 450 // CHECK-LABEL: @test_mm256_cmplt_epu64_mask 451 // CHECK: @llvm.x86.avx512.mask.ucmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i8 1, i8 -1) 452 return (__mmask8)_mm256_cmplt_epu64_mask(__a, __b); 453} 454 455__mmask8 test_mm256_mask_cmplt_epu64_mask(__mmask8 __u, __m256i __a, __m256i __b) { 456 // CHECK-LABEL: @test_mm256_mask_cmplt_epu64_mask 457 // CHECK: @llvm.x86.avx512.mask.ucmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i8 1, i8 {{.*}}) 458 return (__mmask8)_mm256_mask_cmplt_epu64_mask(__u, __a, __b); 459} 460 461__mmask8 test_mm_cmpneq_epi32_mask(__m128i __a, __m128i __b) { 462 // CHECK-LABEL: @test_mm_cmpneq_epi32_mask 463 // CHECK: @llvm.x86.avx512.mask.cmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i8 4, i8 -1) 464 return (__mmask8)_mm_cmpneq_epi32_mask(__a, __b); 465} 466 467__mmask8 test_mm_mask_cmpneq_epi32_mask(__mmask8 __u, __m128i __a, __m128i __b) { 468 // CHECK-LABEL: @test_mm_mask_cmpneq_epi32_mask 469 // CHECK: @llvm.x86.avx512.mask.cmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i8 4, i8 {{.*}}) 470 return (__mmask8)_mm_mask_cmpneq_epi32_mask(__u, __a, __b); 471} 472 473__mmask8 test_mm_cmpneq_epi64_mask(__m128i __a, __m128i __b) { 474 // CHECK-LABEL: @test_mm_cmpneq_epi64_mask 475 // CHECK: @llvm.x86.avx512.mask.cmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i8 4, i8 -1) 476 return (__mmask8)_mm_cmpneq_epi64_mask(__a, __b); 477} 478 479__mmask8 test_mm_mask_cmpneq_epi64_mask(__mmask8 __u, __m128i __a, __m128i __b) { 480 // CHECK-LABEL: @test_mm_mask_cmpneq_epi64_mask 481 // CHECK: @llvm.x86.avx512.mask.cmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i8 4, i8 {{.*}}) 482 return (__mmask8)_mm_mask_cmpneq_epi64_mask(__u, __a, __b); 483} 484 485__mmask8 test_mm256_cmpneq_epi32_mask(__m256i __a, __m256i __b) { 486 // CHECK-LABEL: @test_mm256_cmpneq_epi32_mask 487 // CHECK: @llvm.x86.avx512.mask.cmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i8 4, i8 -1) 488 return (__mmask8)_mm256_cmpneq_epi32_mask(__a, __b); 489} 490 491__mmask8 test_mm256_mask_cmpneq_epi32_mask(__mmask8 __u, __m256i __a, __m256i __b) { 492 // CHECK-LABEL: @test_mm256_mask_cmpneq_epi32_mask 493 // CHECK: @llvm.x86.avx512.mask.cmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i8 4, i8 {{.*}}) 494 return (__mmask8)_mm256_mask_cmpneq_epi32_mask(__u, __a, __b); 495} 496 497__mmask8 test_mm256_cmpneq_epi64_mask(__m256i __a, __m256i __b) { 498 // CHECK-LABEL: @test_mm256_cmpneq_epi64_mask 499 // CHECK: @llvm.x86.avx512.mask.cmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i8 4, i8 -1) 500 return (__mmask8)_mm256_cmpneq_epi64_mask(__a, __b); 501} 502 503__mmask8 test_mm256_mask_cmpneq_epi64_mask(__mmask8 __u, __m256i __a, __m256i __b) { 504 // CHECK-LABEL: @test_mm256_mask_cmpneq_epi64_mask 505 // CHECK: @llvm.x86.avx512.mask.cmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i8 4, i8 {{.*}}) 506 return (__mmask8)_mm256_mask_cmpneq_epi64_mask(__u, __a, __b); 507} 508 509__mmask8 test_mm_cmpneq_epu32_mask(__m128i __a, __m128i __b) { 510 // CHECK-LABEL: @test_mm_cmpneq_epu32_mask 511 // CHECK: @llvm.x86.avx512.mask.ucmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i8 4, i8 -1) 512 return (__mmask8)_mm_cmpneq_epu32_mask(__a, __b); 513} 514 515__mmask8 test_mm_mask_cmpneq_epu32_mask(__mmask8 __u, __m128i __a, __m128i __b) { 516 // CHECK-LABEL: @test_mm_mask_cmpneq_epu32_mask 517 // CHECK: @llvm.x86.avx512.mask.ucmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i8 4, i8 {{.*}}) 518 return (__mmask8)_mm_mask_cmpneq_epu32_mask(__u, __a, __b); 519} 520 521__mmask8 test_mm_cmpneq_epu64_mask(__m128i __a, __m128i __b) { 522 // CHECK-LABEL: @test_mm_cmpneq_epu64_mask 523 // CHECK: @llvm.x86.avx512.mask.ucmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i8 4, i8 -1) 524 return (__mmask8)_mm_cmpneq_epu64_mask(__a, __b); 525} 526 527__mmask8 test_mm_mask_cmpneq_epu64_mask(__mmask8 __u, __m128i __a, __m128i __b) { 528 // CHECK-LABEL: @test_mm_mask_cmpneq_epu64_mask 529 // CHECK: @llvm.x86.avx512.mask.ucmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i8 4, i8 {{.*}}) 530 return (__mmask8)_mm_mask_cmpneq_epu64_mask(__u, __a, __b); 531} 532 533__mmask8 test_mm256_cmpneq_epu32_mask(__m256i __a, __m256i __b) { 534 // CHECK-LABEL: @test_mm256_cmpneq_epu32_mask 535 // CHECK: @llvm.x86.avx512.mask.ucmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i8 4, i8 -1) 536 return (__mmask8)_mm256_cmpneq_epu32_mask(__a, __b); 537} 538 539__mmask8 test_mm256_mask_cmpneq_epu32_mask(__mmask8 __u, __m256i __a, __m256i __b) { 540 // CHECK-LABEL: @test_mm256_mask_cmpneq_epu32_mask 541 // CHECK: @llvm.x86.avx512.mask.ucmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i8 4, i8 {{.*}}) 542 return (__mmask8)_mm256_mask_cmpneq_epu32_mask(__u, __a, __b); 543} 544 545__mmask8 test_mm256_cmpneq_epu64_mask(__m256i __a, __m256i __b) { 546 // CHECK-LABEL: @test_mm256_cmpneq_epu64_mask 547 // CHECK: @llvm.x86.avx512.mask.ucmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i8 4, i8 -1) 548 return (__mmask8)_mm256_cmpneq_epu64_mask(__a, __b); 549} 550 551__mmask8 test_mm256_mask_cmpneq_epu64_mask(__mmask8 __u, __m256i __a, __m256i __b) { 552 // CHECK-LABEL: @test_mm256_mask_cmpneq_epu64_mask 553 // CHECK: @llvm.x86.avx512.mask.ucmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i8 4, i8 {{.*}}) 554 return (__mmask8)_mm256_mask_cmpneq_epu64_mask(__u, __a, __b); 555} 556 557__mmask8 test_mm_cmp_epi32_mask(__m128i __a, __m128i __b) { 558 // CHECK-LABEL: @test_mm_cmp_epi32_mask 559 // CHECK: @llvm.x86.avx512.mask.cmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i8 7, i8 -1) 560 return (__mmask8)_mm_cmp_epi32_mask(__a, __b, 7); 561} 562 563__mmask8 test_mm_mask_cmp_epi32_mask(__mmask8 __u, __m128i __a, __m128i __b) { 564 // CHECK-LABEL: @test_mm_mask_cmp_epi32_mask 565 // CHECK: @llvm.x86.avx512.mask.cmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i8 7, i8 {{.*}}) 566 return (__mmask8)_mm_mask_cmp_epi32_mask(__u, __a, __b, 7); 567} 568 569__mmask8 test_mm_cmp_epi64_mask(__m128i __a, __m128i __b) { 570 // CHECK-LABEL: @test_mm_cmp_epi64_mask 571 // CHECK: @llvm.x86.avx512.mask.cmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i8 7, i8 -1) 572 return (__mmask8)_mm_cmp_epi64_mask(__a, __b, 7); 573} 574 575__mmask8 test_mm_mask_cmp_epi64_mask(__mmask8 __u, __m128i __a, __m128i __b) { 576 // CHECK-LABEL: @test_mm_mask_cmp_epi64_mask 577 // CHECK: @llvm.x86.avx512.mask.cmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i8 7, i8 {{.*}}) 578 return (__mmask8)_mm_mask_cmp_epi64_mask(__u, __a, __b, 7); 579} 580 581__mmask8 test_mm256_cmp_epi32_mask(__m256i __a, __m256i __b) { 582 // CHECK-LABEL: @test_mm256_cmp_epi32_mask 583 // CHECK: @llvm.x86.avx512.mask.cmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i8 7, i8 -1) 584 return (__mmask8)_mm256_cmp_epi32_mask(__a, __b, 7); 585} 586 587__mmask8 test_mm256_mask_cmp_epi32_mask(__mmask8 __u, __m256i __a, __m256i __b) { 588 // CHECK-LABEL: @test_mm256_mask_cmp_epi32_mask 589 // CHECK: @llvm.x86.avx512.mask.cmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i8 7, i8 {{.*}}) 590 return (__mmask8)_mm256_mask_cmp_epi32_mask(__u, __a, __b, 7); 591} 592 593__mmask8 test_mm256_cmp_epi64_mask(__m256i __a, __m256i __b) { 594 // CHECK-LABEL: @test_mm256_cmp_epi64_mask 595 // CHECK: @llvm.x86.avx512.mask.cmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i8 7, i8 -1) 596 return (__mmask8)_mm256_cmp_epi64_mask(__a, __b, 7); 597} 598 599__mmask8 test_mm256_mask_cmp_epi64_mask(__mmask8 __u, __m256i __a, __m256i __b) { 600 // CHECK-LABEL: @test_mm256_mask_cmp_epi64_mask 601 // CHECK: @llvm.x86.avx512.mask.cmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i8 7, i8 {{.*}}) 602 return (__mmask8)_mm256_mask_cmp_epi64_mask(__u, __a, __b, 7); 603} 604 605__mmask8 test_mm_cmp_epu32_mask(__m128i __a, __m128i __b) { 606 // CHECK-LABEL: @test_mm_cmp_epu32_mask 607 // CHECK: @llvm.x86.avx512.mask.ucmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i8 7, i8 -1) 608 return (__mmask8)_mm_cmp_epu32_mask(__a, __b, 7); 609} 610 611__mmask8 test_mm_mask_cmp_epu32_mask(__mmask8 __u, __m128i __a, __m128i __b) { 612 // CHECK-LABEL: @test_mm_mask_cmp_epu32_mask 613 // CHECK: @llvm.x86.avx512.mask.ucmp.d.128(<4 x i32> {{.*}}, <4 x i32> {{.*}}, i8 7, i8 {{.*}}) 614 return (__mmask8)_mm_mask_cmp_epu32_mask(__u, __a, __b, 7); 615} 616 617__mmask8 test_mm_cmp_epu64_mask(__m128i __a, __m128i __b) { 618 // CHECK-LABEL: @test_mm_cmp_epu64_mask 619 // CHECK: @llvm.x86.avx512.mask.ucmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i8 7, i8 -1) 620 return (__mmask8)_mm_cmp_epu64_mask(__a, __b, 7); 621} 622 623__mmask8 test_mm_mask_cmp_epu64_mask(__mmask8 __u, __m128i __a, __m128i __b) { 624 // CHECK-LABEL: @test_mm_mask_cmp_epu64_mask 625 // CHECK: @llvm.x86.avx512.mask.ucmp.q.128(<2 x i64> {{.*}}, <2 x i64> {{.*}}, i8 7, i8 {{.*}}) 626 return (__mmask8)_mm_mask_cmp_epu64_mask(__u, __a, __b, 7); 627} 628 629__mmask8 test_mm256_cmp_epu32_mask(__m256i __a, __m256i __b) { 630 // CHECK-LABEL: @test_mm256_cmp_epu32_mask 631 // CHECK: @llvm.x86.avx512.mask.ucmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i8 7, i8 -1) 632 return (__mmask8)_mm256_cmp_epu32_mask(__a, __b, 7); 633} 634 635__mmask8 test_mm256_mask_cmp_epu32_mask(__mmask8 __u, __m256i __a, __m256i __b) { 636 // CHECK-LABEL: @test_mm256_mask_cmp_epu32_mask 637 // CHECK: @llvm.x86.avx512.mask.ucmp.d.256(<8 x i32> {{.*}}, <8 x i32> {{.*}}, i8 7, i8 {{.*}}) 638 return (__mmask8)_mm256_mask_cmp_epu32_mask(__u, __a, __b, 7); 639} 640 641__mmask8 test_mm256_cmp_epu64_mask(__m256i __a, __m256i __b) { 642 // CHECK-LABEL: @test_mm256_cmp_epu64_mask 643 // CHECK: @llvm.x86.avx512.mask.ucmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i8 7, i8 -1) 644 return (__mmask8)_mm256_cmp_epu64_mask(__a, __b, 7); 645} 646 647__mmask8 test_mm256_mask_cmp_epu64_mask(__mmask8 __u, __m256i __a, __m256i __b) { 648 // CHECK-LABEL: @test_mm256_mask_cmp_epu64_mask 649 // CHECK: @llvm.x86.avx512.mask.ucmp.q.256(<4 x i64> {{.*}}, <4 x i64> {{.*}}, i8 7, i8 {{.*}}) 650 return (__mmask8)_mm256_mask_cmp_epu64_mask(__u, __a, __b, 7); 651} 652