| // 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_mask_and_epi32 (__m256i __W, __mmask8 __U, __m256i __A, |
| __m256i __B) { |
| //CHECK-LABEL: @test_mm256_mask_and_epi32 |
| //CHECK: and <4 x i64> %{{.*}}, %{{.*}} |
| 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 <4 x i64> %{{.*}}, %{{.*}} |
| //CHECK: select <8 x i1> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> %{{.*}} |
| return _mm256_maskz_and_epi32(__U, __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 <2 x i64> %{{.*}}, %{{.*}} |
| 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 <2 x i64> %{{.*}}, %{{.*}} |
| //CHECK: select <4 x i1> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}} |
| return _mm_maskz_and_epi32(__U, __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 <4 x i64> %{{.*}}, <i64 -1, i64 -1, i64 -1, i64 -1> |
| //CHECK: and <4 x i64> %{{.*}}, %{{.*}} |
| //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 <4 x i64> %{{.*}}, <i64 -1, i64 -1, i64 -1, i64 -1> |
| //CHECK: and <4 x i64> %{{.*}}, %{{.*}} |
| //CHECK: select <8 x i1> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> %{{.*}} |
| return _mm256_maskz_andnot_epi32(__U, __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 <2 x i64> %{{.*}}, <i64 -1, i64 -1> |
| //CHECK: and <2 x i64> %{{.*}}, %{{.*}} |
| //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 <2 x i64> %{{.*}}, <i64 -1, i64 -1> |
| //CHECK: and <2 x i64> %{{.*}}, %{{.*}} |
| //CHECK: select <4 x i1> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}} |
| return _mm_maskz_andnot_epi32(__U, __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 <4 x i64> %{{.*}}, %{{.*}} |
| 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 <4 x i64> %{{.*}}, %{{.*}} |
| //CHECK: select <8 x i1> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> %{{.*}} |
| return _mm256_maskz_or_epi32(__U, __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 <2 x i64> %{{.*}}, %{{.*}} |
| 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 <2 x i64> %{{.*}}, %{{.*}} |
| //CHECK: select <4 x i1> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}} |
| return _mm_maskz_or_epi32(__U, __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 <4 x i64> %{{.*}}, %{{.*}} |
| 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 <4 x i64> %{{.*}}, %{{.*}} |
| //CHECK: select <8 x i1> %{{.*}}, <8 x i32> %{{.*}}, <8 x i32> %{{.*}} |
| return _mm256_maskz_xor_epi32(__U, __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 <2 x i64> %{{.*}}, %{{.*}} |
| 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 <2 x i64> %{{.*}}, %{{.*}} |
| //CHECK: select <4 x i1> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> %{{.*}} |
| return _mm_maskz_xor_epi32(__U, __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> %{{.*}}, %{{.*}} |
| 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_mask_and_epi64 (__m128i __W, __mmask8 __U, __m128i __A, |
| __m128i __B) { |
| //CHECK-LABEL: @test_mm_mask_and_epi64 |
| //CHECK: and <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_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_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_mask_or_epi64 (__m256i __W, __mmask8 __U, __m256i __A, |
| __m256i __B) { |
| //CHECK-LABEL: @test_mm256_mask_or_epi64 |
| //CHECK: or <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_mask_or_epi64 (__m128i __W, __mmask8 __U, __m128i __A, __m128i __B) { |
| //CHECK-LABEL: @test_mm_mask_or_epi64 |
| //CHECK: or <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_mask_xor_epi64 (__m256i __W, __mmask8 __U, __m256i __A, |
| __m256i __B) { |
| //CHECK-LABEL: @test_mm256_mask_xor_epi64 |
| //CHECK: xor <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_mask_xor_epi64 (__m128i __W, __mmask8 __U, __m128i __A, __m128i __B) { |
| //CHECK-LABEL: @test_mm_mask_xor_epi64 |
| //CHECK: xor <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 |
| // CHECK: fsub <2 x double> <double -0.000000e+00, double -0.000000e+00>, %{{.*}} |
| // 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_fmsub_pd(__A, __U, __B, __C); |
| } |
| |
| __m128d test_mm_mask3_fmadd_pd(__m128d __A, __m128d __B, __m128d __C, __mmask8 __U) { |
| // CHECK-LABEL: @test_mm_mask3_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_mask3_fmadd_pd(__A, __B, __C, __U); |
| } |
| |
| __m128d test_mm_mask3_fnmadd_pd(__m128d __A, __m128d __B, __m128d __C, __mmask8 __U) { |
| // CHECK-LABEL: @test_mm_mask3_fnmadd_pd |
| // CHECK: fsub <2 x double> <double -0.000000e+00, double -0.000000e+00>, %{{.*}} |
| // 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_mask3_fnmadd_pd(__A, __B, __C, __U); |
| } |
| |
| __m128d test_mm_maskz_fmadd_pd(__mmask8 __U, __m128d __A, __m128d __B, __m128d __C) { |
| // CHECK-LABEL: @test_mm_maskz_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_maskz_fmadd_pd(__U, __A, __B, __C); |
| } |
| |
| __m128d test_mm_maskz_fmsub_pd(__mmask8 __U, __m128d __A, __m128d __B, __m128d __C) { |
| // CHECK-LABEL: @test_mm_maskz_fmsub_pd |
| // CHECK: fsub <2 x double> <double -0.000000e+00, double -0.000000e+00>, %{{.*}} |
| // 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_maskz_fmsub_pd(__U, __A, __B, __C); |
| } |
| |
| __m128d test_mm_maskz_fnmadd_pd(__mmask8 __U, __m128d __A, __m128d __B, __m128d __C) { |
| // CHECK-LABEL: @test_mm_maskz_fnmadd_pd |
| // CHECK: fsub <2 x double> <double -0.000000e+00, double -0.000000e+00>, %{{.*}} |
| // 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_maskz_fnmadd_pd(__U, __A, __B, __C); |
| } |
| |
| __m128d test_mm_maskz_fnmsub_pd(__mmask8 __U, __m128d __A, __m128d __B, __m128d __C) { |
| // CHECK-LABEL: @test_mm_maskz_fnmsub_pd |
| // CHECK: fsub <2 x double> <double -0.000000e+00, double -0.000000e+00>, %{{.*}} |
| // CHECK: fsub <2 x double> <double -0.000000e+00, double -0.000000e+00>, %{{.*}} |
| // 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_maskz_fnmsub_pd(__U, __A, __B, __C); |
| } |
| |
| __m256d test_mm256_mask_fmadd_pd(__m256d __A, __mmask8 __U, __m256d __B, __m256d __C) { |
| // CHECK-LABEL: @test_mm256_mask_fmadd_pd |
| // CHECK: call <4 x double> @llvm.fma.v4f64(<4 x double> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}}) |
| // CHECK: bitcast i8 %{{.*}} to <8 x i1> |
| // CHECK: shufflevector <8 x i1> %{{.*}}, <8 x i1> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3> |
| // CHECK: select <4 x i1> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}} |
| return _mm256_mask_fmadd_pd(__A, __U, __B, __C); |
| } |
| |
| __m256d test_mm256_mask_fmsub_pd(__m256d __A, __mmask8 __U, __m256d __B, __m256d __C) { |
| // CHECK-LABEL: @test_mm256_mask_fmsub_pd |
| // CHECK: fsub <4 x double> <double -0.000000e+00, double -0.000000e+00, double -0.000000e+00, double -0.000000e+00>, %{{.*}} |
| // CHECK: call <4 x double> @llvm.fma.v4f64(<4 x double> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}}) |
| // CHECK: bitcast i8 %{{.*}} to <8 x i1> |
| // CHECK: shufflevector <8 x i1> %{{.*}}, <8 x i1> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3> |
| // CHECK: select <4 x i1> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}} |
| return _mm256_mask_fmsub_pd(__A, __U, __B, __C); |
| } |
| |
| __m256d test_mm256_mask3_fmadd_pd(__m256d __A, __m256d __B, __m256d __C, __mmask8 __U) { |
| // CHECK-LABEL: @test_mm256_mask3_fmadd_pd |
| // CHECK: call <4 x double> @llvm.fma.v4f64(<4 x double> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}}) |
| // CHECK: bitcast i8 %{{.*}} to <8 x i1> |
| // CHECK: shufflevector <8 x i1> %{{.*}}, <8 x i1> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3> |
| // CHECK: select <4 x i1> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}} |
| return _mm256_mask3_fmadd_pd(__A, __B, __C, __U); |
| } |
| |
| __m256d test_mm256_mask3_fnmadd_pd(__m256d __A, __m256d __B, __m256d __C, __mmask8 __U) { |
| // CHECK-LABEL: @test_mm256_mask3_fnmadd_pd |
| // CHECK: fsub <4 x double> <double -0.000000e+00, double -0.000000e+00, double -0.000000e+00, double -0.000000e+00>, %{{.*}} |
| // CHECK: call <4 x double> @llvm.fma.v4f64(<4 x double> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}}) |
| // CHECK: bitcast i8 %{{.*}} to <8 x i1> |
| // CHECK: shufflevector <8 x i1> %{{.*}}, <8 x i1> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3> |
| // CHECK: select <4 x i1> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}} |
| return _mm256_mask3_fnmadd_pd(__A, __B, __C, __U); |
| } |
| |
| __m256d test_mm256_maskz_fmadd_pd(__mmask8 __U, __m256d __A, __m256d __B, __m256d __C) { |
| // CHECK-LABEL: @test_mm256_maskz_fmadd_pd |
| // CHECK: call <4 x double> @llvm.fma.v4f64(<4 x double> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}}) |
| // CHECK: bitcast i8 %{{.*}} to <8 x i1> |
| // CHECK: shufflevector <8 x i1> %{{.*}}, <8 x i1> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3> |
| // CHECK: select <4 x i1> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}} |
| return _mm256_maskz_fmadd_pd(__U, __A, __B, __C); |
| } |
| |
| __m256d test_mm256_maskz_fmsub_pd(__mmask8 __U, __m256d __A, __m256d __B, __m256d __C) { |
| // CHECK-LABEL: @test_mm256_maskz_fmsub_pd |
| // CHECK: fsub <4 x double> <double -0.000000e+00, double -0.000000e+00, double -0.000000e+00, double -0.000000e+00>, %{{.*}} |
| // CHECK: call <4 x double> @llvm.fma.v4f64(<4 x double> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}}) |
| // CHECK: bitcast i8 %{{.*}} to <8 x i1> |
| // CHECK: shufflevector <8 x i1> %{{.*}}, <8 x i1> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3> |
| // CHECK: select <4 x i1> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}} |
| return _mm256_maskz_fmsub_pd(__U, __A, __B, __C); |
| } |
| |
| __m256d test_mm256_maskz_fnmadd_pd(__mmask8 __U, __m256d __A, __m256d __B, __m256d __C) { |
| // CHECK-LABEL: @test_mm256_maskz_fnmadd_pd |
| // CHECK: fsub <4 x double> <double -0.000000e+00, double -0.000000e+00, double -0.000000e+00, double -0.000000e+00>, %{{.*}} |
| // CHECK: call <4 x double> @llvm.fma.v4f64(<4 x double> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}}) |
| // CHECK: bitcast i8 %{{.*}} to <8 x i1> |
| // CHECK: shufflevector <8 x i1> %{{.*}}, <8 x i1> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3> |
| // CHECK: select <4 x i1> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}} |
| return _mm256_maskz_fnmadd_pd(__U, __A, __B, __C); |
| } |
| |
| __m256d test_mm256_maskz_fnmsub_pd(__mmask8 __U, __m256d __A, __m256d __B, __m256d __C) { |
| // CHECK-LABEL: @test_mm256_maskz_fnmsub_pd |
| // CHECK: fsub <4 x double> <double -0.000000e+00, double -0.000000e+00, double -0.000000e+00, double -0.000000e+00>, %{{.*}} |
| // CHECK: fsub <4 x double> <double -0.000000e+00, double -0.000000e+00, double -0.000000e+00, double -0.000000e+00>, %{{.*}} |
| // CHECK: call <4 x double> @llvm.fma.v4f64(<4 x double> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}}) |
| // CHECK: bitcast i8 %{{.*}} to <8 x i1> |
| // CHECK: shufflevector <8 x i1> %{{.*}}, <8 x i1> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3> |
| // CHECK: select <4 x i1> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}} |
| return _mm256_maskz_fnmsub_pd(__U, __A, __B, __C); |
| } |
| |
| __m128 test_mm_mask_fmadd_ps(__m128 __A, __mmask8 __U, __m128 __B, __m128 __C) { |
| // CHECK-LABEL: @test_mm_mask_fmadd_ps |
| // CHECK: call <4 x float> @llvm.fma.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}}) |
| // CHECK: bitcast i8 %{{.*}} to <8 x i1> |
| // CHECK: shufflevector <8 x i1> %{{.*}}, <8 x i1> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3> |
| // CHECK: select <4 x i1> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}} |
| return _mm_mask_fmadd_ps(__A, __U, __B, __C); |
| } |
| |
| __m128 test_mm_mask_fmsub_ps(__m128 __A, __mmask8 __U, __m128 __B, __m128 __C) { |
| // CHECK-LABEL: @test_mm_mask_fmsub_ps |
| // CHECK: fsub <4 x float> <float -0.000000e+00, float -0.000000e+00, float -0.000000e+00, float -0.000000e+00>, %{{.*}} |
| // CHECK: call <4 x float> @llvm.fma.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}}) |
| // CHECK: bitcast i8 %{{.*}} to <8 x i1> |
| // CHECK: shufflevector <8 x i1> %{{.*}}, <8 x i1> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3> |
| // CHECK: select <4 x i1> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}} |
| return _mm_mask_fmsub_ps(__A, __U, __B, __C); |
| } |
| |
| __m128 test_mm_mask3_fmadd_ps(__m128 __A, __m128 __B, __m128 __C, __mmask8 __U) { |
| // CHECK-LABEL: @test_mm_mask3_fmadd_ps |
| // CHECK: call <4 x float> @llvm.fma.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}}) |
| // CHECK: bitcast i8 %{{.*}} to <8 x i1> |
| // CHECK: shufflevector <8 x i1> %{{.*}}, <8 x i1> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3> |
| // CHECK: select <4 x i1> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}} |
| return _mm_mask3_fmadd_ps(__A, __B, __C, __U); |
| } |
| |
| __m128 test_mm_mask3_fnmadd_ps(__m128 __A, __m128 __B, __m128 __C, __mmask8 __U) { |
| // CHECK-LABEL: @test_mm_mask3_fnmadd_ps |
| // CHECK: fsub <4 x float> <float -0.000000e+00, float -0.000000e+00, float -0.000000e+00, float -0.000000e+00>, %{{.*}} |
| // CHECK: call <4 x float> @llvm.fma.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}}) |
| // CHECK: bitcast i8 %{{.*}} to <8 x i1> |
| // CHECK: shufflevector <8 x i1> %{{.*}}, <8 x i1> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3> |
| // CHECK: select <4 x i1> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}} |
| return _mm_mask3_fnmadd_ps(__A, __B, __C, __U); |
| } |
| |
| __m128 test_mm_maskz_fmadd_ps(__mmask8 __U, __m128 __A, __m128 __B, __m128 __C) { |
| // CHECK-LABEL: @test_mm_maskz_fmadd_ps |
| // CHECK: call <4 x float> @llvm.fma.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}}) |
| // CHECK: bitcast i8 %{{.*}} to <8 x i1> |
| // CHECK: shufflevector <8 x i1> %{{.*}}, <8 x i1> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3> |
| // CHECK: select <4 x i1> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}} |
| return _mm_maskz_fmadd_ps(__U, __A, __B, __C); |
| } |
| |
| __m128 test_mm_maskz_fmsub_ps(__mmask8 __U, __m128 __A, __m128 __B, __m128 __C) { |
| // CHECK-LABEL: @test_mm_maskz_fmsub_ps |
| // CHECK: fsub <4 x float> <float -0.000000e+00, float -0.000000e+00, float -0.000000e+00, float -0.000000e+00>, %{{.*}} |
| // CHECK: call <4 x float> @llvm.fma.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}}) |
| // CHECK: bitcast i8 %{{.*}} to <8 x i1> |
| // CHECK: shufflevector <8 x i1> %{{.*}}, <8 x i1> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3> |
| // CHECK: select <4 x i1> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}} |
| return _mm_maskz_fmsub_ps(__U, __A, __B, __C); |
| } |
| |
| __m128 test_mm_maskz_fnmadd_ps(__mmask8 __U, __m128 __A, __m128 __B, __m128 __C) { |
| // CHECK-LABEL: @test_mm_maskz_fnmadd_ps |
| // CHECK: fsub <4 x float> <float -0.000000e+00, float -0.000000e+00, float -0.000000e+00, float -0.000000e+00>, %{{.*}} |
| // CHECK: call <4 x float> @llvm.fma.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}}) |
| // CHECK: bitcast i8 %{{.*}} to <8 x i1> |
| // CHECK: shufflevector <8 x i1> %{{.*}}, <8 x i1> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3> |
| // CHECK: select <4 x i1> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}} |
| return _mm_maskz_fnmadd_ps(__U, __A, __B, __C); |
| } |
| |
| __m128 test_mm_maskz_fnmsub_ps(__mmask8 __U, __m128 __A, __m128 __B, __m128 __C) { |
| // CHECK-LABEL: @test_mm_maskz_fnmsub_ps |
| // CHECK: fsub <4 x float> <float -0.000000e+00, float -0.000000e+00, float -0.000000e+00, float -0.000000e+00>, %{{.*}} |
| // CHECK: fsub <4 x float> <float -0.000000e+00, float -0.000000e+00, float -0.000000e+00, float -0.000000e+00>, %{{.*}} |
| // CHECK: call <4 x float> @llvm.fma.v4f32(<4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}}) |
| // CHECK: bitcast i8 %{{.*}} to <8 x i1> |
| // CHECK: shufflevector <8 x i1> %{{.*}}, <8 x i1> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3> |
| // CHECK: select <4 x i1> %{{.*}}, <4 x float> %{{.*}}, <4 x float> %{{.*}} |
| return _mm_maskz_fnmsub_ps(__U, __A, __B, __C); |
| } |
| |
| __m256 test_mm256_mask_fmadd_ps(__m256 __A, __mmask8 __U, __m256 __B, __m256 __C) { |
| // CHECK-LABEL: @test_mm256_mask_fmadd_ps |
| // CHECK: call <8 x float> @llvm.fma.v8f32(<8 x float> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}}) |
| // CHECK: bitcast i8 %{{.*}} to <8 x i1> |
| // CHECK: select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}} |
| return _mm256_mask_fmadd_ps(__A, __U, __B, __C); |
| } |
| |
| __m256 test_mm256_mask_fmsub_ps(__m256 __A, __mmask8 __U, __m256 __B, __m256 __C) { |
| // CHECK-LABEL: @test_mm256_mask_fmsub_ps |
| // CHECK: fsub <8 x float> <float -0.000000e+00, float -0.000000e+00, float -0.000000e+00, float -0.000000e+00, float -0.000000e+00, float -0.000000e+00, float -0.000000e+00, float -0.000000e+00>, %{{.*}} |
| // CHECK: call <8 x float> @llvm.fma.v8f32(<8 x float> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}}) |
| // CHECK: bitcast i8 %{{.*}} to <8 x i1> |
| // CHECK: select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}} |
| return _mm256_mask_fmsub_ps(__A, __U, __B, __C); |
| } |
| |
| __m256 test_mm256_mask3_fmadd_ps(__m256 __A, __m256 __B, __m256 __C, __mmask8 __U) { |
| // CHECK-LABEL: @test_mm256_mask3_fmadd_ps |
| // CHECK: call <8 x float> @llvm.fma.v8f32(<8 x float> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}}) |
| // CHECK: bitcast i8 %{{.*}} to <8 x i1> |
| // CHECK: select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}} |
| return _mm256_mask3_fmadd_ps(__A, __B, __C, __U); |
| } |
| |
| __m256 test_mm256_mask3_fnmadd_ps(__m256 __A, __m256 __B, __m256 __C, __mmask8 __U) { |
| // CHECK-LABEL: @test_mm256_mask3_fnmadd_ps |
| // CHECK: fsub <8 x float> <float -0.000000e+00, float -0.000000e+00, float -0.000000e+00, float -0.000000e+00, float -0.000000e+00, float -0.000000e+00, float -0.000000e+00, float -0.000000e+00>, %{{.*}} |
| // CHECK: call <8 x float> @llvm.fma.v8f32(<8 x float> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}}) |
| // CHECK: bitcast i8 %{{.*}} to <8 x i1> |
| // CHECK: select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}} |
| return _mm256_mask3_fnmadd_ps(__A, __B, __C, __U); |
| } |
| |
| __m256 test_mm256_maskz_fmadd_ps(__mmask8 __U, __m256 __A, __m256 __B, __m256 __C) { |
| // CHECK-LABEL: @test_mm256_maskz_fmadd_ps |
| // CHECK: call <8 x float> @llvm.fma.v8f32(<8 x float> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}}) |
| // CHECK: bitcast i8 %{{.*}} to <8 x i1> |
| // CHECK: select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}} |
| return _mm256_maskz_fmadd_ps(__U, __A, __B, __C); |
| } |
| |
| __m256 test_mm256_maskz_fmsub_ps(__mmask8 __U, __m256 __A, __m256 __B, __m256 __C) { |
| // CHECK-LABEL: @test_mm256_maskz_fmsub_ps |
| // CHECK: fsub <8 x float> <float -0.000000e+00, float -0.000000e+00, float -0.000000e+00, float -0.000000e+00, float -0.000000e+00, float -0.000000e+00, float -0.000000e+00, float -0.000000e+00>, %{{.*}} |
| // CHECK: call <8 x float> @llvm.fma.v8f32(<8 x float> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}}) |
| // CHECK: bitcast i8 %{{.*}} to <8 x i1> |
| // CHECK: select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}} |
| return _mm256_maskz_fmsub_ps(__U, __A, __B, __C); |
| } |
| |
| __m256 test_mm256_maskz_fnmadd_ps(__mmask8 __U, __m256 __A, __m256 __B, __m256 __C) { |
| // CHECK-LABEL: @test_mm256_maskz_fnmadd_ps |
| // CHECK: fsub <8 x float> <float -0.000000e+00, float -0.000000e+00, float -0.000000e+00, float -0.000000e+00, float -0.000000e+00, float -0.000000e+00, float -0.000000e+00, float -0.000000e+00>, %{{.*}} |
| // CHECK: call <8 x float> @llvm.fma.v8f32(<8 x float> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}}) |
| // CHECK: bitcast i8 %{{.*}} to <8 x i1> |
| // CHECK: select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}} |
| return _mm256_maskz_fnmadd_ps(__U, __A, __B, __C); |
| } |
| |
| __m256 test_mm256_maskz_fnmsub_ps(__mmask8 __U, __m256 __A, __m256 __B, __m256 __C) { |
| // CHECK-LABEL: @test_mm256_maskz_fnmsub_ps |
| // CHECK: fsub <8 x float> <float -0.000000e+00, float -0.000000e+00, float -0.000000e+00, float -0.000000e+00, float -0.000000e+00, float -0.000000e+00, float -0.000000e+00, float -0.000000e+00>, %{{.*}} |
| // CHECK: fsub <8 x float> <float -0.000000e+00, float -0.000000e+00, float -0.000000e+00, float -0.000000e+00, float -0.000000e+00, float -0.000000e+00, float -0.000000e+00, float -0.000000e+00>, %{{.*}} |
| // CHECK: call <8 x float> @llvm.fma.v8f32(<8 x float> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}}) |
| // CHECK: bitcast i8 %{{.*}} to <8 x i1> |
| // CHECK: select <8 x i1> %{{.*}}, <8 x float> %{{.*}}, <8 x float> %{{.*}} |
| return _mm256_maskz_fnmsub_ps(__U, __A, __B, __C); |
| } |
| |
| __m128d test_mm_mask_fmaddsub_pd(__m128d __A, __mmask8 __U, __m128d __B, __m128d __C) { |
| // CHECK-LABEL: @test_mm_mask_fmaddsub_pd |
| // CHECK: [[ADD:%.+]] = call <2 x double> @llvm.fma.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x double> %{{.*}}) |
| // CHECK: [[NEG:%.+]] = fsub <2 x double> <double -0.000000e+00, double -0.000000e+00>, %{{.+}} |
| // CHECK: [[SUB:%.+]] = call <2 x double> @llvm.fma.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x double> [[NEG]] |
| // CHECK: shufflevector <2 x double> [[SUB]], <2 x double> [[ADD]], <2 x i32> <i32 0, i32 3> |
| // 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_fmaddsub_pd(__A, __U, __B, __C); |
| } |
| |
| __m128d test_mm_mask_fmsubadd_pd(__m128d __A, __mmask8 __U, __m128d __B, __m128d __C) { |
| // CHECK-LABEL: @test_mm_mask_fmsubadd_pd |
| // CHECK: [[NEG:%.+]] = fsub <2 x double> <double -0.000000e+00, double -0.000000e+00>, %{{.+}} |
| // CHECK: [[SUB:%.+]] = call <2 x double> @llvm.fma.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x double> [[NEG]] |
| // CHECK: [[ADD:%.+]] = call <2 x double> @llvm.fma.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x double> %{{.*}}) |
| // CHECK: shufflevector <2 x double> [[ADD]], <2 x double> [[SUB]], <2 x i32> <i32 0, i32 3> |
| // 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_fmsubadd_pd(__A, __U, __B, __C); |
| } |
| |
| __m128d test_mm_mask3_fmaddsub_pd(__m128d __A, __m128d __B, __m128d __C, __mmask8 __U) { |
| // CHECK-LABEL: @test_mm_mask3_fmaddsub_pd |
| // CHECK: [[ADD:%.+]] = call <2 x double> @llvm.fma.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x double> %{{.*}}) |
| // CHECK: [[NEG:%.+]] = fsub <2 x double> <double -0.000000e+00, double -0.000000e+00>, %{{.+}} |
| // CHECK: [[SUB:%.+]] = call <2 x double> @llvm.fma.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x double> [[NEG]] |
| // CHECK: shufflevector <2 x double> [[SUB]], <2 x double> [[ADD]], <2 x i32> <i32 0, i32 3> |
| // 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_mask3_fmaddsub_pd(__A, __B, __C, __U); |
| } |
| |
| __m128d test_mm_maskz_fmaddsub_pd(__mmask8 __U, __m128d __A, __m128d __B, __m128d __C) { |
| // CHECK-LABEL: @test_mm_maskz_fmaddsub_pd |
| // CHECK: [[ADD:%.+]] = call <2 x double> @llvm.fma.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x double> %{{.*}}) |
| // CHECK: [[NEG:%.+]] = fsub <2 x double> <double -0.000000e+00, double -0.000000e+00>, %{{.+}} |
| // CHECK: [[SUB:%.+]] = call <2 x double> @llvm.fma.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x double> [[NEG]] |
| // CHECK: shufflevector <2 x double> [[SUB]], <2 x double> [[ADD]], <2 x i32> <i32 0, i32 3> |
| // 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_maskz_fmaddsub_pd(__U, __A, __B, __C); |
| } |
| |
| __m128d test_mm_maskz_fmsubadd_pd(__mmask8 __U, __m128d __A, __m128d __B, __m128d __C) { |
| // CHECK-LABEL: @test_mm_maskz_fmsubadd_pd |
| // CHECK: [[NEG:%.+]] = fsub <2 x double> <double -0.000000e+00, double -0.000000e+00>, %{{.+}} |
| // CHECK: [[SUB:%.+]] = call <2 x double> @llvm.fma.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x double> [[NEG]] |
| // CHECK: [[ADD:%.+]] = call <2 x double> @llvm.fma.v2f64(<2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x double> %{{.*}}) |
| // CHECK: shufflevector <2 x double> [[ADD]], <2 x double> [[SUB]], <2 x i32> <i32 0, i32 3> |
| // 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_maskz_fmsubadd_pd(__U, __A, __B, __C); |
| } |
| |
| __m256d test_mm256_mask_fmaddsub_pd(__m256d __A, __mmask8 __U, __m256d __B, __m256d __C) { |
| // CHECK-LABEL: @test_mm256_mask_fmaddsub_pd |
| // CHECK: [[ADD:%.+]] = call <4 x double> @llvm.fma.v4f64(<4 x double> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}}) |
| // CHECK: [[NEG:%.+]] = fsub <4 x double> <double -0.000000e+00, double -0.000000e+00, double -0.000000e+00, double -0.000000e+00>, %{{.+}} |
| // CHECK: [[SUB:%.+]] = call <4 x double> @llvm.fma.v4f64(<4 x double> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}}) |
| // CHECK: shufflevector <4 x double> [[SUB]], <4 x double> [[ADD]], <4 x i32> <i32 0, i32 5, i32 2, i32 7> |
| // CHECK: bitcast i8 %{{.*}} to <8 x i1> |
| // CHECK: shufflevector <8 x i1> %{{.*}}, <8 x i1> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3> |
| // CHECK: select <4 x i1> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}} |
| return _mm256_mask_fmaddsub_pd(__A, __U, __B, __C); |
| } |
| |
| __m256d test_mm256_mask_fmsubadd_pd(__m256d __A, __mmask8 __U, __m256d __B, __m256d __C) { |
| // CHECK-LABEL: @test_mm256_mask_fmsubadd_pd |
| // CHECK: [[NEG:%.+]] = fsub <4 x double> <double -0.000000e+00, double -0.000000e+00, double -0.000000e+00, double -0.000000e+00>, %{{.+}} |
| // CHECK: [[SUB:%.+]] = call <4 x double> @llvm.fma.v4f64(<4 x double> %{{.*}}, <4 x double> %{{.*}}, <4 x double> [[NEG]] |
| // CHECK: [[ADD:%.+]] = call <4 x double> @llvm.fma.v4f64(<4 x double> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}}) |
| // CHECK: shufflevector <4 x double> [[ADD]], <4 x double> [[SUB]], <4 x i32> <i32 0, i32 5, i32 2, i32 7> |
| // CHECK: bitcast i8 %{{.*}} to <8 x i1> |
| // CHECK: shufflevector <8 x i1> %{{.*}}, <8 x i1> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3> |
| // CHECK: select <4 x i1> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}} |
| return _mm256_mask_fmsubadd_pd(__A, __U, __B, __C); |
| } |
| |
| __m256d test_mm256_mask3_fmaddsub_pd(__m256d __A, __m256d __B, __m256d __C, __mmask8 __U) { |
| // CHECK-LABEL: @test_mm256_mask3_fmaddsub_pd |
| // CHECK: [[ADD:%.+]] = call <4 x double> @llvm.fma.v4f64(<4 x double> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}}) |
| // CHECK: [[NEG:%.+]] = fsub <4 x double> <double -0.000000e+00, double -0.000000e+00, double -0.000000e+00, double -0.000000e+00>, %{{.+}} |
| // CHECK: [[SUB:%.+]] = call <4 x double> @llvm.fma.v4f64(<4 x double> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}}) |
| // CHECK: shufflevector <4 x double> [[SUB]], <4 x double> [[ADD]], <4 x i32> <i32 0, i32 5, i32 2, i32 7> |
| // CHECK: bitcast i8 %{{.*}} to <8 x i1> |
| // CHECK: shufflevector <8 x i1> %{{.*}}, <8 x i1> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3> |
| // CHECK: select <4 x i1> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}} |
| return _mm256_mask3_fmaddsub_pd(__A, __B, __C, __U); |
| } |
| |
| __m256d test_mm256_maskz_fmaddsub_pd(__mmask8 __U, __m256d __A, __m256d __B, __m256d __C) { |
| // CHECK-LABEL: @test_mm256_maskz_fmaddsub_pd |
| // CHECK: [[ADD:%.+]] = call <4 x double> @llvm.fma.v4f64(<4 x double> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}}) |
| // CHECK: [[NEG:%.+]] = fsub <4 x double> <double -0.000000e+00, double -0.000000e+00, double -0.000000e+00, double -0.000000e+00>, %{{.+}} |
| // CHECK: [[SUB:%.+]] = call <4 x double> @llvm.fma.v4f64(<4 x double> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}}) |
| // CHECK: shufflevector <4 x double> [[SUB]], <4 x double> [[ADD]], <4 x i32> <i32 0, i32 5, i32 2, i32 7> |
| // CHECK: bitcast i8 %{{.*}} to <8 x i1> |
| // CHECK: shufflevector <8 x i1> %{{.*}}, <8 x i1> %{{.*}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3> |
| // CHECK: select <4 x i1> %{{.*}}, <4 x double> %{{.*}}, <4 x double> %{{.*}} |
| return _mm256_maskz_fmaddsub_pd(__U, __A, __B, __C); |
| } |
|