blob: 8c9e15d41096dfaa632c0ca11e8b09cb2d6f9e71 [file] [log] [blame]
// RUN: %clang_cc1 -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +avx512f -target-feature +avx512vl -emit-llvm -o - -Wall -Werror | FileCheck %s
#include <immintrin.h>
__mmask8 test_mm_cmpeq_epu32_mask(__m128i __a, __m128i __b) {
// CHECK-LABEL: @test_mm_cmpeq_epu32_mask
// CHECK: icmp eq <4 x i32> %{{.*}}, %{{.*}}
// CHECK: shufflevector <4 x i1> %{{.*}}, <4 x i1> zeroinitializer, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
return (__mmask8)_mm_cmpeq_epu32_mask(__a, __b);
}
__mmask8 test_mm_mask_cmpeq_epu32_mask(__mmask8 __u, __m128i __a, __m128i __b) {
// CHECK-LABEL: @test_mm_mask_cmpeq_epu32_mask
// CHECK: icmp eq <4 x i32> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> %{{.*}}, %{{.*}}
return (__mmask8)_mm_mask_cmpeq_epu32_mask(__u, __a, __b);
}
__mmask8 test_mm_cmpeq_epu64_mask(__m128i __a, __m128i __b) {
// CHECK-LABEL: @test_mm_cmpeq_epu64_mask
// CHECK: icmp eq <2 x i64> %{{.*}}, %{{.*}}
// CHECK: shufflevector <2 x i1> %{{.*}}, <2 x i1> zeroinitializer, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 2, i32 3, i32 2, i32 3>
return (__mmask8)_mm_cmpeq_epu64_mask(__a, __b);
}
__mmask8 test_mm_mask_cmpeq_epu64_mask(__mmask8 __u, __m128i __a, __m128i __b) {
// CHECK-LABEL: @test_mm_mask_cmpeq_epu64_mask
// CHECK: icmp eq <2 x i64> %{{.*}}, %{{.*}}
// CHECK: and <2 x i1> %{{.*}}, %{{.*}}
return (__mmask8)_mm_mask_cmpeq_epu64_mask(__u, __a, __b);
}
__mmask8 test_mm_cmpge_epi32_mask(__m128i __a, __m128i __b) {
// CHECK-LABEL: @test_mm_cmpge_epi32_mask
// CHECK: icmp sge <4 x i32> %{{.*}}, %{{.*}}
return (__mmask8)_mm_cmpge_epi32_mask(__a, __b);
}
__mmask8 test_mm_mask_cmpge_epi32_mask(__mmask8 __u, __m128i __a, __m128i __b) {
// CHECK-LABEL: @test_mm_mask_cmpge_epi32_mask
// CHECK: icmp sge <4 x i32> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> %{{.*}}, %{{.*}}
return (__mmask8)_mm_mask_cmpge_epi32_mask(__u, __a, __b);
}
__mmask8 test_mm_cmpge_epi64_mask(__m128i __a, __m128i __b) {
// CHECK-LABEL: @test_mm_cmpge_epi64_mask
// CHECK: icmp sge <2 x i64> %{{.*}}, %{{.*}}
return (__mmask8)_mm_cmpge_epi64_mask(__a, __b);
}
__mmask8 test_mm_mask_cmpge_epi64_mask(__mmask8 __u, __m128i __a, __m128i __b) {
// CHECK-LABEL: @test_mm_mask_cmpge_epi64_mask
// CHECK: icmp sge <2 x i64> %{{.*}}, %{{.*}}
// CHECK: and <2 x i1> %{{.*}}, %{{.*}}
return (__mmask8)_mm_mask_cmpge_epi64_mask(__u, __a, __b);
}
__mmask8 test_mm256_cmpge_epi32_mask(__m256i __a, __m256i __b) {
// CHECK-LABEL: @test_mm256_cmpge_epi32_mask
// CHECK: icmp sge <8 x i32> %{{.*}}, %{{.*}}
return (__mmask8)_mm256_cmpge_epi32_mask(__a, __b);
}
__mmask8 test_mm256_mask_cmpge_epi32_mask(__mmask8 __u, __m256i __a, __m256i __b) {
// CHECK-LABEL: @test_mm256_mask_cmpge_epi32_mask
// CHECK: icmp sge <8 x i32> %{{.*}}, %{{.*}}
// CHECK: and <8 x i1> %{{.*}}, %{{.*}}
return (__mmask8)_mm256_mask_cmpge_epi32_mask(__u, __a, __b);
}
__mmask8 test_mm256_cmpge_epi64_mask(__m256i __a, __m256i __b) {
// CHECK-LABEL: @test_mm256_cmpge_epi64_mask
// CHECK: icmp sge <4 x i64> %{{.*}}, %{{.*}}
return (__mmask8)_mm256_cmpge_epi64_mask(__a, __b);
}
__mmask8 test_mm256_mask_cmpge_epi64_mask(__mmask8 __u, __m256i __a, __m256i __b) {
// CHECK-LABEL: @test_mm256_mask_cmpge_epi64_mask
// CHECK: icmp sge <4 x i64> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> %{{.*}}, %{{.*}}
return (__mmask8)_mm256_mask_cmpge_epi64_mask(__u, __a, __b);
}
__mmask8 test_mm_cmpge_epu32_mask(__m128i __a, __m128i __b) {
// CHECK-LABEL: @test_mm_cmpge_epu32_mask
// CHECK: icmp uge <4 x i32> %{{.*}}, %{{.*}}
return (__mmask8)_mm_cmpge_epu32_mask(__a, __b);
}
__mmask8 test_mm_mask_cmpge_epu32_mask(__mmask8 __u, __m128i __a, __m128i __b) {
// CHECK-LABEL: @test_mm_mask_cmpge_epu32_mask
// CHECK: icmp uge <4 x i32> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> %{{.*}}, %{{.*}}
return (__mmask8)_mm_mask_cmpge_epu32_mask(__u, __a, __b);
}
__mmask8 test_mm_cmpge_epu64_mask(__m128i __a, __m128i __b) {
// CHECK-LABEL: @test_mm_cmpge_epu64_mask
// CHECK: icmp uge <2 x i64> %{{.*}}, %{{.*}}
return (__mmask8)_mm_cmpge_epu64_mask(__a, __b);
}
__mmask8 test_mm_mask_cmpge_epu64_mask(__mmask8 __u, __m128i __a, __m128i __b) {
// CHECK-LABEL: @test_mm_mask_cmpge_epu64_mask
// CHECK: icmp uge <2 x i64> %{{.*}}, %{{.*}}
// CHECK: and <2 x i1> %{{.*}}, %{{.*}}
return (__mmask8)_mm_mask_cmpge_epu64_mask(__u, __a, __b);
}
__mmask8 test_mm256_cmpge_epu32_mask(__m256i __a, __m256i __b) {
// CHECK-LABEL: @test_mm256_cmpge_epu32_mask
// CHECK: icmp uge <8 x i32> %{{.*}}, %{{.*}}
return (__mmask8)_mm256_cmpge_epu32_mask(__a, __b);
}
__mmask8 test_mm256_mask_cmpge_epu32_mask(__mmask8 __u, __m256i __a, __m256i __b) {
// CHECK-LABEL: @test_mm256_mask_cmpge_epu32_mask
// CHECK: icmp uge <8 x i32> %{{.*}}, %{{.*}}
// CHECK: and <8 x i1> %{{.*}}, %{{.*}}
return (__mmask8)_mm256_mask_cmpge_epu32_mask(__u, __a, __b);
}
__mmask8 test_mm256_cmpge_epu64_mask(__m256i __a, __m256i __b) {
// CHECK-LABEL: @test_mm256_cmpge_epu64_mask
// CHECK: icmp uge <4 x i64> %{{.*}}, %{{.*}}
return (__mmask8)_mm256_cmpge_epu64_mask(__a, __b);
}
__mmask8 test_mm256_mask_cmpge_epu64_mask(__mmask8 __u, __m256i __a, __m256i __b) {
// CHECK-LABEL: @test_mm256_mask_cmpge_epu64_mask
// CHECK: icmp uge <4 x i64> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> %{{.*}}, %{{.*}}
return (__mmask8)_mm256_mask_cmpge_epu64_mask(__u, __a, __b);
}
__mmask8 test_mm_cmpgt_epu32_mask(__m128i __a, __m128i __b) {
// CHECK-LABEL: @test_mm_cmpgt_epu32_mask
// CHECK: icmp ugt <4 x i32> %{{.*}}, %{{.*}}
return (__mmask8)_mm_cmpgt_epu32_mask(__a, __b);
}
__mmask8 test_mm_mask_cmpgt_epu32_mask(__mmask8 __u, __m128i __a, __m128i __b) {
// CHECK-LABEL: @test_mm_mask_cmpgt_epu32_mask
// CHECK: icmp ugt <4 x i32> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> %{{.*}}, %{{.*}}
return (__mmask8)_mm_mask_cmpgt_epu32_mask(__u, __a, __b);
}
__mmask8 test_mm_cmpgt_epu64_mask(__m128i __a, __m128i __b) {
// CHECK-LABEL: @test_mm_cmpgt_epu64_mask
// CHECK: icmp ugt <2 x i64> %{{.*}}, %{{.*}}
return (__mmask8)_mm_cmpgt_epu64_mask(__a, __b);
}
__mmask8 test_mm_mask_cmpgt_epu64_mask(__mmask8 __u, __m128i __a, __m128i __b) {
// CHECK-LABEL: @test_mm_mask_cmpgt_epu64_mask
// CHECK: icmp ugt <2 x i64> %{{.*}}, %{{.*}}
// CHECK: and <2 x i1> %{{.*}}, %{{.*}}
return (__mmask8)_mm_mask_cmpgt_epu64_mask(__u, __a, __b);
}
__mmask8 test_mm256_cmpgt_epu32_mask(__m256i __a, __m256i __b) {
// CHECK-LABEL: @test_mm256_cmpgt_epu32_mask
// CHECK: icmp ugt <8 x i32> %{{.*}}, %{{.*}}
return (__mmask8)_mm256_cmpgt_epu32_mask(__a, __b);
}
__mmask8 test_mm256_mask_cmpgt_epu32_mask(__mmask8 __u, __m256i __a, __m256i __b) {
// CHECK-LABEL: @test_mm256_mask_cmpgt_epu32_mask
// CHECK: icmp ugt <8 x i32> %{{.*}}, %{{.*}}
// CHECK: and <8 x i1> %{{.*}}, %{{.*}}
return (__mmask8)_mm256_mask_cmpgt_epu32_mask(__u, __a, __b);
}
__mmask8 test_mm256_cmpgt_epu64_mask(__m256i __a, __m256i __b) {
// CHECK-LABEL: @test_mm256_cmpgt_epu64_mask
// CHECK: icmp ugt <4 x i64> %{{.*}}, %{{.*}}
return (__mmask8)_mm256_cmpgt_epu64_mask(__a, __b);
}
__mmask8 test_mm256_mask_cmpgt_epu64_mask(__mmask8 __u, __m256i __a, __m256i __b) {
// CHECK-LABEL: @test_mm256_mask_cmpgt_epu64_mask
// CHECK: icmp ugt <4 x i64> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> %{{.*}}, %{{.*}}
return (__mmask8)_mm256_mask_cmpgt_epu64_mask(__u, __a, __b);
}
__mmask8 test_mm_cmple_epi32_mask(__m128i __a, __m128i __b) {
// CHECK-LABEL: @test_mm_cmple_epi32_mask
// CHECK: icmp sle <4 x i32> %{{.*}}, %{{.*}}
return (__mmask8)_mm_cmple_epi32_mask(__a, __b);
}
__mmask8 test_mm_mask_cmple_epi32_mask(__mmask8 __u, __m128i __a, __m128i __b) {
// CHECK-LABEL: @test_mm_mask_cmple_epi32_mask
// CHECK: icmp sle <4 x i32> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> %{{.*}}, %{{.*}}
return (__mmask8)_mm_mask_cmple_epi32_mask(__u, __a, __b);
}
__mmask8 test_mm_cmple_epi64_mask(__m128i __a, __m128i __b) {
// CHECK-LABEL: @test_mm_cmple_epi64_mask
// CHECK: icmp sle <2 x i64> %{{.*}}, %{{.*}}
return (__mmask8)_mm_cmple_epi64_mask(__a, __b);
}
__mmask8 test_mm_mask_cmple_epi64_mask(__mmask8 __u, __m128i __a, __m128i __b) {
// CHECK-LABEL: @test_mm_mask_cmple_epi64_mask
// CHECK: icmp sle <2 x i64> %{{.*}}, %{{.*}}
// CHECK: and <2 x i1> %{{.*}}, %{{.*}}
return (__mmask8)_mm_mask_cmple_epi64_mask(__u, __a, __b);
}
__mmask8 test_mm256_cmple_epi32_mask(__m256i __a, __m256i __b) {
// CHECK-LABEL: @test_mm256_cmple_epi32_mask
// CHECK: icmp sle <8 x i32> %{{.*}}, %{{.*}}
return (__mmask8)_mm256_cmple_epi32_mask(__a, __b);
}
__mmask8 test_mm256_mask_cmple_epi32_mask(__mmask8 __u, __m256i __a, __m256i __b) {
// CHECK-LABEL: @test_mm256_mask_cmple_epi32_mask
// CHECK: icmp sle <8 x i32> %{{.*}}, %{{.*}}
// CHECK: and <8 x i1> %{{.*}}, %{{.*}}
return (__mmask8)_mm256_mask_cmple_epi32_mask(__u, __a, __b);
}
__mmask8 test_mm256_cmple_epi64_mask(__m256i __a, __m256i __b) {
// CHECK-LABEL: @test_mm256_cmple_epi64_mask
// CHECK: icmp sle <4 x i64> %{{.*}}, %{{.*}}
return (__mmask8)_mm256_cmple_epi64_mask(__a, __b);
}
__mmask8 test_mm256_mask_cmple_epi64_mask(__mmask8 __u, __m256i __a, __m256i __b) {
// CHECK-LABEL: @test_mm256_mask_cmple_epi64_mask
// CHECK: icmp sle <4 x i64> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> %{{.*}}, %{{.*}}
return (__mmask8)_mm256_mask_cmple_epi64_mask(__u, __a, __b);
}
__mmask8 test_mm_cmple_epu32_mask(__m128i __a, __m128i __b) {
// CHECK-LABEL: @test_mm_cmple_epu32_mask
// CHECK: icmp ule <4 x i32> %{{.*}}, %{{.*}}
return (__mmask8)_mm_cmple_epu32_mask(__a, __b);
}
__mmask8 test_mm_mask_cmple_epu32_mask(__mmask8 __u, __m128i __a, __m128i __b) {
// CHECK-LABEL: @test_mm_mask_cmple_epu32_mask
// CHECK: icmp ule <4 x i32> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> %{{.*}}, %{{.*}}
return (__mmask8)_mm_mask_cmple_epu32_mask(__u, __a, __b);
}
__mmask8 test_mm_cmple_epu64_mask(__m128i __a, __m128i __b) {
// CHECK-LABEL: @test_mm_cmple_epu64_mask
// CHECK: icmp ule <2 x i64> %{{.*}}, %{{.*}}
return (__mmask8)_mm_cmple_epu64_mask(__a, __b);
}
__mmask8 test_mm_mask_cmple_epu64_mask(__mmask8 __u, __m128i __a, __m128i __b) {
// CHECK-LABEL: @test_mm_mask_cmple_epu64_mask
// CHECK: icmp ule <2 x i64> %{{.*}}, %{{.*}}
// CHECK: and <2 x i1> %{{.*}}, %{{.*}}
return (__mmask8)_mm_mask_cmple_epu64_mask(__u, __a, __b);
}
__mmask8 test_mm256_cmple_epu32_mask(__m256i __a, __m256i __b) {
// CHECK-LABEL: @test_mm256_cmple_epu32_mask
// CHECK: icmp ule <8 x i32> %{{.*}}, %{{.*}}
return (__mmask8)_mm256_cmple_epu32_mask(__a, __b);
}
__mmask8 test_mm256_mask_cmple_epu32_mask(__mmask8 __u, __m256i __a, __m256i __b) {
// CHECK-LABEL: @test_mm256_mask_cmple_epu32_mask
// CHECK: icmp ule <8 x i32> %{{.*}}, %{{.*}}
// CHECK: and <8 x i1> %{{.*}}, %{{.*}}
return (__mmask8)_mm256_mask_cmple_epu32_mask(__u, __a, __b);
}
__mmask8 test_mm256_cmple_epu64_mask(__m256i __a, __m256i __b) {
// CHECK-LABEL: @test_mm256_cmple_epu64_mask
// CHECK: icmp ule <4 x i64> %{{.*}}, %{{.*}}
return (__mmask8)_mm256_cmple_epu64_mask(__a, __b);
}
__mmask8 test_mm256_mask_cmple_epu64_mask(__mmask8 __u, __m256i __a, __m256i __b) {
// CHECK-LABEL: @test_mm256_mask_cmple_epu64_mask
// CHECK: icmp ule <4 x i64> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> %{{.*}}, %{{.*}}
return (__mmask8)_mm256_mask_cmple_epu64_mask(__u, __a, __b);
}
__mmask8 test_mm_cmplt_epi32_mask(__m128i __a, __m128i __b) {
// CHECK-LABEL: @test_mm_cmplt_epi32_mask
// CHECK: icmp slt <4 x i32> %{{.*}}, %{{.*}}
return (__mmask8)_mm_cmplt_epi32_mask(__a, __b);
}
__mmask8 test_mm_mask_cmplt_epi32_mask(__mmask8 __u, __m128i __a, __m128i __b) {
// CHECK-LABEL: @test_mm_mask_cmplt_epi32_mask
// CHECK: icmp slt <4 x i32> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> %{{.*}}, %{{.*}}
return (__mmask8)_mm_mask_cmplt_epi32_mask(__u, __a, __b);
}
__mmask8 test_mm_cmplt_epi64_mask(__m128i __a, __m128i __b) {
// CHECK-LABEL: @test_mm_cmplt_epi64_mask
// CHECK: icmp slt <2 x i64> %{{.*}}, %{{.*}}
return (__mmask8)_mm_cmplt_epi64_mask(__a, __b);
}
__mmask8 test_mm_mask_cmplt_epi64_mask(__mmask8 __u, __m128i __a, __m128i __b) {
// CHECK-LABEL: @test_mm_mask_cmplt_epi64_mask
// CHECK: icmp slt <2 x i64> %{{.*}}, %{{.*}}
// CHECK: and <2 x i1> %{{.*}}, %{{.*}}
return (__mmask8)_mm_mask_cmplt_epi64_mask(__u, __a, __b);
}
__mmask8 test_mm256_cmplt_epi32_mask(__m256i __a, __m256i __b) {
// CHECK-LABEL: @test_mm256_cmplt_epi32_mask
// CHECK: icmp slt <8 x i32> %{{.*}}, %{{.*}}
return (__mmask8)_mm256_cmplt_epi32_mask(__a, __b);
}
__mmask8 test_mm256_mask_cmplt_epi32_mask(__mmask8 __u, __m256i __a, __m256i __b) {
// CHECK-LABEL: @test_mm256_mask_cmplt_epi32_mask
// CHECK: icmp slt <8 x i32> %{{.*}}, %{{.*}}
// CHECK: and <8 x i1> %{{.*}}, %{{.*}}
return (__mmask8)_mm256_mask_cmplt_epi32_mask(__u, __a, __b);
}
__mmask8 test_mm256_cmplt_epi64_mask(__m256i __a, __m256i __b) {
// CHECK-LABEL: @test_mm256_cmplt_epi64_mask
// CHECK: icmp slt <4 x i64> %{{.*}}, %{{.*}}
return (__mmask8)_mm256_cmplt_epi64_mask(__a, __b);
}
__mmask8 test_mm256_mask_cmplt_epi64_mask(__mmask8 __u, __m256i __a, __m256i __b) {
// CHECK-LABEL: @test_mm256_mask_cmplt_epi64_mask
// CHECK: icmp slt <4 x i64> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> %{{.*}}, %{{.*}}
return (__mmask8)_mm256_mask_cmplt_epi64_mask(__u, __a, __b);
}
__mmask8 test_mm_cmplt_epu32_mask(__m128i __a, __m128i __b) {
// CHECK-LABEL: @test_mm_cmplt_epu32_mask
// CHECK: icmp ult <4 x i32> %{{.*}}, %{{.*}}
return (__mmask8)_mm_cmplt_epu32_mask(__a, __b);
}
__mmask8 test_mm_mask_cmplt_epu32_mask(__mmask8 __u, __m128i __a, __m128i __b) {
// CHECK-LABEL: @test_mm_mask_cmplt_epu32_mask
// CHECK: icmp ult <4 x i32> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> %{{.*}}, %{{.*}}
return (__mmask8)_mm_mask_cmplt_epu32_mask(__u, __a, __b);
}
__mmask8 test_mm_cmplt_epu64_mask(__m128i __a, __m128i __b) {
// CHECK-LABEL: @test_mm_cmplt_epu64_mask
// CHECK: icmp ult <2 x i64> %{{.*}}, %{{.*}}
return (__mmask8)_mm_cmplt_epu64_mask(__a, __b);
}
__mmask8 test_mm_mask_cmplt_epu64_mask(__mmask8 __u, __m128i __a, __m128i __b) {
// CHECK-LABEL: @test_mm_mask_cmplt_epu64_mask
// CHECK: icmp ult <2 x i64> %{{.*}}, %{{.*}}
// CHECK: and <2 x i1> %{{.*}}, %{{.*}}
return (__mmask8)_mm_mask_cmplt_epu64_mask(__u, __a, __b);
}
__mmask8 test_mm256_cmplt_epu32_mask(__m256i __a, __m256i __b) {
// CHECK-LABEL: @test_mm256_cmplt_epu32_mask
// CHECK: icmp ult <8 x i32> %{{.*}}, %{{.*}}
return (__mmask8)_mm256_cmplt_epu32_mask(__a, __b);
}
__mmask8 test_mm256_mask_cmplt_epu32_mask(__mmask8 __u, __m256i __a, __m256i __b) {
// CHECK-LABEL: @test_mm256_mask_cmplt_epu32_mask
// CHECK: icmp ult <8 x i32> %{{.*}}, %{{.*}}
// CHECK: and <8 x i1> %{{.*}}, %{{.*}}
return (__mmask8)_mm256_mask_cmplt_epu32_mask(__u, __a, __b);
}
__mmask8 test_mm256_cmplt_epu64_mask(__m256i __a, __m256i __b) {
// CHECK-LABEL: @test_mm256_cmplt_epu64_mask
// CHECK: icmp ult <4 x i64> %{{.*}}, %{{.*}}
return (__mmask8)_mm256_cmplt_epu64_mask(__a, __b);
}
__mmask8 test_mm256_mask_cmplt_epu64_mask(__mmask8 __u, __m256i __a, __m256i __b) {
// CHECK-LABEL: @test_mm256_mask_cmplt_epu64_mask
// CHECK: icmp ult <4 x i64> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> %{{.*}}, %{{.*}}
return (__mmask8)_mm256_mask_cmplt_epu64_mask(__u, __a, __b);
}
__mmask8 test_mm_cmpneq_epi32_mask(__m128i __a, __m128i __b) {
// CHECK-LABEL: @test_mm_cmpneq_epi32_mask
// CHECK: icmp ne <4 x i32> %{{.*}}, %{{.*}}
return (__mmask8)_mm_cmpneq_epi32_mask(__a, __b);
}
__mmask8 test_mm_mask_cmpneq_epi32_mask(__mmask8 __u, __m128i __a, __m128i __b) {
// CHECK-LABEL: @test_mm_mask_cmpneq_epi32_mask
// CHECK: icmp ne <4 x i32> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> %{{.*}}, %{{.*}}
return (__mmask8)_mm_mask_cmpneq_epi32_mask(__u, __a, __b);
}
__mmask8 test_mm_cmpneq_epi64_mask(__m128i __a, __m128i __b) {
// CHECK-LABEL: @test_mm_cmpneq_epi64_mask
// CHECK: icmp ne <2 x i64> %{{.*}}, %{{.*}}
return (__mmask8)_mm_cmpneq_epi64_mask(__a, __b);
}
__mmask8 test_mm_mask_cmpneq_epi64_mask(__mmask8 __u, __m128i __a, __m128i __b) {
// CHECK-LABEL: @test_mm_mask_cmpneq_epi64_mask
// CHECK: icmp ne <2 x i64> %{{.*}}, %{{.*}}
// CHECK: and <2 x i1> %{{.*}}, %{{.*}}
return (__mmask8)_mm_mask_cmpneq_epi64_mask(__u, __a, __b);
}
__mmask8 test_mm256_cmpneq_epi32_mask(__m256i __a, __m256i __b) {
// CHECK-LABEL: @test_mm256_cmpneq_epi32_mask
// CHECK: icmp ne <8 x i32> %{{.*}}, %{{.*}}
return (__mmask8)_mm256_cmpneq_epi32_mask(__a, __b);
}
__mmask8 test_mm256_mask_cmpneq_epi32_mask(__mmask8 __u, __m256i __a, __m256i __b) {
// CHECK-LABEL: @test_mm256_mask_cmpneq_epi32_mask
// CHECK: icmp ne <8 x i32> %{{.*}}, %{{.*}}
// CHECK: and <8 x i1> %{{.*}}, %{{.*}}
return (__mmask8)_mm256_mask_cmpneq_epi32_mask(__u, __a, __b);
}
__mmask8 test_mm256_cmpneq_epi64_mask(__m256i __a, __m256i __b) {
// CHECK-LABEL: @test_mm256_cmpneq_epi64_mask
// CHECK: icmp ne <4 x i64> %{{.*}}, %{{.*}}
return (__mmask8)_mm256_cmpneq_epi64_mask(__a, __b);
}
__mmask8 test_mm256_mask_cmpneq_epi64_mask(__mmask8 __u, __m256i __a, __m256i __b) {
// CHECK-LABEL: @test_mm256_mask_cmpneq_epi64_mask
// CHECK: icmp ne <4 x i64> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> %{{.*}}, %{{.*}}
return (__mmask8)_mm256_mask_cmpneq_epi64_mask(__u, __a, __b);
}
__mmask8 test_mm_cmpneq_epu32_mask(__m128i __a, __m128i __b) {
// CHECK-LABEL: @test_mm_cmpneq_epu32_mask
// CHECK: icmp ne <4 x i32> %{{.*}}, %{{.*}}
return (__mmask8)_mm_cmpneq_epu32_mask(__a, __b);
}
__mmask8 test_mm_mask_cmpneq_epu32_mask(__mmask8 __u, __m128i __a, __m128i __b) {
// CHECK-LABEL: @test_mm_mask_cmpneq_epu32_mask
// CHECK: icmp ne <4 x i32> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> %{{.*}}, %{{.*}}
return (__mmask8)_mm_mask_cmpneq_epu32_mask(__u, __a, __b);
}
__mmask8 test_mm_cmpneq_epu64_mask(__m128i __a, __m128i __b) {
// CHECK-LABEL: @test_mm_cmpneq_epu64_mask
// CHECK: icmp ne <2 x i64> %{{.*}}, %{{.*}}
return (__mmask8)_mm_cmpneq_epu64_mask(__a, __b);
}
__mmask8 test_mm_mask_cmpneq_epu64_mask(__mmask8 __u, __m128i __a, __m128i __b) {
// CHECK-LABEL: @test_mm_mask_cmpneq_epu64_mask
// CHECK: icmp ne <2 x i64> %{{.*}}, %{{.*}}
// CHECK: and <2 x i1> %{{.*}}, %{{.*}}
return (__mmask8)_mm_mask_cmpneq_epu64_mask(__u, __a, __b);
}
__mmask8 test_mm256_cmpneq_epu32_mask(__m256i __a, __m256i __b) {
// CHECK-LABEL: @test_mm256_cmpneq_epu32_mask
// CHECK: icmp ne <8 x i32> %{{.*}}, %{{.*}}
return (__mmask8)_mm256_cmpneq_epu32_mask(__a, __b);
}
__mmask8 test_mm256_mask_cmpneq_epu32_mask(__mmask8 __u, __m256i __a, __m256i __b) {
// CHECK-LABEL: @test_mm256_mask_cmpneq_epu32_mask
// CHECK: icmp ne <8 x i32> %{{.*}}, %{{.*}}
// CHECK: and <8 x i1> %{{.*}}, %{{.*}}
return (__mmask8)_mm256_mask_cmpneq_epu32_mask(__u, __a, __b);
}
__mmask8 test_mm256_cmpneq_epu64_mask(__m256i __a, __m256i __b) {
// CHECK-LABEL: @test_mm256_cmpneq_epu64_mask
// CHECK: icmp ne <4 x i64> %{{.*}}, %{{.*}}
return (__mmask8)_mm256_cmpneq_epu64_mask(__a, __b);
}
__mmask8 test_mm256_mask_cmpneq_epu64_mask(__mmask8 __u, __m256i __a, __m256i __b) {
// CHECK-LABEL: @test_mm256_mask_cmpneq_epu64_mask
// CHECK: icmp ne <4 x i64> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> %{{.*}}, %{{.*}}
return (__mmask8)_mm256_mask_cmpneq_epu64_mask(__u, __a, __b);
}
__mmask8 test_mm_cmp_eq_epi32_mask(__m128i __a, __m128i __b) {
// CHECK-LABEL: @test_mm_cmp_eq_epi32_mask
// CHECK: icmp eq <4 x i32> %{{.*}}, %{{.*}}
return (__mmask8)_mm_cmp_epi32_mask(__a, __b, _MM_CMPINT_EQ);
}
__mmask8 test_mm_mask_cmp_lt_epi32_mask(__mmask8 __u, __m128i __a, __m128i __b) {
// CHECK-LABEL: @test_mm_mask_cmp_lt_epi32_mask
// CHECK: icmp slt <4 x i32> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> %{{.*}}, %{{.*}}
return (__mmask8)_mm_mask_cmp_epi32_mask(__u, __a, __b, _MM_CMPINT_LT);
}
__mmask8 test_mm_cmp_lt_epi64_mask(__m128i __a, __m128i __b) {
// CHECK-LABEL: @test_mm_cmp_lt_epi64_mask
// CHECK: icmp slt <2 x i64> %{{.*}}, %{{.*}}
return (__mmask8)_mm_cmp_epi64_mask(__a, __b, _MM_CMPINT_LT);
}
__mmask8 test_mm_mask_cmp_eq_epi64_mask(__mmask8 __u, __m128i __a, __m128i __b) {
// CHECK-LABEL: @test_mm_mask_cmp_eq_epi64_mask
// CHECK: icmp eq <2 x i64> %{{.*}}, %{{.*}}
// CHECK: and <2 x i1> %{{.*}}, %{{.*}}
return (__mmask8)_mm_mask_cmp_epi64_mask(__u, __a, __b, _MM_CMPINT_EQ);
}
__mmask8 test_mm256_cmp_eq_epi32_mask(__m256i __a, __m256i __b) {
// CHECK-LABEL: @test_mm256_cmp_eq_epi32_mask
// CHECK: icmp eq <8 x i32> %{{.*}}, %{{.*}}
return (__mmask8)_mm256_cmp_epi32_mask(__a, __b, _MM_CMPINT_EQ);
}
__mmask8 test_mm256_mask_cmp_le_epi32_mask(__mmask8 __u, __m256i __a, __m256i __b) {
// CHECK-LABEL: @test_mm256_mask_cmp_le_epi32_mask
// CHECK: icmp sle <8 x i32> %{{.*}}, %{{.*}}
// CHECK: and <8 x i1> %{{.*}}, %{{.*}}
return (__mmask8)_mm256_mask_cmp_epi32_mask(__u, __a, __b, _MM_CMPINT_LE);
}
__mmask8 test_mm256_cmp_eq_epi64_mask(__m256i __a, __m256i __b) {
// CHECK-LABEL: @test_mm256_cmp_eq_epi64_mask
// CHECK: icmp eq <4 x i64> %{{.*}}, %{{.*}}
return (__mmask8)_mm256_cmp_epi64_mask(__a, __b, _MM_CMPINT_EQ);
}
__mmask8 test_mm256_mask_cmp_eq_epi64_mask(__mmask8 __u, __m256i __a, __m256i __b) {
// CHECK-LABEL: @test_mm256_mask_cmp_eq_epi64_mask
// CHECK: icmp eq <4 x i64> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> %{{.*}}, %{{.*}}
return (__mmask8)_mm256_mask_cmp_epi64_mask(__u, __a, __b, _MM_CMPINT_EQ);
}
__mmask8 test_mm_cmp_epu32_mask(__m128i __a, __m128i __b) {
// CHECK-LABEL: @test_mm_cmp_epu32_mask
// CHECK: icmp eq <4 x i32> %{{.*}}, %{{.*}}
return (__mmask8)_mm_cmp_epu32_mask(__a, __b, 0);
}
__mmask8 test_mm_mask_cmp_epu32_mask(__mmask8 __u, __m128i __a, __m128i __b) {
// CHECK-LABEL: @test_mm_mask_cmp_epu32_mask
// CHECK: icmp eq <4 x i32> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> %{{.*}}, %{{.*}}
return (__mmask8)_mm_mask_cmp_epu32_mask(__u, __a, __b, 0);
}
__mmask8 test_mm_cmp_epu64_mask(__m128i __a, __m128i __b) {
// CHECK-LABEL: @test_mm_cmp_epu64_mask
// CHECK: icmp eq <2 x i64> %{{.*}}, %{{.*}}
return (__mmask8)_mm_cmp_epu64_mask(__a, __b, 0);
}
__mmask8 test_mm_mask_cmp_epu64_mask(__mmask8 __u, __m128i __a, __m128i __b) {
// CHECK-LABEL: @test_mm_mask_cmp_epu64_mask
// CHECK: icmp eq <2 x i64> %{{.*}}, %{{.*}}
// CHECK: and <2 x i1> %{{.*}}, %{{.*}}
return (__mmask8)_mm_mask_cmp_epu64_mask(__u, __a, __b, 0);
}
__mmask8 test_mm256_cmp_epu32_mask(__m256i __a, __m256i __b) {
// CHECK-LABEL: @test_mm256_cmp_epu32_mask
// CHECK: icmp eq <8 x i32> %{{.*}}, %{{.*}}
return (__mmask8)_mm256_cmp_epu32_mask(__a, __b, 0);
}
__mmask8 test_mm256_mask_cmp_epu32_mask(__mmask8 __u, __m256i __a, __m256i __b) {
// CHECK-LABEL: @test_mm256_mask_cmp_epu32_mask
// CHECK: icmp eq <8 x i32> %{{.*}}, %{{.*}}
// CHECK: and <8 x i1> %{{.*}}, %{{.*}}
return (__mmask8)_mm256_mask_cmp_epu32_mask(__u, __a, __b, 0);
}
__mmask8 test_mm256_cmp_epu64_mask(__m256i __a, __m256i __b) {
// CHECK-LABEL: @test_mm256_cmp_epu64_mask
// CHECK: icmp eq <4 x i64> %{{.*}}, %{{.*}}
return (__mmask8)_mm256_cmp_epu64_mask(__a, __b, 0);
}
__mmask8 test_mm256_mask_cmp_epu64_mask(__mmask8 __u, __m256i __a, __m256i __b) {
// CHECK-LABEL: @test_mm256_mask_cmp_epu64_mask
// CHECK: icmp eq <4 x i64> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> %{{.*}}, %{{.*}}
return (__mmask8)_mm256_mask_cmp_epu64_mask(__u, __a, __b, 0);
}
__m256i test_mm256_mask_add_epi32 (__m256i __W, __mmask8 __U, __m256i __A,
__m256i __B) {
//CHECK-LABEL: @test_mm256_mask_add_epi32
//CHECK: add <8 x i32> %{{.*}}, %{{.*}}
//CHECK: select <8 x i1> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> %{{.*}}
return _mm256_mask_add_epi32(__W, __U, __A, __B);
}
__m256i test_mm256_maskz_add_epi32 (__mmask8 __U, __m256i __A, __m256i __B) {
//CHECK-LABEL: @test_mm256_maskz_add_epi32
//CHECK: add <8 x i32> %{{.*}}, %{{.*}}
//CHECK: select <8 x i1> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> %{{.*}}
return _mm256_maskz_add_epi32(__U, __A, __B);
}
__m256i test_mm256_mask_add_epi64 (__m256i __W, __mmask8 __U, __m256i __A,
__m256i __B) {
//CHECK-LABEL: @test_mm256_mask_add_epi64
//CHECK: add <4 x i64> %{{.*}}, %{{.*}}
//CHECK: select <4 x i1> %{{.*}}, <4 x i64> %{{.*}}, <4 x i64> %{{.*}}
return _mm256_mask_add_epi64(__W,__U,__A,__B);
}
__m256i test_mm256_maskz_add_epi64 (__mmask8 __U, __m256i __A, __m256i __B) {
//CHECK-LABEL: @test_mm256_maskz_add_epi64
//CHECK: add <4 x i64> %{{.*}}, %{{.*}}
//CHECK: select <4 x i1> %{{.*}}, <4 x i64> %{{.*}}, <4 x i64> %{{.*}}
return _mm256_maskz_add_epi64 (__U,__A,__B);
}
__m256i test_mm256_mask_sub_epi32 (__m256i __W, __mmask8 __U, __m256i __A,
__m256i __B) {
//CHECK-LABEL: @test_mm256_mask_sub_epi32
//CHECK: sub <8 x i32> %{{.*}}, %{{.*}}
//CHECK: select <8 x i1> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> %{{.*}}
return _mm256_mask_sub_epi32 (__W,__U,__A,__B);
}
__m256i test_mm256_maskz_sub_epi32 (__mmask8 __U, __m256i __A, __m256i __B) {
//CHECK-LABEL: @test_mm256_maskz_sub_epi32
//CHECK: sub <8 x i32> %{{.*}}, %{{.*}}
//CHECK: select <8 x i1> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> %{{.*}}
return _mm256_maskz_sub_epi32 (__U,__A,__B);
}
__m256i test_mm256_mask_sub_epi64 (__m256i __W, __mmask8 __U, __m256i __A,
__m256i __B) {
//CHECK-LABEL: @test_mm256_mask_sub_epi64
//CHECK: sub <4 x i64> %{{.*}}, %{{.*}}
//CHECK: select <4 x i1> %{{.*}}, <4 x i64> %{{.*}}, <4 x i64> %{{.*}}
return _mm256_mask_sub_epi64 (__W,__U,__A,__B);
}
__m256i test_mm256_maskz_sub_epi64 (__mmask8 __U, __m256i __A, __m256i __B) {
//CHECK-LABEL: @test_mm256_maskz_sub_epi64
//CHECK: sub <4 x i64> %{{.*}}, %{{.*}}
//CHECK: select <4 x i1> %{{.*}}, <4 x i64> %{{.*}}, <4 x i64> %{{.*}}
return _mm256_maskz_sub_epi64 (__U,__A,__B);
}
__m128i test_mm_mask_add_epi32 (__m128i __W, __mmask8 __U, __m128i __A,
__m128i __B) {
//CHECK-LABEL: @test_mm_mask_add_epi32
//CHECK: add <4 x i32> %{{.*}}, %{{.*}}
//CHECK: select <4 x i1> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}
return _mm_mask_add_epi32(__W,__U,__A,__B);
}
__m128i test_mm_maskz_add_epi32 (__mmask8 __U, __m128i __A, __m128i __B) {
//CHECK-LABEL: @test_mm_maskz_add_epi32
//CHECK: add <4 x i32> %{{.*}}, %{{.*}}
//CHECK: select <4 x i1> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}
return _mm_maskz_add_epi32 (__U,__A,__B);
}
__m128i test_mm_mask_add_epi64 (__m128i __W, __mmask8 __U, __m128i __A,
__m128i __B) {
//CHECK-LABEL: @test_mm_mask_add_epi64
//CHECK: add <2 x i64> %{{.*}}, %{{.*}}
//CHECK: select <2 x i1> %{{.*}}, <2 x i64> %{{.*}}, <2 x i64> %{{.*}}
return _mm_mask_add_epi64 (__W,__U,__A,__B);
}
__m128i test_mm_maskz_add_epi64 (__mmask8 __U, __m128i __A, __m128i __B) {
//CHECK-LABEL: @test_mm_maskz_add_epi64
//CHECK: add <2 x i64> %{{.*}}, %{{.*}}
//CHECK: select <2 x i1> %{{.*}}, <2 x i64> %{{.*}}, <2 x i64> %{{.*}}
return _mm_maskz_add_epi64 (__U,__A,__B);
}
__m128i test_mm_mask_sub_epi32 (__m128i __W, __mmask8 __U, __m128i __A,
__m128i __B) {
//CHECK-LABEL: @test_mm_mask_sub_epi32
//CHECK: sub <4 x i32> %{{.*}}, %{{.*}}
//CHECK: select <4 x i1> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}
return _mm_mask_sub_epi32(__W, __U, __A, __B);
}
__m128i test_mm_maskz_sub_epi32 (__mmask8 __U, __m128i __A, __m128i __B) {
//CHECK-LABEL: @test_mm_maskz_sub_epi32
//CHECK: sub <4 x i32> %{{.*}}, %{{.*}}
//CHECK: select <4 x i1> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}
return _mm_maskz_sub_epi32(__U, __A, __B);
}
__m128i test_mm_mask_sub_epi64 (__m128i __W, __mmask8 __U, __m128i __A,
__m128i __B) {
//CHECK-LABEL: @test_mm_mask_sub_epi64
//CHECK: sub <2 x i64> %{{.*}}, %{{.*}}
//CHECK: select <2 x i1> %{{.*}}, <2 x i64> %{{.*}}, <2 x i64> %{{.*}}
return _mm_mask_sub_epi64 (__W, __U, __A, __B);
}
__m128i test_mm_maskz_sub_epi64 (__mmask8 __U, __m128i __A, __m128i __B) {
//CHECK-LABEL: @test_mm_maskz_sub_epi64
//CHECK: sub <2 x i64> %{{.*}}, %{{.*}}
//CHECK: select <2 x i1> %{{.*}}, <2 x i64> %{{.*}}, <2 x i64> %{{.*}}
return _mm_maskz_sub_epi64 (__U, __A, __B);
}
__m256i test_mm256_mask_mul_epi32 (__m256i __W, __mmask8 __M, __m256i __X,
__m256i __Y) {
//CHECK-LABEL: @test_mm256_mask_mul_epi32
//CHECK: shl <4 x i64> %{{.*}}, <i64 32, i64 32, i64 32, i64 32>
//CHECK: ashr <4 x i64> %{{.*}}, <i64 32, i64 32, i64 32, i64 32>
//CHECK: shl <4 x i64> %{{.*}}, <i64 32, i64 32, i64 32, i64 32>
//CHECK: ashr <4 x i64> %{{.*}}, <i64 32, i64 32, i64 32, i64 32>
//CHECK: mul <4 x i64> %{{.*}}, %{{.*}}
//CHECK: select <4 x i1> %{{.*}}, <4 x i64> %{{.*}}, <4 x i64> %{{.*}}
return _mm256_mask_mul_epi32(__W, __M, __X, __Y);
}
__m256i test_mm256_maskz_mul_epi32 (__mmask8 __M, __m256i __X, __m256i __Y) {
//CHECK-LABEL: @test_mm256_maskz_mul_epi32
//CHECK: shl <4 x i64> %{{.*}}, <i64 32, i64 32, i64 32, i64 32>
//CHECK: ashr <4 x i64> %{{.*}}, <i64 32, i64 32, i64 32, i64 32>
//CHECK: shl <4 x i64> %{{.*}}, <i64 32, i64 32, i64 32, i64 32>
//CHECK: ashr <4 x i64> %{{.*}}, <i64 32, i64 32, i64 32, i64 32>
//CHECK: mul <4 x i64> %{{.*}}, %{{.*}}
//CHECK: select <4 x i1> %{{.*}}, <4 x i64> %{{.*}}, <4 x i64> %{{.*}}
return _mm256_maskz_mul_epi32(__M, __X, __Y);
}
__m128i test_mm_mask_mul_epi32 (__m128i __W, __mmask8 __M, __m128i __X,
__m128i __Y) {
//CHECK-LABEL: @test_mm_mask_mul_epi32
//CHECK: shl <2 x i64> %{{.*}}, <i64 32, i64 32>
//CHECK: ashr <2 x i64> %{{.*}}, <i64 32, i64 32>
//CHECK: shl <2 x i64> %{{.*}}, <i64 32, i64 32>
//CHECK: ashr <2 x i64> %{{.*}}, <i64 32, i64 32>
//CHECK: mul <2 x i64> %{{.*}}, %{{.*}}
//CHECK: select <2 x i1> %{{.*}}, <2 x i64> %{{.*}}, <2 x i64> %{{.*}}
return _mm_mask_mul_epi32(__W, __M, __X, __Y);
}
__m128i test_mm_maskz_mul_epi32 (__mmask8 __M, __m128i __X, __m128i __Y) {
//CHECK-LABEL: @test_mm_maskz_mul_epi32
//CHECK: shl <2 x i64> %{{.*}}, <i64 32, i64 32>
//CHECK: ashr <2 x i64> %{{.*}}, <i64 32, i64 32>
//CHECK: shl <2 x i64> %{{.*}}, <i64 32, i64 32>
//CHECK: ashr <2 x i64> %{{.*}}, <i64 32, i64 32>
//CHECK: mul <2 x i64> %{{.*}}, %{{.*}}
//CHECK: select <2 x i1> %{{.*}}, <2 x i64> %{{.*}}, <2 x i64> %{{.*}}
return _mm_maskz_mul_epi32(__M, __X, __Y);
}
__m256i test_mm256_mask_mul_epu32 (__m256i __W, __mmask8 __M, __m256i __X,
__m256i __Y) {
//CHECK-LABEL: @test_mm256_mask_mul_epu32
//CHECK: and <4 x i64> %{{.*}}, <i64 4294967295, i64 4294967295, i64 4294967295, i64 4294967295>
//CHECK: and <4 x i64> %{{.*}}, <i64 4294967295, i64 4294967295, i64 4294967295, i64 4294967295>
//CHECK: mul <4 x i64> %{{.*}}, %{{.*}}
//CHECK: select <4 x i1> %{{.*}}, <4 x i64> %{{.*}}, <4 x i64> %{{.*}}
return _mm256_mask_mul_epu32(__W, __M, __X, __Y);
}
__m256i test_mm256_maskz_mul_epu32 (__mmask8 __M, __m256i __X, __m256i __Y) {
//CHECK-LABEL: @test_mm256_maskz_mul_epu32
//CHECK: and <4 x i64> %{{.*}}, <i64 4294967295, i64 4294967295, i64 4294967295, i64 4294967295>
//CHECK: and <4 x i64> %{{.*}}, <i64 4294967295, i64 4294967295, i64 4294967295, i64 4294967295>
//CHECK: mul <4 x i64> %{{.*}}, %{{.*}}
//CHECK: select <4 x i1> %{{.*}}, <4 x i64> %{{.*}}, <4 x i64> %{{.*}}
return _mm256_maskz_mul_epu32(__M, __X, __Y);
}
__m128i test_mm_mask_mul_epu32 (__m128i __W, __mmask8 __M, __m128i __X,
__m128i __Y) {
//CHECK-LABEL: @test_mm_mask_mul_epu32
//CHECK: and <2 x i64> %{{.*}}, <i64 4294967295, i64 4294967295>
//CHECK: and <2 x i64> %{{.*}}, <i64 4294967295, i64 4294967295>
//CHECK: mul <2 x i64> %{{.*}}, %{{.*}}
//CHECK: select <2 x i1> %{{.*}}, <2 x i64> %{{.*}}, <2 x i64> %{{.*}}
return _mm_mask_mul_epu32(__W, __M, __X, __Y);
}
__m128i test_mm_maskz_mul_epu32 (__mmask8 __M, __m128i __X, __m128i __Y) {
//CHECK-LABEL: @test_mm_maskz_mul_epu32
//CHECK: and <2 x i64> %{{.*}}, <i64 4294967295, i64 4294967295>
//CHECK: and <2 x i64> %{{.*}}, <i64 4294967295, i64 4294967295>
//CHECK: mul <2 x i64> %{{.*}}, %{{.*}}
//CHECK: select <2 x i1> %{{.*}}, <2 x i64> %{{.*}}, <2 x i64> %{{.*}}
return _mm_maskz_mul_epu32(__M, __X, __Y);
}
__m128i test_mm_maskz_mullo_epi32 (__mmask8 __M, __m128i __A, __m128i __B) {
//CHECK-LABEL: @test_mm_maskz_mullo_epi32
//CHECK: mul <4 x i32> %{{.*}}, %{{.*}}
//CHECK: select <4 x i1> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}
return _mm_maskz_mullo_epi32(__M, __A, __B);
}
__m128i test_mm_mask_mullo_epi32 (__m128i __W, __mmask8 __M, __m128i __A,
__m128i __B) {
//CHECK-LABEL: @test_mm_mask_mullo_epi32
//CHECK: mul <4 x i32> %{{.*}}, %{{.*}}
//CHECK: select <4 x i1> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}
return _mm_mask_mullo_epi32(__W, __M, __A, __B);
}
__m256i test_mm256_maskz_mullo_epi32 (__mmask8 __M, __m256i __A, __m256i __B) {
//CHECK-LABEL: @test_mm256_maskz_mullo_epi32
//CHECK: mul <8 x i32> %{{.*}}, %{{.*}}
//CHECK: select <8 x i1> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> %{{.*}}
return _mm256_maskz_mullo_epi32(__M, __A, __B);
}
__m256i test_mm256_mask_mullo_epi32 (__m256i __W, __mmask8 __M, __m256i __A,
__m256i __B) {
//CHECK-LABEL: @test_mm256_mask_mullo_epi32
//CHECK: mul <8 x i32> %{{.*}}, %{{.*}}
//CHECK: select <8 x i1> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> %{{.*}}
return _mm256_mask_mullo_epi32(__W, __M, __A, __B);
}
__m256i test_mm256_and_epi32 (__m256i __A, __m256i __B) {
//CHECK-LABEL: @test_mm256_and_epi32
//CHECK: and <8 x i32> %{{.*}}, %{{.*}}
return _mm256_and_epi32(__A, __B);
}
__m256i test_mm256_mask_and_epi32 (__m256i __W, __mmask8 __U, __m256i __A, __m256i __B) {
//CHECK-LABEL: @test_mm256_mask_and_epi32
//CHECK: and <8 x i32> %{{.*}}, %{{.*}}
//CHECK: select <8 x i1> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> %{{.*}}
return _mm256_mask_and_epi32(__W, __U, __A, __B);
}
__m256i test_mm256_maskz_and_epi32 (__mmask8 __U, __m256i __A, __m256i __B) {
//CHECK-LABEL: @test_mm256_maskz_and_epi32
//CHECK: and <8 x i32> %{{.*}}, %{{.*}}
//CHECK: select <8 x i1> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> %{{.*}}
return _mm256_maskz_and_epi32(__U, __A, __B);
}
__m128i test_mm_and_epi32 (__m128i __A, __m128i __B) {
//CHECK-LABEL: @test_mm_and_epi32
//CHECK: and <4 x i32> %{{.*}}, %{{.*}}
return _mm_and_epi32(__A, __B);
}
__m128i test_mm_mask_and_epi32 (__m128i __W, __mmask8 __U, __m128i __A, __m128i __B) {
//CHECK-LABEL: @test_mm_mask_and_epi32
//CHECK: and <4 x i32> %{{.*}}, %{{.*}}
//CHECK: select <4 x i1> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}
return _mm_mask_and_epi32(__W, __U, __A, __B);
}
__m128i test_mm_maskz_and_epi32 (__mmask8 __U, __m128i __A, __m128i __B) {
//CHECK-LABEL: @test_mm_maskz_and_epi32
//CHECK: and <4 x i32> %{{.*}}, %{{.*}}
//CHECK: select <4 x i1> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}
return _mm_maskz_and_epi32(__U, __A, __B);
}
__m256i test_mm256_andnot_epi32 (__m256i __A, __m256i __B) {
//CHECK-LABEL: @test_mm256_andnot_epi32
//CHECK: xor <8 x i32> %{{.*}}, <i32 -1, i32 -1, i32 -1, i32 -1, i32 -1, i32 -1, i32 -1, i32 -1>
//CHECK: and <8 x i32> %{{.*}}, %{{.*}}
return _mm256_andnot_epi32(__A, __B);
}
__m256i test_mm256_mask_andnot_epi32 (__m256i __W, __mmask8 __U, __m256i __A, __m256i __B) {
//CHECK-LABEL: @test_mm256_mask_andnot_epi32
//CHECK: xor <8 x i32> %{{.*}}, <i32 -1, i32 -1, i32 -1, i32 -1, i32 -1, i32 -1, i32 -1, i32 -1>
//CHECK: and <8 x i32> %{{.*}}, %{{.*}}
//CHECK: select <8 x i1> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> %{{.*}}
return _mm256_mask_andnot_epi32(__W, __U, __A, __B);
}
__m256i test_mm256_maskz_andnot_epi32 (__mmask8 __U, __m256i __A, __m256i __B) {
//CHECK-LABEL: @test_mm256_maskz_andnot_epi32
//CHECK: xor <8 x i32> %{{.*}}, <i32 -1, i32 -1, i32 -1, i32 -1, i32 -1, i32 -1, i32 -1, i32 -1>
//CHECK: and <8 x i32> %{{.*}}, %{{.*}}
//CHECK: select <8 x i1> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> %{{.*}}
return _mm256_maskz_andnot_epi32(__U, __A, __B);
}
__m128i test_mm_andnot_epi32 (__m128i __A, __m128i __B) {
//CHECK-LABEL: @test_mm_andnot_epi32
//CHECK: xor <4 x i32> %{{.*}}, <i32 -1, i32 -1, i32 -1, i32 -1>
//CHECK: and <4 x i32> %{{.*}}, %{{.*}}
return _mm_andnot_epi32(__A, __B);
}
__m128i test_mm_mask_andnot_epi32 (__m128i __W, __mmask8 __U, __m128i __A, __m128i __B) {
//CHECK-LABEL: @test_mm_mask_andnot_epi32
//CHECK: xor <4 x i32> %{{.*}}, <i32 -1, i32 -1, i32 -1, i32 -1>
//CHECK: and <4 x i32> %{{.*}}, %{{.*}}
//CHECK: select <4 x i1> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}
return _mm_mask_andnot_epi32(__W, __U, __A, __B);
}
__m128i test_mm_maskz_andnot_epi32 (__mmask8 __U, __m128i __A, __m128i __B) {
//CHECK-LABEL: @test_mm_maskz_andnot_epi32
//CHECK: xor <4 x i32> %{{.*}}, <i32 -1, i32 -1, i32 -1, i32 -1>
//CHECK: and <4 x i32> %{{.*}}, %{{.*}}
//CHECK: select <4 x i1> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}
return _mm_maskz_andnot_epi32(__U, __A, __B);
}
__m256i test_mm256_or_epi32 (__m256i __A, __m256i __B) {
//CHECK-LABEL: @test_mm256_or_epi32
//CHECK: or <8 x i32> %{{.*}}, %{{.*}}
return _mm256_or_epi32(__A, __B);
}
__m256i test_mm256_mask_or_epi32 (__m256i __W, __mmask8 __U, __m256i __A, __m256i __B) {
//CHECK-LABEL: @test_mm256_mask_or_epi32
//CHECK: or <8 x i32> %{{.*}}, %{{.*}}
//CHECK: select <8 x i1> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> %{{.*}}
return _mm256_mask_or_epi32(__W, __U, __A, __B);
}
__m256i test_mm256_maskz_or_epi32 (__mmask8 __U, __m256i __A, __m256i __B) {
//CHECK-LABEL: @test_mm256_maskz_or_epi32
//CHECK: or <8 x i32> %{{.*}}, %{{.*}}
//CHECK: select <8 x i1> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> %{{.*}}
return _mm256_maskz_or_epi32(__U, __A, __B);
}
__m128i test_mm_or_epi32 (__m128i __A, __m128i __B) {
//CHECK-LABEL: @test_mm_or_epi32
//CHECK: or <4 x i32> %{{.*}}, %{{.*}}
return _mm_or_epi32(__A, __B);
}
__m128i test_mm_mask_or_epi32 (__m128i __W, __mmask8 __U, __m128i __A, __m128i __B) {
//CHECK-LABEL: @test_mm_mask_or_epi32
//CHECK: or <4 x i32> %{{.*}}, %{{.*}}
//CHECK: select <4 x i1> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}
return _mm_mask_or_epi32(__W, __U, __A, __B);
}
__m128i test_mm_maskz_or_epi32 (__mmask8 __U, __m128i __A, __m128i __B) {
//CHECK-LABEL: @test_mm_maskz_or_epi32
//CHECK: or <4 x i32> %{{.*}}, %{{.*}}
//CHECK: select <4 x i1> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}
return _mm_maskz_or_epi32(__U, __A, __B);
}
__m256i test_mm256_xor_epi32 (__m256i __A, __m256i __B) {
//CHECK-LABEL: @test_mm256_xor_epi32
//CHECK: or <8 x i32> %{{.*}}, %{{.*}}
return _mm256_xor_epi32(__A, __B);
}
__m256i test_mm256_mask_xor_epi32 (__m256i __W, __mmask8 __U, __m256i __A, __m256i __B) {
//CHECK-LABEL: @test_mm256_mask_xor_epi32
//CHECK: xor <8 x i32> %{{.*}}, %{{.*}}
//CHECK: select <8 x i1> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> %{{.*}}
return _mm256_mask_xor_epi32(__W, __U, __A, __B);
}
__m256i test_mm256_maskz_xor_epi32 (__mmask8 __U, __m256i __A, __m256i __B) {
//CHECK-LABEL: @test_mm256_maskz_xor_epi32
//CHECK: xor <8 x i32> %{{.*}}, %{{.*}}
//CHECK: select <8 x i1> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> %{{.*}}
return _mm256_maskz_xor_epi32(__U, __A, __B);
}
__m128i test_mm_xor_epi32 (__m128i __A, __m128i __B) {
//CHECK-LABEL: @test_mm_xor_epi32
//CHECK: xor <4 x i32> %{{.*}}, %{{.*}}
return _mm_xor_epi32(__A, __B);
}
__m128i test_mm_mask_xor_epi32 (__m128i __W, __mmask8 __U, __m128i __A, __m128i __B) {
//CHECK-LABEL: @test_mm_mask_xor_epi32
//CHECK: xor <4 x i32> %{{.*}}, %{{.*}}
//CHECK: select <4 x i1> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}
return _mm_mask_xor_epi32(__W, __U, __A, __B);
}
__m128i test_mm_maskz_xor_epi32 (__mmask8 __U, __m128i __A, __m128i __B) {
//CHECK-LABEL: @test_mm_maskz_xor_epi32
//CHECK: xor <4 x i32> %{{.*}}, %{{.*}}
//CHECK: select <4 x i1> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}}
return _mm_maskz_xor_epi32(__U, __A, __B);
}
__m256i test_mm256_and_epi64 (__m256i __A, __m256i __B) {
//CHECK-LABEL: @test_mm256_and_epi64
//CHECK: and <4 x i64> %{{.*}}, %{{.*}}
return _mm256_and_epi64(__A, __B);
}
__m256i test_mm256_mask_and_epi64 (__m256i __W, __mmask8 __U, __m256i __A, __m256i __B) {
//CHECK-LABEL: @test_mm256_mask_and_epi64
//CHECK: and <4 x i64> %{{.*}}, %{{.*}}
//CHECK: select <4 x i1> %{{.*}}, <4 x i64> %{{.*}}, <4 x i64> %{{.*}}
return _mm256_mask_and_epi64(__W, __U, __A, __B);
}
__m256i test_mm256_maskz_and_epi64 (__mmask8 __U, __m256i __A, __m256i __B) {
//CHECK-LABEL: @test_mm256_maskz_and_epi64
//CHECK: and <4 x i64> %{{.*}}, %{{.*}}
//CHECK: select <4 x i1> %{{.*}}, <4 x i64> %{{.*}}, <4 x i64> %{{.*}}
return _mm256_maskz_and_epi64(__U, __A, __B);
}
__m128i test_mm_and_epi64 (__m128i __A, __m128i __B) {
//CHECK-LABEL: @test_mm_and_epi64
//CHECK: and <2 x i64> %{{.*}}, %{{.*}}
return _mm_and_epi64(__A, __B);
}
__m128i test_mm_mask_and_epi64 (__m128i __W, __mmask8 __U, __m128i __A, __m128i __B) {
//CHECK-LABEL: @test_mm_mask_and_epi64
//CHECK: and <2 x i64> %{{.*}}, %{{.*}}
//CHECK: select <2 x i1> %{{.*}}, <2 x i64> %{{.*}}, <2 x i64> %{{.*}}
return _mm_mask_and_epi64(__W,__U, __A, __B);
}
__m128i test_mm_maskz_and_epi64 (__mmask8 __U, __m128i __A, __m128i __B) {
//CHECK-LABEL: @test_mm_maskz_and_epi64
//CHECK: and <2 x i64> %{{.*}}, %{{.*}}
//CHECK: select <2 x i1> %{{.*}}, <2 x i64> %{{.*}}, <2 x i64> %{{.*}}
return _mm_maskz_and_epi64(__U, __A, __B);
}
__m256i test_mm256_andnot_epi64 (__m256i __A, __m256i __B) {
//CHECK-LABEL: @test_mm256_andnot_epi64
//CHECK: xor <4 x i64> %{{.*}}, <i64 -1, i64 -1, i64 -1, i64 -1>
//CHECK: and <4 x i64> %{{.*}}, %{{.*}}
return _mm256_andnot_epi64(__A, __B);
}
__m256i test_mm256_mask_andnot_epi64 (__m256i __W, __mmask8 __U, __m256i __A, __m256i __B) {
//CHECK-LABEL: @test_mm256_mask_andnot_epi64
//CHECK: xor <4 x i64> %{{.*}}, <i64 -1, i64 -1, i64 -1, i64 -1>
//CHECK: and <4 x i64> %{{.*}}, %{{.*}}
//CHECK: select <4 x i1> %{{.*}}, <4 x i64> %{{.*}}, <4 x i64> %{{.*}}
return _mm256_mask_andnot_epi64(__W, __U, __A, __B);
}
__m256i test_mm256_maskz_andnot_epi64 (__mmask8 __U, __m256i __A, __m256i __B) {
//CHECK-LABEL: @test_mm256_maskz_andnot_epi64
//CHECK: xor <4 x i64> %{{.*}}, <i64 -1, i64 -1, i64 -1, i64 -1>
//CHECK: and <4 x i64> %{{.*}}, %{{.*}}
//CHECK: select <4 x i1> %{{.*}}, <4 x i64> %{{.*}}, <4 x i64> %{{.*}}
return _mm256_maskz_andnot_epi64(__U, __A, __B);
}
__m128i test_mm_andnot_epi64 (__m128i __A, __m128i __B) {
//CHECK-LABEL: @test_mm_andnot_epi64
//CHECK: xor <2 x i64> %{{.*}}, <i64 -1, i64 -1>
//CHECK: and <2 x i64> %{{.*}}, %{{.*}}
return _mm_andnot_epi64(__A, __B);
}
__m128i test_mm_mask_andnot_epi64 (__m128i __W, __mmask8 __U, __m128i __A, __m128i __B) {
//CHECK-LABEL: @test_mm_mask_andnot_epi64
//CHECK: xor <2 x i64> %{{.*}}, <i64 -1, i64 -1>
//CHECK: and <2 x i64> %{{.*}}, %{{.*}}
//CHECK: select <2 x i1> %{{.*}}, <2 x i64> %{{.*}}, <2 x i64> %{{.*}}
return _mm_mask_andnot_epi64(__W,__U, __A, __B);
}
__m128i test_mm_maskz_andnot_epi64 (__mmask8 __U, __m128i __A, __m128i __B) {
//CHECK-LABEL: @test_mm_maskz_andnot_epi64
//CHECK: xor <2 x i64> %{{.*}}, <i64 -1, i64 -1>
//CHECK: and <2 x i64> %{{.*}}, %{{.*}}
//CHECK: select <2 x i1> %{{.*}}, <2 x i64> %{{.*}}, <2 x i64> %{{.*}}
return _mm_maskz_andnot_epi64(__U, __A, __B);
}
__m256i test_mm256_or_epi64 (__m256i __A, __m256i __B) {
//CHECK-LABEL: @test_mm256_or_epi64
//CHECK: or <4 x i64> %{{.*}}, %{{.*}}
return _mm256_or_epi64(__A, __B);
}
__m256i test_mm256_mask_or_epi64 (__m256i __W, __mmask8 __U, __m256i __A, __m256i __B) {
//CHECK-LABEL: @test_mm256_mask_or_epi64
//CHECK: or <4 x i64> %{{.*}}, %{{.*}}
//CHECK: select <4 x i1> %{{.*}}, <4 x i64> %{{.*}}, <4 x i64> %{{.*}}
return _mm256_mask_or_epi64(__W,__U, __A, __B);
}
__m256i test_mm256_maskz_or_epi64 (__mmask8 __U, __m256i __A, __m256i __B) {
//CHECK-LABEL: @test_mm256_maskz_or_epi64
//CHECK: or <4 x i64> %{{.*}}, %{{.*}}
//CHECK: select <4 x i1> %{{.*}}, <4 x i64> %{{.*}}, <4 x i64> %{{.*}}
return _mm256_maskz_or_epi64(__U, __A, __B);
}
__m128i test_mm_or_epi64 (__m128i __A, __m128i __B) {
//CHECK-LABEL: @test_mm_or_epi64
//CHECK: or <2 x i64> %{{.*}}, %{{.*}}
return _mm_or_epi64(__A, __B);
}
__m128i test_mm_mask_or_epi64 (__m128i __W, __mmask8 __U, __m128i __A, __m128i __B) {
//CHECK-LABEL: @test_mm_mask_or_epi64
//CHECK: or <2 x i64> %{{.*}}, %{{.*}}
//CHECK: select <2 x i1> %{{.*}}, <2 x i64> %{{.*}}, <2 x i64> %{{.*}}
return _mm_mask_or_epi64(__W, __U, __A, __B);
}
__m128i test_mm_maskz_or_epi64 (__mmask8 __U, __m128i __A, __m128i __B) {
//CHECK-LABEL: @test_mm_maskz_or_epi64
//CHECK: or <2 x i64> %{{.*}}, %{{.*}}
//CHECK: select <2 x i1> %{{.*}}, <2 x i64> %{{.*}}, <2 x i64> %{{.*}}
return _mm_maskz_or_epi64( __U, __A, __B);
}
__m256i test_mm256_xor_epi64 (__m256i __A, __m256i __B) {
//CHECK-LABEL: @test_mm256_xor_epi64
//CHECK: xor <4 x i64> %{{.*}}, %{{.*}}
return _mm256_xor_epi64(__A, __B);
}
__m256i test_mm256_mask_xor_epi64 (__m256i __W, __mmask8 __U, __m256i __A, __m256i __B) {
//CHECK-LABEL: @test_mm256_mask_xor_epi64
//CHECK: xor <4 x i64> %{{.*}}, %{{.*}}
//CHECK: select <4 x i1> %{{.*}}, <4 x i64> %{{.*}}, <4 x i64> %{{.*}}
return _mm256_mask_xor_epi64(__W,__U, __A, __B);
}
__m256i test_mm256_maskz_xor_epi64 (__mmask8 __U, __m256i __A, __m256i __B) {
//CHECK-LABEL: @test_mm256_maskz_xor_epi64
//CHECK: xor <4 x i64> %{{.*}}, %{{.*}}
//CHECK: select <4 x i1> %{{.*}}, <4 x i64> %{{.*}}, <4 x i64> %{{.*}}
return _mm256_maskz_xor_epi64(__U, __A, __B);
}
__m128i test_mm_xor_epi64 (__m128i __A, __m128i __B) {
//CHECK-LABEL: @test_mm_xor_epi64
//CHECK: xor <2 x i64> %{{.*}}, %{{.*}}
return _mm_xor_epi64(__A, __B);
}
__m128i test_mm_mask_xor_epi64 (__m128i __W, __mmask8 __U, __m128i __A, __m128i __B) {
//CHECK-LABEL: @test_mm_mask_xor_epi64
//CHECK: xor <2 x i64> %{{.*}}, %{{.*}}
//CHECK: select <2 x i1> %{{.*}}, <2 x i64> %{{.*}}, <2 x i64> %{{.*}}
return _mm_mask_xor_epi64(__W, __U, __A, __B);
}
__m128i test_mm_maskz_xor_epi64 (__mmask8 __U, __m128i __A, __m128i __B) {
//CHECK-LABEL: @test_mm_maskz_xor_epi64
//CHECK: xor <2 x i64> %{{.*}}, %{{.*}}
//CHECK: select <2 x i1> %{{.*}}, <2 x i64> %{{.*}}, <2 x i64> %{{.*}}
return _mm_maskz_xor_epi64( __U, __A, __B);
}
__mmask8 test_mm256_cmp_ps_mask_eq_oq(__m256 a, __m256 b) {
// CHECK-LABEL: @test_mm256_cmp_ps_mask_eq_oq
// CHECK: fcmp oeq <8 x float> %{{.*}}, %{{.*}}
return _mm256_cmp_ps_mask(a, b, _CMP_EQ_OQ);
}
__mmask8 test_mm256_cmp_ps_mask_lt_os(__m256 a, __m256 b) {
// CHECK-LABEL: test_mm256_cmp_ps_mask_lt_os
// CHECK: fcmp olt <8 x float> %{{.*}}, %{{.*}}
return _mm256_cmp_ps_mask(a, b, _CMP_LT_OS);
}
__mmask8 test_mm256_cmp_ps_mask_le_os(__m256 a, __m256 b) {
// CHECK-LABEL: test_mm256_cmp_ps_mask_le_os
// CHECK: fcmp ole <8 x float> %{{.*}}, %{{.*}}
return _mm256_cmp_ps_mask(a, b, _CMP_LE_OS);
}
__mmask8 test_mm256_cmp_ps_mask_unord_q(__m256 a, __m256 b) {
// CHECK-LABEL: test_mm256_cmp_ps_mask_unord_q
// CHECK: fcmp uno <8 x float> %{{.*}}, %{{.*}}
return _mm256_cmp_ps_mask(a, b, _CMP_UNORD_Q);
}
__mmask8 test_mm256_cmp_ps_mask_neq_uq(__m256 a, __m256 b) {
// CHECK-LABEL: test_mm256_cmp_ps_mask_neq_uq
// CHECK: fcmp une <8 x float> %{{.*}}, %{{.*}}
return _mm256_cmp_ps_mask(a, b, _CMP_NEQ_UQ);
}
__mmask8 test_mm256_cmp_ps_mask_nlt_us(__m256 a, __m256 b) {
// CHECK-LABEL: test_mm256_cmp_ps_mask_nlt_us
// CHECK: fcmp uge <8 x float> %{{.*}}, %{{.*}}
return _mm256_cmp_ps_mask(a, b, _CMP_NLT_US);
}
__mmask8 test_mm256_cmp_ps_mask_nle_us(__m256 a, __m256 b) {
// CHECK-LABEL: test_mm256_cmp_ps_mask_nle_us
// CHECK: fcmp ugt <8 x float> %{{.*}}, %{{.*}}
return _mm256_cmp_ps_mask(a, b, _CMP_NLE_US);
}
__mmask8 test_mm256_cmp_ps_mask_ord_q(__m256 a, __m256 b) {
// CHECK-LABEL: test_mm256_cmp_ps_mask_ord_q
// CHECK: fcmp ord <8 x float> %{{.*}}, %{{.*}}
return _mm256_cmp_ps_mask(a, b, _CMP_ORD_Q);
}
__mmask8 test_mm256_cmp_ps_mask_eq_uq(__m256 a, __m256 b) {
// CHECK-LABEL: test_mm256_cmp_ps_mask_eq_uq
// CHECK: fcmp ueq <8 x float> %{{.*}}, %{{.*}}
return _mm256_cmp_ps_mask(a, b, _CMP_EQ_UQ);
}
__mmask8 test_mm256_cmp_ps_mask_nge_us(__m256 a, __m256 b) {
// CHECK-LABEL: test_mm256_cmp_ps_mask_nge_us
// CHECK: fcmp ult <8 x float> %{{.*}}, %{{.*}}
return _mm256_cmp_ps_mask(a, b, _CMP_NGE_US);
}
__mmask8 test_mm256_cmp_ps_mask_ngt_us(__m256 a, __m256 b) {
// CHECK-LABEL: test_mm256_cmp_ps_mask_ngt_us
// CHECK: fcmp ule <8 x float> %{{.*}}, %{{.*}}
return _mm256_cmp_ps_mask(a, b, _CMP_NGT_US);
}
__mmask8 test_mm256_cmp_ps_mask_false_oq(__m256 a, __m256 b) {
// CHECK-LABEL: test_mm256_cmp_ps_mask_false_oq
// CHECK: fcmp false <8 x float> %{{.*}}, %{{.*}}
return _mm256_cmp_ps_mask(a, b, _CMP_FALSE_OQ);
}
__mmask8 test_mm256_cmp_ps_mask_neq_oq(__m256 a, __m256 b) {
// CHECK-LABEL: test_mm256_cmp_ps_mask_neq_oq
// CHECK: fcmp one <8 x float> %{{.*}}, %{{.*}}
return _mm256_cmp_ps_mask(a, b, _CMP_NEQ_OQ);
}
__mmask8 test_mm256_cmp_ps_mask_ge_os(__m256 a, __m256 b) {
// CHECK-LABEL: test_mm256_cmp_ps_mask_ge_os
// CHECK: fcmp oge <8 x float> %{{.*}}, %{{.*}}
return _mm256_cmp_ps_mask(a, b, _CMP_GE_OS);
}
__mmask8 test_mm256_cmp_ps_mask_gt_os(__m256 a, __m256 b) {
// CHECK-LABEL: test_mm256_cmp_ps_mask_gt_os
// CHECK: fcmp ogt <8 x float> %{{.*}}, %{{.*}}
return _mm256_cmp_ps_mask(a, b, _CMP_GT_OS);
}
__mmask8 test_mm256_cmp_ps_mask_true_uq(__m256 a, __m256 b) {
// CHECK-LABEL: test_mm256_cmp_ps_mask_true_uq
// CHECK: fcmp true <8 x float> %{{.*}}, %{{.*}}
return _mm256_cmp_ps_mask(a, b, _CMP_TRUE_UQ);
}
__mmask8 test_mm256_cmp_ps_mask_eq_os(__m256 a, __m256 b) {
// CHECK-LABEL: test_mm256_cmp_ps_mask_eq_os
// CHECK: fcmp oeq <8 x float> %{{.*}}, %{{.*}}
return _mm256_cmp_ps_mask(a, b, _CMP_EQ_OS);
}
__mmask8 test_mm256_cmp_ps_mask_lt_oq(__m256 a, __m256 b) {
// CHECK-LABEL: test_mm256_cmp_ps_mask_lt_oq
// CHECK: fcmp olt <8 x float> %{{.*}}, %{{.*}}
return _mm256_cmp_ps_mask(a, b, _CMP_LT_OQ);
}
__mmask8 test_mm256_cmp_ps_mask_le_oq(__m256 a, __m256 b) {
// CHECK-LABEL: test_mm256_cmp_ps_mask_le_oq
// CHECK: fcmp ole <8 x float> %{{.*}}, %{{.*}}
return _mm256_cmp_ps_mask(a, b, _CMP_LE_OQ);
}
__mmask8 test_mm256_cmp_ps_mask_unord_s(__m256 a, __m256 b) {
// CHECK-LABEL: test_mm256_cmp_ps_mask_unord_s
// CHECK: fcmp uno <8 x float> %{{.*}}, %{{.*}}
return _mm256_cmp_ps_mask(a, b, _CMP_UNORD_S);
}
__mmask8 test_mm256_cmp_ps_mask_neq_us(__m256 a, __m256 b) {
// CHECK-LABEL: test_mm256_cmp_ps_mask_neq_us
// CHECK: fcmp une <8 x float> %{{.*}}, %{{.*}}
return _mm256_cmp_ps_mask(a, b, _CMP_NEQ_US);
}
__mmask8 test_mm256_cmp_ps_mask_nlt_uq(__m256 a, __m256 b) {
// CHECK-LABEL: test_mm256_cmp_ps_mask_nlt_uq
// CHECK: fcmp uge <8 x float> %{{.*}}, %{{.*}}
return _mm256_cmp_ps_mask(a, b, _CMP_NLT_UQ);
}
__mmask8 test_mm256_cmp_ps_mask_nle_uq(__m256 a, __m256 b) {
// CHECK-LABEL: test_mm256_cmp_ps_mask_nle_uq
// CHECK: fcmp ugt <8 x float> %{{.*}}, %{{.*}}
return _mm256_cmp_ps_mask(a, b, _CMP_NLE_UQ);
}
__mmask8 test_mm256_cmp_ps_mask_ord_s(__m256 a, __m256 b) {
// CHECK-LABEL: test_mm256_cmp_ps_mask_ord_s
// CHECK: fcmp ord <8 x float> %{{.*}}, %{{.*}}
return _mm256_cmp_ps_mask(a, b, _CMP_ORD_S);
}
__mmask8 test_mm256_cmp_ps_mask_eq_us(__m256 a, __m256 b) {
// CHECK-LABEL: test_mm256_cmp_ps_mask_eq_us
// CHECK: fcmp ueq <8 x float> %{{.*}}, %{{.*}}
return _mm256_cmp_ps_mask(a, b, _CMP_EQ_US);
}
__mmask8 test_mm256_cmp_ps_mask_nge_uq(__m256 a, __m256 b) {
// CHECK-LABEL: test_mm256_cmp_ps_mask_nge_uq
// CHECK: fcmp ult <8 x float> %{{.*}}, %{{.*}}
return _mm256_cmp_ps_mask(a, b, _CMP_NGE_UQ);
}
__mmask8 test_mm256_cmp_ps_mask_ngt_uq(__m256 a, __m256 b) {
// CHECK-LABEL: test_mm256_cmp_ps_mask_ngt_uq
// CHECK: fcmp ule <8 x float> %{{.*}}, %{{.*}}
return _mm256_cmp_ps_mask(a, b, _CMP_NGT_UQ);
}
__mmask8 test_mm256_cmp_ps_mask_false_os(__m256 a, __m256 b) {
// CHECK-LABEL: test_mm256_cmp_ps_mask_false_os
// CHECK: fcmp false <8 x float> %{{.*}}, %{{.*}}
return _mm256_cmp_ps_mask(a, b, _CMP_FALSE_OS);
}
__mmask8 test_mm256_cmp_ps_mask_neq_os(__m256 a, __m256 b) {
// CHECK-LABEL: test_mm256_cmp_ps_mask_neq_os
// CHECK: fcmp one <8 x float> %{{.*}}, %{{.*}}
return _mm256_cmp_ps_mask(a, b, _CMP_NEQ_OS);
}
__mmask8 test_mm256_cmp_ps_mask_ge_oq(__m256 a, __m256 b) {
// CHECK-LABEL: test_mm256_cmp_ps_mask_ge_oq
// CHECK: fcmp oge <8 x float> %{{.*}}, %{{.*}}
return _mm256_cmp_ps_mask(a, b, _CMP_GE_OQ);
}
__mmask8 test_mm256_cmp_ps_mask_gt_oq(__m256 a, __m256 b) {
// CHECK-LABEL: test_mm256_cmp_ps_mask_gt_oq
// CHECK: fcmp ogt <8 x float> %{{.*}}, %{{.*}}
return _mm256_cmp_ps_mask(a, b, _CMP_GT_OQ);
}
__mmask8 test_mm256_cmp_ps_mask_true_us(__m256 a, __m256 b) {
// CHECK-LABEL: test_mm256_cmp_ps_mask_true_us
// CHECK: fcmp true <8 x float> %{{.*}}, %{{.*}}
return _mm256_cmp_ps_mask(a, b, _CMP_TRUE_US);
}
__mmask8 test_mm256_mask_cmp_ps_mask_eq_oq(__mmask8 m, __m256 a, __m256 b) {
// CHECK-LABEL: @test_mm256_mask_cmp_ps_mask_eq_oq
// CHECK: [[CMP:%.*]] = fcmp oeq <8 x float> %{{.*}}, %{{.*}}
// CHECK: and <8 x i1> [[CMP]], {{.*}}
return _mm256_mask_cmp_ps_mask(m, a, b, _CMP_EQ_OQ);
}
__mmask8 test_mm256_mask_cmp_ps_mask_lt_os(__mmask8 m, __m256 a, __m256 b) {
// CHECK-LABEL: test_mm256_mask_cmp_ps_mask_lt_os
// CHECK: [[CMP:%.*]] = fcmp olt <8 x float> %{{.*}}, %{{.*}}
// CHECK: and <8 x i1> [[CMP]], {{.*}}
return _mm256_mask_cmp_ps_mask(m, a, b, _CMP_LT_OS);
}
__mmask8 test_mm256_mask_cmp_ps_mask_le_os(__mmask8 m, __m256 a, __m256 b) {
// CHECK-LABEL: test_mm256_mask_cmp_ps_mask_le_os
// CHECK: [[CMP:%.*]] = fcmp ole <8 x float> %{{.*}}, %{{.*}}
// CHECK: and <8 x i1> [[CMP]], {{.*}}
return _mm256_mask_cmp_ps_mask(m, a, b, _CMP_LE_OS);
}
__mmask8 test_mm256_mask_cmp_ps_mask_unord_q(__mmask8 m, __m256 a, __m256 b) {
// CHECK-LABEL: test_mm256_mask_cmp_ps_mask_unord_q
// CHECK: [[CMP:%.*]] = fcmp uno <8 x float> %{{.*}}, %{{.*}}
// CHECK: and <8 x i1> [[CMP]], {{.*}}
return _mm256_mask_cmp_ps_mask(m, a, b, _CMP_UNORD_Q);
}
__mmask8 test_mm256_mask_cmp_ps_mask_neq_uq(__mmask8 m, __m256 a, __m256 b) {
// CHECK-LABEL: test_mm256_mask_cmp_ps_mask_neq_uq
// CHECK: [[CMP:%.*]] = fcmp une <8 x float> %{{.*}}, %{{.*}}
// CHECK: and <8 x i1> [[CMP]], {{.*}}
return _mm256_mask_cmp_ps_mask(m, a, b, _CMP_NEQ_UQ);
}
__mmask8 test_mm256_mask_cmp_ps_mask_nlt_us(__mmask8 m, __m256 a, __m256 b) {
// CHECK-LABEL: test_mm256_mask_cmp_ps_mask_nlt_us
// CHECK: [[CMP:%.*]] = fcmp uge <8 x float> %{{.*}}, %{{.*}}
// CHECK: and <8 x i1> [[CMP]], {{.*}}
return _mm256_mask_cmp_ps_mask(m, a, b, _CMP_NLT_US);
}
__mmask8 test_mm256_mask_cmp_ps_mask_nle_us(__mmask8 m, __m256 a, __m256 b) {
// CHECK-LABEL: test_mm256_mask_cmp_ps_mask_nle_us
// CHECK: [[CMP:%.*]] = fcmp ugt <8 x float> %{{.*}}, %{{.*}}
// CHECK: and <8 x i1> [[CMP]], {{.*}}
return _mm256_mask_cmp_ps_mask(m, a, b, _CMP_NLE_US);
}
__mmask8 test_mm256_mask_cmp_ps_mask_ord_q(__mmask8 m, __m256 a, __m256 b) {
// CHECK-LABEL: test_mm256_mask_cmp_ps_mask_ord_q
// CHECK: [[CMP:%.*]] = fcmp ord <8 x float> %{{.*}}, %{{.*}}
// CHECK: and <8 x i1> [[CMP]], {{.*}}
return _mm256_mask_cmp_ps_mask(m, a, b, _CMP_ORD_Q);
}
__mmask8 test_mm256_mask_cmp_ps_mask_eq_uq(__mmask8 m, __m256 a, __m256 b) {
// CHECK-LABEL: test_mm256_mask_cmp_ps_mask_eq_uq
// CHECK: [[CMP:%.*]] = fcmp ueq <8 x float> %{{.*}}, %{{.*}}
// CHECK: and <8 x i1> [[CMP]], {{.*}}
return _mm256_mask_cmp_ps_mask(m, a, b, _CMP_EQ_UQ);
}
__mmask8 test_mm256_mask_cmp_ps_mask_nge_us(__mmask8 m, __m256 a, __m256 b) {
// CHECK-LABEL: test_mm256_mask_cmp_ps_mask_nge_us
// CHECK: [[CMP:%.*]] = fcmp ult <8 x float> %{{.*}}, %{{.*}}
// CHECK: and <8 x i1> [[CMP]], {{.*}}
return _mm256_mask_cmp_ps_mask(m, a, b, _CMP_NGE_US);
}
__mmask8 test_mm256_mask_cmp_ps_mask_ngt_us(__mmask8 m, __m256 a, __m256 b) {
// CHECK-LABEL: test_mm256_mask_cmp_ps_mask_ngt_us
// CHECK: [[CMP:%.*]] = fcmp ule <8 x float> %{{.*}}, %{{.*}}
// CHECK: and <8 x i1> [[CMP]], {{.*}}
return _mm256_mask_cmp_ps_mask(m, a, b, _CMP_NGT_US);
}
__mmask8 test_mm256_mask_cmp_ps_mask_false_oq(__mmask8 m, __m256 a, __m256 b) {
// CHECK-LABEL: test_mm256_mask_cmp_ps_mask_false_oq
// CHECK: [[CMP:%.*]] = fcmp false <8 x float> %{{.*}}, %{{.*}}
// CHECK: and <8 x i1> [[CMP]], {{.*}}
return _mm256_mask_cmp_ps_mask(m, a, b, _CMP_FALSE_OQ);
}
__mmask8 test_mm256_mask_cmp_ps_mask_neq_oq(__mmask8 m, __m256 a, __m256 b) {
// CHECK-LABEL: test_mm256_mask_cmp_ps_mask_neq_oq
// CHECK: [[CMP:%.*]] = fcmp one <8 x float> %{{.*}}, %{{.*}}
// CHECK: and <8 x i1> [[CMP]], {{.*}}
return _mm256_mask_cmp_ps_mask(m, a, b, _CMP_NEQ_OQ);
}
__mmask8 test_mm256_mask_cmp_ps_mask_ge_os(__mmask8 m, __m256 a, __m256 b) {
// CHECK-LABEL: test_mm256_mask_cmp_ps_mask_ge_os
// CHECK: [[CMP:%.*]] = fcmp oge <8 x float> %{{.*}}, %{{.*}}
// CHECK: and <8 x i1> [[CMP]], {{.*}}
return _mm256_mask_cmp_ps_mask(m, a, b, _CMP_GE_OS);
}
__mmask8 test_mm256_mask_cmp_ps_mask_gt_os(__mmask8 m, __m256 a, __m256 b) {
// CHECK-LABEL: test_mm256_mask_cmp_ps_mask_gt_os
// CHECK: [[CMP:%.*]] = fcmp ogt <8 x float> %{{.*}}, %{{.*}}
// CHECK: and <8 x i1> [[CMP]], {{.*}}
return _mm256_mask_cmp_ps_mask(m, a, b, _CMP_GT_OS);
}
__mmask8 test_mm256_mask_cmp_ps_mask_true_uq(__mmask8 m, __m256 a, __m256 b) {
// CHECK-LABEL: test_mm256_mask_cmp_ps_mask_true_uq
// CHECK: [[CMP:%.*]] = fcmp true <8 x float> %{{.*}}, %{{.*}}
// CHECK: and <8 x i1> [[CMP]], {{.*}}
return _mm256_mask_cmp_ps_mask(m, a, b, _CMP_TRUE_UQ);
}
__mmask8 test_mm256_mask_cmp_ps_mask_eq_os(__mmask8 m, __m256 a, __m256 b) {
// CHECK-LABEL: test_mm256_mask_cmp_ps_mask_eq_os
// CHECK: [[CMP:%.*]] = fcmp oeq <8 x float> %{{.*}}, %{{.*}}
// CHECK: and <8 x i1> [[CMP]], {{.*}}
return _mm256_mask_cmp_ps_mask(m, a, b, _CMP_EQ_OS);
}
__mmask8 test_mm256_mask_cmp_ps_mask_lt_oq(__mmask8 m, __m256 a, __m256 b) {
// CHECK-LABEL: test_mm256_mask_cmp_ps_mask_lt_oq
// CHECK: [[CMP:%.*]] = fcmp olt <8 x float> %{{.*}}, %{{.*}}
// CHECK: and <8 x i1> [[CMP]], {{.*}}
return _mm256_mask_cmp_ps_mask(m, a, b, _CMP_LT_OQ);
}
__mmask8 test_mm256_mask_cmp_ps_mask_le_oq(__mmask8 m, __m256 a, __m256 b) {
// CHECK-LABEL: test_mm256_mask_cmp_ps_mask_le_oq
// CHECK: [[CMP:%.*]] = fcmp ole <8 x float> %{{.*}}, %{{.*}}
// CHECK: and <8 x i1> [[CMP]], {{.*}}
return _mm256_mask_cmp_ps_mask(m, a, b, _CMP_LE_OQ);
}
__mmask8 test_mm256_mask_cmp_ps_mask_unord_s(__mmask8 m, __m256 a, __m256 b) {
// CHECK-LABEL: test_mm256_mask_cmp_ps_mask_unord_s
// CHECK: [[CMP:%.*]] = fcmp uno <8 x float> %{{.*}}, %{{.*}}
// CHECK: and <8 x i1> [[CMP]], {{.*}}
return _mm256_mask_cmp_ps_mask(m, a, b, _CMP_UNORD_S);
}
__mmask8 test_mm256_mask_cmp_ps_mask_neq_us(__mmask8 m, __m256 a, __m256 b) {
// CHECK-LABEL: test_mm256_mask_cmp_ps_mask_neq_us
// CHECK: [[CMP:%.*]] = fcmp une <8 x float> %{{.*}}, %{{.*}}
// CHECK: and <8 x i1> [[CMP]], {{.*}}
return _mm256_mask_cmp_ps_mask(m, a, b, _CMP_NEQ_US);
}
__mmask8 test_mm256_mask_cmp_ps_mask_nlt_uq(__mmask8 m, __m256 a, __m256 b) {
// CHECK-LABEL: test_mm256_mask_cmp_ps_mask_nlt_uq
// CHECK: [[CMP:%.*]] = fcmp uge <8 x float> %{{.*}}, %{{.*}}
// CHECK: and <8 x i1> [[CMP]], {{.*}}
return _mm256_mask_cmp_ps_mask(m, a, b, _CMP_NLT_UQ);
}
__mmask8 test_mm256_mask_cmp_ps_mask_nle_uq(__mmask8 m, __m256 a, __m256 b) {
// CHECK-LABEL: test_mm256_mask_cmp_ps_mask_nle_uq
// CHECK: [[CMP:%.*]] = fcmp ugt <8 x float> %{{.*}}, %{{.*}}
// CHECK: and <8 x i1> [[CMP]], {{.*}}
return _mm256_mask_cmp_ps_mask(m, a, b, _CMP_NLE_UQ);
}
__mmask8 test_mm256_mask_cmp_ps_mask_ord_s(__mmask8 m, __m256 a, __m256 b) {
// CHECK-LABEL: test_mm256_mask_cmp_ps_mask_ord_s
// CHECK: [[CMP:%.*]] = fcmp ord <8 x float> %{{.*}}, %{{.*}}
// CHECK: and <8 x i1> [[CMP]], {{.*}}
return _mm256_mask_cmp_ps_mask(m, a, b, _CMP_ORD_S);
}
__mmask8 test_mm256_mask_cmp_ps_mask_eq_us(__mmask8 m, __m256 a, __m256 b) {
// CHECK-LABEL: test_mm256_mask_cmp_ps_mask_eq_us
// CHECK: [[CMP:%.*]] = fcmp ueq <8 x float> %{{.*}}, %{{.*}}
// CHECK: and <8 x i1> [[CMP]], {{.*}}
return _mm256_mask_cmp_ps_mask(m, a, b, _CMP_EQ_US);
}
__mmask8 test_mm256_mask_cmp_ps_mask_nge_uq(__mmask8 m, __m256 a, __m256 b) {
// CHECK-LABEL: test_mm256_mask_cmp_ps_mask_nge_uq
// CHECK: [[CMP:%.*]] = fcmp ult <8 x float> %{{.*}}, %{{.*}}
// CHECK: and <8 x i1> [[CMP]], {{.*}}
return _mm256_mask_cmp_ps_mask(m, a, b, _CMP_NGE_UQ);
}
__mmask8 test_mm256_mask_cmp_ps_mask_ngt_uq(__mmask8 m, __m256 a, __m256 b) {
// CHECK-LABEL: test_mm256_mask_cmp_ps_mask_ngt_uq
// CHECK: [[CMP:%.*]] = fcmp ule <8 x float> %{{.*}}, %{{.*}}
// CHECK: and <8 x i1> [[CMP]], {{.*}}
return _mm256_mask_cmp_ps_mask(m, a, b, _CMP_NGT_UQ);
}
__mmask8 test_mm256_mask_cmp_ps_mask_false_os(__mmask8 m, __m256 a, __m256 b) {
// CHECK-LABEL: test_mm256_mask_cmp_ps_mask_false_os
// CHECK: [[CMP:%.*]] = fcmp false <8 x float> %{{.*}}, %{{.*}}
// CHECK: and <8 x i1> [[CMP]], {{.*}}
return _mm256_mask_cmp_ps_mask(m, a, b, _CMP_FALSE_OS);
}
__mmask8 test_mm256_mask_cmp_ps_mask_neq_os(__mmask8 m, __m256 a, __m256 b) {
// CHECK-LABEL: test_mm256_mask_cmp_ps_mask_neq_os
// CHECK: [[CMP:%.*]] = fcmp one <8 x float> %{{.*}}, %{{.*}}
// CHECK: and <8 x i1> [[CMP]], {{.*}}
return _mm256_mask_cmp_ps_mask(m, a, b, _CMP_NEQ_OS);
}
__mmask8 test_mm256_mask_cmp_ps_mask_ge_oq(__mmask8 m, __m256 a, __m256 b) {
// CHECK-LABEL: test_mm256_mask_cmp_ps_mask_ge_oq
// CHECK: [[CMP:%.*]] = fcmp oge <8 x float> %{{.*}}, %{{.*}}
// CHECK: and <8 x i1> [[CMP]], {{.*}}
return _mm256_mask_cmp_ps_mask(m, a, b, _CMP_GE_OQ);
}
__mmask8 test_mm256_mask_cmp_ps_mask_gt_oq(__mmask8 m, __m256 a, __m256 b) {
// CHECK-LABEL: test_mm256_mask_cmp_ps_mask_gt_oq
// CHECK: [[CMP:%.*]] = fcmp ogt <8 x float> %{{.*}}, %{{.*}}
// CHECK: and <8 x i1> [[CMP]], {{.*}}
return _mm256_mask_cmp_ps_mask(m, a, b, _CMP_GT_OQ);
}
__mmask8 test_mm256_mask_cmp_ps_mask_true_us(__mmask8 m, __m256 a, __m256 b) {
// CHECK-LABEL: test_mm256_mask_cmp_ps_mask_true_us
// CHECK: [[CMP:%.*]] = fcmp true <8 x float> %{{.*}}, %{{.*}}
// CHECK: and <8 x i1> [[CMP]], {{.*}}
return _mm256_mask_cmp_ps_mask(m, a, b, _CMP_TRUE_US);
}
__mmask8 test_mm256_cmp_pd_mask_eq_oq(__m256d a, __m256d b) {
// CHECK-LABEL: @test_mm256_cmp_pd_mask_eq_oq
// CHECK: fcmp oeq <4 x double> %{{.*}}, %{{.*}}
return _mm256_cmp_pd_mask(a, b, _CMP_EQ_OQ);
}
__mmask8 test_mm256_cmp_pd_mask_lt_os(__m256d a, __m256d b) {
// CHECK-LABEL: test_mm256_cmp_pd_mask_lt_os
// CHECK: fcmp olt <4 x double> %{{.*}}, %{{.*}}
return _mm256_cmp_pd_mask(a, b, _CMP_LT_OS);
}
__mmask8 test_mm256_cmp_pd_mask_le_os(__m256d a, __m256d b) {
// CHECK-LABEL: test_mm256_cmp_pd_mask_le_os
// CHECK: fcmp ole <4 x double> %{{.*}}, %{{.*}}
return _mm256_cmp_pd_mask(a, b, _CMP_LE_OS);
}
__mmask8 test_mm256_cmp_pd_mask_unord_q(__m256d a, __m256d b) {
// CHECK-LABEL: test_mm256_cmp_pd_mask_unord_q
// CHECK: fcmp uno <4 x double> %{{.*}}, %{{.*}}
return _mm256_cmp_pd_mask(a, b, _CMP_UNORD_Q);
}
__mmask8 test_mm256_cmp_pd_mask_neq_uq(__m256d a, __m256d b) {
// CHECK-LABEL: test_mm256_cmp_pd_mask_neq_uq
// CHECK: fcmp une <4 x double> %{{.*}}, %{{.*}}
return _mm256_cmp_pd_mask(a, b, _CMP_NEQ_UQ);
}
__mmask8 test_mm256_cmp_pd_mask_nlt_us(__m256d a, __m256d b) {
// CHECK-LABEL: test_mm256_cmp_pd_mask_nlt_us
// CHECK: fcmp uge <4 x double> %{{.*}}, %{{.*}}
return _mm256_cmp_pd_mask(a, b, _CMP_NLT_US);
}
__mmask8 test_mm256_cmp_pd_mask_nle_us(__m256d a, __m256d b) {
// CHECK-LABEL: test_mm256_cmp_pd_mask_nle_us
// CHECK: fcmp ugt <4 x double> %{{.*}}, %{{.*}}
return _mm256_cmp_pd_mask(a, b, _CMP_NLE_US);
}
__mmask8 test_mm256_cmp_pd_mask_ord_q(__m256d a, __m256d b) {
// CHECK-LABEL: test_mm256_cmp_pd_mask_ord_q
// CHECK: fcmp ord <4 x double> %{{.*}}, %{{.*}}
return _mm256_cmp_pd_mask(a, b, _CMP_ORD_Q);
}
__mmask8 test_mm256_cmp_pd_mask_eq_uq(__m256d a, __m256d b) {
// CHECK-LABEL: test_mm256_cmp_pd_mask_eq_uq
// CHECK: fcmp ueq <4 x double> %{{.*}}, %{{.*}}
return _mm256_cmp_pd_mask(a, b, _CMP_EQ_UQ);
}
__mmask8 test_mm256_cmp_pd_mask_nge_us(__m256d a, __m256d b) {
// CHECK-LABEL: test_mm256_cmp_pd_mask_nge_us
// CHECK: fcmp ult <4 x double> %{{.*}}, %{{.*}}
return _mm256_cmp_pd_mask(a, b, _CMP_NGE_US);
}
__mmask8 test_mm256_cmp_pd_mask_ngt_us(__m256d a, __m256d b) {
// CHECK-LABEL: test_mm256_cmp_pd_mask_ngt_us
// CHECK: fcmp ule <4 x double> %{{.*}}, %{{.*}}
return _mm256_cmp_pd_mask(a, b, _CMP_NGT_US);
}
__mmask8 test_mm256_cmp_pd_mask_false_oq(__m256d a, __m256d b) {
// CHECK-LABEL: test_mm256_cmp_pd_mask_false_oq
// CHECK: fcmp false <4 x double> %{{.*}}, %{{.*}}
return _mm256_cmp_pd_mask(a, b, _CMP_FALSE_OQ);
}
__mmask8 test_mm256_cmp_pd_mask_neq_oq(__m256d a, __m256d b) {
// CHECK-LABEL: test_mm256_cmp_pd_mask_neq_oq
// CHECK: fcmp one <4 x double> %{{.*}}, %{{.*}}
return _mm256_cmp_pd_mask(a, b, _CMP_NEQ_OQ);
}
__mmask8 test_mm256_cmp_pd_mask_ge_os(__m256d a, __m256d b) {
// CHECK-LABEL: test_mm256_cmp_pd_mask_ge_os
// CHECK: fcmp oge <4 x double> %{{.*}}, %{{.*}}
return _mm256_cmp_pd_mask(a, b, _CMP_GE_OS);
}
__mmask8 test_mm256_cmp_pd_mask_gt_os(__m256d a, __m256d b) {
// CHECK-LABEL: test_mm256_cmp_pd_mask_gt_os
// CHECK: fcmp ogt <4 x double> %{{.*}}, %{{.*}}
return _mm256_cmp_pd_mask(a, b, _CMP_GT_OS);
}
__mmask8 test_mm256_cmp_pd_mask_true_uq(__m256d a, __m256d b) {
// CHECK-LABEL: test_mm256_cmp_pd_mask_true_uq
// CHECK: fcmp true <4 x double> %{{.*}}, %{{.*}}
return _mm256_cmp_pd_mask(a, b, _CMP_TRUE_UQ);
}
__mmask8 test_mm256_cmp_pd_mask_eq_os(__m256d a, __m256d b) {
// CHECK-LABEL: test_mm256_cmp_pd_mask_eq_os
// CHECK: fcmp oeq <4 x double> %{{.*}}, %{{.*}}
return _mm256_cmp_pd_mask(a, b, _CMP_EQ_OS);
}
__mmask8 test_mm256_cmp_pd_mask_lt_oq(__m256d a, __m256d b) {
// CHECK-LABEL: test_mm256_cmp_pd_mask_lt_oq
// CHECK: fcmp olt <4 x double> %{{.*}}, %{{.*}}
return _mm256_cmp_pd_mask(a, b, _CMP_LT_OQ);
}
__mmask8 test_mm256_cmp_pd_mask_le_oq(__m256d a, __m256d b) {
// CHECK-LABEL: test_mm256_cmp_pd_mask_le_oq
// CHECK: fcmp ole <4 x double> %{{.*}}, %{{.*}}
return _mm256_cmp_pd_mask(a, b, _CMP_LE_OQ);
}
__mmask8 test_mm256_cmp_pd_mask_unord_s(__m256d a, __m256d b) {
// CHECK-LABEL: test_mm256_cmp_pd_mask_unord_s
// CHECK: fcmp uno <4 x double> %{{.*}}, %{{.*}}
return _mm256_cmp_pd_mask(a, b, _CMP_UNORD_S);
}
__mmask8 test_mm256_cmp_pd_mask_neq_us(__m256d a, __m256d b) {
// CHECK-LABEL: test_mm256_cmp_pd_mask_neq_us
// CHECK: fcmp une <4 x double> %{{.*}}, %{{.*}}
return _mm256_cmp_pd_mask(a, b, _CMP_NEQ_US);
}
__mmask8 test_mm256_cmp_pd_mask_nlt_uq(__m256d a, __m256d b) {
// CHECK-LABEL: test_mm256_cmp_pd_mask_nlt_uq
// CHECK: fcmp uge <4 x double> %{{.*}}, %{{.*}}
return _mm256_cmp_pd_mask(a, b, _CMP_NLT_UQ);
}
__mmask8 test_mm256_cmp_pd_mask_nle_uq(__m256d a, __m256d b) {
// CHECK-LABEL: test_mm256_cmp_pd_mask_nle_uq
// CHECK: fcmp ugt <4 x double> %{{.*}}, %{{.*}}
return _mm256_cmp_pd_mask(a, b, _CMP_NLE_UQ);
}
__mmask8 test_mm256_cmp_pd_mask_ord_s(__m256d a, __m256d b) {
// CHECK-LABEL: test_mm256_cmp_pd_mask_ord_s
// CHECK: fcmp ord <4 x double> %{{.*}}, %{{.*}}
return _mm256_cmp_pd_mask(a, b, _CMP_ORD_S);
}
__mmask8 test_mm256_cmp_pd_mask_eq_us(__m256d a, __m256d b) {
// CHECK-LABEL: test_mm256_cmp_pd_mask_eq_us
// CHECK: fcmp ueq <4 x double> %{{.*}}, %{{.*}}
return _mm256_cmp_pd_mask(a, b, _CMP_EQ_US);
}
__mmask8 test_mm256_cmp_pd_mask_nge_uq(__m256d a, __m256d b) {
// CHECK-LABEL: test_mm256_cmp_pd_mask_nge_uq
// CHECK: fcmp ult <4 x double> %{{.*}}, %{{.*}}
return _mm256_cmp_pd_mask(a, b, _CMP_NGE_UQ);
}
__mmask8 test_mm256_cmp_pd_mask_ngt_uq(__m256d a, __m256d b) {
// CHECK-LABEL: test_mm256_cmp_pd_mask_ngt_uq
// CHECK: fcmp ule <4 x double> %{{.*}}, %{{.*}}
return _mm256_cmp_pd_mask(a, b, _CMP_NGT_UQ);
}
__mmask8 test_mm256_cmp_pd_mask_false_os(__m256d a, __m256d b) {
// CHECK-LABEL: test_mm256_cmp_pd_mask_false_os
// CHECK: fcmp false <4 x double> %{{.*}}, %{{.*}}
return _mm256_cmp_pd_mask(a, b, _CMP_FALSE_OS);
}
__mmask8 test_mm256_cmp_pd_mask_neq_os(__m256d a, __m256d b) {
// CHECK-LABEL: test_mm256_cmp_pd_mask_neq_os
// CHECK: fcmp one <4 x double> %{{.*}}, %{{.*}}
return _mm256_cmp_pd_mask(a, b, _CMP_NEQ_OS);
}
__mmask8 test_mm256_cmp_pd_mask_ge_oq(__m256d a, __m256d b) {
// CHECK-LABEL: test_mm256_cmp_pd_mask_ge_oq
// CHECK: fcmp oge <4 x double> %{{.*}}, %{{.*}}
return _mm256_cmp_pd_mask(a, b, _CMP_GE_OQ);
}
__mmask8 test_mm256_cmp_pd_mask_gt_oq(__m256d a, __m256d b) {
// CHECK-LABEL: test_mm256_cmp_pd_mask_gt_oq
// CHECK: fcmp ogt <4 x double> %{{.*}}, %{{.*}}
return _mm256_cmp_pd_mask(a, b, _CMP_GT_OQ);
}
__mmask8 test_mm256_cmp_pd_mask_true_us(__m256d a, __m256d b) {
// CHECK-LABEL: test_mm256_cmp_pd_mask_true_us
// CHECK: fcmp true <4 x double> %{{.*}}, %{{.*}}
return _mm256_cmp_pd_mask(a, b, _CMP_TRUE_US);
}
__mmask8 test_mm256_mask_cmp_pd_mask_eq_oq(__mmask8 m, __m256d a, __m256d b) {
// CHECK-LABEL: @test_mm256_mask_cmp_pd_mask_eq_oq
// CHECK: [[CMP:%.*]] = fcmp oeq <4 x double> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> [[CMP]], {{.*}}
return _mm256_mask_cmp_pd_mask(m, a, b, _CMP_EQ_OQ);
}
__mmask8 test_mm256_mask_cmp_pd_mask_lt_os(__mmask8 m, __m256d a, __m256d b) {
// CHECK-LABEL: test_mm256_mask_cmp_pd_mask_lt_os
// CHECK: [[CMP:%.*]] = fcmp olt <4 x double> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> [[CMP]], {{.*}}
return _mm256_mask_cmp_pd_mask(m, a, b, _CMP_LT_OS);
}
__mmask8 test_mm256_mask_cmp_pd_mask_le_os(__mmask8 m, __m256d a, __m256d b) {
// CHECK-LABEL: test_mm256_mask_cmp_pd_mask_le_os
// CHECK: [[CMP:%.*]] = fcmp ole <4 x double> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> [[CMP]], {{.*}}
return _mm256_mask_cmp_pd_mask(m, a, b, _CMP_LE_OS);
}
__mmask8 test_mm256_mask_cmp_pd_mask_unord_q(__mmask8 m, __m256d a, __m256d b) {
// CHECK-LABEL: test_mm256_mask_cmp_pd_mask_unord_q
// CHECK: [[CMP:%.*]] = fcmp uno <4 x double> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> [[CMP]], {{.*}}
return _mm256_mask_cmp_pd_mask(m, a, b, _CMP_UNORD_Q);
}
__mmask8 test_mm256_mask_cmp_pd_mask_neq_uq(__mmask8 m, __m256d a, __m256d b) {
// CHECK-LABEL: test_mm256_mask_cmp_pd_mask_neq_uq
// CHECK: [[CMP:%.*]] = fcmp une <4 x double> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> [[CMP]], {{.*}}
return _mm256_mask_cmp_pd_mask(m, a, b, _CMP_NEQ_UQ);
}
__mmask8 test_mm256_mask_cmp_pd_mask_nlt_us(__mmask8 m, __m256d a, __m256d b) {
// CHECK-LABEL: test_mm256_mask_cmp_pd_mask_nlt_us
// CHECK: [[CMP:%.*]] = fcmp uge <4 x double> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> [[CMP]], {{.*}}
return _mm256_mask_cmp_pd_mask(m, a, b, _CMP_NLT_US);
}
__mmask8 test_mm256_mask_cmp_pd_mask_nle_us(__mmask8 m, __m256d a, __m256d b) {
// CHECK-LABEL: test_mm256_mask_cmp_pd_mask_nle_us
// CHECK: [[CMP:%.*]] = fcmp ugt <4 x double> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> [[CMP]], {{.*}}
return _mm256_mask_cmp_pd_mask(m, a, b, _CMP_NLE_US);
}
__mmask8 test_mm256_mask_cmp_pd_mask_ord_q(__mmask8 m, __m256d a, __m256d b) {
// CHECK-LABEL: test_mm256_mask_cmp_pd_mask_ord_q
// CHECK: [[CMP:%.*]] = fcmp ord <4 x double> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> [[CMP]], {{.*}}
return _mm256_mask_cmp_pd_mask(m, a, b, _CMP_ORD_Q);
}
__mmask8 test_mm256_mask_cmp_pd_mask_eq_uq(__mmask8 m, __m256d a, __m256d b) {
// CHECK-LABEL: test_mm256_mask_cmp_pd_mask_eq_uq
// CHECK: [[CMP:%.*]] = fcmp ueq <4 x double> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> [[CMP]], {{.*}}
return _mm256_mask_cmp_pd_mask(m, a, b, _CMP_EQ_UQ);
}
__mmask8 test_mm256_mask_cmp_pd_mask_nge_us(__mmask8 m, __m256d a, __m256d b) {
// CHECK-LABEL: test_mm256_mask_cmp_pd_mask_nge_us
// CHECK: [[CMP:%.*]] = fcmp ult <4 x double> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> [[CMP]], {{.*}}
return _mm256_mask_cmp_pd_mask(m, a, b, _CMP_NGE_US);
}
__mmask8 test_mm256_mask_cmp_pd_mask_ngt_us(__mmask8 m, __m256d a, __m256d b) {
// CHECK-LABEL: test_mm256_mask_cmp_pd_mask_ngt_us
// CHECK: [[CMP:%.*]] = fcmp ule <4 x double> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> [[CMP]], {{.*}}
return _mm256_mask_cmp_pd_mask(m, a, b, _CMP_NGT_US);
}
__mmask8 test_mm256_mask_cmp_pd_mask_false_oq(__mmask8 m, __m256d a, __m256d b) {
// CHECK-LABEL: test_mm256_mask_cmp_pd_mask_false_oq
// CHECK: [[CMP:%.*]] = fcmp false <4 x double> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> [[CMP]], {{.*}}
return _mm256_mask_cmp_pd_mask(m, a, b, _CMP_FALSE_OQ);
}
__mmask8 test_mm256_mask_cmp_pd_mask_neq_oq(__mmask8 m, __m256d a, __m256d b) {
// CHECK-LABEL: test_mm256_mask_cmp_pd_mask_neq_oq
// CHECK: [[CMP:%.*]] = fcmp one <4 x double> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> [[CMP]], {{.*}}
return _mm256_mask_cmp_pd_mask(m, a, b, _CMP_NEQ_OQ);
}
__mmask8 test_mm256_mask_cmp_pd_mask_ge_os(__mmask8 m, __m256d a, __m256d b) {
// CHECK-LABEL: test_mm256_mask_cmp_pd_mask_ge_os
// CHECK: [[CMP:%.*]] = fcmp oge <4 x double> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> [[CMP]], {{.*}}
return _mm256_mask_cmp_pd_mask(m, a, b, _CMP_GE_OS);
}
__mmask8 test_mm256_mask_cmp_pd_mask_gt_os(__mmask8 m, __m256d a, __m256d b) {
// CHECK-LABEL: test_mm256_mask_cmp_pd_mask_gt_os
// CHECK: [[CMP:%.*]] = fcmp ogt <4 x double> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> [[CMP]], {{.*}}
return _mm256_mask_cmp_pd_mask(m, a, b, _CMP_GT_OS);
}
__mmask8 test_mm256_mask_cmp_pd_mask_true_uq(__mmask8 m, __m256d a, __m256d b) {
// CHECK-LABEL: test_mm256_mask_cmp_pd_mask_true_uq
// CHECK: [[CMP:%.*]] = fcmp true <4 x double> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> [[CMP]], {{.*}}
return _mm256_mask_cmp_pd_mask(m, a, b, _CMP_TRUE_UQ);
}
__mmask8 test_mm256_mask_cmp_pd_mask_eq_os(__mmask8 m, __m256d a, __m256d b) {
// CHECK-LABEL: test_mm256_mask_cmp_pd_mask_eq_os
// CHECK: [[CMP:%.*]] = fcmp oeq <4 x double> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> [[CMP]], {{.*}}
return _mm256_mask_cmp_pd_mask(m, a, b, _CMP_EQ_OS);
}
__mmask8 test_mm256_mask_cmp_pd_mask_lt_oq(__mmask8 m, __m256d a, __m256d b) {
// CHECK-LABEL: test_mm256_mask_cmp_pd_mask_lt_oq
// CHECK: [[CMP:%.*]] = fcmp olt <4 x double> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> [[CMP]], {{.*}}
return _mm256_mask_cmp_pd_mask(m, a, b, _CMP_LT_OQ);
}
__mmask8 test_mm256_mask_cmp_pd_mask_le_oq(__mmask8 m, __m256d a, __m256d b) {
// CHECK-LABEL: test_mm256_mask_cmp_pd_mask_le_oq
// CHECK: [[CMP:%.*]] = fcmp ole <4 x double> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> [[CMP]], {{.*}}
return _mm256_mask_cmp_pd_mask(m, a, b, _CMP_LE_OQ);
}
__mmask8 test_mm256_mask_cmp_pd_mask_unord_s(__mmask8 m, __m256d a, __m256d b) {
// CHECK-LABEL: test_mm256_mask_cmp_pd_mask_unord_s
// CHECK: [[CMP:%.*]] = fcmp uno <4 x double> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> [[CMP]], {{.*}}
return _mm256_mask_cmp_pd_mask(m, a, b, _CMP_UNORD_S);
}
__mmask8 test_mm256_mask_cmp_pd_mask_neq_us(__mmask8 m, __m256d a, __m256d b) {
// CHECK-LABEL: test_mm256_mask_cmp_pd_mask_neq_us
// CHECK: [[CMP:%.*]] = fcmp une <4 x double> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> [[CMP]], {{.*}}
return _mm256_mask_cmp_pd_mask(m, a, b, _CMP_NEQ_US);
}
__mmask8 test_mm256_mask_cmp_pd_mask_nlt_uq(__mmask8 m, __m256d a, __m256d b) {
// CHECK-LABEL: test_mm256_mask_cmp_pd_mask_nlt_uq
// CHECK: [[CMP:%.*]] = fcmp uge <4 x double> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> [[CMP]], {{.*}}
return _mm256_mask_cmp_pd_mask(m, a, b, _CMP_NLT_UQ);
}
__mmask8 test_mm256_mask_cmp_pd_mask_nle_uq(__mmask8 m, __m256d a, __m256d b) {
// CHECK-LABEL: test_mm256_mask_cmp_pd_mask_nle_uq
// CHECK: [[CMP:%.*]] = fcmp ugt <4 x double> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> [[CMP]], {{.*}}
return _mm256_mask_cmp_pd_mask(m, a, b, _CMP_NLE_UQ);
}
__mmask8 test_mm256_mask_cmp_pd_mask_ord_s(__mmask8 m, __m256d a, __m256d b) {
// CHECK-LABEL: test_mm256_mask_cmp_pd_mask_ord_s
// CHECK: [[CMP:%.*]] = fcmp ord <4 x double> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> [[CMP]], {{.*}}
return _mm256_mask_cmp_pd_mask(m, a, b, _CMP_ORD_S);
}
__mmask8 test_mm256_mask_cmp_pd_mask_eq_us(__mmask8 m, __m256d a, __m256d b) {
// CHECK-LABEL: test_mm256_mask_cmp_pd_mask_eq_us
// CHECK: [[CMP:%.*]] = fcmp ueq <4 x double> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> [[CMP]], {{.*}}
return _mm256_mask_cmp_pd_mask(m, a, b, _CMP_EQ_US);
}
__mmask8 test_mm256_mask_cmp_pd_mask_nge_uq(__mmask8 m, __m256d a, __m256d b) {
// CHECK-LABEL: test_mm256_mask_cmp_pd_mask_nge_uq
// CHECK: [[CMP:%.*]] = fcmp ult <4 x double> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> [[CMP]], {{.*}}
return _mm256_mask_cmp_pd_mask(m, a, b, _CMP_NGE_UQ);
}
__mmask8 test_mm256_mask_cmp_pd_mask_ngt_uq(__mmask8 m, __m256d a, __m256d b) {
// CHECK-LABEL: test_mm256_mask_cmp_pd_mask_ngt_uq
// CHECK: [[CMP:%.*]] = fcmp ule <4 x double> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> [[CMP]], {{.*}}
return _mm256_mask_cmp_pd_mask(m, a, b, _CMP_NGT_UQ);
}
__mmask8 test_mm256_mask_cmp_pd_mask_false_os(__mmask8 m, __m256d a, __m256d b) {
// CHECK-LABEL: test_mm256_mask_cmp_pd_mask_false_os
// CHECK: [[CMP:%.*]] = fcmp false <4 x double> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> [[CMP]], {{.*}}
return _mm256_mask_cmp_pd_mask(m, a, b, _CMP_FALSE_OS);
}
__mmask8 test_mm256_mask_cmp_pd_mask_neq_os(__mmask8 m, __m256d a, __m256d b) {
// CHECK-LABEL: test_mm256_mask_cmp_pd_mask_neq_os
// CHECK: [[CMP:%.*]] = fcmp one <4 x double> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> [[CMP]], {{.*}}
return _mm256_mask_cmp_pd_mask(m, a, b, _CMP_NEQ_OS);
}
__mmask8 test_mm256_mask_cmp_pd_mask_ge_oq(__mmask8 m, __m256d a, __m256d b) {
// CHECK-LABEL: test_mm256_mask_cmp_pd_mask_ge_oq
// CHECK: [[CMP:%.*]] = fcmp oge <4 x double> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> [[CMP]], {{.*}}
return _mm256_mask_cmp_pd_mask(m, a, b, _CMP_GE_OQ);
}
__mmask8 test_mm256_mask_cmp_pd_mask_gt_oq(__mmask8 m, __m256d a, __m256d b) {
// CHECK-LABEL: test_mm256_mask_cmp_pd_mask_gt_oq
// CHECK: [[CMP:%.*]] = fcmp ogt <4 x double> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> [[CMP]], {{.*}}
return _mm256_mask_cmp_pd_mask(m, a, b, _CMP_GT_OQ);
}
__mmask8 test_mm256_mask_cmp_pd_mask_true_us(__mmask8 m, __m256d a, __m256d b) {
// CHECK-LABEL: test_mm256_mask_cmp_pd_mask_true_us
// CHECK: [[CMP:%.*]] = fcmp true <4 x double> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> [[CMP]], {{.*}}
return _mm256_mask_cmp_pd_mask(m, a, b, _CMP_TRUE_US);
}
__mmask8 test_mm_cmp_ps_mask_eq_oq(__m128 a, __m128 b) {
// CHECK-LABEL: @test_mm_cmp_ps_mask_eq_oq
// CHECK: fcmp oeq <4 x float> %{{.*}}, %{{.*}}
return _mm_cmp_ps_mask(a, b, _CMP_EQ_OQ);
}
__mmask8 test_mm_cmp_ps_mask_lt_os(__m128 a, __m128 b) {
// CHECK-LABEL: test_mm_cmp_ps_mask_lt_os
// CHECK: fcmp olt <4 x float> %{{.*}}, %{{.*}}
return _mm_cmp_ps_mask(a, b, _CMP_LT_OS);
}
__mmask8 test_mm_cmp_ps_mask_le_os(__m128 a, __m128 b) {
// CHECK-LABEL: test_mm_cmp_ps_mask_le_os
// CHECK: fcmp ole <4 x float> %{{.*}}, %{{.*}}
return _mm_cmp_ps_mask(a, b, _CMP_LE_OS);
}
__mmask8 test_mm_cmp_ps_mask_unord_q(__m128 a, __m128 b) {
// CHECK-LABEL: test_mm_cmp_ps_mask_unord_q
// CHECK: fcmp uno <4 x float> %{{.*}}, %{{.*}}
return _mm_cmp_ps_mask(a, b, _CMP_UNORD_Q);
}
__mmask8 test_mm_cmp_ps_mask_neq_uq(__m128 a, __m128 b) {
// CHECK-LABEL: test_mm_cmp_ps_mask_neq_uq
// CHECK: fcmp une <4 x float> %{{.*}}, %{{.*}}
return _mm_cmp_ps_mask(a, b, _CMP_NEQ_UQ);
}
__mmask8 test_mm_cmp_ps_mask_nlt_us(__m128 a, __m128 b) {
// CHECK-LABEL: test_mm_cmp_ps_mask_nlt_us
// CHECK: fcmp uge <4 x float> %{{.*}}, %{{.*}}
return _mm_cmp_ps_mask(a, b, _CMP_NLT_US);
}
__mmask8 test_mm_cmp_ps_mask_nle_us(__m128 a, __m128 b) {
// CHECK-LABEL: test_mm_cmp_ps_mask_nle_us
// CHECK: fcmp ugt <4 x float> %{{.*}}, %{{.*}}
return _mm_cmp_ps_mask(a, b, _CMP_NLE_US);
}
__mmask8 test_mm_cmp_ps_mask_ord_q(__m128 a, __m128 b) {
// CHECK-LABEL: test_mm_cmp_ps_mask_ord_q
// CHECK: fcmp ord <4 x float> %{{.*}}, %{{.*}}
return _mm_cmp_ps_mask(a, b, _CMP_ORD_Q);
}
__mmask8 test_mm_cmp_ps_mask_eq_uq(__m128 a, __m128 b) {
// CHECK-LABEL: test_mm_cmp_ps_mask_eq_uq
// CHECK: fcmp ueq <4 x float> %{{.*}}, %{{.*}}
return _mm_cmp_ps_mask(a, b, _CMP_EQ_UQ);
}
__mmask8 test_mm_cmp_ps_mask_nge_us(__m128 a, __m128 b) {
// CHECK-LABEL: test_mm_cmp_ps_mask_nge_us
// CHECK: fcmp ult <4 x float> %{{.*}}, %{{.*}}
return _mm_cmp_ps_mask(a, b, _CMP_NGE_US);
}
__mmask8 test_mm_cmp_ps_mask_ngt_us(__m128 a, __m128 b) {
// CHECK-LABEL: test_mm_cmp_ps_mask_ngt_us
// CHECK: fcmp ule <4 x float> %{{.*}}, %{{.*}}
return _mm_cmp_ps_mask(a, b, _CMP_NGT_US);
}
__mmask8 test_mm_cmp_ps_mask_false_oq(__m128 a, __m128 b) {
// CHECK-LABEL: test_mm_cmp_ps_mask_false_oq
// CHECK: fcmp false <4 x float> %{{.*}}, %{{.*}}
return _mm_cmp_ps_mask(a, b, _CMP_FALSE_OQ);
}
__mmask8 test_mm_cmp_ps_mask_neq_oq(__m128 a, __m128 b) {
// CHECK-LABEL: test_mm_cmp_ps_mask_neq_oq
// CHECK: fcmp one <4 x float> %{{.*}}, %{{.*}}
return _mm_cmp_ps_mask(a, b, _CMP_NEQ_OQ);
}
__mmask8 test_mm_cmp_ps_mask_ge_os(__m128 a, __m128 b) {
// CHECK-LABEL: test_mm_cmp_ps_mask_ge_os
// CHECK: fcmp oge <4 x float> %{{.*}}, %{{.*}}
return _mm_cmp_ps_mask(a, b, _CMP_GE_OS);
}
__mmask8 test_mm_cmp_ps_mask_gt_os(__m128 a, __m128 b) {
// CHECK-LABEL: test_mm_cmp_ps_mask_gt_os
// CHECK: fcmp ogt <4 x float> %{{.*}}, %{{.*}}
return _mm_cmp_ps_mask(a, b, _CMP_GT_OS);
}
__mmask8 test_mm_cmp_ps_mask_true_uq(__m128 a, __m128 b) {
// CHECK-LABEL: test_mm_cmp_ps_mask_true_uq
// CHECK: fcmp true <4 x float> %{{.*}}, %{{.*}}
return _mm_cmp_ps_mask(a, b, _CMP_TRUE_UQ);
}
__mmask8 test_mm_cmp_ps_mask_eq_os(__m128 a, __m128 b) {
// CHECK-LABEL: test_mm_cmp_ps_mask_eq_os
// CHECK: fcmp oeq <4 x float> %{{.*}}, %{{.*}}
return _mm_cmp_ps_mask(a, b, _CMP_EQ_OS);
}
__mmask8 test_mm_cmp_ps_mask_lt_oq(__m128 a, __m128 b) {
// CHECK-LABEL: test_mm_cmp_ps_mask_lt_oq
// CHECK: fcmp olt <4 x float> %{{.*}}, %{{.*}}
return _mm_cmp_ps_mask(a, b, _CMP_LT_OQ);
}
__mmask8 test_mm_cmp_ps_mask_le_oq(__m128 a, __m128 b) {
// CHECK-LABEL: test_mm_cmp_ps_mask_le_oq
// CHECK: fcmp ole <4 x float> %{{.*}}, %{{.*}}
return _mm_cmp_ps_mask(a, b, _CMP_LE_OQ);
}
__mmask8 test_mm_cmp_ps_mask_unord_s(__m128 a, __m128 b) {
// CHECK-LABEL: test_mm_cmp_ps_mask_unord_s
// CHECK: fcmp uno <4 x float> %{{.*}}, %{{.*}}
return _mm_cmp_ps_mask(a, b, _CMP_UNORD_S);
}
__mmask8 test_mm_cmp_ps_mask_neq_us(__m128 a, __m128 b) {
// CHECK-LABEL: test_mm_cmp_ps_mask_neq_us
// CHECK: fcmp une <4 x float> %{{.*}}, %{{.*}}
return _mm_cmp_ps_mask(a, b, _CMP_NEQ_US);
}
__mmask8 test_mm_cmp_ps_mask_nlt_uq(__m128 a, __m128 b) {
// CHECK-LABEL: test_mm_cmp_ps_mask_nlt_uq
// CHECK: fcmp uge <4 x float> %{{.*}}, %{{.*}}
return _mm_cmp_ps_mask(a, b, _CMP_NLT_UQ);
}
__mmask8 test_mm_cmp_ps_mask_nle_uq(__m128 a, __m128 b) {
// CHECK-LABEL: test_mm_cmp_ps_mask_nle_uq
// CHECK: fcmp ugt <4 x float> %{{.*}}, %{{.*}}
return _mm_cmp_ps_mask(a, b, _CMP_NLE_UQ);
}
__mmask8 test_mm_cmp_ps_mask_ord_s(__m128 a, __m128 b) {
// CHECK-LABEL: test_mm_cmp_ps_mask_ord_s
// CHECK: fcmp ord <4 x float> %{{.*}}, %{{.*}}
return _mm_cmp_ps_mask(a, b, _CMP_ORD_S);
}
__mmask8 test_mm_cmp_ps_mask_eq_us(__m128 a, __m128 b) {
// CHECK-LABEL: test_mm_cmp_ps_mask_eq_us
// CHECK: fcmp ueq <4 x float> %{{.*}}, %{{.*}}
return _mm_cmp_ps_mask(a, b, _CMP_EQ_US);
}
__mmask8 test_mm_cmp_ps_mask_nge_uq(__m128 a, __m128 b) {
// CHECK-LABEL: test_mm_cmp_ps_mask_nge_uq
// CHECK: fcmp ult <4 x float> %{{.*}}, %{{.*}}
return _mm_cmp_ps_mask(a, b, _CMP_NGE_UQ);
}
__mmask8 test_mm_cmp_ps_mask_ngt_uq(__m128 a, __m128 b) {
// CHECK-LABEL: test_mm_cmp_ps_mask_ngt_uq
// CHECK: fcmp ule <4 x float> %{{.*}}, %{{.*}}
return _mm_cmp_ps_mask(a, b, _CMP_NGT_UQ);
}
__mmask8 test_mm_cmp_ps_mask_false_os(__m128 a, __m128 b) {
// CHECK-LABEL: test_mm_cmp_ps_mask_false_os
// CHECK: fcmp false <4 x float> %{{.*}}, %{{.*}}
return _mm_cmp_ps_mask(a, b, _CMP_FALSE_OS);
}
__mmask8 test_mm_cmp_ps_mask_neq_os(__m128 a, __m128 b) {
// CHECK-LABEL: test_mm_cmp_ps_mask_neq_os
// CHECK: fcmp one <4 x float> %{{.*}}, %{{.*}}
return _mm_cmp_ps_mask(a, b, _CMP_NEQ_OS);
}
__mmask8 test_mm_cmp_ps_mask_ge_oq(__m128 a, __m128 b) {
// CHECK-LABEL: test_mm_cmp_ps_mask_ge_oq
// CHECK: fcmp oge <4 x float> %{{.*}}, %{{.*}}
return _mm_cmp_ps_mask(a, b, _CMP_GE_OQ);
}
__mmask8 test_mm_cmp_ps_mask_gt_oq(__m128 a, __m128 b) {
// CHECK-LABEL: test_mm_cmp_ps_mask_gt_oq
// CHECK: fcmp ogt <4 x float> %{{.*}}, %{{.*}}
return _mm_cmp_ps_mask(a, b, _CMP_GT_OQ);
}
__mmask8 test_mm_cmp_ps_mask_true_us(__m128 a, __m128 b) {
// CHECK-LABEL: test_mm_cmp_ps_mask_true_us
// CHECK: fcmp true <4 x float> %{{.*}}, %{{.*}}
return _mm_cmp_ps_mask(a, b, _CMP_TRUE_US);
}
__mmask8 test_mm_mask_cmp_ps_mask_eq_oq(__mmask8 m, __m128 a, __m128 b) {
// CHECK-LABEL: @test_mm_mask_cmp_ps_mask_eq_oq
// CHECK: [[CMP:%.*]] = fcmp oeq <4 x float> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> [[CMP]], {{.*}}
return _mm_mask_cmp_ps_mask(m, a, b, _CMP_EQ_OQ);
}
__mmask8 test_mm_mask_cmp_ps_mask_lt_os(__mmask8 m, __m128 a, __m128 b) {
// CHECK-LABEL: test_mm_mask_cmp_ps_mask_lt_os
// CHECK: [[CMP:%.*]] = fcmp olt <4 x float> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> [[CMP]], {{.*}}
return _mm_mask_cmp_ps_mask(m, a, b, _CMP_LT_OS);
}
__mmask8 test_mm_mask_cmp_ps_mask_le_os(__mmask8 m, __m128 a, __m128 b) {
// CHECK-LABEL: test_mm_mask_cmp_ps_mask_le_os
// CHECK: [[CMP:%.*]] = fcmp ole <4 x float> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> [[CMP]], {{.*}}
return _mm_mask_cmp_ps_mask(m, a, b, _CMP_LE_OS);
}
__mmask8 test_mm_mask_cmp_ps_mask_unord_q(__mmask8 m, __m128 a, __m128 b) {
// CHECK-LABEL: test_mm_mask_cmp_ps_mask_unord_q
// CHECK: [[CMP:%.*]] = fcmp uno <4 x float> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> [[CMP]], {{.*}}
return _mm_mask_cmp_ps_mask(m, a, b, _CMP_UNORD_Q);
}
__mmask8 test_mm_mask_cmp_ps_mask_neq_uq(__mmask8 m, __m128 a, __m128 b) {
// CHECK-LABEL: test_mm_mask_cmp_ps_mask_neq_uq
// CHECK: [[CMP:%.*]] = fcmp une <4 x float> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> [[CMP]], {{.*}}
return _mm_mask_cmp_ps_mask(m, a, b, _CMP_NEQ_UQ);
}
__mmask8 test_mm_mask_cmp_ps_mask_nlt_us(__mmask8 m, __m128 a, __m128 b) {
// CHECK-LABEL: test_mm_mask_cmp_ps_mask_nlt_us
// CHECK: [[CMP:%.*]] = fcmp uge <4 x float> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> [[CMP]], {{.*}}
return _mm_mask_cmp_ps_mask(m, a, b, _CMP_NLT_US);
}
__mmask8 test_mm_mask_cmp_ps_mask_nle_us(__mmask8 m, __m128 a, __m128 b) {
// CHECK-LABEL: test_mm_mask_cmp_ps_mask_nle_us
// CHECK: [[CMP:%.*]] = fcmp ugt <4 x float> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> [[CMP]], {{.*}}
return _mm_mask_cmp_ps_mask(m, a, b, _CMP_NLE_US);
}
__mmask8 test_mm_mask_cmp_ps_mask_ord_q(__mmask8 m, __m128 a, __m128 b) {
// CHECK-LABEL: test_mm_mask_cmp_ps_mask_ord_q
// CHECK: [[CMP:%.*]] = fcmp ord <4 x float> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> [[CMP]], {{.*}}
return _mm_mask_cmp_ps_mask(m, a, b, _CMP_ORD_Q);
}
__mmask8 test_mm_mask_cmp_ps_mask_eq_uq(__mmask8 m, __m128 a, __m128 b) {
// CHECK-LABEL: test_mm_mask_cmp_ps_mask_eq_uq
// CHECK: [[CMP:%.*]] = fcmp ueq <4 x float> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> [[CMP]], {{.*}}
return _mm_mask_cmp_ps_mask(m, a, b, _CMP_EQ_UQ);
}
__mmask8 test_mm_mask_cmp_ps_mask_nge_us(__mmask8 m, __m128 a, __m128 b) {
// CHECK-LABEL: test_mm_mask_cmp_ps_mask_nge_us
// CHECK: [[CMP:%.*]] = fcmp ult <4 x float> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> [[CMP]], {{.*}}
return _mm_mask_cmp_ps_mask(m, a, b, _CMP_NGE_US);
}
__mmask8 test_mm_mask_cmp_ps_mask_ngt_us(__mmask8 m, __m128 a, __m128 b) {
// CHECK-LABEL: test_mm_mask_cmp_ps_mask_ngt_us
// CHECK: [[CMP:%.*]] = fcmp ule <4 x float> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> [[CMP]], {{.*}}
return _mm_mask_cmp_ps_mask(m, a, b, _CMP_NGT_US);
}
__mmask8 test_mm_mask_cmp_ps_mask_false_oq(__mmask8 m, __m128 a, __m128 b) {
// CHECK-LABEL: test_mm_mask_cmp_ps_mask_false_oq
// CHECK: [[CMP:%.*]] = fcmp false <4 x float> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> [[CMP]], {{.*}}
return _mm_mask_cmp_ps_mask(m, a, b, _CMP_FALSE_OQ);
}
__mmask8 test_mm_mask_cmp_ps_mask_neq_oq(__mmask8 m, __m128 a, __m128 b) {
// CHECK-LABEL: test_mm_mask_cmp_ps_mask_neq_oq
// CHECK: [[CMP:%.*]] = fcmp one <4 x float> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> [[CMP]], {{.*}}
return _mm_mask_cmp_ps_mask(m, a, b, _CMP_NEQ_OQ);
}
__mmask8 test_mm_mask_cmp_ps_mask_ge_os(__mmask8 m, __m128 a, __m128 b) {
// CHECK-LABEL: test_mm_mask_cmp_ps_mask_ge_os
// CHECK: [[CMP:%.*]] = fcmp oge <4 x float> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> [[CMP]], {{.*}}
return _mm_mask_cmp_ps_mask(m, a, b, _CMP_GE_OS);
}
__mmask8 test_mm_mask_cmp_ps_mask_gt_os(__mmask8 m, __m128 a, __m128 b) {
// CHECK-LABEL: test_mm_mask_cmp_ps_mask_gt_os
// CHECK: [[CMP:%.*]] = fcmp ogt <4 x float> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> [[CMP]], {{.*}}
return _mm_mask_cmp_ps_mask(m, a, b, _CMP_GT_OS);
}
__mmask8 test_mm_mask_cmp_ps_mask_true_uq(__mmask8 m, __m128 a, __m128 b) {
// CHECK-LABEL: test_mm_mask_cmp_ps_mask_true_uq
// CHECK: [[CMP:%.*]] = fcmp true <4 x float> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> [[CMP]], {{.*}}
return _mm_mask_cmp_ps_mask(m, a, b, _CMP_TRUE_UQ);
}
__mmask8 test_mm_mask_cmp_ps_mask_eq_os(__mmask8 m, __m128 a, __m128 b) {
// CHECK-LABEL: test_mm_mask_cmp_ps_mask_eq_os
// CHECK: [[CMP:%.*]] = fcmp oeq <4 x float> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> [[CMP]], {{.*}}
return _mm_mask_cmp_ps_mask(m, a, b, _CMP_EQ_OS);
}
__mmask8 test_mm_mask_cmp_ps_mask_lt_oq(__mmask8 m, __m128 a, __m128 b) {
// CHECK-LABEL: test_mm_mask_cmp_ps_mask_lt_oq
// CHECK: [[CMP:%.*]] = fcmp olt <4 x float> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> [[CMP]], {{.*}}
return _mm_mask_cmp_ps_mask(m, a, b, _CMP_LT_OQ);
}
__mmask8 test_mm_mask_cmp_ps_mask_le_oq(__mmask8 m, __m128 a, __m128 b) {
// CHECK-LABEL: test_mm_mask_cmp_ps_mask_le_oq
// CHECK: [[CMP:%.*]] = fcmp ole <4 x float> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> [[CMP]], {{.*}}
return _mm_mask_cmp_ps_mask(m, a, b, _CMP_LE_OQ);
}
__mmask8 test_mm_mask_cmp_ps_mask_unord_s(__mmask8 m, __m128 a, __m128 b) {
// CHECK-LABEL: test_mm_mask_cmp_ps_mask_unord_s
// CHECK: [[CMP:%.*]] = fcmp uno <4 x float> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> [[CMP]], {{.*}}
return _mm_mask_cmp_ps_mask(m, a, b, _CMP_UNORD_S);
}
__mmask8 test_mm_mask_cmp_ps_mask_neq_us(__mmask8 m, __m128 a, __m128 b) {
// CHECK-LABEL: test_mm_mask_cmp_ps_mask_neq_us
// CHECK: [[CMP:%.*]] = fcmp une <4 x float> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> [[CMP]], {{.*}}
return _mm_mask_cmp_ps_mask(m, a, b, _CMP_NEQ_US);
}
__mmask8 test_mm_mask_cmp_ps_mask_nlt_uq(__mmask8 m, __m128 a, __m128 b) {
// CHECK-LABEL: test_mm_mask_cmp_ps_mask_nlt_uq
// CHECK: [[CMP:%.*]] = fcmp uge <4 x float> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> [[CMP]], {{.*}}
return _mm_mask_cmp_ps_mask(m, a, b, _CMP_NLT_UQ);
}
__mmask8 test_mm_mask_cmp_ps_mask_nle_uq(__mmask8 m, __m128 a, __m128 b) {
// CHECK-LABEL: test_mm_mask_cmp_ps_mask_nle_uq
// CHECK: [[CMP:%.*]] = fcmp ugt <4 x float> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> [[CMP]], {{.*}}
return _mm_mask_cmp_ps_mask(m, a, b, _CMP_NLE_UQ);
}
__mmask8 test_mm_mask_cmp_ps_mask_ord_s(__mmask8 m, __m128 a, __m128 b) {
// CHECK-LABEL: test_mm_mask_cmp_ps_mask_ord_s
// CHECK: [[CMP:%.*]] = fcmp ord <4 x float> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> [[CMP]], {{.*}}
return _mm_mask_cmp_ps_mask(m, a, b, _CMP_ORD_S);
}
__mmask8 test_mm_mask_cmp_ps_mask_eq_us(__mmask8 m, __m128 a, __m128 b) {
// CHECK-LABEL: test_mm_mask_cmp_ps_mask_eq_us
// CHECK: [[CMP:%.*]] = fcmp ueq <4 x float> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> [[CMP]], {{.*}}
return _mm_mask_cmp_ps_mask(m, a, b, _CMP_EQ_US);
}
__mmask8 test_mm_mask_cmp_ps_mask_nge_uq(__mmask8 m, __m128 a, __m128 b) {
// CHECK-LABEL: test_mm_mask_cmp_ps_mask_nge_uq
// CHECK: [[CMP:%.*]] = fcmp ult <4 x float> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> [[CMP]], {{.*}}
return _mm_mask_cmp_ps_mask(m, a, b, _CMP_NGE_UQ);
}
__mmask8 test_mm_mask_cmp_ps_mask_ngt_uq(__mmask8 m, __m128 a, __m128 b) {
// CHECK-LABEL: test_mm_mask_cmp_ps_mask_ngt_uq
// CHECK: [[CMP:%.*]] = fcmp ule <4 x float> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> [[CMP]], {{.*}}
return _mm_mask_cmp_ps_mask(m, a, b, _CMP_NGT_UQ);
}
__mmask8 test_mm_mask_cmp_ps_mask_false_os(__mmask8 m, __m128 a, __m128 b) {
// CHECK-LABEL: test_mm_mask_cmp_ps_mask_false_os
// CHECK: [[CMP:%.*]] = fcmp false <4 x float> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> [[CMP]], {{.*}}
return _mm_mask_cmp_ps_mask(m, a, b, _CMP_FALSE_OS);
}
__mmask8 test_mm_mask_cmp_ps_mask_neq_os(__mmask8 m, __m128 a, __m128 b) {
// CHECK-LABEL: test_mm_mask_cmp_ps_mask_neq_os
// CHECK: [[CMP:%.*]] = fcmp one <4 x float> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> [[CMP]], {{.*}}
return _mm_mask_cmp_ps_mask(m, a, b, _CMP_NEQ_OS);
}
__mmask8 test_mm_mask_cmp_ps_mask_ge_oq(__mmask8 m, __m128 a, __m128 b) {
// CHECK-LABEL: test_mm_mask_cmp_ps_mask_ge_oq
// CHECK: [[CMP:%.*]] = fcmp oge <4 x float> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> [[CMP]], {{.*}}
return _mm_mask_cmp_ps_mask(m, a, b, _CMP_GE_OQ);
}
__mmask8 test_mm_mask_cmp_ps_mask_gt_oq(__mmask8 m, __m128 a, __m128 b) {
// CHECK-LABEL: test_mm_mask_cmp_ps_mask_gt_oq
// CHECK: [[CMP:%.*]] = fcmp ogt <4 x float> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> [[CMP]], {{.*}}
return _mm_mask_cmp_ps_mask(m, a, b, _CMP_GT_OQ);
}
__mmask8 test_mm_mask_cmp_ps_mask_true_us(__mmask8 m, __m128 a, __m128 b) {
// CHECK-LABEL: test_mm_mask_cmp_ps_mask_true_us
// CHECK: [[CMP:%.*]] = fcmp true <4 x float> %{{.*}}, %{{.*}}
// CHECK: and <4 x i1> [[CMP]], {{.*}}
return _mm_mask_cmp_ps_mask(m, a, b, _CMP_TRUE_US);
}
__mmask8 test_mm_cmp_pd_mask_eq_oq(__m128d a, __m128d b) {
// CHECK-LABEL: @test_mm_cmp_pd_mask_eq_oq
// CHECK: fcmp oeq <2 x double> %{{.*}}, %{{.*}}
return _mm_cmp_pd_mask(a, b, _CMP_EQ_OQ);
}
__mmask8 test_mm_cmp_pd_mask_lt_os(__m128d a, __m128d b) {
// CHECK-LABEL: test_mm_cmp_pd_mask_lt_os
// CHECK: fcmp olt <2 x double> %{{.*}}, %{{.*}}
return _mm_cmp_pd_mask(a, b, _CMP_LT_OS);
}
__mmask8 test_mm_cmp_pd_mask_le_os(__m128d a, __m128d b) {
// CHECK-LABEL: test_mm_cmp_pd_mask_le_os
// CHECK: fcmp ole <2 x double> %{{.*}}, %{{.*}}
return _mm_cmp_pd_mask(a, b, _CMP_LE_OS);
}
__mmask8 test_mm_cmp_pd_mask_unord_q(__m128d a, __m128d b) {
// CHECK-LABEL: test_mm_cmp_pd_mask_unord_q
// CHECK: fcmp uno <2 x double> %{{.*}}, %{{.*}}
return _mm_cmp_pd_mask(a, b, _CMP_UNORD_Q);
}
__mmask8 test_mm_cmp_pd_mask_neq_uq(__m128d a, __m128d b) {
// CHECK-LABEL: test_mm_cmp_pd_mask_neq_uq
// CHECK: fcmp une <2 x double> %{{.*}}, %{{.*}}
return _mm_cmp_pd_mask(a, b, _CMP_NEQ_UQ);
}
__mmask8 test_mm_cmp_pd_mask_nlt_us(__m128d a, __m128d b) {
// CHECK-LABEL: test_mm_cmp_pd_mask_nlt_us
// CHECK: fcmp uge <2 x double> %{{.*}}, %{{.*}}
return _mm_cmp_pd_mask(a, b, _CMP_NLT_US);
}
__mmask8 test_mm_cmp_pd_mask_nle_us(__m128d a, __m128d b) {
// CHECK-LABEL: test_mm_cmp_pd_mask_nle_us
// CHECK: fcmp ugt <2 x double> %{{.*}}, %{{.*}}
return _mm_cmp_pd_mask(a, b, _CMP_NLE_US);
}
__mmask8 test_mm_cmp_pd_mask_ord_q(__m128d a, __m128d b) {
// CHECK-LABEL: test_mm_cmp_pd_mask_ord_q
// CHECK: fcmp ord <2 x double> %{{.*}}, %{{.*}}
return _mm_cmp_pd_mask(a, b, _CMP_ORD_Q);
}
__mmask8 test_mm_cmp_pd_mask_eq_uq(__m128d a, __m128d b) {
// CHECK-LABEL: test_mm_cmp_pd_mask_eq_uq
// CHECK: fcmp ueq <2 x double> %{{.*}}, %{{.*}}
return _mm_cmp_pd_mask(a, b, _CMP_EQ_UQ);
}
__mmask8 test_mm_cmp_pd_mask_nge_us(__m128d a, __m128d b) {
// CHECK-LABEL: test_mm_cmp_pd_mask_nge_us
// CHECK: fcmp ult <2 x double> %{{.*}}, %{{.*}}
return _mm_cmp_pd_mask(a, b, _CMP_NGE_US);
}
__mmask8 test_mm_cmp_pd_mask_ngt_us(__m128d a, __m128d b) {
// CHECK-LABEL: test_mm_cmp_pd_mask_ngt_us
// CHECK: fcmp ule <2 x double> %{{.*}}, %{{.*}}
return _mm_cmp_pd_mask(a, b, _CMP_NGT_US);
}
__mmask8 test_mm_cmp_pd_mask_false_oq(__m128d a, __m128d b) {
// CHECK-LABEL: test_mm_cmp_pd_mask_false_oq
// CHECK: fcmp false <2 x double> %{{.*}}, %{{.*}}
return _mm_cmp_pd_mask(a, b, _CMP_FALSE_OQ);
}
__mmask8 test_mm_cmp_pd_mask_neq_oq(__m128d a, __m128d b) {
// CHECK-LABEL: test_mm_cmp_pd_mask_neq_oq
// CHECK: fcmp one <2 x double> %{{.*}}, %{{.*}}
return _mm_cmp_pd_mask(a, b, _CMP_NEQ_OQ);
}
__mmask8 test_mm_cmp_pd_mask_ge_os(__m128d a, __m128d b) {
// CHECK-LABEL: test_mm_cmp_pd_mask_ge_os
// CHECK: fcmp oge <2 x double> %{{.*}}, %{{.*}}
return _mm_cmp_pd_mask(a, b, _CMP_GE_OS);
}
__mmask8 test_mm_cmp_pd_mask_gt_os(__m128d a, __m128d b) {
// CHECK-LABEL: test_mm_cmp_pd_mask_gt_os
// CHECK: fcmp ogt <2 x double> %{{.*}}, %{{.*}}
return _mm_cmp_pd_mask(a, b, _CMP_GT_OS);
}
__mmask8 test_mm_cmp_pd_mask_true_uq(__m128d a, __m128d b) {
// CHECK-LABEL: test_mm_cmp_pd_mask_true_uq
// CHECK: fcmp true <2 x double> %{{.*}}, %{{.*}}
return _mm_cmp_pd_mask(a, b, _CMP_TRUE_UQ);
}
__mmask8 test_mm_cmp_pd_mask_eq_os(__m128d a, __m128d b) {
// CHECK-LABEL: test_mm_cmp_pd_mask_eq_os
// CHECK: fcmp oeq <2 x double> %{{.*}}, %{{.*}}
return _mm_cmp_pd_mask(a, b, _CMP_EQ_OS);
}
__mmask8 test_mm_cmp_pd_mask_lt_oq(__m128d a, __m128d b) {
// CHECK-LABEL: test_mm_cmp_pd_mask_lt_oq
// CHECK: fcmp olt <2 x double> %{{.*}}, %{{.*}}
return _mm_cmp_pd_mask(a, b, _CMP_LT_OQ);
}
__mmask8 test_mm_cmp_pd_mask_le_oq(__m128d a, __m128d b) {
// CHECK-LABEL: test_mm_cmp_pd_mask_le_oq
// CHECK: fcmp ole <2 x double> %{{.*}}, %{{.*}}
return _mm_cmp_pd_mask(a, b, _CMP_LE_OQ);
}
__mmask8 test_mm_cmp_pd_mask_unord_s(__m128d a, __m128d b) {
// CHECK-LABEL: test_mm_cmp_pd_mask_unord_s
// CHECK: fcmp uno <2 x double> %{{.*}}, %{{.*}}
return _mm_cmp_pd_mask(a, b, _CMP_UNORD_S);
}
__mmask8 test_mm_cmp_pd_mask_neq_us(__m128d a, __m128d b) {
// CHECK-LABEL: test_mm_cmp_pd_mask_neq_us
// CHECK: fcmp une <2 x double> %{{.*}}, %{{.*}}
return _mm_cmp_pd_mask(a, b, _CMP_NEQ_US);
}
__mmask8 test_mm_cmp_pd_mask_nlt_uq(__m128d a, __m128d b) {
// CHECK-LABEL: test_mm_cmp_pd_mask_nlt_uq
// CHECK: fcmp uge <2 x double> %{{.*}}, %{{.*}}
return _mm_cmp_pd_mask(a, b, _CMP_NLT_UQ);
}
__mmask8 test_mm_cmp_pd_mask_nle_uq(__m128d a, __m128d b) {
// CHECK-LABEL: test_mm_cmp_pd_mask_nle_uq
// CHECK: fcmp ugt <2 x double> %{{.*}}, %{{.*}}
return _mm_cmp_pd_mask(a, b, _CMP_NLE_UQ);
}
__mmask8 test_mm_cmp_pd_mask_ord_s(__m128d a, __m128d b) {
// CHECK-LABEL: test_mm_cmp_pd_mask_ord_s
// CHECK: fcmp ord <2 x double> %{{.*}}, %{{.*}}
return _mm_cmp_pd_mask(a, b, _CMP_ORD_S);
}
__mmask8 test_mm_cmp_pd_mask_eq_us(__m128d a, __m128d b) {
// CHECK-LABEL: test_mm_cmp_pd_mask_eq_us
// CHECK: fcmp ueq <2 x double> %{{.*}}, %{{.*}}
return _mm_cmp_pd_mask(a, b, _CMP_EQ_US);
}
__mmask8 test_mm_cmp_pd_mask_nge_uq(__m128d a, __m128d b) {
// CHECK-LABEL: test_mm_cmp_pd_mask_nge_uq
// CHECK: fcmp ult <2 x double> %{{.*}}, %{{.*}}
return _mm_cmp_pd_mask(a, b, _CMP_NGE_UQ);
}
__mmask8 test_mm_cmp_pd_mask_ngt_uq(__m128d a, __m128d b) {
// CHECK-LABEL: test_mm_cmp_pd_mask_ngt_uq
// CHECK: fcmp ule <2 x double> %{{.*}}, %{{.*}}
return _mm_cmp_pd_mask(a, b, _CMP_NGT_UQ);
}
__mmask8 test_mm_cmp_pd_mask_false_os(__m128d a, __m128d b) {
// CHECK-LABEL: test_mm_cmp_pd_mask_false_os
// CHECK: fcmp false <2 x double> %{{.*}}, %{{.*}}
return _mm_cmp_pd_mask(a, b, _CMP_FALSE_OS);
}
__mmask8 test_mm_cmp_pd_mask_neq_os(__m128d a, __m128d b) {
// CHECK-LABEL: test_mm_cmp_pd_mask_neq_os
// CHECK: fcmp one <2 x double> %{{.*}}, %{{.*}}
return _mm_cmp_pd_mask(a, b, _CMP_NEQ_OS);
}
__mmask8 test_mm_cmp_pd_mask_ge_oq(__m128d a, __m128d b) {
// CHECK-LABEL: test_mm_cmp_pd_mask_ge_oq
// CHECK: fcmp oge <2 x double> %{{.*}}, %{{.*}}
return _mm_cmp_pd_mask(a, b, _CMP_GE_OQ);
}
__mmask8 test_mm_cmp_pd_mask_gt_oq(__m128d a, __m128d b) {
// CHECK-LABEL: test_mm_cmp_pd_mask_gt_oq
// CHECK: fcmp ogt <2 x double> %{{.*}}, %{{.*}}
return _mm_cmp_pd_mask(a, b, _CMP_GT_OQ);
}
__mmask8 test_mm_cmp_pd_mask_true_us(__m128d a, __m128d b) {
// CHECK-LABEL: test_mm_cmp_pd_mask_true_us
// CHECK: fcmp true <2 x double> %{{.*}}, %{{.*}}
return _mm_cmp_pd_mask(a, b, _CMP_TRUE_US);
}
__mmask8 test_mm_mask_cmp_pd_mask_eq_oq(__mmask8 m, __m128d a, __m128d b) {
// CHECK-LABEL: @test_mm_mask_cmp_pd_mask_eq_oq
// CHECK: [[CMP:%.*]] = fcmp oeq <2 x double> %{{.*}}, %{{.*}}
// CHECK: and <2 x i1> [[CMP]], {{.*}}
return _mm_mask_cmp_pd_mask(m, a, b, _CMP_EQ_OQ);
}
__mmask8 test_mm_mask_cmp_pd_mask_lt_os(__mmask8 m, __m128d a, __m128d b) {
// CHECK-LABEL: test_mm_mask_cmp_pd_mask_lt_os
// CHECK: [[CMP:%.*]] = fcmp olt <2 x double> %{{.*}}, %{{.*}}
// CHECK: and <2 x i1> [[CMP]], {{.*}}
return _mm_mask_cmp_pd_mask(m, a, b, _CMP_LT_OS);
}
__mmask8 test_mm_mask_cmp_pd_mask_le_os(__mmask8 m, __m128d a, __m128d b) {
// CHECK-LABEL: test_mm_mask_cmp_pd_mask_le_os
// CHECK: [[CMP:%.*]] = fcmp ole <2 x double> %{{.*}}, %{{.*}}
// CHECK: and <2 x i1> [[CMP]], {{.*}}
return _mm_mask_cmp_pd_mask(m, a, b, _CMP_LE_OS);
}
__mmask8 test_mm_mask_cmp_pd_mask_unord_q(__mmask8 m, __m128d a, __m128d b) {
// CHECK-LABEL: test_mm_mask_cmp_pd_mask_unord_q
// CHECK: [[CMP:%.*]] = fcmp uno <2 x double> %{{.*}}, %{{.*}}
// CHECK: and <2 x i1> [[CMP]], {{.*}}
return _mm_mask_cmp_pd_mask(m, a, b, _CMP_UNORD_Q);
}
__mmask8 test_mm_mask_cmp_pd_mask_neq_uq(__mmask8 m, __m128d a, __m128d b) {
// CHECK-LABEL: test_mm_mask_cmp_pd_mask_neq_uq
// CHECK: [[CMP:%.*]] = fcmp une <2 x double> %{{.*}}, %{{.*}}
// CHECK: and <2 x i1> [[CMP]], {{.*}}
return _mm_mask_cmp_pd_mask(m, a, b, _CMP_NEQ_UQ);
}
__mmask8 test_mm_mask_cmp_pd_mask_nlt_us(__mmask8 m, __m128d a, __m128d b) {
// CHECK-LABEL: test_mm_mask_cmp_pd_mask_nlt_us
// CHECK: [[CMP:%.*]] = fcmp uge <2 x double> %{{.*}}, %{{.*}}
// CHECK: and <2 x i1> [[CMP]], {{.*}}
return _mm_mask_cmp_pd_mask(m, a, b, _CMP_NLT_US);
}
__mmask8 test_mm_mask_cmp_pd_mask_nle_us(__mmask8 m, __m128d a, __m128d b) {
// CHECK-LABEL: test_mm_mask_cmp_pd_mask_nle_us
// CHECK: [[CMP:%.*]] = fcmp ugt <2 x double> %{{.*}}, %{{.*}}
// CHECK: and <2 x i1> [[CMP]], {{.*}}
return _mm_mask_cmp_pd_mask(m, a, b, _CMP_NLE_US);
}
__mmask8 test_mm_mask_cmp_pd_mask_ord_q(__mmask8 m, __m128d a, __m128d b) {
// CHECK-LABEL: test_mm_mask_cmp_pd_mask_ord_q
// CHECK: [[CMP:%.*]] = fcmp ord <2 x double> %{{.*}}, %{{.*}}
// CHECK: and <2 x i1> [[CMP]], {{.*}}
return _mm_mask_cmp_pd_mask(m, a, b, _CMP_ORD_Q);
}
__mmask8 test_mm_mask_cmp_pd_mask_eq_uq(__mmask8 m, __m128d a, __m128d b) {
// CHECK-LABEL: test_mm_mask_cmp_pd_mask_eq_uq
// CHECK: [[CMP:%.*]] = fcmp ueq <2 x double> %{{.*}}, %{{.*}}
// CHECK: and <2 x i1> [[CMP]], {{.*}}
return _mm_mask_cmp_pd_mask(m, a, b, _CMP_EQ_UQ);
}
__mmask8 test_mm_mask_cmp_pd_mask_nge_us(__mmask8 m, __m128d a, __m128d b) {
// CHECK-LABEL: test_mm_mask_cmp_pd_mask_nge_us
// CHECK: [[CMP:%.*]] = fcmp ult <2 x double> %{{.*}}, %{{.*}}
// CHECK: and <2 x i1> [[CMP]], {{.*}}
return _mm_mask_cmp_pd_mask(m, a, b, _CMP_NGE_US);
}
__mmask8 test_mm_mask_cmp_pd_mask_ngt_us(__mmask8 m, __m128d a, __m128d b) {
// CHECK-LABEL: test_mm_mask_cmp_pd_mask_ngt_us
// CHECK: [[CMP:%.*]] = fcmp ule <2 x double> %{{.*}}, %{{.*}}
// CHECK: and <2 x i1> [[CMP]], {{.*}}
return _mm_mask_cmp_pd_mask(m, a, b, _CMP_NGT_US);
}
__mmask8 test_mm_mask_cmp_pd_mask_false_oq(__mmask8 m, __m128d a, __m128d b) {
// CHECK-LABEL: test_mm_mask_cmp_pd_mask_false_oq
// CHECK: [[CMP:%.*]] = fcmp false <2 x double> %{{.*}}, %{{.*}}
// CHECK: and <2 x i1> [[CMP]], {{.*}}
return _mm_mask_cmp_pd_mask(m, a, b, _CMP_FALSE_OQ);
}
__mmask8 test_mm_mask_cmp_pd_mask_neq_oq(__mmask8 m, __m128d a, __m128d b) {
// CHECK-LABEL: test_mm_mask_cmp_pd_mask_neq_oq
// CHECK: [[CMP:%.*]] = fcmp one <2 x double> %{{.*}}, %{{.*}}
// CHECK: and <2 x i1> [[CMP]], {{.*}}
return _mm_mask_cmp_pd_mask(m, a, b, _CMP_NEQ_OQ);
}
__mmask8 test_mm_mask_cmp_pd_mask_ge_os(__mmask8 m, __m128d a, __m128d b) {
// CHECK-LABEL: test_mm_mask_cmp_pd_mask_ge_os
// CHECK: [[CMP:%.*]] = fcmp oge <2 x double> %{{.*}}, %{{.*}}
// CHECK: and <2 x i1> [[CMP]], {{.*}}
return _mm_mask_cmp_pd_mask(m, a, b, _CMP_GE_OS);
}
__mmask8 test_mm_mask_cmp_pd_mask_gt_os(__mmask8 m, __m128d a, __m128d b) {
// CHECK-LABEL: test_mm_mask_cmp_pd_mask_gt_os
// CHECK: [[CMP:%.*]] = fcmp ogt <2 x double> %{{.*}}, %{{.*}}
// CHECK: and <2 x i1> [[CMP]], {{.*}}
return _mm_mask_cmp_pd_mask(m, a, b, _CMP_GT_OS);
}
__mmask8 test_mm_mask_cmp_pd_mask_true_uq(__mmask8 m, __m128d a, __m128d b) {
// CHECK-LABEL: test_mm_mask_cmp_pd_mask_true_uq
// CHECK: [[CMP:%.*]] = fcmp true <2 x double> %{{.*}}, %{{.*}}
// CHECK: and <2 x i1> [[CMP]], {{.*}}
return _mm_mask_cmp_pd_mask(m, a, b, _CMP_TRUE_UQ);
}
__mmask8 test_mm_mask_cmp_pd_mask_eq_os(__mmask8 m, __m128d a, __m128d b) {
// CHECK-LABEL: test_mm_mask_cmp_pd_mask_eq_os
// CHECK: [[CMP:%.*]] = fcmp oeq <2 x double> %{{.*}}, %{{.*}}
// CHECK: and <2 x i1> [[CMP]], {{.*}}
return _mm_mask_cmp_pd_mask(m, a, b, _CMP_EQ_OS);
}
__mmask8 test_mm_mask_cmp_pd_mask_lt_oq(__mmask8 m, __m128d a, __m128d b) {
// CHECK-LABEL: test_mm_mask_cmp_pd_mask_lt_oq
// CHECK: [[CMP:%.*]] = fcmp olt <2 x double> %{{.*}}, %{{.*}}
// CHECK: and <2 x i1> [[CMP]], {{.*}}
return _mm_mask_cmp_pd_mask(m, a, b, _CMP_LT_OQ);
}
__mmask8 test_mm_mask_cmp_pd_mask_le_oq(__mmask8 m, __m128d a, __m128d b) {
// CHECK-LABEL: test_mm_mask_cmp_pd_mask_le_oq
// CHECK: [[CMP:%.*]] = fcmp ole <2 x double> %{{.*}}, %{{.*}}
// CHECK: and <2 x i1> [[CMP]], {{.*}}
return _mm_mask_cmp_pd_mask(m, a, b, _CMP_LE_OQ);
}
__mmask8 test_mm_mask_cmp_pd_mask_unord_s(__mmask8 m, __m128d a, __m128d b) {
// CHECK-LABEL: test_mm_mask_cmp_pd_mask_unord_s
// CHECK: [[CMP:%.*]] = fcmp uno <2 x double> %{{.*}}, %{{.*}}
// CHECK: and <2 x i1> [[CMP]], {{.*}}
return _mm_mask_cmp_pd_mask(m, a, b, _CMP_UNORD_S);
}
__mmask8 test_mm_mask_cmp_pd_mask_neq_us(__mmask8 m, __m128d a, __m128d b) {
// CHECK-LABEL: test_mm_mask_cmp_pd_mask_neq_us
// CHECK: [[CMP:%.*]] = fcmp une <2 x double> %{{.*}}, %{{.*}}
// CHECK: and <2 x i1> [[CMP]], {{.*}}
return _mm_mask_cmp_pd_mask(m, a, b, _CMP_NEQ_US);
}
__mmask8 test_mm_mask_cmp_pd_mask_nlt_uq(__mmask8 m, __m128d a, __m128d b) {
// CHECK-LABEL: test_mm_mask_cmp_pd_mask_nlt_uq
// CHECK: [[CMP:%.*]] = fcmp uge <2 x double> %{{.*}}, %{{.*}}
// CHECK: and <2 x i1> [[CMP]], {{.*}}
return _mm_mask_cmp_pd_mask(m, a, b, _CMP_NLT_UQ);
}
__mmask8 test_mm_mask_cmp_pd_mask_nle_uq(__mmask8 m, __m128d a, __m128d b) {
// CHECK-LABEL: test_mm_mask_cmp_pd_mask_nle_uq
// CHECK: [[CMP:%.*]] = fcmp ugt <2 x double> %{{.*}}, %{{.*}}
// CHECK: and <2 x i1> [[CMP]], {{.*}}
return _mm_mask_cmp_pd_mask(m, a, b, _CMP_NLE_UQ);
}
__mmask8 test_mm_mask_cmp_pd_mask_ord_s(__mmask8 m, __m128d a, __m128d b) {
// CHECK-LABEL: test_mm_mask_cmp_pd_mask_ord_s
// CHECK: [[CMP:%.*]] = fcmp ord <2 x double> %{{.*}}, %{{.*}}
// CHECK: and <2 x i1> [[CMP]], {{.*}}
return _mm_mask_cmp_pd_mask(m, a, b, _CMP_ORD_S);
}
__mmask8 test_mm_mask_cmp_pd_mask_eq_us(__mmask8 m, __m128d a, __m128d b) {
// CHECK-LABEL: test_mm_mask_cmp_pd_mask_eq_us
// CHECK: [[CMP:%.*]] = fcmp ueq <2 x double> %{{.*}}, %{{.*}}
// CHECK: and <2 x i1> [[CMP]], {{.*}}
return _mm_mask_cmp_pd_mask(m, a, b, _CMP_EQ_US);
}
__mmask8 test_mm_mask_cmp_pd_mask_nge_uq(__mmask8 m, __m128d a, __m128d b) {
// CHECK-LABEL: test_mm_mask_cmp_pd_mask_nge_uq
// CHECK: [[CMP:%.*]] = fcmp ult <2 x double> %{{.*}}, %{{.*}}
// CHECK: and <2 x i1> [[CMP]], {{.*}}
return _mm_mask_cmp_pd_mask(m, a, b, _CMP_NGE_UQ);
}
__mmask8 test_mm_mask_cmp_pd_mask_ngt_uq(__mmask8 m, __m128d a, __m128d b) {
// CHECK-LABEL: test_mm_mask_cmp_pd_mask_ngt_uq
// CHECK: [[CMP:%.*]] = fcmp ule <2 x double> %{{.*}}, %{{.*}}
// CHECK: and <2 x i1> [[CMP]], {{.*}}
return _mm_mask_cmp_pd_mask(m, a, b, _CMP_NGT_UQ);
}
__mmask8 test_mm_mask_cmp_pd_mask_false_os(__mmask8 m, __m128d a, __m128d b) {
// CHECK-LABEL: test_mm_mask_cmp_pd_mask_false_os
// CHECK: [[CMP:%.*]] = fcmp false <2 x double> %{{.*}}, %{{.*}}
// CHECK: and <2 x i1> [[CMP]], {{.*}}
return _mm_mask_cmp_pd_mask(m, a, b, _CMP_FALSE_OS);
}
__mmask8 test_mm_mask_cmp_pd_mask_neq_os(__mmask8 m, __m128d a, __m128d b) {
// CHECK-LABEL: test_mm_mask_cmp_pd_mask_neq_os
// CHECK: [[CMP:%.*]] = fcmp one <2 x double> %{{.*}}, %{{.*}}
// CHECK: and <2 x i1> [[CMP]], {{.*}}
return _mm_mask_cmp_pd_mask(m, a, b, _CMP_NEQ_OS);
}
__mmask8 test_mm_mask_cmp_pd_mask_ge_oq(__mmask8 m, __m128d a, __m128d b) {
// CHECK-LABEL: test_mm_mask_cmp_pd_mask_ge_oq
// CHECK: [[CMP:%.*]] = fcmp oge <2 x double> %{{.*}}, %{{.*}}
// CHECK: and <2 x i1> [[CMP]], {{.*}}
return _mm_mask_cmp_pd_mask(m, a, b, _CMP_GE_OQ);
}
__mmask8 test_mm_mask_cmp_pd_mask_gt_oq(__mmask8 m, __m128d a, __m128d b) {
// CHECK-LABEL: test_mm_mask_cmp_pd_mask_gt_oq
// CHECK: [[CMP:%.*]] = fcmp ogt <2 x double> %{{.*}}, %{{.*}}
// CHECK: and <2 x i1> [[CMP]], {{.*}}
return _mm_mask_cmp_pd_mask(m, a, b, _CMP_GT_OQ);
}
__mmask8 test_mm_mask_cmp_pd_mask_true_us(__mmask8 m, __m128d a, __m128d b) {
// CHECK-LABEL: test_mm_mask_cmp_pd_mask_true_us
// CHECK: [[CMP:%.*]] = fcmp true <2 x double> %{{.*}}, %{{.*}}
// CHECK: and <2 x i1> [[CMP]], {{.*}}
return _mm_mask_cmp_pd_mask(m, a, b, _CMP_TRUE_US);
}
__m128d test_mm_mask_fmadd_pd(__m128d __A, __mmask8 __U, __m128d __B, __m128d __C) {
// CHECK-LABEL: @test_mm_mask_fmadd_pd
// CHECK: call <2 x double> @llvm.fma.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x double> %{{.*}})
// CHECK: bitcast i8 %{{.*}} to <8 x i1>
// CHECK: shufflevector <8 x i1> %{{.*}}, <8 x i1> %{{.*}}, <2 x i32> <i32 0, i32 1>
// CHECK: select <2 x i1> %{{.*}}, <2 x double> %{{.*}}, <2 x double> %{{.*}}
return _mm_mask_fmadd_pd(__A, __U, __B, __C);
}
__m128d test_mm_mask_fmsub_pd(__m128d __A, __mmask8 __U, __m128d __B, __m128d __C) {
// CHECK-LABEL: @test_mm_mask_fmsub_pd