From: Simon Pilgrim Date: Thu, 3 Dec 2015 08:45:21 +0000 (+0000) Subject: [X86] Stripped backend codegen tests X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=fafcf339e8ba54a02504ba2163c55fac6af856bd;p=clang [X86] Stripped backend codegen tests As discussed on the ml, backend tests need to be put in llvm/test/CodeGen/X86 as fast-isel tests using IR that is as close to what is generated here as possible. The llvm tests will (re)added in a future commit I will update PR24580 on this new plan git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@254594 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/test/CodeGen/fma4-builtins.c b/test/CodeGen/fma4-builtins.c index 27cd093864..69cbcd83d3 100644 --- a/test/CodeGen/fma4-builtins.c +++ b/test/CodeGen/fma4-builtins.c @@ -1,6 +1,4 @@ -// REQUIRES: x86-registered-target // RUN: %clang_cc1 %s -triple=x86_64-apple-darwin -target-feature +fma4 -emit-llvm -o - -Werror | FileCheck %s -// RUN: %clang_cc1 %s -triple=x86_64-apple-darwin -target-feature +fma4 -S -o - -Werror | FileCheck %s --check-prefix=CHECK-ASM // Don't include mm_malloc.h, it's system specific. #define __MM_MALLOC_H @@ -8,193 +6,193 @@ #include __m128 test_mm_macc_ps(__m128 a, __m128 b, __m128 c) { + // CHECK-LABEL: test_mm_macc_ps // CHECK: @llvm.x86.fma.vfmadd.ps - // CHECK-ASM: vfmaddps %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}} return _mm_macc_ps(a, b, c); } __m128d test_mm_macc_pd(__m128d a, __m128d b, __m128d c) { + // CHECK-LABEL: test_mm_macc_pd // CHECK: @llvm.x86.fma.vfmadd.pd - // CHECK-ASM: vfmaddpd %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}} return _mm_macc_pd(a, b, c); } __m128 test_mm_macc_ss(__m128 a, __m128 b, __m128 c) { + // CHECK-LABEL: test_mm_macc_ss // CHECK: @llvm.x86.fma.vfmadd.ss - // CHECK-ASM: vfmaddss %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}} return _mm_macc_ss(a, b, c); } __m128d test_mm_macc_sd(__m128d a, __m128d b, __m128d c) { + // CHECK-LABEL: test_mm_macc_sd // CHECK: @llvm.x86.fma.vfmadd.sd - // CHECK-ASM: vfmaddsd %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}} return _mm_macc_sd(a, b, c); } __m128 test_mm_msub_ps(__m128 a, __m128 b, __m128 c) { + // CHECK-LABEL: test_mm_msub_ps // CHECK: @llvm.x86.fma.vfmsub.ps - // CHECK-ASM: vfmsubps %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}} return _mm_msub_ps(a, b, c); } __m128d test_mm_msub_pd(__m128d a, __m128d b, __m128d c) { + // CHECK-LABEL: test_mm_msub_pd // CHECK: @llvm.x86.fma.vfmsub.pd - // CHECK-ASM: vfmsubpd %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}} return _mm_msub_pd(a, b, c); } __m128 test_mm_msub_ss(__m128 a, __m128 b, __m128 c) { + // CHECK-LABEL: test_mm_msub_ss // CHECK: @llvm.x86.fma.vfmsub.ss - // CHECK-ASM: vfmsubss %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}} return _mm_msub_ss(a, b, c); } __m128d test_mm_msub_sd(__m128d a, __m128d b, __m128d c) { + // CHECK-LABEL: test_mm_msub_sd // CHECK: @llvm.x86.fma.vfmsub.sd - // CHECK-ASM: vfmsubsd %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}} return _mm_msub_sd(a, b, c); } __m128 test_mm_nmacc_ps(__m128 a, __m128 b, __m128 c) { + // CHECK-LABEL: test_mm_nmacc_ps // CHECK: @llvm.x86.fma.vfnmadd.ps - // CHECK-ASM: vfnmaddps %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}} return _mm_nmacc_ps(a, b, c); } __m128d test_mm_nmacc_pd(__m128d a, __m128d b, __m128d c) { + // CHECK-LABEL: test_mm_nmacc_pd // CHECK: @llvm.x86.fma.vfnmadd.pd - // CHECK-ASM: vfnmaddpd %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}} return _mm_nmacc_pd(a, b, c); } __m128 test_mm_nmacc_ss(__m128 a, __m128 b, __m128 c) { + // CHECK-LABEL: test_mm_nmacc_ss // CHECK: @llvm.x86.fma.vfnmadd.ss - // CHECK-ASM: vfnmaddss %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}} return _mm_nmacc_ss(a, b, c); } __m128d test_mm_nmacc_sd(__m128d a, __m128d b, __m128d c) { + // CHECK-LABEL: test_mm_nmacc_sd // CHECK: @llvm.x86.fma.vfnmadd.sd - // CHECK-ASM: vfnmaddsd %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}} return _mm_nmacc_sd(a, b, c); } __m128 test_mm_nmsub_ps(__m128 a, __m128 b, __m128 c) { + // CHECK-LABEL: test_mm_nmsub_ps // CHECK: @llvm.x86.fma.vfnmsub.ps - // CHECK-ASM: vfnmsubps %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}} return _mm_nmsub_ps(a, b, c); } __m128d test_mm_nmsub_pd(__m128d a, __m128d b, __m128d c) { + // CHECK-LABEL: test_mm_nmsub_pd // CHECK: @llvm.x86.fma.vfnmsub.pd - // CHECK-ASM: vfnmsubpd %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}} return _mm_nmsub_pd(a, b, c); } __m128 test_mm_nmsub_ss(__m128 a, __m128 b, __m128 c) { + // CHECK-LABEL: test_mm_nmsub_ss // CHECK: @llvm.x86.fma.vfnmsub.ss - // CHECK-ASM: vfnmsubss %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}} return _mm_nmsub_ss(a, b, c); } __m128d test_mm_nmsub_sd(__m128d a, __m128d b, __m128d c) { + // CHECK-LABEL: test_mm_nmsub_sd // CHECK: @llvm.x86.fma.vfnmsub.sd - // CHECK-ASM: vfnmsubsd %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}} return _mm_nmsub_sd(a, b, c); } __m128 test_mm_maddsub_ps(__m128 a, __m128 b, __m128 c) { + // CHECK-LABEL: test_mm_maddsub_ps // CHECK: @llvm.x86.fma.vfmaddsub.ps - // CHECK-ASM: vfmaddsubps %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}} return _mm_maddsub_ps(a, b, c); } __m128d test_mm_maddsub_pd(__m128d a, __m128d b, __m128d c) { + // CHECK-LABEL: test_mm_maddsub_pd // CHECK: @llvm.x86.fma.vfmaddsub.pd - // CHECK-ASM: vfmaddsubpd %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}} return _mm_maddsub_pd(a, b, c); } __m128 test_mm_msubadd_ps(__m128 a, __m128 b, __m128 c) { + // CHECK-LABEL: test_mm_msubadd_ps // CHECK: @llvm.x86.fma.vfmsubadd.ps - // CHECK-ASM: vfmsubaddps %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}} return _mm_msubadd_ps(a, b, c); } __m128d test_mm_msubadd_pd(__m128d a, __m128d b, __m128d c) { + // CHECK-LABEL: test_mm_msubadd_pd // CHECK: @llvm.x86.fma.vfmsubadd.pd - // CHECK-ASM: vfmsubaddpd %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}} return _mm_msubadd_pd(a, b, c); } __m256 test_mm256_macc_ps(__m256 a, __m256 b, __m256 c) { + // CHECK-LABEL: test_mm256_macc_ps // CHECK: @llvm.x86.fma.vfmadd.ps.256 - // CHECK-ASM: vfmaddps %ymm{{.*}}, %ymm{{.*}}, %ymm{{.*}}, %ymm{{.*}} return _mm256_macc_ps(a, b, c); } __m256d test_mm256_macc_pd(__m256d a, __m256d b, __m256d c) { + // CHECK-LABEL: test_mm256_macc_pd // CHECK: @llvm.x86.fma.vfmadd.pd.256 - // CHECK-ASM: vfmaddpd %ymm{{.*}}, %ymm{{.*}}, %ymm{{.*}}, %ymm{{.*}} return _mm256_macc_pd(a, b, c); } __m256 test_mm256_msub_ps(__m256 a, __m256 b, __m256 c) { + // CHECK-LABEL: test_mm256_msub_ps // CHECK: @llvm.x86.fma.vfmsub.ps.256 - // CHECK-ASM: vfmsubps %ymm{{.*}}, %ymm{{.*}}, %ymm{{.*}}, %ymm{{.*}} return _mm256_msub_ps(a, b, c); } __m256d test_mm256_msub_pd(__m256d a, __m256d b, __m256d c) { + // CHECK-LABEL: test_mm256_msub_pd // CHECK: @llvm.x86.fma.vfmsub.pd.256 - // CHECK-ASM: vfmsubpd %ymm{{.*}}, %ymm{{.*}}, %ymm{{.*}}, %ymm{{.*}} return _mm256_msub_pd(a, b, c); } __m256 test_mm256_nmacc_ps(__m256 a, __m256 b, __m256 c) { + // CHECK-LABEL: test_mm256_nmacc_ps // CHECK: @llvm.x86.fma.vfnmadd.ps.256 - // CHECK-ASM: vfnmaddps %ymm{{.*}}, %ymm{{.*}}, %ymm{{.*}}, %ymm{{.*}} return _mm256_nmacc_ps(a, b, c); } __m256d test_mm256_nmacc_pd(__m256d a, __m256d b, __m256d c) { + // CHECK-LABEL: test_mm256_nmacc_pd // CHECK: @llvm.x86.fma.vfnmadd.pd.256 - // CHECK-ASM: vfnmaddpd %ymm{{.*}}, %ymm{{.*}}, %ymm{{.*}}, %ymm{{.*}} return _mm256_nmacc_pd(a, b, c); } __m256 test_mm256_nmsub_ps(__m256 a, __m256 b, __m256 c) { + // CHECK-LABEL: test_mm256_nmsub_ps // CHECK: @llvm.x86.fma.vfnmsub.ps.256 - // CHECK-ASM: vfnmsubps %ymm{{.*}}, %ymm{{.*}}, %ymm{{.*}}, %ymm{{.*}} return _mm256_nmsub_ps(a, b, c); } __m256d test_mm256_nmsub_pd(__m256d a, __m256d b, __m256d c) { + // CHECK-LABEL: test_mm256_nmsub_pd // CHECK: @llvm.x86.fma.vfnmsub.pd.256 - // CHECK-ASM: vfnmsubpd %ymm{{.*}}, %ymm{{.*}}, %ymm{{.*}}, %ymm{{.*}} return _mm256_nmsub_pd(a, b, c); } __m256 test_mm256_maddsub_ps(__m256 a, __m256 b, __m256 c) { + // CHECK-LABEL: test_mm256_maddsub_ps // CHECK: @llvm.x86.fma.vfmaddsub.ps.256 - // CHECK-ASM: vfmaddsubps %ymm{{.*}}, %ymm{{.*}}, %ymm{{.*}}, %ymm{{.*}} return _mm256_maddsub_ps(a, b, c); } __m256d test_mm256_maddsub_pd(__m256d a, __m256d b, __m256d c) { + // CHECK-LABEL: test_mm256_maddsub_pd // CHECK: @llvm.x86.fma.vfmaddsub.pd.256 - // CHECK-ASM: vfmaddsubpd %ymm{{.*}}, %ymm{{.*}}, %ymm{{.*}}, %ymm{{.*}} return _mm256_maddsub_pd(a, b, c); } __m256 test_mm256_msubadd_ps(__m256 a, __m256 b, __m256 c) { + // CHECK-LABEL: test_mm256_msubadd_ps // CHECK: @llvm.x86.fma.vfmsubadd.ps.256 - // CHECK-ASM: vfmsubaddps %ymm{{.*}}, %ymm{{.*}}, %ymm{{.*}}, %ymm{{.*}} return _mm256_msubadd_ps(a, b, c); } __m256d test_mm256_msubadd_pd(__m256d a, __m256d b, __m256d c) { + // CHECK-LABEL: test_mm256_msubadd_pd // CHECK: @llvm.x86.fma.vfmsubadd.pd.256 - // CHECK-ASM: vfmsubaddpd %ymm{{.*}}, %ymm{{.*}}, %ymm{{.*}}, %ymm{{.*}} return _mm256_msubadd_pd(a, b, c); } diff --git a/test/CodeGen/mmx-builtins.c b/test/CodeGen/mmx-builtins.c index 563169a205..a69468544a 100644 --- a/test/CodeGen/mmx-builtins.c +++ b/test/CodeGen/mmx-builtins.c @@ -1,8 +1,5 @@ -// REQUIRES: x86-registered-target // RUN: %clang_cc1 %s -triple=x86_64-apple-darwin -target-feature +ssse3 -emit-llvm -o - -Werror | FileCheck %s // RUN: %clang_cc1 %s -triple=x86_64-apple-darwin -target-feature +ssse3 -fno-signed-char -emit-llvm -o - -Werror | FileCheck %s -// RUN: %clang_cc1 %s -triple=x86_64-apple-darwin -target-feature +ssse3 -S -o - -Werror | FileCheck %s --check-prefix=CHECK-ASM -// RUN: %clang_cc1 %s -triple=x86_64-apple-darwin -target-feature +ssse3 -fno-signed-char -S -o - -Werror | FileCheck %s --check-prefix=CHECK-ASM // Don't include mm_malloc.h, it's system specific. #define __MM_MALLOC_H @@ -12,196 +9,168 @@ __m64 test_mm_abs_pi8(__m64 a) { // CHECK-LABEL: test_mm_abs_pi8 // CHECK: call x86_mmx @llvm.x86.ssse3.pabs.b - // CHECK-ASM: pabsb %mm{{.*}}, %mm{{.*}} return _mm_abs_pi8(a); } __m64 test_mm_abs_pi16(__m64 a) { // CHECK-LABEL: test_mm_abs_pi16 // CHECK: call x86_mmx @llvm.x86.ssse3.pabs.w - // CHECK-ASM: pabsw %mm{{.*}}, %mm{{.*}} return _mm_abs_pi16(a); } __m64 test_mm_abs_pi32(__m64 a) { // CHECK-LABEL: test_mm_abs_pi32 // CHECK: call x86_mmx @llvm.x86.ssse3.pabs.d - // CHECK-ASM: pabsd %mm{{.*}}, %mm{{.*}} return _mm_abs_pi32(a); } __m64 test_mm_add_pi8(__m64 a, __m64 b) { // CHECK-LABEL: test_mm_add_pi8 // CHECK: call x86_mmx @llvm.x86.mmx.padd.b - // CHECK-ASM: paddb %mm{{.*}}, %mm{{.*}} return _mm_add_pi8(a, b); } __m64 test_mm_add_pi16(__m64 a, __m64 b) { // CHECK-LABEL: test_mm_add_pi16 // CHECK: call x86_mmx @llvm.x86.mmx.padd.w - // CHECK-ASM: paddw %mm{{.*}}, %mm{{.*}} return _mm_add_pi16(a, b); } __m64 test_mm_add_pi32(__m64 a, __m64 b) { // CHECK-LABEL: test_mm_add_pi32 // CHECK: call x86_mmx @llvm.x86.mmx.padd.d - // CHECK-ASM: paddd %mm{{.*}}, %mm{{.*}} return _mm_add_pi32(a, b); } __m64 test_mm_add_si64(__m64 a, __m64 b) { // CHECK-LABEL: test_mm_add_si64 // CHECK: call x86_mmx @llvm.x86.mmx.padd.q - // CHECK-ASM: paddq %mm{{.*}}, %mm{{.*}} return __builtin_ia32_paddq(a, b); } __m64 test_mm_adds_pi8(__m64 a, __m64 b) { // CHECK-LABEL: test_mm_adds_pi8 // CHECK: call x86_mmx @llvm.x86.mmx.padds.b - // CHECK-ASM: paddsb %mm{{.*}}, %mm{{.*}} return _mm_adds_pi8(a, b); } __m64 test_mm_adds_pi16(__m64 a, __m64 b) { // CHECK-LABEL: test_mm_adds_pi16 // CHECK: call x86_mmx @llvm.x86.mmx.padds.w - // CHECK-ASM: paddsw %mm{{.*}}, %mm{{.*}} return _mm_adds_pi16(a, b); } __m64 test_mm_adds_pu8(__m64 a, __m64 b) { // CHECK-LABEL: test_mm_adds_pu8 // CHECK: call x86_mmx @llvm.x86.mmx.paddus.b - // CHECK-ASM: paddusb %mm{{.*}}, %mm{{.*}} return _mm_adds_pu8(a, b); } __m64 test_mm_adds_pu16(__m64 a, __m64 b) { // CHECK-LABEL: test_mm_adds_pu16 // CHECK: call x86_mmx @llvm.x86.mmx.paddus.w - // CHECK-ASM: paddusw %mm{{.*}}, %mm{{.*}} return _mm_adds_pu16(a, b); } __m64 test_mm_alignr_pi8(__m64 a, __m64 b) { // CHECK-LABEL: test_mm_alignr_pi8 // CHECK: call x86_mmx @llvm.x86.mmx.palignr.b - // CHECK-ASM: palignr $2, %mm{{.*}}, %mm{{.*}} return _mm_alignr_pi8(a, b, 2); } __m64 test_mm_and_si64(__m64 a, __m64 b) { // CHECK-LABEL: test_mm_and_si64 // CHECK: call x86_mmx @llvm.x86.mmx.pand - // CHECK-ASM: pand %mm{{.*}}, %mm{{.*}} return _mm_and_si64(a, b); } __m64 test_mm_andnot_si64(__m64 a, __m64 b) { // CHECK-LABEL: test_mm_andnot_si64 // CHECK: call x86_mmx @llvm.x86.mmx.pandn - // CHECK-ASM: pandn %mm{{.*}}, %mm{{.*}} return _mm_andnot_si64(a, b); } __m64 test_mm_avg_pu8(__m64 a, __m64 b) { // CHECK-LABEL: test_mm_avg_pu8 // CHECK: call x86_mmx @llvm.x86.mmx.pavg.b - // CHECK-ASM: pavgb %mm{{.*}}, %mm{{.*}} return _mm_avg_pu8(a, b); } __m64 test_mm_avg_pu16(__m64 a, __m64 b) { // CHECK-LABEL: test_mm_avg_pu16 // CHECK: call x86_mmx @llvm.x86.mmx.pavg.w - // CHECK-ASM: pavgw %mm{{.*}}, %mm{{.*}} return _mm_avg_pu16(a, b); } __m64 test_mm_cmpeq_pi8(__m64 a, __m64 b) { // CHECK-LABEL: test_mm_cmpeq_pi8 // CHECK: call x86_mmx @llvm.x86.mmx.pcmpeq.b - // CHECK-ASM: pcmpeqb %mm{{.*}}, %mm{{.*}} return _mm_cmpeq_pi8(a, b); } __m64 test_mm_cmpeq_pi16(__m64 a, __m64 b) { // CHECK-LABEL: test_mm_cmpeq_pi16 // CHECK: call x86_mmx @llvm.x86.mmx.pcmpeq.w - // CHECK-ASM: pcmpeqw %mm{{.*}}, %mm{{.*}} return _mm_cmpeq_pi16(a, b); } __m64 test_mm_cmpeq_pi32(__m64 a, __m64 b) { // CHECK-LABEL: test_mm_cmpeq_pi32 // CHECK: call x86_mmx @llvm.x86.mmx.pcmpeq.d - // CHECK-ASM: pcmpeqd %mm{{.*}}, %mm{{.*}} return _mm_cmpeq_pi32(a, b); } __m64 test_mm_cmpgt_pi8(__m64 a, __m64 b) { // CHECK-LABEL: test_mm_cmpgt_pi8 // CHECK: call x86_mmx @llvm.x86.mmx.pcmpgt.b - // CHECK-ASM: pcmpgtb %mm{{.*}}, %mm{{.*}} return _mm_cmpgt_pi8(a, b); } __m64 test_mm_cmpgt_pi16(__m64 a, __m64 b) { // CHECK-LABEL: test_mm_cmpgt_pi16 // CHECK: call x86_mmx @llvm.x86.mmx.pcmpgt.w - // CHECK-ASM: pcmpgtw %mm{{.*}}, %mm{{.*}} return _mm_cmpgt_pi16(a, b); } __m64 test_mm_cmpgt_pi32(__m64 a, __m64 b) { // CHECK-LABEL: test_mm_cmpgt_pi32 // CHECK: call x86_mmx @llvm.x86.mmx.pcmpgt.d - // CHECK-ASM: pcmpgtd %mm{{.*}}, %mm{{.*}} return _mm_cmpgt_pi32(a, b); } __m128 test_mm_cvt_pi2ps(__m128 a, __m64 b) { // CHECK-LABEL: test_mm_cvt_pi2ps // CHECK: <4 x float> @llvm.x86.sse.cvtpi2ps - // CHECK-ASM: cvtpi2ps %mm{{.*}}, %xmm{{.*}} return _mm_cvt_pi2ps(a, b); } __m64 test_mm_cvt_ps2pi(__m128 a) { // CHECK-LABEL: test_mm_cvt_ps2pi // CHECK: call x86_mmx @llvm.x86.sse.cvtps2pi - // CHECK-ASM: cvtps2pi %xmm{{.*}}, %mm{{.*}} return _mm_cvt_ps2pi(a); } __m64 test_mm_cvtpd_pi32(__m128d a) { // CHECK-LABEL: test_mm_cvtpd_pi32 // CHECK: call x86_mmx @llvm.x86.sse.cvtpd2pi - // CHECK-ASM: cvtpd2pi %xmm{{.*}}, %mm{{.*}} return _mm_cvtpd_pi32(a); } __m128 test_mm_cvtpi16_ps(__m64 a) { // CHECK-LABEL: test_mm_cvtpi16_ps // CHECK: call <4 x float> @llvm.x86.sse.cvtpi2ps - // CHECK-ASM: cvtpi2ps %mm{{.*}}, %xmm{{.*}} return _mm_cvtpi16_ps(a); } __m128d test_mm_cvtpi32_pd(__m64 a) { // CHECK-LABEL: test_mm_cvtpi32_pd // CHECK: call <2 x double> @llvm.x86.sse.cvtpi2pd - // CHECK-ASM: cvtpi2pd %mm{{.*}}, %xmm{{.*}} return _mm_cvtpi32_pd(a); } __m128 test_mm_cvtpi32_ps(__m128 a, __m64 b) { // CHECK-LABEL: test_mm_cvtpi32_ps // CHECK: call <4 x float> @llvm.x86.sse.cvtpi2ps - // CHECK-ASM: cvtpi2ps %mm{{.*}}, %xmm{{.*}} return _mm_cvtpi32_ps(a, b); } @@ -209,492 +178,419 @@ __m128 test_mm_cvtpi32x2_ps(__m64 a, __m64 b) { // CHECK-LABEL: test_mm_cvtpi32x2_ps // CHECK: call <4 x float> @llvm.x86.sse.cvtpi2ps // CHECK: call <4 x float> @llvm.x86.sse.cvtpi2ps - // CHECK-ASM: cvtpi2ps %mm{{.*}}, %xmm{{.*}} - // CHECK-ASM: cvtpi2ps %mm{{.*}}, %xmm{{.*}} return _mm_cvtpi32x2_ps(a, b); } __m64 test_mm_cvtps_pi16(__m128 a) { // CHECK-LABEL: test_mm_cvtps_pi16 // CHECK: call x86_mmx @llvm.x86.sse.cvtps2pi - // CHECK-ASM: cvtps2pi %xmm{{.*}}, %mm{{.*}} - // CHECK-ASM: cvtps2pi %xmm{{.*}}, %mm{{.*}} - // CHECK-ASM: packssdw %mm{{.*}}, %mm{{.*}} return _mm_cvtps_pi16(a); } __m64 test_mm_cvtps_pi32(__m128 a) { // CHECK-LABEL: test_mm_cvtps_pi32 // CHECK: call x86_mmx @llvm.x86.sse.cvtps2pi - // CHECK-ASM: cvtps2pi %xmm{{.*}}, %mm{{.*}} return _mm_cvtps_pi32(a); } __m64 test_mm_cvtsi32_si64(int a) { // CHECK-LABEL: test_mm_cvtsi32_si64 // CHECK: insertelement <2 x i32> - // CHECK-ASM: movd return _mm_cvtsi32_si64(a); } int test_mm_cvtsi64_si32(__m64 a) { // CHECK-LABEL: test_mm_cvtsi64_si32 // CHECK: extractelement <2 x i32> - // CHECK-ASM: movd return _mm_cvtsi64_si32(a); } __m64 test_mm_cvttpd_pi32(__m128d a) { // CHECK-LABEL: test_mm_cvttpd_pi32 // CHECK: call x86_mmx @llvm.x86.sse.cvttpd2pi - // CHECK-ASM: cvttpd2pi %xmm{{.*}}, %mm{{.*}} return _mm_cvttpd_pi32(a); } __m64 test_mm_cvttps_pi32(__m128 a) { // CHECK-LABEL: test_mm_cvttps_pi32 // CHECK: call x86_mmx @llvm.x86.sse.cvttps2pi - // CHECK-ASM: cvttps2pi %xmm{{.*}}, %mm{{.*}} return _mm_cvttps_pi32(a); } __m64 test_m_from_int(int a) { // CHECK-LABEL: test_m_from_int // CHECK: insertelement <2 x i32> - // CHECK-ASM: movd return _m_from_int(a); } __m64 test_mm_hadd_pi16(__m64 a, __m64 b) { // CHECK-LABEL: test_mm_hadd_pi16 // CHECK: call x86_mmx @llvm.x86.ssse3.phadd.w - // CHECK-ASM: phaddw %mm{{.*}}, %mm{{.*}} return _mm_hadd_pi16(a, b); } __m64 test_mm_hadd_pi32(__m64 a, __m64 b) { // CHECK-LABEL: test_mm_hadd_pi32 // CHECK: call x86_mmx @llvm.x86.ssse3.phadd.d - // CHECK-ASM: phaddd %mm{{.*}}, %mm{{.*}} return _mm_hadd_pi32(a, b); } __m64 test_mm_hadds_pi16(__m64 a, __m64 b) { // CHECK-LABEL: test_mm_hadds_pi16 // CHECK: call x86_mmx @llvm.x86.ssse3.phadd.sw - // CHECK-ASM: phaddsw %mm{{.*}}, %mm{{.*}} return _mm_hadds_pi16(a, b); } __m64 test_mm_hsub_pi16(__m64 a, __m64 b) { // CHECK-LABEL: test_mm_hsub_pi16 // CHECK: call x86_mmx @llvm.x86.ssse3.phsub.w - // CHECK-ASM: phsubw %mm{{.*}}, %mm{{.*}} return _mm_hsub_pi16(a, b); } __m64 test_mm_hsub_pi32(__m64 a, __m64 b) { // CHECK-LABEL: test_mm_hsub_pi32 // CHECK: call x86_mmx @llvm.x86.ssse3.phsub.d - // CHECK-ASM: phsubd %mm{{.*}}, %mm{{.*}} return _mm_hsub_pi32(a, b); } __m64 test_mm_hsubs_pi16(__m64 a, __m64 b) { // CHECK-LABEL: test_mm_hsubs_pi16 // CHECK: call x86_mmx @llvm.x86.ssse3.phsub.sw - // CHECK-ASM: phsubsw %mm{{.*}}, %mm{{.*}} return _mm_hsubs_pi16(a, b); } __m64 test_mm_madd_pi16(__m64 a, __m64 b) { // CHECK-LABEL: test_mm_madd_pi16 // CHECK: call x86_mmx @llvm.x86.mmx.pmadd.wd - // CHECK-ASM: pmaddwd %mm{{.*}}, %mm{{.*}} return _mm_madd_pi16(a, b); } __m64 test_mm_maddubs_pi16(__m64 a, __m64 b) { // CHECK-LABEL: test_mm_maddubs_pi16 // CHECK: call x86_mmx @llvm.x86.ssse3.pmadd.ub.sw - // CHECK-ASM: pmaddubsw %mm{{.*}}, %mm{{.*}} return _mm_maddubs_pi16(a, b); } void test_mm_maskmove_si64(__m64 d, __m64 n, char *p) { // CHECK-LABEL: test_mm_maskmove_si64 // CHECK: call void @llvm.x86.mmx.maskmovq - // CHECK-ASM: maskmovq _mm_maskmove_si64(d, n, p); } __m64 test_mm_max_pi16(__m64 a, __m64 b) { // CHECK-LABEL: test_mm_max_pi16 // CHECK: call x86_mmx @llvm.x86.mmx.pmaxs.w - // CHECK-ASM: pmaxsw %mm{{.*}}, %mm{{.*}} return _mm_max_pi16(a, b); } __m64 test_mm_max_pu8(__m64 a, __m64 b) { // CHECK-LABEL: test_mm_max_pu8 // CHECK: call x86_mmx @llvm.x86.mmx.pmaxu.b - // CHECK-ASM: pmaxub %mm{{.*}}, %mm{{.*}} return _mm_max_pu8(a, b); } __m64 test_mm_min_pi16(__m64 a, __m64 b) { // CHECK-LABEL: test_mm_min_pi16 // CHECK: call x86_mmx @llvm.x86.mmx.pmins.w - // CHECK-ASM: pminsw %mm{{.*}}, %mm{{.*}} return _mm_min_pi16(a, b); } __m64 test_mm_min_pu8(__m64 a, __m64 b) { // CHECK-LABEL: test_mm_min_pu8 // CHECK: call x86_mmx @llvm.x86.mmx.pminu.b - // CHECK-ASM: pminub %mm{{.*}}, %mm{{.*}} return _mm_min_pu8(a, b); } int test_mm_movemask_pi8(__m64 a) { // CHECK-LABEL: test_mm_movemask_pi8 // CHECK: call i32 @llvm.x86.mmx.pmovmskb - // CHECK-ASM: pmovmskb return _mm_movemask_pi8(a); } __m64 test_mm_mul_su32(__m64 a, __m64 b) { // CHECK-LABEL: test_mm_mul_su32 // CHECK: call x86_mmx @llvm.x86.mmx.pmulu.dq - // CHECK-ASM: pmuludq %mm{{.*}}, %mm{{.*}} return _mm_mul_su32(a, b); } __m64 test_mm_mulhi_pi16(__m64 a, __m64 b) { // CHECK-LABEL: test_mm_mulhi_pi16 // CHECK: call x86_mmx @llvm.x86.mmx.pmulh.w - // CHECK-ASM: pmulhw %mm{{.*}}, %mm{{.*}} return _mm_mulhi_pi16(a, b); } __m64 test_mm_mulhi_pu16(__m64 a, __m64 b) { // CHECK-LABEL: test_mm_mulhi_pu16 // CHECK: call x86_mmx @llvm.x86.mmx.pmulhu.w - // CHECK-ASM: pmulhuw %mm{{.*}}, %mm{{.*}} return _mm_mulhi_pu16(a, b); } __m64 test_mm_mulhrs_pi16(__m64 a, __m64 b) { // CHECK-LABEL: test_mm_mulhrs_pi16 // CHECK: call x86_mmx @llvm.x86.ssse3.pmul.hr.sw - // CHECK-ASM: pmulhrsw %mm{{.*}}, %mm{{.*}} return _mm_mulhrs_pi16(a, b); } __m64 test_mm_mullo_pi16(__m64 a, __m64 b) { // CHECK-LABEL: test_mm_mullo_pi16 // CHECK: call x86_mmx @llvm.x86.mmx.pmull.w - // CHECK-ASM: pmullw %mm{{.*}}, %mm{{.*}} return _mm_mullo_pi16(a, b); } __m64 test_mm_or_si64(__m64 a, __m64 b) { // CHECK-LABEL: test_mm_or_si64 // CHECK: call x86_mmx @llvm.x86.mmx.por - // CHECK-ASM: por %mm{{.*}}, %mm{{.*}} return _mm_or_si64(a, b); } __m64 test_mm_packs_pi16(__m64 a, __m64 b) { // CHECK-LABEL: test_mm_packs_pi16 // CHECK: call x86_mmx @llvm.x86.mmx.packsswb - // CHECK-ASM: packsswb %mm{{.*}}, %mm{{.*}} return _mm_packs_pi16(a, b); } __m64 test_mm_packs_pi32(__m64 a, __m64 b) { // CHECK-LABEL: test_mm_packs_pi32 // CHECK: call x86_mmx @llvm.x86.mmx.packssdw - // CHECK-ASM: packssdw %mm{{.*}}, %mm{{.*}} return _mm_packs_pi32(a, b); } __m64 test_mm_packs_pu16(__m64 a, __m64 b) { // CHECK-LABEL: test_mm_packs_pu16 // CHECK: call x86_mmx @llvm.x86.mmx.packuswb - // CHECK-ASM: packuswb %mm{{.*}}, %mm{{.*}} return _mm_packs_pu16(a, b); } __m64 test_mm_sad_pu8(__m64 a, __m64 b) { // CHECK-LABEL: test_mm_sad_pu8 // CHECK: call x86_mmx @llvm.x86.mmx.psad.bw - // CHECK-ASM: psadbw %mm{{.*}}, %mm{{.*}} return _mm_sad_pu8(a, b); } __m64 test_mm_shuffle_pi8(__m64 a, __m64 b) { // CHECK-LABEL: test_mm_shuffle_pi8 // CHECK: call x86_mmx @llvm.x86.ssse3.pshuf.b - // CHECK-ASM: pshufb %mm{{.*}}, %mm{{.*}} return _mm_shuffle_pi8(a, b); } __m64 test_mm_shuffle_pi16(__m64 a) { // CHECK-LABEL: test_mm_shuffle_pi16 // CHECK: call x86_mmx @llvm.x86.sse.pshuf.w - // CHECK-ASM: pshufw $3, %mm{{.*}}, %mm{{.*}} return _mm_shuffle_pi16(a, 3); } __m64 test_mm_sign_pi8(__m64 a, __m64 b) { // CHECK-LABEL: test_mm_sign_pi8 // CHECK: call x86_mmx @llvm.x86.ssse3.psign.b - // CHECK-ASM: psignb %mm{{.*}}, %mm{{.*}} return _mm_sign_pi8(a, b); } __m64 test_mm_sign_pi16(__m64 a, __m64 b) { // CHECK-LABEL: test_mm_sign_pi16 // CHECK: call x86_mmx @llvm.x86.ssse3.psign.w - // CHECK-ASM: psignw %mm{{.*}}, %mm{{.*}} return _mm_sign_pi16(a, b); } __m64 test_mm_sign_pi32(__m64 a, __m64 b) { // CHECK-LABEL: test_mm_sign_pi32 // CHECK: call x86_mmx @llvm.x86.ssse3.psign.d - // CHECK-ASM: psignd %mm{{.*}}, %mm{{.*}} return _mm_sign_pi32(a, b); } __m64 test_mm_sll_pi16(__m64 a, __m64 b) { // CHECK-LABEL: test_mm_sll_pi16 // CHECK: call x86_mmx @llvm.x86.mmx.psll.w - // CHECK-ASM: psllw %mm{{.*}}, %mm{{.*}} return _mm_sll_pi16(a, b); } __m64 test_mm_sll_pi32(__m64 a, __m64 b) { // CHECK-LABEL: test_mm_sll_pi32 // CHECK: call x86_mmx @llvm.x86.mmx.psll.d - // CHECK-ASM: pslld %mm{{.*}}, %mm{{.*}} return _mm_sll_pi32(a, b); } __m64 test_mm_sll_si64(__m64 a, __m64 b) { // CHECK-LABEL: test_mm_sll_si64 // CHECK: call x86_mmx @llvm.x86.mmx.psll.q - // CHECK-ASM: psllq %mm{{.*}}, %mm{{.*}} return _mm_sll_si64(a, b); } __m64 test_mm_slli_pi16(__m64 a) { // CHECK-LABEL: test_mm_slli_pi16 // CHECK: call x86_mmx @llvm.x86.mmx.pslli.w - // CHECK-ASM: psllw return _mm_slli_pi16(a, 3); } __m64 test_mm_slli_pi32(__m64 a) { // CHECK-LABEL: test_mm_slli_pi32 // CHECK: call x86_mmx @llvm.x86.mmx.pslli.d - // CHECK-ASM: pslld return _mm_slli_pi32(a, 3); } __m64 test_mm_slli_si64(__m64 a) { // CHECK-LABEL: test_mm_slli_si64 // CHECK: call x86_mmx @llvm.x86.mmx.pslli.q - // CHECK-ASM: psllq return _mm_slli_si64(a, 3); } __m64 test_mm_sra_pi16(__m64 a, __m64 b) { // CHECK-LABEL: test_mm_sra_pi16 // CHECK: call x86_mmx @llvm.x86.mmx.psra.w - // CHECK-ASM: psraw %mm{{.*}}, %mm{{.*}} return _mm_sra_pi16(a, b); } __m64 test_mm_sra_pi32(__m64 a, __m64 b) { // CHECK-LABEL: test_mm_sra_pi32 // CHECK: call x86_mmx @llvm.x86.mmx.psra.d - // CHECK-ASM: psrad %mm{{.*}}, %mm{{.*}} return _mm_sra_pi32(a, b); } __m64 test_mm_srai_pi16(__m64 a) { // CHECK-LABEL: test_mm_srai_pi16 // CHECK: call x86_mmx @llvm.x86.mmx.psrai.w - // CHECK-ASM: psraw return _mm_srai_pi16(a, 3); } __m64 test_mm_srai_pi32(__m64 a) { // CHECK-LABEL: test_mm_srai_pi32 // CHECK: call x86_mmx @llvm.x86.mmx.psrai.d - // CHECK-ASM: psrad return _mm_srai_pi32(a, 3); } __m64 test_mm_srl_pi16(__m64 a, __m64 b) { // CHECK-LABEL: test_mm_srl_pi16 // CHECK: call x86_mmx @llvm.x86.mmx.psrl.w - // CHECK-ASM: psrlw %mm{{.*}}, %mm{{.*}} return _mm_srl_pi16(a, b); } __m64 test_mm_srl_pi32(__m64 a, __m64 b) { // CHECK-LABEL: test_mm_srl_pi32 // CHECK: call x86_mmx @llvm.x86.mmx.psrl.d - // CHECK-ASM: psrld %mm{{.*}}, %mm{{.*}} return _mm_srl_pi32(a, b); } __m64 test_mm_srl_si64(__m64 a, __m64 b) { // CHECK-LABEL: test_mm_srl_si64 // CHECK: call x86_mmx @llvm.x86.mmx.psrl.q - // CHECK-ASM: psrlq %mm{{.*}}, %mm{{.*}} return _mm_srl_si64(a, b); } __m64 test_mm_srli_pi16(__m64 a) { // CHECK-LABEL: test_mm_srli_pi16 // CHECK: call x86_mmx @llvm.x86.mmx.psrli.w - // CHECK-ASM: psrlw return _mm_srli_pi16(a, 3); } __m64 test_mm_srli_pi32(__m64 a) { // CHECK-LABEL: test_mm_srli_pi32 // CHECK: call x86_mmx @llvm.x86.mmx.psrli.d - // CHECK-ASM: psrld return _mm_srli_pi32(a, 3); } __m64 test_mm_srli_si64(__m64 a) { // CHECK-LABEL: test_mm_srli_si64 // CHECK: call x86_mmx @llvm.x86.mmx.psrli.q - // CHECK-ASM: psrlq return _mm_srli_si64(a, 3); } void test_mm_stream_pi(__m64 *p, __m64 a) { // CHECK-LABEL: test_mm_stream_pi // CHECK: call void @llvm.x86.mmx.movnt.dq - // CHECK-ASM: movntq _mm_stream_pi(p, a); } __m64 test_mm_sub_pi8(__m64 a, __m64 b) { // CHECK-LABEL: test_mm_sub_pi8 // CHECK: call x86_mmx @llvm.x86.mmx.psub.b - // CHECK-ASM: psubb %mm{{.*}}, %mm{{.*}} return _mm_sub_pi8(a, b); } __m64 test_mm_sub_pi16(__m64 a, __m64 b) { // CHECK-LABEL: test_mm_sub_pi16 // CHECK: call x86_mmx @llvm.x86.mmx.psub.w - // CHECK-ASM: psubw %mm{{.*}}, %mm{{.*}} return _mm_sub_pi16(a, b); } __m64 test_mm_sub_pi32(__m64 a, __m64 b) { // CHECK-LABEL: test_mm_sub_pi32 // CHECK: call x86_mmx @llvm.x86.mmx.psub.d - // CHECK-ASM: psubd %mm{{.*}}, %mm{{.*}} return _mm_sub_pi32(a, b); } __m64 test_mm_sub_si64(__m64 a, __m64 b) { // CHECK-LABEL: test_mm_sub_si64 // CHECK: call x86_mmx @llvm.x86.mmx.psub.q - // CHECK-ASM: psubq %mm{{.*}}, %mm{{.*}} return __builtin_ia32_psubq(a, b); } __m64 test_mm_subs_pi8(__m64 a, __m64 b) { // CHECK-LABEL: test_mm_subs_pi8 // CHECK: call x86_mmx @llvm.x86.mmx.psubs.b - // CHECK-ASM: psubsb %mm{{.*}}, %mm{{.*}} return _mm_subs_pi8(a, b); } __m64 test_mm_subs_pi16(__m64 a, __m64 b) { // CHECK-LABEL: test_mm_subs_pi16 // CHECK: call x86_mmx @llvm.x86.mmx.psubs.w - // CHECK-ASM: psubsw %mm{{.*}}, %mm{{.*}} return _mm_subs_pi16(a, b); } __m64 test_mm_subs_pu8(__m64 a, __m64 b) { // CHECK-LABEL: test_mm_subs_pu8 // CHECK: call x86_mmx @llvm.x86.mmx.psubus.b - // CHECK-ASM: psubusb %mm{{.*}}, %mm{{.*}} return _mm_subs_pu8(a, b); } __m64 test_mm_subs_pu16(__m64 a, __m64 b) { // CHECK-LABEL: test_mm_subs_pu16 // CHECK: call x86_mmx @llvm.x86.mmx.psubus.w - // CHECK-ASM: psubusw %mm{{.*}}, %mm{{.*}} return _mm_subs_pu16(a, b); } int test_m_to_int(__m64 a) { // CHECK-LABEL: test_m_to_int // CHECK: extractelement <2 x i32> - // CHECK-ASM: movd return _m_to_int(a); } __m64 test_mm_unpackhi_pi8(__m64 a, __m64 b) { // CHECK-LABEL: test_mm_unpackhi_pi8 // CHECK: call x86_mmx @llvm.x86.mmx.punpckhbw - // CHECK-ASM: punpckhbw %mm{{.*}}, %mm{{.*}} return _mm_unpackhi_pi8(a, b); } __m64 test_mm_unpackhi_pi16(__m64 a, __m64 b) { // CHECK-LABEL: test_mm_unpackhi_pi16 // CHECK: call x86_mmx @llvm.x86.mmx.punpckhwd - // CHECK-ASM: punpckhwd %mm{{.*}}, %mm{{.*}} return _mm_unpackhi_pi16(a, b); } __m64 test_mm_unpackhi_pi32(__m64 a, __m64 b) { // CHECK-LABEL: test_mm_unpackhi_pi32 // CHECK: call x86_mmx @llvm.x86.mmx.punpckhdq - // CHECK-ASM: punpckhdq %mm{{.*}}, %mm{{.*}} return _mm_unpackhi_pi32(a, b); } __m64 test_mm_unpacklo_pi8(__m64 a, __m64 b) { // CHECK-LABEL: test_mm_unpacklo_pi8 // CHECK: call x86_mmx @llvm.x86.mmx.punpcklbw - // CHECK-ASM: punpcklbw %mm{{.*}}, %mm{{.*}} return _mm_unpacklo_pi8(a, b); } __m64 test_mm_unpacklo_pi16(__m64 a, __m64 b) { // CHECK-LABEL: test_mm_unpacklo_pi16 // CHECK: call x86_mmx @llvm.x86.mmx.punpcklwd - // CHECK-ASM: punpcklwd %mm{{.*}}, %mm{{.*}} return _mm_unpacklo_pi16(a, b); } __m64 test_mm_unpacklo_pi32(__m64 a, __m64 b) { // CHECK-LABEL: test_mm_unpacklo_pi32 // CHECK: call x86_mmx @llvm.x86.mmx.punpckldq - // CHECK-ASM: punpckldq %mm{{.*}}, %mm{{.*}} return _mm_unpacklo_pi32(a, b); } __m64 test_mm_xor_si64(__m64 a, __m64 b) { // CHECK-LABEL: test_mm_xor_si64 // CHECK: call x86_mmx @llvm.x86.mmx.pxor - // CHECK-ASM: pxor %mm{{.*}}, %mm{{.*}} return _mm_xor_si64(a, b); } diff --git a/test/CodeGen/sse2-builtins.c b/test/CodeGen/sse2-builtins.c index 39478bc2d8..4ceb93abfc 100644 --- a/test/CodeGen/sse2-builtins.c +++ b/test/CodeGen/sse2-builtins.c @@ -1,8 +1,5 @@ -// REQUIRES: x86-registered-target -// RUN: %clang_cc1 %s -triple=x86_64-apple-darwin -target-feature +sse2 -emit-llvm -o - -Werror | FileCheck %s --check-prefix=DAG -// RUN: %clang_cc1 %s -triple=x86_64-apple-darwin -target-feature +sse2 -fno-signed-char -emit-llvm -o - -Werror | FileCheck %s --check-prefix=DAG -// RUN: %clang_cc1 %s -triple=x86_64-apple-darwin -target-feature +sse2 -S -o - -Werror | FileCheck %s --check-prefix=ASM -// RUN: %clang_cc1 %s -triple=x86_64-apple-darwin -target-feature +sse2 -fno-signed-char -S -o - -Werror | FileCheck %s --check-prefix=ASM +// RUN: %clang_cc1 %s -triple=x86_64-apple-darwin -target-feature +sse2 -emit-llvm -o - -Werror | FileCheck %s +// RUN: %clang_cc1 %s -triple=x86_64-apple-darwin -target-feature +sse2 -fno-signed-char -emit-llvm -o - -Werror | FileCheck %s // Don't include mm_malloc.h, it's system specific. #define __MM_MALLOC_H @@ -10,1647 +7,1099 @@ #include __m128i test_mm_add_epi8(__m128i A, __m128i B) { - // DAG-LABEL: test_mm_add_epi8 - // DAG: add <16 x i8> - // - // ASM-LABEL: test_mm_add_epi8 - // ASM: paddb + // CHECK-LABEL: test_mm_add_epi8 + // CHECK: add <16 x i8> return _mm_add_epi8(A, B); } __m128i test_mm_add_epi16(__m128i A, __m128i B) { - // DAG-LABEL: test_mm_add_epi16 - // DAG: add <8 x i16> - // - // ASM-LABEL: test_mm_add_epi16 - // ASM: paddw + // CHECK-LABEL: test_mm_add_epi16 + // CHECK: add <8 x i16> return _mm_add_epi16(A, B); } __m128i test_mm_add_epi32(__m128i A, __m128i B) { - // DAG-LABEL: test_mm_add_epi32 - // DAG: add <4 x i32> - // - // ASM-LABEL: test_mm_add_epi32 - // ASM: paddd + // CHECK-LABEL: test_mm_add_epi32 + // CHECK: add <4 x i32> return _mm_add_epi32(A, B); } __m128i test_mm_add_epi64(__m128i A, __m128i B) { - // DAG-LABEL: test_mm_add_epi64 - // DAG: add <2 x i64> - // - // ASM-LABEL: test_mm_add_epi64 - // ASM: paddq + // CHECK-LABEL: test_mm_add_epi64 + // CHECK: add <2 x i64> return _mm_add_epi64(A, B); } __m128d test_mm_add_pd(__m128d A, __m128d B) { - // DAG-LABEL: test_mm_add_pd - // DAG: fadd <2 x double> - // - // ASM-LABEL: test_mm_add_pd - // ASM: addpd + // CHECK-LABEL: test_mm_add_pd + // CHECK: fadd <2 x double> return _mm_add_pd(A, B); } __m128d test_mm_add_sd(__m128d A, __m128d B) { - // DAG-LABEL: test_mm_add_sd - // DAG: fadd double - // - // ASM-LABEL: test_mm_add_sd - // ASM: addsd + // CHECK-LABEL: test_mm_add_sd + // CHECK: fadd double return _mm_add_sd(A, B); } __m128i test_mm_adds_epi8(__m128i A, __m128i B) { - // DAG-LABEL: test_mm_adds_epi8 - // DAG: call <16 x i8> @llvm.x86.sse2.padds.b - // - // ASM-LABEL: test_mm_adds_epi8 - // ASM: paddsb + // CHECK-LABEL: test_mm_adds_epi8 + // CHECK: call <16 x i8> @llvm.x86.sse2.padds.b return _mm_adds_epi8(A, B); } __m128i test_mm_adds_epi16(__m128i A, __m128i B) { - // DAG-LABEL: test_mm_adds_epi16 - // DAG: call <8 x i16> @llvm.x86.sse2.padds.w - // - // ASM-LABEL: test_mm_adds_epi16 - // ASM: paddsw + // CHECK-LABEL: test_mm_adds_epi16 + // CHECK: call <8 x i16> @llvm.x86.sse2.padds.w return _mm_adds_epi16(A, B); } __m128i test_mm_adds_epu8(__m128i A, __m128i B) { - // DAG-LABEL: test_mm_adds_epu8 - // DAG: call <16 x i8> @llvm.x86.sse2.paddus.b - // - // ASM-LABEL: test_mm_adds_epu8 - // ASM: paddusb + // CHECK-LABEL: test_mm_adds_epu8 + // CHECK: call <16 x i8> @llvm.x86.sse2.paddus.b return _mm_adds_epu8(A, B); } __m128i test_mm_adds_epu16(__m128i A, __m128i B) { - // DAG-LABEL: test_mm_adds_epu16 - // DAG: call <8 x i16> @llvm.x86.sse2.paddus.w - // - // ASM-LABEL: test_mm_adds_epu16 - // ASM: paddusw + // CHECK-LABEL: test_mm_adds_epu16 + // CHECK: call <8 x i16> @llvm.x86.sse2.paddus.w return _mm_adds_epu16(A, B); } __m128d test_mm_and_pd(__m128d A, __m128d B) { - // DAG-LABEL: test_mm_and_pd - // DAG: and <4 x i32> - // - // ASM-LABEL: test_mm_and_pd - // ASM: pand + // CHECK-LABEL: test_mm_and_pd + // CHECK: and <4 x i32> return _mm_and_pd(A, B); } __m128i test_mm_and_si128(__m128i A, __m128i B) { - // DAG-LABEL: test_mm_and_si128 - // DAG: and <2 x i64> - // - // ASM-LABEL: test_mm_and_si128 - // ASM: andps + // CHECK-LABEL: test_mm_and_si128 + // CHECK: and <2 x i64> return _mm_and_si128(A, B); } __m128i test_mm_avg_epu8(__m128i A, __m128i B) { - // DAG-LABEL: test_mm_avg_epu8 - // DAG: call <16 x i8> @llvm.x86.sse2.pavg.b - // - // ASM-LABEL: test_mm_avg_epu8 - // ASM: pavgb + // CHECK-LABEL: test_mm_avg_epu8 + // CHECK: call <16 x i8> @llvm.x86.sse2.pavg.b return _mm_avg_epu8(A, B); } __m128i test_mm_avg_epu16(__m128i A, __m128i B) { - // DAG-LABEL: test_mm_avg_epu16 - // DAG: call <8 x i16> @llvm.x86.sse2.pavg.w - // - // ASM-LABEL: test_mm_avg_epu16 - // ASM: pavgw + // CHECK-LABEL: test_mm_avg_epu16 + // CHECK: call <8 x i16> @llvm.x86.sse2.pavg.w return _mm_avg_epu16(A, B); } __m128i test_mm_bslli_si128(__m128i A) { - // DAG-LABEL: test_mm_bslli_si128 - // DAG: shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i32> - // - // ASM-LABEL: test_mm_bslli_si128 - // ASM: pslldq $5, %xmm{{.*}} + // CHECK-LABEL: test_mm_bslli_si128 + // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i32> return _mm_bslli_si128(A, 5); } __m128i test_mm_bsrli_si128(__m128i A) { - // DAG-LABEL: test_mm_bsrli_si128 - // DAG: shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i32> - // - // ASM-LABEL: test_mm_bsrli_si128 - // ASM: psrldq $5, %xmm{{.*}} + // CHECK-LABEL: test_mm_bsrli_si128 + // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i32> return _mm_bsrli_si128(A, 5); } void test_mm_clflush(void* A) { - // DAG-LABEL: test_mm_clflush - // DAG: call void @llvm.x86.sse2.clflush(i8* %{{.*}}) - // - // ASM-LABEL: test_mm_clflush - // ASM: clflush + // CHECK-LABEL: test_mm_clflush + // CHECK: call void @llvm.x86.sse2.clflush(i8* %{{.*}}) _mm_clflush(A); } __m128i test_mm_cmpeq_epi8(__m128i A, __m128i B) { - // DAG-LABEL: test_mm_cmpeq_epi8 - // DAG: icmp eq <16 x i8> - // - // ASM-LABEL: test_mm_cmpeq_epi8 - // ASM: pcmpeqb + // CHECK-LABEL: test_mm_cmpeq_epi8 + // CHECK: icmp eq <16 x i8> return _mm_cmpeq_epi8(A, B); } __m128i test_mm_cmpeq_epi16(__m128i A, __m128i B) { - // DAG-LABEL: test_mm_cmpeq_epi16 - // DAG: icmp eq <8 x i16> - // - // ASM-LABEL: test_mm_cmpeq_epi16 - // ASM: pcmpeqw + // CHECK-LABEL: test_mm_cmpeq_epi16 + // CHECK: icmp eq <8 x i16> return _mm_cmpeq_epi16(A, B); } __m128i test_mm_cmpeq_epi32(__m128i A, __m128i B) { - // DAG-LABEL: test_mm_cmpeq_epi32 - // DAG: icmp eq <4 x i32> - // - // ASM-LABEL: test_mm_cmpeq_epi32 - // ASM: pcmpeqd + // CHECK-LABEL: test_mm_cmpeq_epi32 + // CHECK: icmp eq <4 x i32> return _mm_cmpeq_epi32(A, B); } __m128d test_mm_cmpeq_pd(__m128d A, __m128d B) { - // DAG-LABEL: test_mm_cmpeq_pd - // DAG: call <2 x double> @llvm.x86.sse2.cmp.pd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 0) - // - // ASM-LABEL: test_mm_cmpeq_pd - // ASM: cmpeqpd + // CHECK-LABEL: test_mm_cmpeq_pd + // CHECK: call <2 x double> @llvm.x86.sse2.cmp.pd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 0) return _mm_cmpeq_pd(A, B); } __m128d test_mm_cmpeq_sd(__m128d A, __m128d B) { - // DAG-LABEL: test_mm_cmpeq_sd - // DAG: call <2 x double> @llvm.x86.sse2.cmp.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 0) - // - // ASM-LABEL: test_mm_cmpeq_sd - // ASM: cmpeqsd + // CHECK-LABEL: test_mm_cmpeq_sd + // CHECK: call <2 x double> @llvm.x86.sse2.cmp.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 0) return _mm_cmpeq_sd(A, B); } __m128d test_mm_cmpge_pd(__m128d A, __m128d B) { - // DAG-LABEL: test_mm_cmpge_pd - // DAG: call <2 x double> @llvm.x86.sse2.cmp.pd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 2) - // - // ASM-LABEL: test_mm_cmpge_pd - // ASM: cmplepd + // CHECK-LABEL: test_mm_cmpge_pd + // CHECK: call <2 x double> @llvm.x86.sse2.cmp.pd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 2) return _mm_cmpge_pd(A, B); } __m128d test_mm_cmpge_sd(__m128d A, __m128d B) { - // DAG-LABEL: test_mm_cmpge_sd - // DAG: call <2 x double> @llvm.x86.sse2.cmp.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 2) - // - // ASM-LABEL: test_mm_cmpge_sd - // ASM: cmplesd + // CHECK-LABEL: test_mm_cmpge_sd + // CHECK: call <2 x double> @llvm.x86.sse2.cmp.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 2) return _mm_cmpge_sd(A, B); } __m128i test_mm_cmpgt_epi8(__m128i A, __m128i B) { - // DAG-LABEL: test_mm_cmpgt_epi8 - // DAG: icmp sgt <16 x i8> - // - // ASM-LABEL: test_mm_cmpgt_epi8 - // ASM: pcmpgtb + // CHECK-LABEL: test_mm_cmpgt_epi8 + // CHECK: icmp sgt <16 x i8> return _mm_cmpgt_epi8(A, B); } __m128i test_mm_cmpgt_epi16(__m128i A, __m128i B) { - // DAG-LABEL: test_mm_cmpgt_epi16 - // DAG: icmp sgt <8 x i16> - // - // ASM-LABEL: test_mm_cmpgt_epi16 - // ASM: pcmpgtw + // CHECK-LABEL: test_mm_cmpgt_epi16 + // CHECK: icmp sgt <8 x i16> return _mm_cmpgt_epi16(A, B); } __m128i test_mm_cmpgt_epi32(__m128i A, __m128i B) { - // DAG-LABEL: test_mm_cmpgt_epi32 - // DAG: icmp sgt <4 x i32> - // - // ASM-LABEL: test_mm_cmpgt_epi32 - // ASM: pcmpgtd + // CHECK-LABEL: test_mm_cmpgt_epi32 + // CHECK: icmp sgt <4 x i32> return _mm_cmpgt_epi32(A, B); } __m128d test_mm_cmpgt_pd(__m128d A, __m128d B) { - // DAG-LABEL: test_mm_cmpgt_pd - // DAG: call <2 x double> @llvm.x86.sse2.cmp.pd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 1) - // - // ASM-LABEL: test_mm_cmpgt_pd - // ASM: cmpltpd + // CHECK-LABEL: test_mm_cmpgt_pd + // CHECK: call <2 x double> @llvm.x86.sse2.cmp.pd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 1) return _mm_cmpgt_pd(A, B); } __m128d test_mm_cmpgt_sd(__m128d A, __m128d B) { - // DAG-LABEL: test_mm_cmpgt_sd - // DAG: call <2 x double> @llvm.x86.sse2.cmp.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 1) - // - // ASM-LABEL: test_mm_cmpgt_sd - // ASM: cmpltsd + // CHECK-LABEL: test_mm_cmpgt_sd + // CHECK: call <2 x double> @llvm.x86.sse2.cmp.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 1) return _mm_cmpgt_sd(A, B); } __m128d test_mm_cmple_pd(__m128d A, __m128d B) { - // DAG-LABEL: test_mm_cmple_pd - // DAG: call <2 x double> @llvm.x86.sse2.cmp.pd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 2) - // - // ASM-LABEL: test_mm_cmple_pd - // ASM: cmplepd + // CHECK-LABEL: test_mm_cmple_pd + // CHECK: call <2 x double> @llvm.x86.sse2.cmp.pd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 2) return _mm_cmple_pd(A, B); } __m128d test_mm_cmple_sd(__m128d A, __m128d B) { - // DAG-LABEL: test_mm_cmple_sd - // DAG: call <2 x double> @llvm.x86.sse2.cmp.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 2) - // - // ASM-LABEL: test_mm_cmple_sd - // ASM: cmplesd + // CHECK-LABEL: test_mm_cmple_sd + // CHECK: call <2 x double> @llvm.x86.sse2.cmp.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 2) return _mm_cmple_sd(A, B); } __m128i test_mm_cmplt_epi8(__m128i A, __m128i B) { - // DAG-LABEL: test_mm_cmplt_epi8 - // DAG: icmp sgt <16 x i8> - // - // ASM-LABEL: test_mm_cmplt_epi8 - // ASM: pcmpgtb + // CHECK-LABEL: test_mm_cmplt_epi8 + // CHECK: icmp sgt <16 x i8> return _mm_cmplt_epi8(A, B); } __m128i test_mm_cmplt_epi16(__m128i A, __m128i B) { - // DAG-LABEL: test_mm_cmplt_epi16 - // DAG: icmp sgt <8 x i16> - // - // ASM-LABEL: test_mm_cmplt_epi16 - // ASM: pcmpgtw + // CHECK-LABEL: test_mm_cmplt_epi16 + // CHECK: icmp sgt <8 x i16> return _mm_cmplt_epi16(A, B); } __m128i test_mm_cmplt_epi32(__m128i A, __m128i B) { - // DAG-LABEL: test_mm_cmplt_epi32 - // DAG: icmp sgt <4 x i32> - // - // ASM-LABEL: test_mm_cmplt_epi32 - // ASM: pcmpgtd + // CHECK-LABEL: test_mm_cmplt_epi32 + // CHECK: icmp sgt <4 x i32> return _mm_cmplt_epi32(A, B); } __m128d test_mm_cmplt_pd(__m128d A, __m128d B) { - // DAG-LABEL: test_mm_cmplt_pd - // DAG: call <2 x double> @llvm.x86.sse2.cmp.pd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 1) - // - // ASM-LABEL: test_mm_cmplt_pd - // ASM: cmpltpd + // CHECK-LABEL: test_mm_cmplt_pd + // CHECK: call <2 x double> @llvm.x86.sse2.cmp.pd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 1) return _mm_cmplt_pd(A, B); } __m128d test_mm_cmplt_sd(__m128d A, __m128d B) { - // DAG-LABEL: test_mm_cmplt_sd - // DAG: call <2 x double> @llvm.x86.sse2.cmp.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 1) - // - // ASM-LABEL: test_mm_cmplt_sd - // ASM: cmpltsd + // CHECK-LABEL: test_mm_cmplt_sd + // CHECK: call <2 x double> @llvm.x86.sse2.cmp.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 1) return _mm_cmplt_sd(A, B); } __m128d test_mm_cmpneq_pd(__m128d A, __m128d B) { - // DAG-LABEL: test_mm_cmpneq_pd - // DAG: call <2 x double> @llvm.x86.sse2.cmp.pd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 4) - // - // ASM-LABEL: test_mm_cmpneq_pd - // ASM: cmpneqpd + // CHECK-LABEL: test_mm_cmpneq_pd + // CHECK: call <2 x double> @llvm.x86.sse2.cmp.pd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 4) return _mm_cmpneq_pd(A, B); } __m128d test_mm_cmpneq_sd(__m128d A, __m128d B) { - // DAG-LABEL: test_mm_cmpneq_sd - // DAG: call <2 x double> @llvm.x86.sse2.cmp.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 4) - // - // ASM-LABEL: test_mm_cmpneq_sd - // ASM: cmpneqsd + // CHECK-LABEL: test_mm_cmpneq_sd + // CHECK: call <2 x double> @llvm.x86.sse2.cmp.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 4) return _mm_cmpneq_sd(A, B); } __m128d test_mm_cmpnge_pd(__m128d A, __m128d B) { - // DAG-LABEL: test_mm_cmpnge_pd - // DAG: call <2 x double> @llvm.x86.sse2.cmp.pd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 6) - // - // ASM-LABEL: test_mm_cmpnge_pd - // ASM: cmpnlepd + // CHECK-LABEL: test_mm_cmpnge_pd + // CHECK: call <2 x double> @llvm.x86.sse2.cmp.pd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 6) return _mm_cmpnge_pd(A, B); } __m128d test_mm_cmpnge_sd(__m128d A, __m128d B) { - // DAG-LABEL: test_mm_cmpnge_sd - // DAG: call <2 x double> @llvm.x86.sse2.cmp.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 6) - // - // ASM-LABEL: test_mm_cmpnge_sd - // ASM: cmpnlesd + // CHECK-LABEL: test_mm_cmpnge_sd + // CHECK: call <2 x double> @llvm.x86.sse2.cmp.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 6) return _mm_cmpnge_sd(A, B); } __m128d test_mm_cmpngt_pd(__m128d A, __m128d B) { - // DAG-LABEL: test_mm_cmpngt_pd - // DAG: call <2 x double> @llvm.x86.sse2.cmp.pd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 5) - // - // ASM-LABEL: test_mm_cmpngt_pd - // ASM: cmpnltpd + // CHECK-LABEL: test_mm_cmpngt_pd + // CHECK: call <2 x double> @llvm.x86.sse2.cmp.pd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 5) return _mm_cmpngt_pd(A, B); } __m128d test_mm_cmpngt_sd(__m128d A, __m128d B) { - // DAG-LABEL: test_mm_cmpngt_sd - // DAG: call <2 x double> @llvm.x86.sse2.cmp.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 5) - // - // ASM-LABEL: test_mm_cmpngt_sd - // ASM: cmpnltsd + // CHECK-LABEL: test_mm_cmpngt_sd + // CHECK: call <2 x double> @llvm.x86.sse2.cmp.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 5) return _mm_cmpngt_sd(A, B); } __m128d test_mm_cmpnle_pd(__m128d A, __m128d B) { - // DAG-LABEL: test_mm_cmpnle_pd - // DAG: call <2 x double> @llvm.x86.sse2.cmp.pd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 6) - // - // ASM-LABEL: test_mm_cmpnle_pd - // ASM: cmpnlepd + // CHECK-LABEL: test_mm_cmpnle_pd + // CHECK: call <2 x double> @llvm.x86.sse2.cmp.pd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 6) return _mm_cmpnle_pd(A, B); } __m128d test_mm_cmpnle_sd(__m128d A, __m128d B) { - // DAG-LABEL: test_mm_cmpnle_sd - // DAG: call <2 x double> @llvm.x86.sse2.cmp.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 6) - // - // ASM-LABEL: test_mm_cmpnle_sd - // ASM: cmpnlesd + // CHECK-LABEL: test_mm_cmpnle_sd + // CHECK: call <2 x double> @llvm.x86.sse2.cmp.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 6) return _mm_cmpnle_sd(A, B); } __m128d test_mm_cmpnlt_pd(__m128d A, __m128d B) { - // DAG-LABEL: test_mm_cmpnlt_pd - // DAG: call <2 x double> @llvm.x86.sse2.cmp.pd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 5) - // - // ASM-LABEL: test_mm_cmpnlt_pd - // ASM: cmpnltpd + // CHECK-LABEL: test_mm_cmpnlt_pd + // CHECK: call <2 x double> @llvm.x86.sse2.cmp.pd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 5) return _mm_cmpnlt_pd(A, B); } __m128d test_mm_cmpnlt_sd(__m128d A, __m128d B) { - // DAG-LABEL: test_mm_cmpnlt_sd - // DAG: call <2 x double> @llvm.x86.sse2.cmp.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 5) - // - // ASM-LABEL: test_mm_cmpnlt_sd - // ASM: cmpnltsd + // CHECK-LABEL: test_mm_cmpnlt_sd + // CHECK: call <2 x double> @llvm.x86.sse2.cmp.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 5) return _mm_cmpnlt_sd(A, B); } __m128d test_mm_cmpord_pd(__m128d A, __m128d B) { - // DAG-LABEL: test_mm_cmpord_pd - // DAG: call <2 x double> @llvm.x86.sse2.cmp.pd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 7) - // - // ASM-LABEL: test_mm_cmpord_pd - // ASM: cmpordpd + // CHECK-LABEL: test_mm_cmpord_pd + // CHECK: call <2 x double> @llvm.x86.sse2.cmp.pd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 7) return _mm_cmpord_pd(A, B); } __m128d test_mm_cmpord_sd(__m128d A, __m128d B) { - // DAG-LABEL: test_mm_cmpord_sd - // DAG: call <2 x double> @llvm.x86.sse2.cmp.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 7) - // - // ASM-LABEL: test_mm_cmpord_sd - // ASM: cmpordsd + // CHECK-LABEL: test_mm_cmpord_sd + // CHECK: call <2 x double> @llvm.x86.sse2.cmp.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 7) return _mm_cmpord_sd(A, B); } __m128d test_mm_cmpunord_pd(__m128d A, __m128d B) { - // DAG-LABEL: test_mm_cmpunord_pd - // DAG: call <2 x double> @llvm.x86.sse2.cmp.pd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 3) - // - // ASM-LABEL: test_mm_cmpunord_pd - // ASM: cmpunordpd + // CHECK-LABEL: test_mm_cmpunord_pd + // CHECK: call <2 x double> @llvm.x86.sse2.cmp.pd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 3) return _mm_cmpunord_pd(A, B); } __m128d test_mm_cmpunord_sd(__m128d A, __m128d B) { - // DAG-LABEL: test_mm_cmpunord_sd - // DAG: call <2 x double> @llvm.x86.sse2.cmp.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 3) - // - // ASM-LABEL: test_mm_cmpunord_sd - // ASM: cmpunordsd + // CHECK-LABEL: test_mm_cmpunord_sd + // CHECK: call <2 x double> @llvm.x86.sse2.cmp.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}, i8 3) return _mm_cmpunord_sd(A, B); } int test_mm_comieq_sd(__m128d A, __m128d B) { - // DAG-LABEL: test_mm_comieq_sd - // DAG: call i32 @llvm.x86.sse2.comieq.sd - // - // ASM-LABEL: test_mm_comieq_sd - // ASM: comisd + // CHECK-LABEL: test_mm_comieq_sd + // CHECK: call i32 @llvm.x86.sse2.comieq.sd return _mm_comieq_sd(A, B); } int test_mm_comige_sd(__m128d A, __m128d B) { - // DAG-LABEL: test_mm_comige_sd - // DAG: call i32 @llvm.x86.sse2.comige.sd - // - // ASM-LABEL: test_mm_comige_sd - // ASM: comisd + // CHECK-LABEL: test_mm_comige_sd + // CHECK: call i32 @llvm.x86.sse2.comige.sd return _mm_comige_sd(A, B); } int test_mm_comigt_sd(__m128d A, __m128d B) { - // DAG-LABEL: test_mm_comigt_sd - // DAG: call i32 @llvm.x86.sse2.comigt.sd - // - // ASM-LABEL: test_mm_comigt_sd - // ASM: comisd + // CHECK-LABEL: test_mm_comigt_sd + // CHECK: call i32 @llvm.x86.sse2.comigt.sd return _mm_comigt_sd(A, B); } int test_mm_comile_sd(__m128d A, __m128d B) { - // DAG-LABEL: test_mm_comile_sd - // DAG: call i32 @llvm.x86.sse2.comile.sd - // - // ASM-LABEL: test_mm_comile_sd - // ASM: comisd + // CHECK-LABEL: test_mm_comile_sd + // CHECK: call i32 @llvm.x86.sse2.comile.sd return _mm_comile_sd(A, B); } int test_mm_comilt_sd(__m128d A, __m128d B) { - // DAG-LABEL: test_mm_comilt_sd - // DAG: call i32 @llvm.x86.sse2.comilt.sd - // - // ASM-LABEL: test_mm_comilt_sd - // ASM: comisd + // CHECK-LABEL: test_mm_comilt_sd + // CHECK: call i32 @llvm.x86.sse2.comilt.sd return _mm_comilt_sd(A, B); } int test_mm_comineq_sd(__m128d A, __m128d B) { - // DAG-LABEL: test_mm_comineq_sd - // DAG: call i32 @llvm.x86.sse2.comineq.sd - // - // ASM-LABEL: test_mm_comineq_sd - // ASM: comisd + // CHECK-LABEL: test_mm_comineq_sd + // CHECK: call i32 @llvm.x86.sse2.comineq.sd return _mm_comineq_sd(A, B); } __m128d test_mm_cvtepi32_pd(__m128i A) { - // DAG-LABEL: test_mm_cvtepi32_pd - // DAG: call <2 x double> @llvm.x86.sse2.cvtdq2pd - // - // ASM-LABEL: test_mm_cvtepi32_pd - // ASM: cvtdq2pd + // CHECK-LABEL: test_mm_cvtepi32_pd + // CHECK: call <2 x double> @llvm.x86.sse2.cvtdq2pd return _mm_cvtepi32_pd(A); } __m128 test_mm_cvtepi32_ps(__m128i A) { - // DAG-LABEL: test_mm_cvtepi32_ps - // DAG: call <4 x float> @llvm.x86.sse2.cvtdq2ps - // - // ASM-LABEL: test_mm_cvtepi32_ps - // ASM: cvtdq2ps + // CHECK-LABEL: test_mm_cvtepi32_ps + // CHECK: call <4 x float> @llvm.x86.sse2.cvtdq2ps return _mm_cvtepi32_ps(A); } __m128i test_mm_cvtpd_epi32(__m128d A) { - // DAG-LABEL: test_mm_cvtpd_epi32 - // DAG: call <4 x i32> @llvm.x86.sse2.cvtpd2dq - // - // ASM-LABEL: test_mm_cvtpd_epi32 - // ASM: cvtpd2dq + // CHECK-LABEL: test_mm_cvtpd_epi32 + // CHECK: call <4 x i32> @llvm.x86.sse2.cvtpd2dq return _mm_cvtpd_epi32(A); } __m128 test_mm_cvtpd_ps(__m128d A) { - // DAG-LABEL: test_mm_cvtpd_ps - // DAG: call <4 x float> @llvm.x86.sse2.cvtpd2ps - // - // ASM-LABEL: test_mm_cvtpd_ps - // ASM: cvtpd2ps + // CHECK-LABEL: test_mm_cvtpd_ps + // CHECK: call <4 x float> @llvm.x86.sse2.cvtpd2ps return _mm_cvtpd_ps(A); } __m128i test_mm_cvtps_epi32(__m128 A) { - // DAG-LABEL: test_mm_cvtps_epi32 - // DAG: call <4 x i32> @llvm.x86.sse2.cvtps2dq - // - // ASM-LABEL: test_mm_cvtps_epi32 - // ASM: cvtps2dq + // CHECK-LABEL: test_mm_cvtps_epi32 + // CHECK: call <4 x i32> @llvm.x86.sse2.cvtps2dq return _mm_cvtps_epi32(A); } __m128d test_mm_cvtps_pd(__m128 A) { - // DAG-LABEL: test_mm_cvtps_pd - // DAG: call <2 x double> @llvm.x86.sse2.cvtps2pd - // - // ASM-LABEL: test_mm_cvtps_pd - // ASM: cvtps2pd + // CHECK-LABEL: test_mm_cvtps_pd + // CHECK: call <2 x double> @llvm.x86.sse2.cvtps2pd return _mm_cvtps_pd(A); } double test_mm_cvtsd_f64(__m128d A) { - // DAG-LABEL: test_mm_cvtsd_f64 - // DAG: extractelement <2 x double> %{{.*}}, i32 0 - // - // ASM-LABEL: test_mm_cvtsd_f64 - // ASM: movapd + // CHECK-LABEL: test_mm_cvtsd_f64 + // CHECK: extractelement <2 x double> %{{.*}}, i32 0 return _mm_cvtsd_f64(A); } int test_mm_cvtsd_si32(__m128d A) { - // DAG-LABEL: test_mm_cvtsd_si32 - // DAG: call i32 @llvm.x86.sse2.cvtsd2si - // - // ASM-LABEL: test_mm_cvtsd_si32 - // ASM: cvtsd2si + // CHECK-LABEL: test_mm_cvtsd_si32 + // CHECK: call i32 @llvm.x86.sse2.cvtsd2si return _mm_cvtsd_si32(A); } long long test_mm_cvtsd_si64(__m128d A) { - // DAG-LABEL: test_mm_cvtsd_si64 - // DAG: call i64 @llvm.x86.sse2.cvtsd2si64 - // - // ASM-LABEL: test_mm_cvtsd_si64 - // ASM: cvtsd2si + // CHECK-LABEL: test_mm_cvtsd_si64 + // CHECK: call i64 @llvm.x86.sse2.cvtsd2si64 return _mm_cvtsd_si64(A); } __m128 test_mm_cvtsd_ss(__m128 A, __m128d B) { - // DAG-LABEL: test_mm_cvtsd_ss - // DAG: fptrunc double %{{.*}} to float - // - // ASM-LABEL: test_mm_cvtsd_ss - // ASM: cvtsd2ss + // CHECK-LABEL: test_mm_cvtsd_ss + // CHECK: fptrunc double %{{.*}} to float return _mm_cvtsd_ss(A, B); } int test_mm_cvtsi128_si32(__m128i A) { - // DAG-LABEL: test_mm_cvtsi128_si32 - // DAG: extractelement <4 x i32> %{{.*}}, i32 0 - // - // ASM-LABEL: test_mm_cvtsi128_si32 - // ASM: movd + // CHECK-LABEL: test_mm_cvtsi128_si32 + // CHECK: extractelement <4 x i32> %{{.*}}, i32 0 return _mm_cvtsi128_si32(A); } long long test_mm_cvtsi128_si64(__m128i A) { - // DAG-LABEL: test_mm_cvtsi128_si64 - // DAG: extractelement <2 x i64> %{{.*}}, i32 0 - // - // ASM-LABEL: test_mm_cvtsi128_si64 - // ASM: movd + // CHECK-LABEL: test_mm_cvtsi128_si64 + // CHECK: extractelement <2 x i64> %{{.*}}, i32 0 return _mm_cvtsi128_si64(A); } __m128d test_mm_cvtsi32_sd(__m128d A, int B) { - // DAG-LABEL: test_mm_cvtsi32_sd - // DAG: sitofp i32 %{{.*}} to double - // DAG: insertelement <2 x double> %{{.*}}, double %{{.*}}, i32 0 - // - // ASM-LABEL: test_mm_cvtsi32_sd - // ASM: cvtsi2sdl + // CHECK-LABEL: test_mm_cvtsi32_sd + // CHECK: sitofp i32 %{{.*}} to double + // CHECK: insertelement <2 x double> %{{.*}}, double %{{.*}}, i32 0 return _mm_cvtsi32_sd(A, B); } __m128i test_mm_cvtsi32_si128(int A) { - // DAG-LABEL: test_mm_cvtsi32_si128 - // DAG: insertelement <4 x i32> undef, i32 %{{.*}}, i32 0 - // - // ASM-LABEL: test_mm_cvtsi32_si128 - // ASM: movd + // CHECK-LABEL: test_mm_cvtsi32_si128 + // CHECK: insertelement <4 x i32> undef, i32 %{{.*}}, i32 0 return _mm_cvtsi32_si128(A); } __m128d test_mm_cvtsi64_sd(__m128d A, long long B) { - // DAG-LABEL: test_mm_cvtsi64_sd - // DAG: sitofp i64 %{{.*}} to double - // DAG: insertelement <2 x double> %{{.*}}, double %{{.*}}, i32 0 - // - // ASM-LABEL: test_mm_cvtsi64_sd - // ASM: cvtsi2sdq + // CHECK-LABEL: test_mm_cvtsi64_sd + // CHECK: sitofp i64 %{{.*}} to double + // CHECK: insertelement <2 x double> %{{.*}}, double %{{.*}}, i32 0 return _mm_cvtsi64_sd(A, B); } __m128i test_mm_cvtsi64_si128(long long A) { - // DAG-LABEL: test_mm_cvtsi64_si128 - // DAG: insertelement <2 x i64> undef, i64 %{{.*}}, i32 0 - // - // ASM-LABEL: test_mm_cvtsi64_si128 - // ASM: movq + // CHECK-LABEL: test_mm_cvtsi64_si128 + // CHECK: insertelement <2 x i64> undef, i64 %{{.*}}, i32 0 return _mm_cvtsi64_si128(A); } __m128d test_mm_cvtss_sd(__m128d A, __m128 B) { - // DAG-LABEL: test_mm_cvtss_sd - // DAG: extractelement <4 x float> %{{.*}}, i32 0 - // DAG: fpext float %{{.*}} to double - // DAG: insertelement <2 x double> %{{.*}}, double %{{.*}}, i32 0 - // - // ASM-LABEL: test_mm_cvtss_sd - // ASM: cvtss2sd + // CHECK-LABEL: test_mm_cvtss_sd + // CHECK: extractelement <4 x float> %{{.*}}, i32 0 + // CHECK: fpext float %{{.*}} to double + // CHECK: insertelement <2 x double> %{{.*}}, double %{{.*}}, i32 0 return _mm_cvtss_sd(A, B); } __m128i test_mm_cvttpd_epi32(__m128d A) { - // DAG-LABEL: test_mm_cvttpd_epi32 - // DAG: call <4 x i32> @llvm.x86.sse2.cvttpd2dq - // - // ASM-LABEL: test_mm_cvttpd_epi32 - // ASM: cvttpd2dq + // CHECK-LABEL: test_mm_cvttpd_epi32 + // CHECK: call <4 x i32> @llvm.x86.sse2.cvttpd2dq return _mm_cvttpd_epi32(A); } __m128i test_mm_cvttps_epi32(__m128 A) { - // DAG-LABEL: test_mm_cvttps_epi32 - // DAG: call <4 x i32> @llvm.x86.sse2.cvttps2dq - // - // ASM-LABEL: test_mm_cvttps_epi32 - // ASM: cvttps2dq + // CHECK-LABEL: test_mm_cvttps_epi32 + // CHECK: call <4 x i32> @llvm.x86.sse2.cvttps2dq return _mm_cvttps_epi32(A); } int test_mm_cvttsd_si32(__m128d A) { - // DAG-LABEL: test_mm_cvttsd_si32 - // DAG: extractelement <2 x double> %{{.*}}, i32 0 - // DAG: fptosi double %{{.*}} to i32 - // - // ASM-LABEL: test_mm_cvttsd_si32 - // ASM: cvttsd2si + // CHECK-LABEL: test_mm_cvttsd_si32 + // CHECK: extractelement <2 x double> %{{.*}}, i32 0 + // CHECK: fptosi double %{{.*}} to i32 return _mm_cvttsd_si32(A); } long long test_mm_cvttsd_si64(__m128d A) { - // DAG-LABEL: test_mm_cvttsd_si64 - // DAG: extractelement <2 x double> %{{.*}}, i32 0 - // DAG: fptosi double %{{.*}} to i64 - // - // ASM-LABEL: test_mm_cvttsd_si64 - // ASM: cvttsd2si + // CHECK-LABEL: test_mm_cvttsd_si64 + // CHECK: extractelement <2 x double> %{{.*}}, i32 0 + // CHECK: fptosi double %{{.*}} to i64 return _mm_cvttsd_si64(A); } __m128d test_mm_div_pd(__m128d A, __m128d B) { - // DAG-LABEL: test_mm_div_pd - // DAG: fdiv <2 x double> - // - // ASM-LABEL: test_mm_div_pd - // ASM: divpd + // CHECK-LABEL: test_mm_div_pd + // CHECK: fdiv <2 x double> return _mm_div_pd(A, B); } __m128d test_mm_div_sd(__m128d A, __m128d B) { - // DAG-LABEL: test_mm_div_sd - // DAG: fdiv double - // - // ASM-LABEL: test_mm_div_sd - // ASM: divsd + // CHECK-LABEL: test_mm_div_sd + // CHECK: fdiv double return _mm_div_sd(A, B); } // Lowering to pextrw requires optimization. int test_mm_extract_epi16(__m128i A) { - // DAG-LABEL: test_mm_extract_epi16 - // DAG: [[x:%.*]] = and i32 %{{.*}}, 7 - // DAG: extractelement <8 x i16> %{{.*}}, i32 [[x]] - // - // ASM-LABEL: test_mm_extract_epi16 - // ASM: movzwl + // CHECK-LABEL: test_mm_extract_epi16 + // CHECK: [[x:%.*]] = and i32 %{{.*}}, 7 + // CHECK: extractelement <8 x i16> %{{.*}}, i32 [[x]] return _mm_extract_epi16(A, 8); } -// Lowering to pinsrw requires optimization. __m128i test_mm_insert_epi16(__m128i A, short B) { - // DAG-LABEL: test_mm_insert_epi16 - // DAG: [[x:%.*]] = and i32 %{{.*}}, 7 - // DAG: insertelement <8 x i16> %{{.*}}, i32 [[x]] - // - // ASM-LABEL: test_mm_insert_epi16 - // ASM: movw + // CHECK-LABEL: test_mm_insert_epi16 + // CHECK: [[x:%.*]] = and i32 %{{.*}}, 7 + // CHECK: insertelement <8 x i16> %{{.*}}, i32 [[x]] return _mm_insert_epi16(A, B, 8); } void test_mm_lfence() { - // DAG-LABEL: test_mm_lfence - // DAG: call void @llvm.x86.sse2.lfence() - // - // ASM-LABEL: test_mm_lfence - // ASM: lfence + // CHECK-LABEL: test_mm_lfence + // CHECK: call void @llvm.x86.sse2.lfence() _mm_lfence(); } __m128d test_mm_load_pd(double const* A) { - // DAG-LABEL: test_mm_load_pd - // DAG: load <2 x double>, <2 x double>* %{{.*}}, align 16 - // - // ASM-LABEL: test_mm_load_pd - // ASM: movapd + // CHECK-LABEL: test_mm_load_pd + // CHECK: load <2 x double>, <2 x double>* %{{.*}}, align 16 return _mm_load_pd(A); } __m128d test_mm_load_sd(double const* A) { - // DAG-LABEL: test_mm_load_sd - // DAG: load double, double* %{{.*}}, align 1 - // - // ASM-LABEL: test_mm_load_sd - // ASM: movsd + // CHECK-LABEL: test_mm_load_sd + // CHECK: load double, double* %{{.*}}, align 1 return _mm_load_sd(A); } __m128i test_mm_load_si128(__m128i const* A) { - // DAG-LABEL: test_mm_load_si128 - // DAG: load <2 x i64>, <2 x i64>* %{{.*}}, align 16 - // - // ASM-LABEL: test_mm_load_si128 - // ASM: movdqa + // CHECK-LABEL: test_mm_load_si128 + // CHECK: load <2 x i64>, <2 x i64>* %{{.*}}, align 16 return _mm_load_si128(A); } __m128d test_mm_load1_pd(double const* A) { - // DAG-LABEL: test_mm_load1_pd - // DAG: load double, double* %{{.*}}, align 8 - // DAG: insertelement <2 x double> undef, double %{{.*}}, i32 0 - // DAG: insertelement <2 x double> %{{.*}}, double %{{.*}}, i32 1 - // - // ASM-LABEL: test_mm_load1_pd - // ASM: movsd - // ASM: movlhps + // CHECK-LABEL: test_mm_load1_pd + // CHECK: load double, double* %{{.*}}, align 8 + // CHECK: insertelement <2 x double> undef, double %{{.*}}, i32 0 + // CHECK: insertelement <2 x double> %{{.*}}, double %{{.*}}, i32 1 return _mm_load1_pd(A); } __m128d test_mm_loadh_pd(__m128d x, void* y) { - // DAG-LABEL: test_mm_loadh_pd - // DAG: load double, double* %{{.*}}, align 1{{$}} - // - // ASM-LABEL: test_mm_loadh_pd - // ASM: movsd - // ASM: unpcklpd + // CHECK-LABEL: test_mm_loadh_pd + // CHECK: load double, double* %{{.*}}, align 1{{$}} return _mm_loadh_pd(x, y); } __m128d test_mm_loadr_pd(double const* A) { - // DAG-LABEL: test_mm_loadr_pd - // DAG: load <2 x double>, <2 x double>* %{{.*}}, align 16 - // DAG: shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x i32> - // - // ASM-LABEL: test_mm_loadr_pd - // ASM: movapd - // ASM: shufpd $1, + // CHECK-LABEL: test_mm_loadr_pd + // CHECK: load <2 x double>, <2 x double>* %{{.*}}, align 16 + // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x i32> return _mm_loadr_pd(A); } __m128d test_mm_loadu_pd(double const* A) { - // DAG-LABEL: test_mm_loadu_pd - // DAG: load <2 x double>, <2 x double>* %{{.*}}, align 1 - // - // ASM-LABEL: test_mm_loadu_pd - // ASM: movupd + // CHECK-LABEL: test_mm_loadu_pd + // CHECK: load <2 x double>, <2 x double>* %{{.*}}, align 1 return _mm_loadu_pd(A); } __m128i test_mm_loadu_si128(__m128i const* A) { - // DAG-LABEL: test_mm_loadu_si128 - // DAG: load <2 x i64>, <2 x i64>* %{{.*}}, align 1 - // - // ASM-LABEL: test_mm_loadu_si128 - // ASM: movdqu + // CHECK-LABEL: test_mm_loadu_si128 + // CHECK: load <2 x i64>, <2 x i64>* %{{.*}}, align 1 return _mm_loadu_si128(A); } __m128i test_mm_madd_epi16(__m128i A, __m128i B) { - // DAG-LABEL: test_mm_madd_epi16 - // DAG: call <4 x i32> @llvm.x86.sse2.pmadd.wd(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) - // - // ASM-LABEL: test_mm_madd_epi16 - // ASM: pmaddwd + // CHECK-LABEL: test_mm_madd_epi16 + // CHECK: call <4 x i32> @llvm.x86.sse2.pmadd.wd(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) return _mm_madd_epi16(A, B); } void test_mm_maskmoveu_si128(__m128i A, __m128i B, char* C) { - // DAG-LABEL: test_mm_maskmoveu_si128 - // DAG: call void @llvm.x86.sse2.maskmov.dqu(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i8* %{{.*}}) - // - // ASM-LABEL: test_mm_maskmoveu_si128 - // ASM: maskmovdqu + // CHECK-LABEL: test_mm_maskmoveu_si128 + // CHECK: call void @llvm.x86.sse2.maskmov.dqu(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}, i8* %{{.*}}) _mm_maskmoveu_si128(A, B, C); } __m128i test_mm_max_epi16(__m128i A, __m128i B) { - // DAG-LABEL: test_mm_max_epi16 - // DAG: call <8 x i16> @llvm.x86.sse2.pmaxs.w(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) - // - // ASM-LABEL: test_mm_max_epi16 - // ASM: pmaxsw + // CHECK-LABEL: test_mm_max_epi16 + // CHECK: call <8 x i16> @llvm.x86.sse2.pmaxs.w(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) return _mm_max_epi16(A, B); } __m128i test_mm_max_epu8(__m128i A, __m128i B) { - // DAG-LABEL: test_mm_max_epu8 - // DAG: call <16 x i8> @llvm.x86.sse2.pmaxu.b(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) - // - // ASM-LABEL: test_mm_max_epu8 - // ASM: pmaxub + // CHECK-LABEL: test_mm_max_epu8 + // CHECK: call <16 x i8> @llvm.x86.sse2.pmaxu.b(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) return _mm_max_epu8(A, B); } __m128d test_mm_max_pd(__m128d A, __m128d B) { - // DAG-LABEL: test_mm_max_pd - // DAG: call <2 x double> @llvm.x86.sse2.max.pd(<2 x double> %{{.*}}, <2 x double> %{{.*}}) - // - // ASM-LABEL: test_mm_max_pd - // ASM: maxpd + // CHECK-LABEL: test_mm_max_pd + // CHECK: call <2 x double> @llvm.x86.sse2.max.pd(<2 x double> %{{.*}}, <2 x double> %{{.*}}) return _mm_max_pd(A, B); } __m128d test_mm_max_sd(__m128d A, __m128d B) { - // DAG-LABEL: test_mm_max_sd - // DAG: call <2 x double> @llvm.x86.sse2.max.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}) - // - // ASM-LABEL: test_mm_max_sd - // ASM: maxsd + // CHECK-LABEL: test_mm_max_sd + // CHECK: call <2 x double> @llvm.x86.sse2.max.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}) return _mm_max_sd(A, B); } void test_mm_mfence() { - // DAG-LABEL: test_mm_mfence - // DAG: call void @llvm.x86.sse2.mfence() - // - // ASM-LABEL: test_mm_mfence - // ASM: mfence + // CHECK-LABEL: test_mm_mfence + // CHECK: call void @llvm.x86.sse2.mfence() _mm_mfence(); } __m128i test_mm_min_epi16(__m128i A, __m128i B) { - // DAG-LABEL: test_mm_min_epi16 - // DAG: call <8 x i16> @llvm.x86.sse2.pmins.w(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) - // - // ASM-LABEL: test_mm_min_epi16 - // ASM: pminsw + // CHECK-LABEL: test_mm_min_epi16 + // CHECK: call <8 x i16> @llvm.x86.sse2.pmins.w(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) return _mm_min_epi16(A, B); } __m128i test_mm_min_epu8(__m128i A, __m128i B) { - // DAG-LABEL: test_mm_min_epu8 - // DAG: call <16 x i8> @llvm.x86.sse2.pminu.b(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) - // - // ASM-LABEL: test_mm_min_epu8 - // ASM: pminub + // CHECK-LABEL: test_mm_min_epu8 + // CHECK: call <16 x i8> @llvm.x86.sse2.pminu.b(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) return _mm_min_epu8(A, B); } __m128d test_mm_min_pd(__m128d A, __m128d B) { - // DAG-LABEL: test_mm_min_pd - // DAG: call <2 x double> @llvm.x86.sse2.min.pd(<2 x double> %{{.*}}, <2 x double> %{{.*}}) - // - // ASM-LABEL: test_mm_min_pd - // ASM: minpd + // CHECK-LABEL: test_mm_min_pd + // CHECK: call <2 x double> @llvm.x86.sse2.min.pd(<2 x double> %{{.*}}, <2 x double> %{{.*}}) return _mm_min_pd(A, B); } __m128d test_mm_min_sd(__m128d A, __m128d B) { - // DAG-LABEL: test_mm_min_sd - // DAG: call <2 x double> @llvm.x86.sse2.min.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}) - // - // ASM-LABEL: test_mm_min_sd - // ASM: minsd + // CHECK-LABEL: test_mm_min_sd + // CHECK: call <2 x double> @llvm.x86.sse2.min.sd(<2 x double> %{{.*}}, <2 x double> %{{.*}}) return _mm_min_sd(A, B); } int test_mm_movemask_epi8(__m128i A) { - // DAG-LABEL: test_mm_movemask_epi8 - // DAG: call i32 @llvm.x86.sse2.pmovmskb.128(<16 x i8> %{{.*}}) - // - // ASM-LABEL: test_mm_movemask_epi8 - // ASM: pmovmskb + // CHECK-LABEL: test_mm_movemask_epi8 + // CHECK: call i32 @llvm.x86.sse2.pmovmskb.128(<16 x i8> %{{.*}}) return _mm_movemask_epi8(A); } int test_mm_movemask_pd(__m128d A) { - // DAG-LABEL: test_mm_movemask_pd - // DAG: call i32 @llvm.x86.sse2.movmsk.pd(<2 x double> %{{.*}}) - // - // ASM-LABEL: test_mm_movemask_pd - // ASM: movmskpd + // CHECK-LABEL: test_mm_movemask_pd + // CHECK: call i32 @llvm.x86.sse2.movmsk.pd(<2 x double> %{{.*}}) return _mm_movemask_pd(A); } __m128i test_mm_mul_epu32(__m128i A, __m128i B) { - // DAG-LABEL: test_mm_mul_epu32 - // DAG: call <2 x i64> @llvm.x86.sse2.pmulu.dq(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) - // - // ASM-LABEL: test_mm_mul_epu32 - // ASM: pmuludq + // CHECK-LABEL: test_mm_mul_epu32 + // CHECK: call <2 x i64> @llvm.x86.sse2.pmulu.dq(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) return _mm_mul_epu32(A, B); } __m128d test_mm_mul_pd(__m128d A, __m128d B) { - // DAG-LABEL: test_mm_mul_pd - // DAG: fmul <2 x double> %{{.*}}, %{{.*}} - // - // ASM-LABEL: test_mm_mul_pd - // ASM: mulpd + // CHECK-LABEL: test_mm_mul_pd + // CHECK: fmul <2 x double> %{{.*}}, %{{.*}} return _mm_mul_pd(A, B); } __m128d test_mm_mul_sd(__m128d A, __m128d B) { - // DAG-LABEL: test_mm_mul_sd - // DAG: fmul double %{{.*}}, %{{.*}} - // - // ASM-LABEL: test_mm_mul_sd - // ASM: mulsd + // CHECK-LABEL: test_mm_mul_sd + // CHECK: fmul double %{{.*}}, %{{.*}} return _mm_mul_sd(A, B); } __m128i test_mm_mulhi_epi16(__m128i A, __m128i B) { - // DAG-LABEL: test_mm_mulhi_epi16 - // DAG: call <8 x i16> @llvm.x86.sse2.pmulh.w(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) - // - // ASM-LABEL: test_mm_mulhi_epi16 - // ASM: pmulhw + // CHECK-LABEL: test_mm_mulhi_epi16 + // CHECK: call <8 x i16> @llvm.x86.sse2.pmulh.w(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) return _mm_mulhi_epi16(A, B); } __m128i test_mm_mulhi_epu16(__m128i A, __m128i B) { - // DAG-LABEL: test_mm_mulhi_epu16 - // DAG: call <8 x i16> @llvm.x86.sse2.pmulhu.w(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) - // - // ASM-LABEL: test_mm_mulhi_epu16 - // ASM: pmulhuw + // CHECK-LABEL: test_mm_mulhi_epu16 + // CHECK: call <8 x i16> @llvm.x86.sse2.pmulhu.w(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) return _mm_mulhi_epu16(A, B); } __m128i test_mm_mullo_epi16(__m128i A, __m128i B) { - // DAG-LABEL: test_mm_mullo_epi16 - // DAG: mul <8 x i16> %{{.*}}, %{{.*}} - // - // ASM-LABEL: test_mm_mullo_epi16 - // ASM: pmullw + // CHECK-LABEL: test_mm_mullo_epi16 + // CHECK: mul <8 x i16> %{{.*}}, %{{.*}} return _mm_mullo_epi16(A, B); } __m128d test_mm_or_pd(__m128d A, __m128d B) { - // DAG-LABEL: test_mm_or_pd - // DAG: or <4 x i32> %{{.*}}, %{{.*}} - // - // ASM-LABEL: test_mm_or_pd - // ASM: por + // CHECK-LABEL: test_mm_or_pd + // CHECK: or <4 x i32> %{{.*}}, %{{.*}} return _mm_or_pd(A, B); } __m128i test_mm_or_si128(__m128i A, __m128i B) { - // DAG-LABEL: test_mm_or_si128 - // DAG: or <2 x i64> %{{.*}}, %{{.*}} - // - // ASM-LABEL: test_mm_or_si128 - // ASM: orps + // CHECK-LABEL: test_mm_or_si128 + // CHECK: or <2 x i64> %{{.*}}, %{{.*}} return _mm_or_si128(A, B); } __m128i test_mm_packs_epi16(__m128i A, __m128i B) { - // DAG-LABEL: test_mm_packs_epi16 - // DAG: call <16 x i8> @llvm.x86.sse2.packsswb.128(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) - // - // ASM-LABEL: test_mm_packs_epi16 - // ASM: packsswb + // CHECK-LABEL: test_mm_packs_epi16 + // CHECK: call <16 x i8> @llvm.x86.sse2.packsswb.128(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) return _mm_packs_epi16(A, B); } __m128i test_mm_packs_epi32(__m128i A, __m128i B) { - // DAG-LABEL: test_mm_packs_epi32 - // DAG: call <8 x i16> @llvm.x86.sse2.packssdw.128(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) - // - // ASM-LABEL: test_mm_packs_epi32 - // ASM: packssdw + // CHECK-LABEL: test_mm_packs_epi32 + // CHECK: call <8 x i16> @llvm.x86.sse2.packssdw.128(<4 x i32> %{{.*}}, <4 x i32> %{{.*}}) return _mm_packs_epi32(A, B); } __m128i test_mm_packus_epi16(__m128i A, __m128i B) { - // DAG-LABEL: test_mm_packus_epi16 - // DAG: call <16 x i8> @llvm.x86.sse2.packuswb.128(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) - // - // ASM-LABEL: test_mm_packus_epi16 - // ASM: packuswb + // CHECK-LABEL: test_mm_packus_epi16 + // CHECK: call <16 x i8> @llvm.x86.sse2.packuswb.128(<8 x i16> %{{.*}}, <8 x i16> %{{.*}}) return _mm_packus_epi16(A, B); } void test_mm_pause() { - // DAG-LABEL: test_mm_pause - // DAG: call void @llvm.x86.sse2.pause() - // - // ASM-LABEL: test_mm_pause - // ASM: pause + // CHECK-LABEL: test_mm_pause + // CHECK: call void @llvm.x86.sse2.pause() return _mm_pause(); } __m128i test_mm_sad_epu8(__m128i A, __m128i B) { - // DAG-LABEL: test_mm_sad_epu8 - // DAG: call <2 x i64> @llvm.x86.sse2.psad.bw(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) - // - // ASM-LABEL: test_mm_sad_epu8 - // ASM: psadbw + // CHECK-LABEL: test_mm_sad_epu8 + // CHECK: call <2 x i64> @llvm.x86.sse2.psad.bw(<16 x i8> %{{.*}}, <16 x i8> %{{.*}}) return _mm_sad_epu8(A, B); } __m128d test_mm_setzero_pd() { - // DAG-LABEL: test_mm_setzero_pd - // DAG: store <2 x double> zeroinitializer - // - // ASM-LABEL: test_mm_setzero_pd - // ASM: xorps + // CHECK-LABEL: test_mm_setzero_pd + // CHECK: store <2 x double> zeroinitializer return _mm_setzero_pd(); } __m128i test_mm_setzero_si128() { - // DAG-LABEL: test_mm_setzero_si128 - // DAG: store <2 x i64> zeroinitializer - // - // ASM-LABEL: test_mm_setzero_si128 - // ASM: xorps + // CHECK-LABEL: test_mm_setzero_si128 + // CHECK: store <2 x i64> zeroinitializer return _mm_setzero_si128(); } __m128i test_mm_shuffle_epi32(__m128i A) { - // DAG-LABEL: test_mm_shuffle_epi32 - // DAG: shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> zeroinitializer - // - // ASM-LABEL: test_mm_shuffle_epi32 - // ASM: pshufd $0, + // CHECK-LABEL: test_mm_shuffle_epi32 + // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> zeroinitializer return _mm_shuffle_epi32(A, 0); } __m128d test_mm_shuffle_pd(__m128d A, __m128d B) { - // DAG-LABEL: test_mm_shuffle_pd - // DAG: shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x i32> - // - // ASM-LABEL: test_mm_shuffle_pd - // ASM: shufpd $1, + // CHECK-LABEL: test_mm_shuffle_pd + // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x i32> return _mm_shuffle_pd(A, B, 1); } __m128i test_mm_shufflehi_epi16(__m128i A) { - // DAG-LABEL: test_mm_shufflehi_epi16 - // DAG: shufflevector <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i32> - // - // ASM-LABEL: test_mm_shufflehi_epi16 - // ASM: pshufhw $0, + // CHECK-LABEL: test_mm_shufflehi_epi16 + // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i32> return _mm_shufflehi_epi16(A, 0); } __m128i test_mm_shufflelo_epi16(__m128i A) { - // DAG-LABEL: test_mm_shufflelo_epi16 - // DAG: shufflevector <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i32> - // - // ASM-LABEL: test_mm_shufflelo_epi16 - // ASM: pshuflw $0, + // CHECK-LABEL: test_mm_shufflelo_epi16 + // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i32> return _mm_shufflelo_epi16(A, 0); } __m128i test_mm_sll_epi16(__m128i A, __m128i B) { - // DAG-LABEL: test_mm_sll_epi16 - // DAG: call <8 x i16> @llvm.x86.sse2.psll.w - // - // ASM-LABEL: test_mm_sll_epi16 - // ASM: psllw + // CHECK-LABEL: test_mm_sll_epi16 + // CHECK: call <8 x i16> @llvm.x86.sse2.psll.w return _mm_sll_epi16(A, B); } __m128i test_mm_sll_epi32(__m128i A, __m128i B) { - // DAG-LABEL: test_mm_sll_epi32 - // DAG: call <4 x i32> @llvm.x86.sse2.psll.d - // - // ASM-LABEL: test_mm_sll_epi32 - // ASM: pslld + // CHECK-LABEL: test_mm_sll_epi32 + // CHECK: call <4 x i32> @llvm.x86.sse2.psll.d return _mm_sll_epi32(A, B); } __m128i test_mm_sll_epi64(__m128i A, __m128i B) { - // DAG-LABEL: test_mm_sll_epi64 - // DAG: call <2 x i64> @llvm.x86.sse2.psll.q - // - // ASM-LABEL: test_mm_sll_epi64 - // ASM: psllq + // CHECK-LABEL: test_mm_sll_epi64 + // CHECK: call <2 x i64> @llvm.x86.sse2.psll.q return _mm_sll_epi64(A, B); } __m128i test_mm_slli_epi16(__m128i A) { - // DAG-LABEL: test_mm_slli_epi16 - // DAG: call <8 x i16> @llvm.x86.sse2.pslli.w - // - // ASM-LABEL: test_mm_slli_epi16 - // ASM: psllw + // CHECK-LABEL: test_mm_slli_epi16 + // CHECK: call <8 x i16> @llvm.x86.sse2.pslli.w return _mm_slli_epi16(A, 1); } __m128i test_mm_slli_epi32(__m128i A) { - // DAG-LABEL: test_mm_slli_epi32 - // DAG: call <4 x i32> @llvm.x86.sse2.pslli.d - // - // ASM-LABEL: test_mm_slli_epi32 - // ASM: pslld + // CHECK-LABEL: test_mm_slli_epi32 + // CHECK: call <4 x i32> @llvm.x86.sse2.pslli.d return _mm_slli_epi32(A, 1); } __m128i test_mm_slli_epi64(__m128i A) { - // DAG-LABEL: test_mm_slli_epi64 - // DAG: call <2 x i64> @llvm.x86.sse2.pslli.q - // - // ASM-LABEL: test_mm_slli_epi64 - // ASM: psllq + // CHECK-LABEL: test_mm_slli_epi64 + // CHECK: call <2 x i64> @llvm.x86.sse2.pslli.q return _mm_slli_epi64(A, 1); } __m128i test_mm_slli_si128(__m128i A) { - // DAG-LABEL: test_mm_slli_si128 - // DAG: shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i32> - // - // ASM-LABEL: test_mm_slli_si128 - // ASM: pslldq $5, %xmm{{.*}} + // CHECK-LABEL: test_mm_slli_si128 + // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i32> return _mm_slli_si128(A, 5); } __m128d test_mm_sqrt_pd(__m128d A) { - // DAG-LABEL: test_mm_sqrt_pd - // DAG: call <2 x double> @llvm.x86.sse2.sqrt.pd(<2 x double> %{{.*}}) - // - // ASM-LABEL: test_mm_sqrt_pd - // ASM: sqrtpd + // CHECK-LABEL: test_mm_sqrt_pd + // CHECK: call <2 x double> @llvm.x86.sse2.sqrt.pd(<2 x double> %{{.*}}) return _mm_sqrt_pd(A); } __m128d test_mm_sqrt_sd(__m128d A, __m128d B) { - // DAG-LABEL: test_mm_sqrt_sd - // DAG: call <2 x double> @llvm.x86.sse2.sqrt.sd(<2 x double> %{{.*}}) - // - // ASM-LABEL: test_mm_sqrt_sd - // ASM: sqrtsd + // CHECK-LABEL: test_mm_sqrt_sd + // CHECK: call <2 x double> @llvm.x86.sse2.sqrt.sd(<2 x double> %{{.*}}) return _mm_sqrt_sd(A, B); } __m128i test_mm_sra_epi16(__m128i A, __m128i B) { - // DAG-LABEL: test_mm_sra_epi16 - // DAG: call <8 x i16> @llvm.x86.sse2.psra.w - // - // ASM-LABEL: test_mm_sra_epi16 - // ASM: psraw + // CHECK-LABEL: test_mm_sra_epi16 + // CHECK: call <8 x i16> @llvm.x86.sse2.psra.w return _mm_sra_epi16(A, B); } __m128i test_mm_sra_epi32(__m128i A, __m128i B) { - // DAG-LABEL: test_mm_sra_epi32 - // DAG: call <4 x i32> @llvm.x86.sse2.psra.d - // - // ASM-LABEL: test_mm_sra_epi32 - // ASM: psrad + // CHECK-LABEL: test_mm_sra_epi32 + // CHECK: call <4 x i32> @llvm.x86.sse2.psra.d return _mm_sra_epi32(A, B); } __m128i test_mm_srai_epi16(__m128i A) { - // DAG-LABEL: test_mm_srai_epi16 - // DAG: call <8 x i16> @llvm.x86.sse2.psrai.w - // - // ASM-LABEL: test_mm_srai_epi16 - // ASM: psraw + // CHECK-LABEL: test_mm_srai_epi16 + // CHECK: call <8 x i16> @llvm.x86.sse2.psrai.w return _mm_srai_epi16(A, 1); } __m128i test_mm_srai_epi32(__m128i A) { - // DAG-LABEL: test_mm_srai_epi32 - // DAG: call <4 x i32> @llvm.x86.sse2.psrai.d - // - // ASM-LABEL: test_mm_srai_epi32 - // ASM: psrad + // CHECK-LABEL: test_mm_srai_epi32 + // CHECK: call <4 x i32> @llvm.x86.sse2.psrai.d return _mm_srai_epi32(A, 1); } __m128i test_mm_srl_epi16(__m128i A, __m128i B) { - // DAG-LABEL: test_mm_srl_epi16 - // DAG: call <8 x i16> @llvm.x86.sse2.psrl.w - // - // ASM-LABEL: test_mm_srl_epi16 - // ASM: psrlw + // CHECK-LABEL: test_mm_srl_epi16 + // CHECK: call <8 x i16> @llvm.x86.sse2.psrl.w return _mm_srl_epi16(A, B); } __m128i test_mm_srl_epi32(__m128i A, __m128i B) { - // DAG-LABEL: test_mm_srl_epi32 - // DAG: call <4 x i32> @llvm.x86.sse2.psrl.d - // - // ASM-LABEL: test_mm_srl_epi32 - // ASM: psrld + // CHECK-LABEL: test_mm_srl_epi32 + // CHECK: call <4 x i32> @llvm.x86.sse2.psrl.d return _mm_srl_epi32(A, B); } __m128i test_mm_srl_epi64(__m128i A, __m128i B) { - // DAG-LABEL: test_mm_srl_epi64 - // DAG: call <2 x i64> @llvm.x86.sse2.psrl.q - // - // ASM-LABEL: test_mm_srl_epi64 - // ASM: psrlq + // CHECK-LABEL: test_mm_srl_epi64 + // CHECK: call <2 x i64> @llvm.x86.sse2.psrl.q return _mm_srl_epi64(A, B); } __m128i test_mm_srli_epi16(__m128i A) { - // DAG-LABEL: test_mm_srli_epi16 - // DAG: call <8 x i16> @llvm.x86.sse2.psrli.w - // - // ASM-LABEL: test_mm_srli_epi16 - // ASM: psrlw + // CHECK-LABEL: test_mm_srli_epi16 + // CHECK: call <8 x i16> @llvm.x86.sse2.psrli.w return _mm_srli_epi16(A, 1); } __m128i test_mm_srli_epi32(__m128i A) { - // DAG-LABEL: test_mm_srli_epi32 - // DAG: call <4 x i32> @llvm.x86.sse2.psrli.d - // - // ASM-LABEL: test_mm_srli_epi32 - // ASM: psrld + // CHECK-LABEL: test_mm_srli_epi32 + // CHECK: call <4 x i32> @llvm.x86.sse2.psrli.d return _mm_srli_epi32(A, 1); } __m128i test_mm_srli_epi64(__m128i A) { - // DAG-LABEL: test_mm_srli_epi64 - // DAG: call <2 x i64> @llvm.x86.sse2.psrli.q - // - // ASM-LABEL: test_mm_srli_epi64 - // ASM: psrlq + // CHECK-LABEL: test_mm_srli_epi64 + // CHECK: call <2 x i64> @llvm.x86.sse2.psrli.q return _mm_srli_epi64(A, 1); } __m128i test_mm_srli_si128(__m128i A) { - // DAG-LABEL: test_mm_srli_si128 - // DAG: shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i32> - // - // ASM-LABEL: test_mm_srli_si128 - // ASM: psrldq $5, %xmm{{.*}} + // CHECK-LABEL: test_mm_srli_si128 + // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i32> return _mm_srli_si128(A, 5); } void test_mm_store_pd(double* A, __m128d B) { - // DAG-LABEL: test_mm_store_pd - // DAG: store <2 x double> %{{.*}}, <2 x double>* %{{.*}}, align 16 - // - // ASM-LABEL: test_mm_store_pd - // ASM: movapd + // CHECK-LABEL: test_mm_store_pd + // CHECK: store <2 x double> %{{.*}}, <2 x double>* %{{.*}}, align 16 _mm_store_pd(A, B); } void test_mm_store_sd(double* A, __m128d B) { - // DAG-LABEL: test_mm_store_sd - // DAG: store double %{{.*}}, double* %{{.*}}, align 1{{$}} - // - // ASM-LABEL: test_mm_store_sd - // ASM: movsd + // CHECK-LABEL: test_mm_store_sd + // CHECK: store double %{{.*}}, double* %{{.*}}, align 1{{$}} _mm_store_sd(A, B); } void test_mm_store_si128(__m128i* A, __m128i B) { - // DAG-LABEL: test_mm_store_si128 - // DAG: store <2 x i64> %{{.*}}, <2 x i64>* %{{.*}}, align 16 - // - // ASM-LABEL: test_mm_store_si128 - // ASM: movdqa + // CHECK-LABEL: test_mm_store_si128 + // CHECK: store <2 x i64> %{{.*}}, <2 x i64>* %{{.*}}, align 16 _mm_store_si128(A, B); } void test_mm_storeh_pd(double* A, __m128d B) { - // DAG-LABEL: test_mm_storeh_pd - // DAG: store double %{{.*}}, double* %{{.*}}, align 1 - // - // ASM-LABEL: test_mm_storeh_pd - // ASM: shufpd $1 - // ASM: movsd + // CHECK-LABEL: test_mm_storeh_pd + // CHECK: store double %{{.*}}, double* %{{.*}}, align 1 _mm_storeh_pd(A, B); } void test_mm_storel_pd(double* A, __m128d B) { - // DAG-LABEL: test_mm_storel_pd - // DAG: store double %{{.*}}, double* %{{.*}}, align 1 - // - // ASM-LABEL: test_mm_storel_pd - // ASM: movsd + // CHECK-LABEL: test_mm_storel_pd + // CHECK: store double %{{.*}}, double* %{{.*}}, align 1 _mm_storel_pd(A, B); } void test_mm_storeu_pd(double* A, __m128d B) { - // DAG-LABEL: test_mm_storeu_pd - // DAG: store <2 x double> %{{.*}}, <2 x double>* %{{.*}}, align 1 - // - // ASM-LABEL: test_mm_storeu_pd - // ASM: movupd + // CHECK-LABEL: test_mm_storeu_pd + // CHECK: store <2 x double> %{{.*}}, <2 x double>* %{{.*}}, align 1 _mm_storeu_pd(A, B); } void test_mm_storeu_si128(__m128i* A, __m128i B) { - // DAG-LABEL: test_mm_storeu_si128 - // DAG: store <2 x i64> %{{.*}}, <2 x i64>* %{{.*}}, align 1 - // - // ASM-LABEL: test_mm_storeu_si128 - // ASM: movdqu + // CHECK-LABEL: test_mm_storeu_si128 + // CHECK: store <2 x i64> %{{.*}}, <2 x i64>* %{{.*}}, align 1 _mm_storeu_si128(A, B); } void test_mm_stream_pd(double *A, __m128d B) { - // DAG-LABEL: test_mm_stream_pd - // DAG: store <2 x double> %{{.*}}, <2 x double>* %{{.*}}, align 16, !nontemporal - // - // ASM-LABEL: test_mm_stream_pd - // ASM: movntpd + // CHECK-LABEL: test_mm_stream_pd + // CHECK: store <2 x double> %{{.*}}, <2 x double>* %{{.*}}, align 16, !nontemporal _mm_stream_pd(A, B); } void test_mm_stream_si32(int *A, int B) { - // DAG-LABEL: test_mm_stream_si32 - // DAG: store i32 %{{.*}}, i32* %{{.*}}, align 1, !nontemporal - // - // ASM-LABEL: test_mm_stream_si32 - // ASM: movntil + // CHECK-LABEL: test_mm_stream_si32 + // CHECK: store i32 %{{.*}}, i32* %{{.*}}, align 1, !nontemporal _mm_stream_si32(A, B); } void test_mm_stream_si64(long long *A, long long B) { - // DAG-LABEL: test_mm_stream_si64 - // DAG: store i64 %{{.*}}, i64* %{{.*}}, align 1, !nontemporal - // - // ASM-LABEL: test_mm_stream_si64 - // ASM: movntiq + // CHECK-LABEL: test_mm_stream_si64 + // CHECK: store i64 %{{.*}}, i64* %{{.*}}, align 1, !nontemporal _mm_stream_si64(A, B); } void test_mm_stream_si128(__m128i *A, __m128i B) { - // DAG-LABEL: test_mm_stream_si128 - // DAG: store <2 x i64> %{{.*}}, <2 x i64>* %{{.*}}, align 16, !nontemporal - // - // ASM-LABEL: test_mm_stream_si128 - // ASM: movntdq + // CHECK-LABEL: test_mm_stream_si128 + // CHECK: store <2 x i64> %{{.*}}, <2 x i64>* %{{.*}}, align 16, !nontemporal _mm_stream_si128(A, B); } __m128i test_mm_sub_epi8(__m128i A, __m128i B) { - // DAG-LABEL: test_mm_sub_epi8 - // DAG: sub <16 x i8> - // - // ASM-LABEL: test_mm_sub_epi8 - // ASM: psubb + // CHECK-LABEL: test_mm_sub_epi8 + // CHECK: sub <16 x i8> return _mm_sub_epi8(A, B); } __m128i test_mm_sub_epi16(__m128i A, __m128i B) { - // DAG-LABEL: test_mm_sub_epi16 - // DAG: sub <8 x i16> - // - // ASM-LABEL: test_mm_sub_epi16 - // ASM: psubw + // CHECK-LABEL: test_mm_sub_epi16 + // CHECK: sub <8 x i16> return _mm_sub_epi16(A, B); } __m128i test_mm_sub_epi32(__m128i A, __m128i B) { - // DAG-LABEL: test_mm_sub_epi32 - // DAG: sub <4 x i32> - // - // ASM-LABEL: test_mm_sub_epi32 - // ASM: psubd + // CHECK-LABEL: test_mm_sub_epi32 + // CHECK: sub <4 x i32> return _mm_sub_epi32(A, B); } __m128i test_mm_sub_epi64(__m128i A, __m128i B) { - // DAG-LABEL: test_mm_sub_epi64 - // DAG: sub <2 x i64> - // - // ASM-LABEL: test_mm_sub_epi64 - // ASM: psubq + // CHECK-LABEL: test_mm_sub_epi64 + // CHECK: sub <2 x i64> return _mm_sub_epi64(A, B); } __m128d test_mm_sub_pd(__m128d A, __m128d B) { - // DAG-LABEL: test_mm_sub_pd - // DAG: fsub <2 x double> - // - // ASM-LABEL: test_mm_sub_pd - // ASM: subpd + // CHECK-LABEL: test_mm_sub_pd + // CHECK: fsub <2 x double> return _mm_sub_pd(A, B); } __m128d test_mm_sub_sd(__m128d A, __m128d B) { - // DAG-LABEL: test_mm_sub_sd - // DAG: fsub double - // - // ASM-LABEL: test_mm_sub_sd - // ASM: subsd + // CHECK-LABEL: test_mm_sub_sd + // CHECK: fsub double return _mm_sub_sd(A, B); } __m128i test_mm_subs_epi8(__m128i A, __m128i B) { - // DAG-LABEL: test_mm_subs_epi8 - // DAG: call <16 x i8> @llvm.x86.sse2.psubs.b - // - // ASM-LABEL: test_mm_subs_epi8 - // ASM: psubsb + // CHECK-LABEL: test_mm_subs_epi8 + // CHECK: call <16 x i8> @llvm.x86.sse2.psubs.b return _mm_subs_epi8(A, B); } __m128i test_mm_subs_epi16(__m128i A, __m128i B) { - // DAG-LABEL: test_mm_subs_epi16 - // DAG: call <8 x i16> @llvm.x86.sse2.psubs.w - // - // ASM-LABEL: test_mm_subs_epi16 - // ASM: psubsw + // CHECK-LABEL: test_mm_subs_epi16 + // CHECK: call <8 x i16> @llvm.x86.sse2.psubs.w return _mm_subs_epi16(A, B); } __m128i test_mm_subs_epu8(__m128i A, __m128i B) { - // DAG-LABEL: test_mm_subs_epu8 - // DAG: call <16 x i8> @llvm.x86.sse2.psubus.b - // - // ASM-LABEL: test_mm_subs_epu8 - // ASM: psubusb + // CHECK-LABEL: test_mm_subs_epu8 + // CHECK: call <16 x i8> @llvm.x86.sse2.psubus.b return _mm_subs_epu8(A, B); } __m128i test_mm_subs_epu16(__m128i A, __m128i B) { - // DAG-LABEL: test_mm_subs_epu16 - // DAG: call <8 x i16> @llvm.x86.sse2.psubus.w - // - // ASM-LABEL: test_mm_subs_epu16 - // ASM: psubusw + // CHECK-LABEL: test_mm_subs_epu16 + // CHECK: call <8 x i16> @llvm.x86.sse2.psubus.w return _mm_subs_epu16(A, B); } int test_mm_ucomieq_sd(__m128d A, __m128d B) { - // DAG-LABEL: test_mm_ucomieq_sd - // DAG: call i32 @llvm.x86.sse2.ucomieq.sd - // - // ASM-LABEL: test_mm_ucomieq_sd - // ASM: ucomisd + // CHECK-LABEL: test_mm_ucomieq_sd + // CHECK: call i32 @llvm.x86.sse2.ucomieq.sd return _mm_ucomieq_sd(A, B); } int test_mm_ucomige_sd(__m128d A, __m128d B) { - // DAG-LABEL: test_mm_ucomige_sd - // DAG: call i32 @llvm.x86.sse2.ucomige.sd - // - // ASM-LABEL: test_mm_ucomige_sd - // ASM: ucomisd + // CHECK-LABEL: test_mm_ucomige_sd + // CHECK: call i32 @llvm.x86.sse2.ucomige.sd return _mm_ucomige_sd(A, B); } int test_mm_ucomigt_sd(__m128d A, __m128d B) { - // DAG-LABEL: test_mm_ucomigt_sd - // DAG: call i32 @llvm.x86.sse2.ucomigt.sd - // - // ASM-LABEL: test_mm_ucomigt_sd - // ASM: ucomisd + // CHECK-LABEL: test_mm_ucomigt_sd + // CHECK: call i32 @llvm.x86.sse2.ucomigt.sd return _mm_ucomigt_sd(A, B); } int test_mm_ucomile_sd(__m128d A, __m128d B) { - // DAG-LABEL: test_mm_ucomile_sd - // DAG: call i32 @llvm.x86.sse2.ucomile.sd - // - // ASM-LABEL: test_mm_ucomile_sd - // ASM: ucomisd + // CHECK-LABEL: test_mm_ucomile_sd + // CHECK: call i32 @llvm.x86.sse2.ucomile.sd return _mm_ucomile_sd(A, B); } int test_mm_ucomilt_sd(__m128d A, __m128d B) { - // DAG-LABEL: test_mm_ucomilt_sd - // DAG: call i32 @llvm.x86.sse2.ucomilt.sd - // - // ASM-LABEL: test_mm_ucomilt_sd - // ASM: ucomisd + // CHECK-LABEL: test_mm_ucomilt_sd + // CHECK: call i32 @llvm.x86.sse2.ucomilt.sd return _mm_ucomilt_sd(A, B); } int test_mm_ucomineq_sd(__m128d A, __m128d B) { - // DAG-LABEL: test_mm_ucomineq_sd - // DAG: call i32 @llvm.x86.sse2.ucomineq.sd - // - // ASM-LABEL: test_mm_ucomineq_sd - // ASM: ucomisd + // CHECK-LABEL: test_mm_ucomineq_sd + // CHECK: call i32 @llvm.x86.sse2.ucomineq.sd return _mm_ucomineq_sd(A, B); } __m128i test_mm_unpackhi_epi8(__m128i A, __m128i B) { - // DAG-LABEL: test_mm_unpackhi_epi8 - // DAG: shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i32> - // - // ASM-LABEL: test_mm_unpackhi_epi8 - // ASM: unpckhbw + // CHECK-LABEL: test_mm_unpackhi_epi8 + // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i32> return _mm_unpackhi_epi8(A, B); } __m128i test_mm_unpackhi_epi16(__m128i A, __m128i B) { - // DAG-LABEL: test_mm_unpackhi_epi16 - // DAG: shufflevector <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i32> - // - // ASM-LABEL: test_mm_unpackhi_epi16 - // ASM: unpckhwd + // CHECK-LABEL: test_mm_unpackhi_epi16 + // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i32> return _mm_unpackhi_epi16(A, B); } __m128i test_mm_unpackhi_epi32(__m128i A, __m128i B) { - // DAG-LABEL: test_mm_unpackhi_epi32 - // DAG: shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> - // - // ASM-LABEL: test_mm_unpackhi_epi32 - // ASM: unpckhdq + // CHECK-LABEL: test_mm_unpackhi_epi32 + // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> return _mm_unpackhi_epi32(A, B); } __m128i test_mm_unpackhi_epi64(__m128i A, __m128i B) { - // DAG-LABEL: test_mm_unpackhi_epi64 - // DAG: shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <2 x i32> - // - // ASM-LABEL: test_mm_unpackhi_epi64 - // ASM: unpckhqdq + // CHECK-LABEL: test_mm_unpackhi_epi64 + // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <2 x i32> return _mm_unpackhi_epi64(A, B); } __m128d test_mm_unpackhi_pd(__m128d A, __m128d B) { - // DAG-LABEL: test_mm_unpackhi_pd - // DAG: shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x i32> - // - // ASM-LABEL: test_mm_unpackhi_pd - // ASM: unpckhpd + // CHECK-LABEL: test_mm_unpackhi_pd + // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x i32> return _mm_unpackhi_pd(A, B); } __m128i test_mm_unpacklo_epi8(__m128i A, __m128i B) { - // DAG-LABEL: test_mm_unpacklo_epi8 - // DAG: shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i32> - // - // ASM-LABEL: test_mm_unpacklo_epi8 - // ASM: unpcklbw + // CHECK-LABEL: test_mm_unpacklo_epi8 + // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i32> return _mm_unpacklo_epi8(A, B); } __m128i test_mm_unpacklo_epi16(__m128i A, __m128i B) { - // DAG-LABEL: test_mm_unpacklo_epi16 - // DAG: shufflevector <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i32> - // - // ASM-LABEL: test_mm_unpacklo_epi16 - // ASM: unpcklwd + // CHECK-LABEL: test_mm_unpacklo_epi16 + // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i32> return _mm_unpacklo_epi16(A, B); } __m128i test_mm_unpacklo_epi32(__m128i A, __m128i B) { - // DAG-LABEL: test_mm_unpacklo_epi32 - // DAG: shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> - // - // ASM-LABEL: test_mm_unpacklo_epi32 - // ASM: unpckldq + // CHECK-LABEL: test_mm_unpacklo_epi32 + // CHECK: shufflevector <4 x i32> %{{.*}}, <4 x i32> %{{.*}}, <4 x i32> return _mm_unpacklo_epi32(A, B); } __m128i test_mm_unpacklo_epi64(__m128i A, __m128i B) { - // DAG-LABEL: test_mm_unpacklo_epi64 - // DAG: shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <2 x i32> - // - // ASM-LABEL: test_mm_unpacklo_epi64 - // ASM: unpcklqdq + // CHECK-LABEL: test_mm_unpacklo_epi64 + // CHECK: shufflevector <2 x i64> %{{.*}}, <2 x i64> %{{.*}}, <2 x i32> return _mm_unpacklo_epi64(A, B); } __m128d test_mm_unpacklo_pd(__m128d A, __m128d B) { - // DAG-LABEL: test_mm_unpacklo_pd - // DAG: shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x i32> - // - // ASM-LABEL: test_mm_unpacklo_pd - // ASM: unpcklpd + // CHECK-LABEL: test_mm_unpacklo_pd + // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x i32> return _mm_unpacklo_pd(A, B); } __m128d test_mm_xor_pd(__m128d A, __m128d B) { - // DAG-LABEL: test_mm_xor_pd - // DAG: xor <4 x i32> %{{.*}}, %{{.*}} - // - // ASM-LABEL: test_mm_xor_pd - // ASM: pxor + // CHECK-LABEL: test_mm_xor_pd + // CHECK: xor <4 x i32> %{{.*}}, %{{.*}} return _mm_xor_pd(A, B); } __m128i test_mm_xor_si128(__m128i A, __m128i B) { - // DAG-LABEL: test_mm_xor_si128 - // DAG: xor <2 x i64> %{{.*}}, %{{.*}} - // - // ASM-LABEL: test_mm_xor_si128 - // ASM: xorps + // CHECK-LABEL: test_mm_xor_si128 + // CHECK: xor <2 x i64> %{{.*}}, %{{.*}} return _mm_xor_si128(A, B); } diff --git a/test/CodeGen/sse3-builtins.c b/test/CodeGen/sse3-builtins.c index 5b80e5c4b0..5064841ec7 100644 --- a/test/CodeGen/sse3-builtins.c +++ b/test/CodeGen/sse3-builtins.c @@ -1,6 +1,4 @@ -// REQUIRES: x86-registered-target // RUN: %clang_cc1 %s -triple=x86_64-apple-darwin -target-feature +sse3 -emit-llvm -o - -Werror | FileCheck %s -// RUN: %clang_cc1 %s -triple=x86_64-apple-darwin -target-feature +sse3 -S -o - -Werror | FileCheck %s --check-prefix=CHECK-ASM // Don't include mm_malloc.h, it's system specific. #define __MM_MALLOC_H @@ -10,76 +8,65 @@ __m128d test_mm_addsub_pd(__m128d A, __m128d B) { // CHECK-LABEL: test_mm_addsub_pd // CHECK: call <2 x double> @llvm.x86.sse3.addsub.pd - // CHECK-ASM: addsubpd %xmm{{.*}}, %xmm{{.*}} return _mm_addsub_pd(A, B); } __m128 test_mm_addsub_ps(__m128 A, __m128 B) { // CHECK-LABEL: test_mm_addsub_ps // CHECK: call <4 x float> @llvm.x86.sse3.addsub.ps - // CHECK-ASM: addsubps %xmm{{.*}}, %xmm{{.*}} return _mm_addsub_ps(A, B); } __m128d test_mm_hadd_pd(__m128d A, __m128d B) { // CHECK-LABEL: test_mm_hadd_pd // CHECK: call <2 x double> @llvm.x86.sse3.hadd.pd - // CHECK-ASM: haddpd %xmm{{.*}}, %xmm{{.*}} return _mm_hadd_pd(A, B); } __m128 test_mm_hadd_ps(__m128 A, __m128 B) { // CHECK-LABEL: test_mm_hadd_ps // CHECK: call <4 x float> @llvm.x86.sse3.hadd.ps - // CHECK-ASM: haddps %xmm{{.*}}, %xmm{{.*}} return _mm_hadd_ps(A, B); } __m128d test_mm_hsub_pd(__m128d A, __m128d B) { // CHECK-LABEL: test_mm_hsub_pd // CHECK: call <2 x double> @llvm.x86.sse3.hsub.pd - // CHECK-ASM: hsubpd %xmm{{.*}}, %xmm{{.*}} return _mm_hsub_pd(A, B); } __m128 test_mm_hsub_ps(__m128 A, __m128 B) { // CHECK-LABEL: test_mm_hsub_ps // CHECK: call <4 x float> @llvm.x86.sse3.hsub.ps - // CHECK-ASM: hsubps %xmm{{.*}}, %xmm{{.*}} return _mm_hsub_ps(A, B); } __m128i test_mm_lddqu_si128(__m128i const* P) { // CHECK-LABEL: test_mm_lddqu_si128 // CHECK: call <16 x i8> @llvm.x86.sse3.ldu.dq - // CHECK-ASM: lddqu return _mm_lddqu_si128(P); } __m128d test_mm_loaddup_pd(double const* P) { // CHECK-LABEL: test_mm_loaddup_pd // CHECK: load double* - // CHECK-ASM: movddup %xmm{{.*}} return _mm_loaddup_pd(P); } __m128d test_mm_movedup_pd(__m128d A) { // CHECK-LABEL: test_mm_movedup_pd // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x i32> zeroinitializer - // CHECK-ASM: movddup %xmm{{.*}}, %xmm{{.*}} return _mm_movedup_pd(A); } __m128 test_mm_movehdup_ps(__m128 A) { // CHECK-LABEL: test_mm_movehdup_ps // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x i32> - // CHECK-ASM: movshdup %xmm{{.*}}, %xmm{{.*}} return _mm_movehdup_ps(A); } __m128 test_mm_movedup_ps(__m128 A) { // CHECK-LABEL: test_mm_movedup_ps // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x i32> - // CHECK-ASM: movsldup %xmm{{.*}}, %xmm{{.*}} return _mm_moveldup_ps(A); } diff --git a/test/CodeGen/sse41-builtins.c b/test/CodeGen/sse41-builtins.c index 63d8e80543..9cd5c45659 100644 --- a/test/CodeGen/sse41-builtins.c +++ b/test/CodeGen/sse41-builtins.c @@ -1,435 +1,372 @@ -// REQUIRES: x86-registered-target // RUN: %clang_cc1 %s -triple=x86_64-apple-darwin -target-feature +sse4.1 -emit-llvm -o - -Werror | FileCheck %s // RUN: %clang_cc1 %s -triple=x86_64-apple-darwin -target-feature +sse4.1 -fno-signed-char -emit-llvm -o - -Werror | FileCheck %s -// RUN: %clang_cc1 %s -triple=x86_64-apple-darwin -target-feature +sse4.1 -S -o - -Werror | FileCheck %s --check-prefix=CHECK-ASM -// RUN: %clang_cc1 %s -triple=x86_64-apple-darwin -target-feature +sse4.1 -fno-signed-char -S -o - -Werror | FileCheck %s --check-prefix=CHECK-ASM // Don't include mm_malloc.h, it's system specific. #define __MM_MALLOC_H #include -__m128i test_blend_epi16(__m128i V1, __m128i V2) { - // CHECK-LABEL: test_blend_epi16 +__m128i test_mm_blend_epi16(__m128i V1, __m128i V2) { + // CHECK-LABEL: test_mm_blend_epi16 // CHECK: shufflevector <8 x i16> %{{.*}}, <8 x i16> %{{.*}}, <8 x i32> - // CHECK-ASM: pblendw $42, %xmm{{.*}}, %xmm{{.*}} return _mm_blend_epi16(V1, V2, 42); } -__m128d test_blend_pd(__m128d V1, __m128d V2) { - // CHECK-LABEL: test_blend_pd +__m128d test_mm_blend_pd(__m128d V1, __m128d V2) { + // CHECK-LABEL: test_mm_blend_pd // CHECK: shufflevector <2 x double> %{{.*}}, <2 x double> %{{.*}}, <2 x i32> - // CHECK-ASM: blendpd $2, %xmm{{.*}}, %xmm{{.*}} return _mm_blend_pd(V1, V2, 2); } -__m128 test_blend_ps(__m128 V1, __m128 V2) { - // CHECK-LABEL: test_blend_ps +__m128 test_mm_blend_ps(__m128 V1, __m128 V2) { + // CHECK-LABEL: test_mm_blend_ps // CHECK: shufflevector <4 x float> %{{.*}}, <4 x float> %{{.*}}, <4 x i32> - // CHECK-ASM: blendps $6, %xmm{{.*}}, %xmm{{.*}} return _mm_blend_ps(V1, V2, 6); } -__m128i test_blendv_epi8(__m128i V1, __m128i V2, __m128i V3) { - // CHECK-LABEL: test_blendv_epi8 +__m128i test_mm_blendv_epi8(__m128i V1, __m128i V2, __m128i V3) { + // CHECK-LABEL: test_mm_blendv_epi8 // CHECK: call <16 x i8> @llvm.x86.sse41.pblendvb - // CHECK-ASM: pblendvb %xmm{{.*}}, %xmm{{.*}} return _mm_blendv_epi8(V1, V2, V3); } -__m128d test_blendv_pd(__m128d V1, __m128d V2, __m128d V3) { - // CHECK-LABEL: test_blendv_pd +__m128d test_mm_blendv_pd(__m128d V1, __m128d V2, __m128d V3) { + // CHECK-LABEL: test_mm_blendv_pd // CHECK: call <2 x double> @llvm.x86.sse41.blendvpd - // CHECK-ASM: blendvpd %xmm{{.*}}, %xmm{{.*}} return _mm_blendv_pd(V1, V2, V3); } -__m128 test_blendv_ps(__m128 V1, __m128 V2, __m128 V3) { - // CHECK-LABEL: test_blendv_ps +__m128 test_mm_blendv_ps(__m128 V1, __m128 V2, __m128 V3) { + // CHECK-LABEL: test_mm_blendv_ps // CHECK: call <4 x float> @llvm.x86.sse41.blendvps - // CHECK-ASM: blendvps %xmm{{.*}}, %xmm{{.*}} return _mm_blendv_ps(V1, V2, V3); } __m128d test_mm_ceil_pd(__m128d x) { // CHECK-LABEL: test_mm_ceil_pd // CHECK: call <2 x double> @llvm.x86.sse41.round.pd - // CHECK-ASM: roundpd $2, %xmm{{.*}}, %xmm{{.*}} return _mm_ceil_pd(x); } __m128 test_mm_ceil_ps(__m128 x) { // CHECK-LABEL: test_mm_ceil_ps // CHECK: call <4 x float> @llvm.x86.sse41.round.ps - // CHECK-ASM: roundps $2, %xmm{{.*}}, %xmm{{.*}} return _mm_ceil_ps(x); } __m128d test_mm_ceil_sd(__m128d x, __m128d y) { // CHECK-LABEL: test_mm_ceil_sd // CHECK: call <2 x double> @llvm.x86.sse41.round.sd - // CHECK-ASM: roundsd $2, %xmm{{.*}}, %xmm{{.*}} return _mm_ceil_sd(x, y); } __m128 test_mm_ceil_ss(__m128 x, __m128 y) { // CHECK-LABEL: test_mm_ceil_ss // CHECK: call <4 x float> @llvm.x86.sse41.round.ss - // CHECK-ASM: roundss $2, %xmm{{.*}}, %xmm{{.*}} return _mm_ceil_ss(x, y); } __m128i test_mm_cmpeq_epi64(__m128i A, __m128i B) { // CHECK-LABEL: test_mm_cmpeq_epi64 // CHECK: icmp eq <2 x i64> - // CHECK-ASM: pcmpeqq %xmm{{.*}}, %xmm{{.*}} return _mm_cmpeq_epi64(A, B); } __m128i test_mm_cvtepi8_epi16(__m128i a) { // CHECK-LABEL: test_mm_cvtepi8_epi16 // CHECK: sext <8 x i8> {{.*}} to <8 x i16> - // CHECK-ASM: pmovsxbw %xmm{{.*}}, %xmm{{.*}} return _mm_cvtepi8_epi16(a); } __m128i test_mm_cvtepi8_epi32(__m128i a) { // CHECK-LABEL: test_mm_cvtepi8_epi32 // CHECK: sext <4 x i8> {{.*}} to <4 x i32> - // CHECK-ASM: pmovsxbd %xmm{{.*}}, %xmm{{.*}} return _mm_cvtepi8_epi32(a); } __m128i test_mm_cvtepi8_epi64(__m128i a) { // CHECK-LABEL: test_mm_cvtepi8_epi64 // CHECK: sext <2 x i8> {{.*}} to <2 x i64> - // CHECK-ASM: pmovsxbq %xmm{{.*}}, %xmm{{.*}} return _mm_cvtepi8_epi64(a); } __m128i test_mm_cvtepi16_epi32(__m128i a) { // CHECK-LABEL: test_mm_cvtepi16_epi32 // CHECK: sext <4 x i16> {{.*}} to <4 x i32> - // CHECK-ASM: pmovsxwd %xmm{{.*}}, %xmm{{.*}} return _mm_cvtepi16_epi32(a); } __m128i test_mm_cvtepi16_epi64(__m128i a) { // CHECK-LABEL: test_mm_cvtepi16_epi64 // CHECK: sext <2 x i16> {{.*}} to <2 x i64> - // CHECK-ASM: pmovsxwq %xmm{{.*}}, %xmm{{.*}} return _mm_cvtepi16_epi64(a); } __m128i test_mm_cvtepi32_epi64(__m128i a) { // CHECK-LABEL: test_mm_cvtepi32_epi64 // CHECK: sext <2 x i32> {{.*}} to <2 x i64> - // CHECK-ASM: pmovsxdq %xmm{{.*}}, %xmm{{.*}} return _mm_cvtepi32_epi64(a); } __m128i test_mm_cvtepu8_epi16(__m128i a) { // CHECK-LABEL: test_mm_cvtepu8_epi16 // CHECK: call <8 x i16> @llvm.x86.sse41.pmovzxbw(<16 x i8> {{.*}}) - // CHECK-ASM: pmovzxbw %xmm{{.*}}, %xmm{{.*}} return _mm_cvtepu8_epi16(a); } __m128i test_mm_cvtepu8_epi32(__m128i a) { // CHECK-LABEL: test_mm_cvtepu8_epi32 // CHECK: call <4 x i32> @llvm.x86.sse41.pmovzxbd(<16 x i8> {{.*}}) - // CHECK-ASM: pmovzxbd %xmm{{.*}}, %xmm{{.*}} return _mm_cvtepu8_epi32(a); } __m128i test_mm_cvtepu8_epi64(__m128i a) { // CHECK-LABEL: test_mm_cvtepu8_epi64 // CHECK: call <2 x i64> @llvm.x86.sse41.pmovzxbq(<16 x i8> {{.*}}) - // CHECK-ASM: pmovzxbq %xmm{{.*}}, %xmm{{.*}} return _mm_cvtepu8_epi64(a); } __m128i test_mm_cvtepu16_epi32(__m128i a) { // CHECK-LABEL: test_mm_cvtepu16_epi32 // CHECK: call <4 x i32> @llvm.x86.sse41.pmovzxwd(<8 x i16> {{.*}}) - // CHECK-ASM: pmovzxwd %xmm{{.*}}, %xmm{{.*}} return _mm_cvtepu16_epi32(a); } __m128i test_mm_cvtepu16_epi64(__m128i a) { // CHECK-LABEL: test_mm_cvtepu16_epi64 // CHECK: call <2 x i64> @llvm.x86.sse41.pmovzxwq(<8 x i16> {{.*}}) - // CHECK-ASM: pmovzxwq %xmm{{.*}}, %xmm{{.*}} return _mm_cvtepu16_epi64(a); } __m128i test_mm_cvtepu32_epi64(__m128i a) { // CHECK-LABEL: test_mm_cvtepu32_epi64 // CHECK: call <2 x i64> @llvm.x86.sse41.pmovzxdq(<4 x i32> {{.*}}) - // CHECK-ASM: pmovzxdq %xmm{{.*}}, %xmm{{.*}} return _mm_cvtepu32_epi64(a); } __m128d test_mm_dp_pd(__m128d x, __m128d y) { // CHECK-LABEL: test_mm_dp_pd // CHECK: call <2 x double> @llvm.x86.sse41.dppd - // CHECK-ASM: dppd $2, %xmm{{.*}}, %xmm{{.*}} return _mm_dp_pd(x, y, 2); } __m128 test_mm_dp_ps(__m128 x, __m128 y) { // CHECK-LABEL: test_mm_dp_ps // CHECK: call <4 x float> @llvm.x86.sse41.dpps - // CHECK-ASM: dpps $2, %xmm{{.*}}, %xmm{{.*}} return _mm_dp_ps(x, y, 2); } -int test_extract_epi8(__m128i x) { - // CHECK-LABEL: test_extract_epi8 +int test_mm_extract_epi8(__m128i x) { + // CHECK-LABEL: test_mm_extract_epi8 // CHECK: extractelement <16 x i8> %{{.*}}, i32 0 - // CHECK-ASM: pextrb return _mm_extract_epi8(x, 16); } -int test_extract_epi32(__m128i x) { - // CHECK-LABEL: test_extract_epi32 +int test_mm_extract_epi32(__m128i x) { + // CHECK-LABEL: test_mm_extract_epi32 // CHECK: extractelement <4 x i32> %{{.*}}, i32 1 - // CHECK-ASM: pextrd return _mm_extract_epi32(x, 1); } -long long test_extract_epi64(__m128i x) { - // CHECK-LABEL: test_extract_epi64 +long long test_mm_extract_epi64(__m128i x) { + // CHECK-LABEL: test_mm_extract_epi64 // CHECK: extractelement <2 x i64> %{{.*}}, i32 1 - // CHECK-ASM: pextrq return _mm_extract_epi64(x, 1); } //TODO -//int test_extract_ps(__m128i x) { +//int test_mm_extract_ps(__m128i x) { // return _mm_extract_ps(_mm_add_ps(x,x), 1); //} __m128d test_mm_floor_pd(__m128d x) { // CHECK-LABEL: test_mm_floor_pd // CHECK: call <2 x double> @llvm.x86.sse41.round.pd - // CHECK-ASM: roundpd $1, %xmm{{.*}}, %xmm{{.*}} return _mm_floor_pd(x); } __m128 test_mm_floor_ps(__m128 x) { // CHECK-LABEL: test_mm_floor_ps // CHECK: call <4 x float> @llvm.x86.sse41.round.ps - // CHECK-ASM: roundps $1, %xmm{{.*}}, %xmm{{.*}} return _mm_floor_ps(x); } __m128d test_mm_floor_sd(__m128d x, __m128d y) { // CHECK-LABEL: test_mm_floor_sd // CHECK: call <2 x double> @llvm.x86.sse41.round.sd - // CHECK-ASM: roundsd $1, %xmm{{.*}}, %xmm{{.*}} return _mm_floor_sd(x, y); } __m128 test_mm_floor_ss(__m128 x, __m128 y) { // CHECK-LABEL: test_mm_floor_ss // CHECK: call <4 x float> @llvm.x86.sse41.round.ss - // CHECK-ASM: roundss $1, %xmm{{.*}}, %xmm{{.*}} return _mm_floor_ss(x, y); } -__m128i test_insert_epi8(__m128i x, char b) { - // CHECK-LABEL: test_insert_epi8 +__m128i test_mm_insert_epi8(__m128i x, char b) { + // CHECK-LABEL: test_mm_insert_epi8 // CHECK: insertelement <16 x i8> %{{.*}}, i8 %{{.*}}, i32 0 - // CHECK-ASM: pinsrb return _mm_insert_epi8(x, b, 16); } -__m128i test_insert_epi32(__m128i x, int b) { - // CHECK-LABEL: test_insert_epi32 +__m128i test_mm_insert_epi32(__m128i x, int b) { + // CHECK-LABEL: test_mm_insert_epi32 // CHECK: insertelement <4 x i32> %{{.*}}, i32 %{{.*}}, i32 0 - // CHECK-ASM: pinsrd return _mm_insert_epi32(x, b, 4); } -__m128i test_insert_epi64(__m128i x, long long b) { - // CHECK-LABEL: test_insert_epi64 +__m128i test_mm_insert_epi64(__m128i x, long long b) { + // CHECK-LABEL: test_mm_insert_epi64 // CHECK: insertelement <2 x i64> %{{.*}}, i64 %{{.*}}, i32 0 - // CHECK-ASM: pinsrq return _mm_insert_epi64(x, b, 2); } -__m128 test_insert_ps(__m128 x, __m128 y) { - // CHECK-LABEL: test_insert_ps +__m128 test_mm_insert_ps(__m128 x, __m128 y) { + // CHECK-LABEL: test_mm_insert_ps // CHECK: call <4 x float> @llvm.x86.sse41.insertps - // CHECK-ASM: insertps $5, %xmm{{.*}}, %xmm{{.*}} return _mm_insert_ps(x, y, 5); } __m128i test_mm_max_epi8(__m128i x, __m128i y) { // CHECK-LABEL: test_mm_max_epi8 // CHECK: call <16 x i8> @llvm.x86.sse41.pmaxsb - // CHECK-ASM: pmaxsb %xmm{{.*}}, %xmm{{.*}} return _mm_max_epi8(x, y); } __m128i test_mm_max_epu16(__m128i x, __m128i y) { // CHECK-LABEL: test_mm_max_epu16 // CHECK: call <8 x i16> @llvm.x86.sse41.pmaxuw - // CHECK-ASM: pmaxuw %xmm{{.*}}, %xmm{{.*}} return _mm_max_epu16(x, y); } __m128i test_mm_max_epi32(__m128i x, __m128i y) { // CHECK-LABEL: test_mm_max_epi32 // CHECK: call <4 x i32> @llvm.x86.sse41.pmaxsd - // CHECK-ASM: pmaxsd %xmm{{.*}}, %xmm{{.*}} return _mm_max_epi32(x, y); } __m128i test_mm_max_epu32(__m128i x, __m128i y) { // CHECK-LABEL: test_mm_max_epu32 // CHECK: call <4 x i32> @llvm.x86.sse41.pmaxud - // CHECK-ASM: pmaxud %xmm{{.*}}, %xmm{{.*}} return _mm_max_epu32(x, y); } __m128i test_mm_min_epi8(__m128i x, __m128i y) { // CHECK-LABEL: test_mm_min_epi8 // CHECK: call <16 x i8> @llvm.x86.sse41.pminsb - // CHECK-ASM: pminsb %xmm{{.*}}, %xmm{{.*}} return _mm_min_epi8(x, y); } __m128i test_mm_min_epu16(__m128i x, __m128i y) { // CHECK-LABEL: test_mm_min_epu16 // CHECK: call <8 x i16> @llvm.x86.sse41.pminuw - // CHECK-ASM: pminuw %xmm{{.*}}, %xmm{{.*}} return _mm_min_epu16(x, y); } __m128i test_mm_min_epi32(__m128i x, __m128i y) { // CHECK-LABEL: test_mm_min_epi32 // CHECK: call <4 x i32> @llvm.x86.sse41.pminsd - // CHECK-ASM: pminsd %xmm{{.*}}, %xmm{{.*}} return _mm_min_epi32(x, y); } __m128i test_mm_min_epu32(__m128i x, __m128i y) { // CHECK-LABEL: test_mm_min_epu32 // CHECK: call <4 x i32> @llvm.x86.sse41.pminud - // CHECK-ASM: pminud %xmm{{.*}}, %xmm{{.*}} return _mm_min_epu32(x, y); } __m128i test_mm_minpos_epu16(__m128i x) { // CHECK-LABEL: test_mm_minpos_epu16 // CHECK: call <8 x i16> @llvm.x86.sse41.phminposuw - // CHECK-ASM: phminposuw %xmm{{.*}}, %xmm{{.*}} return _mm_minpos_epu16(x); } __m128i test_mm_mpsadbw_epu8(__m128i x, __m128i y) { // CHECK-LABEL: test_mm_mpsadbw_epu8 // CHECK: call <8 x i16> @llvm.x86.sse41.mpsadbw - // CHECK-ASM: mpsadbw $1, %xmm{{.*}}, %xmm{{.*}} return _mm_mpsadbw_epu8(x, y, 1); } __m128i test_mm_mul_epi32(__m128i x, __m128i y) { // CHECK-LABEL: test_mm_mul_epi32 // CHECK: call <2 x i64> @llvm.x86.sse41.pmuldq - // CHECK-ASM: pmuldq %xmm{{.*}}, %xmm{{.*}} return _mm_mul_epi32(x, y); } __m128i test_mm_mullo_epi32(__m128i x, __m128i y) { // CHECK-LABEL: test_mm_mullo_epi32 // CHECK: mul <4 x i32> - // CHECK-ASM: pmulld %xmm{{.*}}, %xmm{{.*}} return _mm_mullo_epi32(x, y); } __m128i test_mm_packus_epi32(__m128i x, __m128i y) { // CHECK-LABEL: test_mm_packus_epi32 // CHECK: call <8 x i16> @llvm.x86.sse41.packusdw - // CHECK-ASM: packusdw %xmm{{.*}}, %xmm{{.*}} return _mm_packus_epi32(x, y); } __m128d test_mm_round_pd(__m128d x) { // CHECK-LABEL: test_mm_round_pd // CHECK: call <2 x double> @llvm.x86.sse41.round.pd - // CHECK-ASM: roundpd $2, %xmm{{.*}}, %xmm{{.*}} return _mm_round_pd(x, 2); } __m128 test_mm_round_ps(__m128 x) { // CHECK-LABEL: test_mm_round_ps // CHECK: call <4 x float> @llvm.x86.sse41.round.ps - // CHECK-ASM: roundps $2, %xmm{{.*}}, %xmm{{.*}} return _mm_round_ps(x, 2); } __m128d test_mm_round_sd(__m128d x, __m128d y) { // CHECK-LABEL: test_mm_round_sd // CHECK: call <2 x double> @llvm.x86.sse41.round.sd - // CHECK-ASM: roundsd $2, %xmm{{.*}}, %xmm{{.*}} return _mm_round_sd(x, y, 2); } __m128 test_mm_round_ss(__m128 x, __m128 y) { // CHECK-LABEL: test_mm_round_ss // CHECK: call <4 x float> @llvm.x86.sse41.round.ss - // CHECK-ASM: roundss $2, %xmm{{.*}}, %xmm{{.*}} return _mm_round_ss(x, y, 2); } __m128i test_mm_stream_load_si128(__m128i const *a) { // CHECK-LABEL: test_mm_stream_load_si128 // CHECK: call <2 x i64> @llvm.x86.sse41.movntdqa - // CHECK-ASM: movntdqa return _mm_stream_load_si128(a); } int test_mm_test_all_ones(__m128i x) { // CHECK-LABEL: test_mm_test_all_ones // CHECK: call i32 @llvm.x86.sse41.ptestc - // CHECK-ASM: ptest %xmm{{.*}}, %xmm{{.*}} return _mm_test_all_ones(x); } int test_mm_test_all_zeros(__m128i x, __m128i y) { // CHECK-LABEL: test_mm_test_all_zeros // CHECK: call i32 @llvm.x86.sse41.ptestz - // CHECK-ASM: ptest %xmm{{.*}}, %xmm{{.*}} return _mm_test_all_zeros(x, y); } int test_mm_test_mix_ones_zeros(__m128i x, __m128i y) { // CHECK-LABEL: test_mm_test_mix_ones_zeros // CHECK: call i32 @llvm.x86.sse41.ptestnzc - // CHECK-ASM: ptest %xmm{{.*}}, %xmm{{.*}} return _mm_test_mix_ones_zeros(x, y); } int test_mm_testc_si128(__m128i x, __m128i y) { // CHECK-LABEL: test_mm_testc_si128 // CHECK: call i32 @llvm.x86.sse41.ptestc - // CHECK-ASM: ptest %xmm{{.*}}, %xmm{{.*}} return _mm_testc_si128(x, y); } int test_mm_testnzc_si128(__m128i x, __m128i y) { // CHECK-LABEL: test_mm_testnzc_si128 // CHECK: call i32 @llvm.x86.sse41.ptestnzc - // CHECK-ASM: ptest %xmm{{.*}}, %xmm{{.*}} return _mm_testnzc_si128(x, y); } int test_mm_testz_si128(__m128i x, __m128i y) { // CHECK-LABEL: test_mm_testz_si128 // CHECK: call i32 @llvm.x86.sse41.ptestz - // CHECK-ASM: ptest %xmm{{.*}}, %xmm{{.*}} return _mm_testz_si128(x, y); } diff --git a/test/CodeGen/sse42-builtins.c b/test/CodeGen/sse42-builtins.c index f45355f9a0..e3215ddaf7 100644 --- a/test/CodeGen/sse42-builtins.c +++ b/test/CodeGen/sse42-builtins.c @@ -1,8 +1,5 @@ -// REQUIRES: x86-registered-target // RUN: %clang_cc1 %s -triple=x86_64-apple-darwin -target-feature +sse4.2 -emit-llvm -o - -Werror | FileCheck %s // RUN: %clang_cc1 %s -triple=x86_64-apple-darwin -target-feature +sse4.2 -fno-signed-char -emit-llvm -o - -Werror | FileCheck %s -// RUN: %clang_cc1 %s -triple=x86_64-apple-darwin -target-feature +sse4.2 -S -o - -Werror | FileCheck %s --check-prefix=CHECK-ASM -// RUN: %clang_cc1 %s -triple=x86_64-apple-darwin -target-feature +sse4.2 -fno-signed-char -S -o - -Werror | FileCheck %s --check-prefix=CHECK-ASM // Don't include mm_malloc.h, it's system specific. #define __MM_MALLOC_H @@ -12,153 +9,131 @@ __m128i test_mm_cmpgt_epi8(__m128i A, __m128i B) { // CHECK-LABEL: test_mm_cmpgt_epi8 // CHECK: icmp sgt <16 x i8> - // CHECK-ASM: pcmpgtb %xmm{{.*}}, %xmm{{.*}} return _mm_cmpgt_epi8(A, B); } __m128i test_mm_cmpgt_epi16(__m128i A, __m128i B) { // CHECK-LABEL: test_mm_cmpgt_epi16 // CHECK: icmp sgt <8 x i16> - // CHECK-ASM: pcmpgtw %xmm{{.*}}, %xmm{{.*}} return _mm_cmpgt_epi16(A, B); } __m128i test_mm_cmpgt_epi32(__m128i A, __m128i B) { // CHECK-LABEL: test_mm_cmpgt_epi32 // CHECK: icmp sgt <4 x i32> - // CHECK-ASM: pcmpgtd %xmm{{.*}}, %xmm{{.*}} return _mm_cmpgt_epi32(A, B); } __m128i test_mm_cmpgt_epi64(__m128i A, __m128i B) { // CHECK-LABEL: test_mm_cmpgt_epi64 // CHECK: icmp sgt <2 x i64> - // CHECK-ASM: pcmpgtq %xmm{{.*}}, %xmm{{.*}} return _mm_cmpgt_epi64(A, B); } int test_mm_cmpestra(__m128i A, int LA, __m128i B, int LB) { // CHECK-LABEL: test_mm_cmpestra // CHECK: @llvm.x86.sse42.pcmpestria128 - // CHECK-ASM: pcmpestri $7, %xmm{{.*}}, %xmm{{.*}} return _mm_cmpestra(A, LA, B, LB, 7); } int test_mm_cmpestrc(__m128i A, int LA, __m128i B, int LB) { // CHECK-LABEL: test_mm_cmpestrc // CHECK: @llvm.x86.sse42.pcmpestric128 - // CHECK-ASM: pcmpestri $7, %xmm{{.*}}, %xmm{{.*}} return _mm_cmpestrc(A, LA, B, LB, 7); } int test_mm_cmpestri(__m128i A, int LA, __m128i B, int LB) { // CHECK-LABEL: test_mm_cmpestri // CHECK: @llvm.x86.sse42.pcmpestri128 - // CHECK-ASM: pcmpestri $7, %xmm{{.*}}, %xmm{{.*}} return _mm_cmpestri(A, LA, B, LB, 7); } __m128i test_mm_cmpestrm(__m128i A, int LA, __m128i B, int LB) { // CHECK-LABEL: test_mm_cmpestrm // CHECK: @llvm.x86.sse42.pcmpestrm128 - // CHECK-ASM: pcmpestrm $7, %xmm{{.*}}, %xmm{{.*}} return _mm_cmpestrm(A, LA, B, LB, 7); } int test_mm_cmpestro(__m128i A, int LA, __m128i B, int LB) { // CHECK-LABEL: test_mm_cmpestro // CHECK: @llvm.x86.sse42.pcmpestrio128 - // CHECK-ASM: pcmpestri $7, %xmm{{.*}}, %xmm{{.*}} return _mm_cmpestro(A, LA, B, LB, 7); } int test_mm_cmpestrs(__m128i A, int LA, __m128i B, int LB) { // CHECK-LABEL: test_mm_cmpestrs // CHECK: @llvm.x86.sse42.pcmpestris128 - // CHECK-ASM: pcmpestri $7, %xmm{{.*}}, %xmm{{.*}} return _mm_cmpestrs(A, LA, B, LB, 7); } int test_mm_cmpestrz(__m128i A, int LA, __m128i B, int LB) { // CHECK-LABEL: test_mm_cmpestrz // CHECK: @llvm.x86.sse42.pcmpestriz128 - // CHECK-ASM: pcmpestri $7, %xmm{{.*}}, %xmm{{.*}} return _mm_cmpestrz(A, LA, B, LB, 7); } int test_mm_cmpistra(__m128i A, __m128i B) { // CHECK-LABEL: test_mm_cmpistra // CHECK: @llvm.x86.sse42.pcmpistria128 - // CHECK-ASM: pcmpistri $7, %xmm{{.*}}, %xmm{{.*}} return _mm_cmpistra(A, B, 7); } int test_mm_cmpistrc(__m128i A, __m128i B) { // CHECK-LABEL: test_mm_cmpistrc // CHECK: @llvm.x86.sse42.pcmpistric128 - // CHECK-ASM: pcmpistri $7, %xmm{{.*}}, %xmm{{.*}} return _mm_cmpistrc(A, B, 7); } int test_mm_cmpistri(__m128i A, __m128i B) { // CHECK-LABEL: test_mm_cmpistri // CHECK: @llvm.x86.sse42.pcmpistri128 - // CHECK-ASM: pcmpistri $7, %xmm{{.*}}, %xmm{{.*}} return _mm_cmpistri(A, B, 7); } __m128i test_mm_cmpistrm(__m128i A, __m128i B) { // CHECK-LABEL: test_mm_cmpistrm // CHECK: @llvm.x86.sse42.pcmpistrm128 - // CHECK-ASM: pcmpistrm $7, %xmm{{.*}}, %xmm{{.*}} return _mm_cmpistrm(A, B, 7); } int test_mm_cmpistro(__m128i A, __m128i B) { // CHECK-LABEL: test_mm_cmpistro // CHECK: @llvm.x86.sse42.pcmpistrio128 - // CHECK-ASM: pcmpistri $7, %xmm{{.*}}, %xmm{{.*}} return _mm_cmpistro(A, B, 7); } int test_mm_cmpistrs(__m128i A, __m128i B) { // CHECK-LABEL: test_mm_cmpistrs // CHECK: @llvm.x86.sse42.pcmpistris128 - // CHECK-ASM: pcmpistri $7, %xmm{{.*}}, %xmm{{.*}} return _mm_cmpistrs(A, B, 7); } int test_mm_cmpistrz(__m128i A, __m128i B) { // CHECK-LABEL: test_mm_cmpistrz // CHECK: @llvm.x86.sse42.pcmpistriz128 - // CHECK-ASM: pcmpistri $7, %xmm{{.*}}, %xmm{{.*}} return _mm_cmpistrz(A, B, 7); } unsigned int test_mm_crc32_u8(unsigned int CRC, unsigned char V) { // CHECK-LABEL: test_mm_crc32_u8 // CHECK: call i32 @llvm.x86.sse42.crc32.32.8 - // CHECK-ASM: crc32 return _mm_crc32_u8(CRC, V); } unsigned int test_mm_crc32_u16(unsigned int CRC, unsigned short V) { // CHECK-LABEL: test_mm_crc32_u16 // CHECK: call i32 @llvm.x86.sse42.crc32.32.16 - // CHECK-ASM: crc32 return _mm_crc32_u16(CRC, V); } unsigned int test_mm_crc32_u32(unsigned int CRC, unsigned int V) { // CHECK-LABEL: test_mm_crc32_u32 // CHECK: call i32 @llvm.x86.sse42.crc32.32.32 - // CHECK-ASM: crc32 return _mm_crc32_u32(CRC, V); } unsigned int test_mm_crc32_u64(unsigned long long CRC, unsigned long long V) { // CHECK-LABEL: test_mm_crc32_u64 // CHECK: call i64 @llvm.x86.sse42.crc32.64.64 - // CHECK-ASM: crc32 return _mm_crc32_u64(CRC, V); } diff --git a/test/CodeGen/sse4a-builtins.c b/test/CodeGen/sse4a-builtins.c index cdea03f890..aee61b7d1e 100644 --- a/test/CodeGen/sse4a-builtins.c +++ b/test/CodeGen/sse4a-builtins.c @@ -1,6 +1,4 @@ -// REQUIRES: x86-registered-target // RUN: %clang_cc1 %s -triple=x86_64-apple-darwin -target-feature +sse4a -emit-llvm -o - -Werror | FileCheck %s -// RUN: %clang_cc1 %s -triple=x86_64-apple-darwin -target-feature +sse4a -S -o - -Werror | FileCheck %s --check-prefix=CHECK-ASM // Don't include mm_malloc.h, it's system specific. #define __MM_MALLOC_H @@ -10,41 +8,35 @@ __m128i test_extracti_si64(__m128i x) { // CHECK-LABEL: test_extracti_si64 // CHECK: call <2 x i64> @llvm.x86.sse4a.extrqi(<2 x i64> %{{[^,]+}}, i8 3, i8 2) - // CHECK-ASM: extrq $2, $3, %xmm{{.*}} return _mm_extracti_si64(x, 3, 2); } __m128i test_extract_si64(__m128i x, __m128i y) { // CHECK-LABEL: test_extract_si64 // CHECK: call <2 x i64> @llvm.x86.sse4a.extrq(<2 x i64> %{{[^,]+}}, <16 x i8> %{{[^,]+}}) - // CHECK-ASM: extrq %xmm{{.*}}, %xmm{{.*}} return _mm_extract_si64(x, y); } __m128i test_inserti_si64(__m128i x, __m128i y) { // CHECK-LABEL: test_inserti_si64 // CHECK: call <2 x i64> @llvm.x86.sse4a.insertqi(<2 x i64> %{{[^,]+}}, <2 x i64> %{{[^,]+}}, i8 5, i8 6) - // CHECK-ASM: insertq $6, $5, %xmm{{.*}}, %xmm{{.*}} return _mm_inserti_si64(x, y, 5, 6); } __m128i test_insert_si64(__m128i x, __m128i y) { // CHECK-LABEL: test_insert_si64 // CHECK: call <2 x i64> @llvm.x86.sse4a.insertq(<2 x i64> %{{[^,]+}}, <2 x i64> %{{[^,]+}}) - // CHECK-ASM: insertq %xmm{{.*}}, %xmm{{.*}} return _mm_insert_si64(x, y); } void test_stream_sd(double *p, __m128d a) { // CHECK-LABEL: test_stream_sd // CHECK: call void @llvm.x86.sse4a.movnt.sd(i8* %{{[^,]+}}, <2 x double> %{{[^,]+}}) - // CHECK-ASM: movntsd %xmm{{.*}} _mm_stream_sd(p, a); } void test_stream_ss(float *p, __m128 a) { // CHECK-LABEL: test_stream_ss // CHECK: call void @llvm.x86.sse4a.movnt.ss(i8* %{{[^,]+}}, <4 x float> %{{[^,]+}}) - // CHECK-ASM: movntss %xmm{{.*}} _mm_stream_ss(p, a); } diff --git a/test/CodeGen/ssse3-builtins.c b/test/CodeGen/ssse3-builtins.c index ec311d9646..d4b27a1e85 100644 --- a/test/CodeGen/ssse3-builtins.c +++ b/test/CodeGen/ssse3-builtins.c @@ -1,6 +1,4 @@ -// REQUIRES: x86-registered-target // RUN: %clang_cc1 %s -triple=x86_64-apple-darwin -target-feature +ssse3 -emit-llvm -o - -Werror | FileCheck %s -// RUN: %clang_cc1 %s -triple=x86_64-apple-darwin -target-feature +ssse3 -S -o - -Werror | FileCheck %s --check-prefix=CHECK-ASM // Don't include mm_malloc.h, it's system specific. #define __MM_MALLOC_H @@ -10,118 +8,101 @@ __m128i test_mm_abs_epi8(__m128i a) { // CHECK-LABEL: test_mm_abs_epi8 // CHECK: call <16 x i8> @llvm.x86.ssse3.pabs.b.128 - // CHECK-ASM: pabsb %xmm{{.*}}, %xmm{{.*}} return _mm_abs_epi8(a); } __m128i test_mm_abs_epi16(__m128i a) { // CHECK-LABEL: test_mm_abs_epi16 // CHECK: call <8 x i16> @llvm.x86.ssse3.pabs.w.128 - // CHECK-ASM: pabsw %xmm{{.*}}, %xmm{{.*}} return _mm_abs_epi16(a); } __m128i test_mm_abs_epi32(__m128i a) { // CHECK-LABEL: test_mm_abs_epi32 // CHECK: call <4 x i32> @llvm.x86.ssse3.pabs.d.128 - // CHECK-ASM: pabsd %xmm{{.*}}, %xmm{{.*}} return _mm_abs_epi32(a); } __m128i test_mm_alignr_epi8(__m128i a, __m128i b) { // CHECK-LABEL: test_mm_alignr_epi8 // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> %{{.*}}, <16 x i32> - // CHECK-ASM: palignr $2, %xmm{{.*}}, %xmm{{.*}} return _mm_alignr_epi8(a, b, 2); } __m128i test2_mm_alignr_epi8(__m128i a, __m128i b) { // CHECK-LABEL: test2_mm_alignr_epi8 // CHECK: shufflevector <16 x i8> %{{.*}}, <16 x i8> zeroinitializer, <16 x i32> - // CHECK-ASM: psrldq $1, %xmm{{.*}} return _mm_alignr_epi8(a, b, 17); } __m128i test_mm_hadd_epi16(__m128i a, __m128i b) { // CHECK-LABEL: test_mm_hadd_epi16 // CHECK: call <8 x i16> @llvm.x86.ssse3.phadd.w.128 - // CHECK-ASM: phaddw %xmm{{.*}}, %xmm{{.*}} return _mm_hadd_epi16(a, b); } __m128i test_mm_hadd_epi32(__m128i a, __m128i b) { // CHECK-LABEL: test_mm_hadd_epi32 // CHECK: call <4 x i32> @llvm.x86.ssse3.phadd.d.128 - // CHECK-ASM: phaddd %xmm{{.*}}, %xmm{{.*}} return _mm_hadd_epi32(a, b); } __m128i test_mm_hadds_epi16(__m128i a, __m128i b) { // CHECK-LABEL: test_mm_hadds_epi16 // CHECK: call <8 x i16> @llvm.x86.ssse3.phadd.sw.128 - // CHECK-ASM: phaddsw %xmm{{.*}}, %xmm{{.*}} return _mm_hadds_epi16(a, b); } __m128i test_mm_hsub_epi16(__m128i a, __m128i b) { // CHECK-LABEL: test_mm_hsub_epi16 // CHECK: call <8 x i16> @llvm.x86.ssse3.phsub.w.128 - // CHECK-ASM: phsubw %xmm{{.*}}, %xmm{{.*}} return _mm_hsub_epi16(a, b); } __m128i test_mm_hsub_epi32(__m128i a, __m128i b) { // CHECK-LABEL: test_mm_hsub_epi32 // CHECK: call <4 x i32> @llvm.x86.ssse3.phsub.d.128 - // CHECK-ASM: phsubd %xmm{{.*}}, %xmm{{.*}} return _mm_hsub_epi32(a, b); } __m128i test_mm_hsubs_epi16(__m128i a, __m128i b) { // CHECK-LABEL: test_mm_hsubs_epi16 // CHECK: call <8 x i16> @llvm.x86.ssse3.phsub.sw.128 - // CHECK-ASM: phsubsw %xmm{{.*}}, %xmm{{.*}} return _mm_hsubs_epi16(a, b); } __m128i test_mm_maddubs_epi16(__m128i a, __m128i b) { // CHECK-LABEL: test_mm_maddubs_epi16 // CHECK: call <8 x i16> @llvm.x86.ssse3.pmadd.ub.sw.128 - // CHECK-ASM: pmaddubsw %xmm{{.*}}, %xmm{{.*}} return _mm_maddubs_epi16(a, b); } __m128i test_mm_mulhrs_epi16(__m128i a, __m128i b) { // CHECK-LABEL: test_mm_mulhrs_epi16 // CHECK: call <8 x i16> @llvm.x86.ssse3.pmul.hr.sw.128 - // CHECK-ASM: pmulhrsw %xmm{{.*}}, %xmm{{.*}} return _mm_mulhrs_epi16(a, b); } __m128i test_mm_shuffle_epi8(__m128i a, __m128i b) { // CHECK-LABEL: test_mm_shuffle_epi8 // CHECK: call <16 x i8> @llvm.x86.ssse3.pshuf.b.128 - // CHECK-ASM: pshufb %xmm{{.*}}, %xmm{{.*}} return _mm_shuffle_epi8(a, b); } __m128i test_mm_sign_epi8(__m128i a, __m128i b) { // CHECK-LABEL: test_mm_sign_epi8 // CHECK: call <16 x i8> @llvm.x86.ssse3.psign.b.128 - // CHECK-ASM: psignb %xmm{{.*}}, %xmm{{.*}} return _mm_sign_epi8(a, b); } __m128i test_mm_sign_epi16(__m128i a, __m128i b) { // CHECK-LABEL: test_mm_sign_epi16 // CHECK: call <8 x i16> @llvm.x86.ssse3.psign.w.128 - // CHECK-ASM: psignw %xmm{{.*}}, %xmm{{.*}} return _mm_sign_epi16(a, b); } __m128i test_mm_sign_epi32(__m128i a, __m128i b) { // CHECK-LABEL: test_mm_sign_epi32 // CHECK: call <4 x i32> @llvm.x86.ssse3.psign.d.128 - // CHECK-ASM: psignd %xmm{{.*}}, %xmm{{.*}} return _mm_sign_epi32(a, b); } diff --git a/test/CodeGen/xop-builtins.c b/test/CodeGen/xop-builtins.c index 359fc6026e..5f0f20d07b 100644 --- a/test/CodeGen/xop-builtins.c +++ b/test/CodeGen/xop-builtins.c @@ -1,6 +1,4 @@ -// REQUIRES: x86-registered-target // RUN: %clang_cc1 %s -triple=x86_64-apple-darwin -target-feature +xop -emit-llvm -o - -Werror | FileCheck %s -// RUN: %clang_cc1 %s -triple=x86_64-apple-darwin -target-feature +xop -S -o - -Werror | FileCheck %s --check-prefix=CHECK-ASM // Don't include mm_malloc.h, it's system specific. #define __MM_MALLOC_H @@ -8,385 +6,385 @@ #include __m128i test_mm_maccs_epi16(__m128i a, __m128i b, __m128i c) { + // CHECK-LABEL: test_mm_maccs_epi16 // CHECK: @llvm.x86.xop.vpmacssww - // CHECK-ASM: vpmacssww %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}} return _mm_maccs_epi16(a, b, c); } __m128i test_mm_macc_epi16(__m128i a, __m128i b, __m128i c) { + // CHECK-LABEL: test_mm_macc_epi16 // CHECK: @llvm.x86.xop.vpmacsww - // CHECK-ASM: vpmacsww %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}} return _mm_macc_epi16(a, b, c); } __m128i test_mm_maccsd_epi16(__m128i a, __m128i b, __m128i c) { + // CHECK-LABEL: test_mm_maccsd_epi16 // CHECK: @llvm.x86.xop.vpmacsswd - // CHECK-ASM: vpmacsswd %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}} return _mm_maccsd_epi16(a, b, c); } __m128i test_mm_maccd_epi16(__m128i a, __m128i b, __m128i c) { + // CHECK-LABEL: test_mm_maccd_epi16 // CHECK: @llvm.x86.xop.vpmacswd - // CHECK-ASM: vpmacswd %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}} return _mm_maccd_epi16(a, b, c); } __m128i test_mm_maccs_epi32(__m128i a, __m128i b, __m128i c) { + // CHECK-LABEL: test_mm_maccs_epi32 // CHECK: @llvm.x86.xop.vpmacssdd - // CHECK-ASM: vpmacssdd %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}} return _mm_maccs_epi32(a, b, c); } __m128i test_mm_macc_epi32(__m128i a, __m128i b, __m128i c) { + // CHECK-LABEL: test_mm_macc_epi32 // CHECK: @llvm.x86.xop.vpmacsdd - // CHECK-ASM: vpmacsdd %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}} return _mm_macc_epi32(a, b, c); } __m128i test_mm_maccslo_epi32(__m128i a, __m128i b, __m128i c) { + // CHECK-LABEL: test_mm_maccslo_epi32 // CHECK: @llvm.x86.xop.vpmacssdql - // CHECK-ASM: vpmacssdql %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}} return _mm_maccslo_epi32(a, b, c); } __m128i test_mm_macclo_epi32(__m128i a, __m128i b, __m128i c) { + // CHECK-LABEL: test_mm_macclo_epi32 // CHECK: @llvm.x86.xop.vpmacsdql - // CHECK-ASM: vpmacsdql %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}} return _mm_macclo_epi32(a, b, c); } __m128i test_mm_maccshi_epi32(__m128i a, __m128i b, __m128i c) { + // CHECK-LABEL: test_mm_maccshi_epi32 // CHECK: @llvm.x86.xop.vpmacssdqh - // CHECK-ASM: vpmacssdqh %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}} return _mm_maccshi_epi32(a, b, c); } __m128i test_mm_macchi_epi32(__m128i a, __m128i b, __m128i c) { + // CHECK-LABEL: test_mm_macchi_epi32 // CHECK: @llvm.x86.xop.vpmacsdqh - // CHECK-ASM: vpmacsdqh %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}} return _mm_macchi_epi32(a, b, c); } __m128i test_mm_maddsd_epi16(__m128i a, __m128i b, __m128i c) { + // CHECK-LABEL: test_mm_maddsd_epi16 // CHECK: @llvm.x86.xop.vpmadcsswd - // CHECK-ASM: vpmadcsswd %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}} return _mm_maddsd_epi16(a, b, c); } __m128i test_mm_maddd_epi16(__m128i a, __m128i b, __m128i c) { + // CHECK-LABEL: test_mm_maddd_epi16 // CHECK: @llvm.x86.xop.vpmadcswd - // CHECK-ASM: vpmadcswd %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}} return _mm_maddd_epi16(a, b, c); } __m128i test_mm_haddw_epi8(__m128i a) { + // CHECK-LABEL: test_mm_haddw_epi8 // CHECK: @llvm.x86.xop.vphaddbw - // CHECK-ASM: vphaddbw %xmm{{.*}}, %xmm{{.*}} return _mm_haddw_epi8(a); } __m128i test_mm_haddd_epi8(__m128i a) { + // CHECK-LABEL: test_mm_haddd_epi8 // CHECK: @llvm.x86.xop.vphaddbd - // CHECK-ASM: vphaddbd %xmm{{.*}}, %xmm{{.*}} return _mm_haddd_epi8(a); } __m128i test_mm_haddq_epi8(__m128i a) { + // CHECK-LABEL: test_mm_haddq_epi8 // CHECK: @llvm.x86.xop.vphaddbq - // CHECK-ASM: vphaddbq %xmm{{.*}}, %xmm{{.*}} return _mm_haddq_epi8(a); } __m128i test_mm_haddd_epi16(__m128i a) { + // CHECK-LABEL: test_mm_haddd_epi16 // CHECK: @llvm.x86.xop.vphaddwd - // CHECK-ASM: vphaddwd %xmm{{.*}}, %xmm{{.*}} return _mm_haddd_epi16(a); } __m128i test_mm_haddq_epi16(__m128i a) { + // CHECK-LABEL: test_mm_haddq_epi16 // CHECK: @llvm.x86.xop.vphaddwq - // CHECK-ASM: vphaddwq %xmm{{.*}}, %xmm{{.*}} return _mm_haddq_epi16(a); } __m128i test_mm_haddq_epi32(__m128i a) { + // CHECK-LABEL: test_mm_haddq_epi32 // CHECK: @llvm.x86.xop.vphadddq - // CHECK-ASM: vphadddq %xmm{{.*}}, %xmm{{.*}} return _mm_haddq_epi32(a); } __m128i test_mm_haddw_epu8(__m128i a) { + // CHECK-LABEL: test_mm_haddw_epu8 // CHECK: @llvm.x86.xop.vphaddubw - // CHECK-ASM: vphaddubw %xmm{{.*}}, %xmm{{.*}} return _mm_haddw_epu8(a); } __m128i test_mm_haddd_epu8(__m128i a) { + // CHECK-LABEL: test_mm_haddd_epu8 // CHECK: @llvm.x86.xop.vphaddubd - // CHECK-ASM: vphaddubd %xmm{{.*}}, %xmm{{.*}} return _mm_haddd_epu8(a); } __m128i test_mm_haddq_epu8(__m128i a) { + // CHECK-LABEL: test_mm_haddq_epu8 // CHECK: @llvm.x86.xop.vphaddubq - // CHECK-ASM: vphaddubq %xmm{{.*}}, %xmm{{.*}} return _mm_haddq_epu8(a); } __m128i test_mm_haddd_epu16(__m128i a) { + // CHECK-LABEL: test_mm_haddd_epu16 // CHECK: @llvm.x86.xop.vphadduwd - // CHECK-ASM: vphadduwd %xmm{{.*}}, %xmm{{.*}} return _mm_haddd_epu16(a); } __m128i test_mm_haddq_epu16(__m128i a) { + // CHECK-LABEL: test_mm_haddq_epu16 // CHECK: @llvm.x86.xop.vphadduwq - // CHECK-ASM: vphadduwq %xmm{{.*}}, %xmm{{.*}} return _mm_haddq_epu16(a); } __m128i test_mm_haddq_epu32(__m128i a) { + // CHECK-LABEL: test_mm_haddq_epu32 // CHECK: @llvm.x86.xop.vphaddudq - // CHECK-ASM: vphaddudq %xmm{{.*}}, %xmm{{.*}} return _mm_haddq_epu32(a); } __m128i test_mm_hsubw_epi8(__m128i a) { + // CHECK-LABEL: test_mm_hsubw_epi8 // CHECK: @llvm.x86.xop.vphsubbw - // CHECK-ASM: vphsubbw %xmm{{.*}}, %xmm{{.*}} return _mm_hsubw_epi8(a); } __m128i test_mm_hsubd_epi16(__m128i a) { + // CHECK-LABEL: test_mm_hsubd_epi16 // CHECK: @llvm.x86.xop.vphsubwd - // CHECK-ASM: vphsubwd %xmm{{.*}}, %xmm{{.*}} return _mm_hsubd_epi16(a); } __m128i test_mm_hsubq_epi32(__m128i a) { + // CHECK-LABEL: test_mm_hsubq_epi32 // CHECK: @llvm.x86.xop.vphsubdq - // CHECK-ASM: vphsubdq %xmm{{.*}}, %xmm{{.*}} return _mm_hsubq_epi32(a); } __m128i test_mm_cmov_si128(__m128i a, __m128i b, __m128i c) { + // CHECK-LABEL: test_mm_cmov_si128 // CHECK: @llvm.x86.xop.vpcmov - // CHECK-ASM: vpcmov %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}} return _mm_cmov_si128(a, b, c); } __m256i test_mm256_cmov_si256(__m256i a, __m256i b, __m256i c) { + // CHECK-LABEL: test_mm256_cmov_si256 // CHECK: @llvm.x86.xop.vpcmov.256 - // CHECK-ASM: vpcmov %ymm{{.*}}, %ymm{{.*}}, %ymm{{.*}}, %ymm{{.*}} return _mm256_cmov_si256(a, b, c); } __m128i test_mm_perm_epi8(__m128i a, __m128i b, __m128i c) { + // CHECK-LABEL: test_mm_perm_epi8 // CHECK: @llvm.x86.xop.vpperm - // CHECK-ASM: vpperm %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}} return _mm_perm_epi8(a, b, c); } __m128i test_mm_rot_epi8(__m128i a, __m128i b) { + // CHECK-LABEL: test_mm_rot_epi8 // CHECK: @llvm.x86.xop.vprotb - // CHECK-ASM: vprotb %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}} return _mm_rot_epi8(a, b); } __m128i test_mm_rot_epi16(__m128i a, __m128i b) { + // CHECK-LABEL: test_mm_rot_epi16 // CHECK: @llvm.x86.xop.vprotw - // CHECK-ASM: vprotw %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}} return _mm_rot_epi16(a, b); } __m128i test_mm_rot_epi32(__m128i a, __m128i b) { + // CHECK-LABEL: test_mm_rot_epi32 // CHECK: @llvm.x86.xop.vprotd - // CHECK-ASM: vprotd %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}} return _mm_rot_epi32(a, b); } __m128i test_mm_rot_epi64(__m128i a, __m128i b) { + // CHECK-LABEL: test_mm_rot_epi64 // CHECK: @llvm.x86.xop.vprotq - // CHECK-ASM: vprotq %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}} return _mm_rot_epi64(a, b); } __m128i test_mm_roti_epi8(__m128i a) { + // CHECK-LABEL: test_mm_roti_epi8 // CHECK: @llvm.x86.xop.vprotbi - // CHECK-ASM: vprotb $1, %xmm{{.*}}, %xmm{{.*}} return _mm_roti_epi8(a, 1); } __m128i test_mm_roti_epi16(__m128i a) { + // CHECK-LABEL: test_mm_roti_epi16 // CHECK: @llvm.x86.xop.vprotwi - // CHECK-ASM: vprotw $50, %xmm{{.*}}, %xmm{{.*}} return _mm_roti_epi16(a, 50); } __m128i test_mm_roti_epi32(__m128i a) { + // CHECK-LABEL: test_mm_roti_epi32 // CHECK: @llvm.x86.xop.vprotdi - // CHECK-ASM: vprotd $226, %xmm{{.*}}, %xmm{{.*}} return _mm_roti_epi32(a, -30); } __m128i test_mm_roti_epi64(__m128i a) { + // CHECK-LABEL: test_mm_roti_epi64 // CHECK: @llvm.x86.xop.vprotqi - // CHECK-ASM: vprotq $100, %xmm{{.*}}, %xmm{{.*}} return _mm_roti_epi64(a, 100); } __m128i test_mm_shl_epi8(__m128i a, __m128i b) { + // CHECK-LABEL: test_mm_shl_epi8 // CHECK: @llvm.x86.xop.vpshlb - // CHECK-ASM: vpshlb %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}} return _mm_shl_epi8(a, b); } __m128i test_mm_shl_epi16(__m128i a, __m128i b) { + // CHECK-LABEL: test_mm_shl_epi16 // CHECK: @llvm.x86.xop.vpshlw - // CHECK-ASM: vpshlw %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}} return _mm_shl_epi16(a, b); } __m128i test_mm_shl_epi32(__m128i a, __m128i b) { + // CHECK-LABEL: test_mm_shl_epi32 // CHECK: @llvm.x86.xop.vpshld - // CHECK-ASM: vpshld %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}} return _mm_shl_epi32(a, b); } __m128i test_mm_shl_epi64(__m128i a, __m128i b) { + // CHECK-LABEL: test_mm_shl_epi64 // CHECK: @llvm.x86.xop.vpshlq - // CHECK-ASM: vpshlq %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}} return _mm_shl_epi64(a, b); } __m128i test_mm_sha_epi8(__m128i a, __m128i b) { + // CHECK-LABEL: test_mm_sha_epi8 // CHECK: @llvm.x86.xop.vpshab - // CHECK-ASM: vpshab %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}} return _mm_sha_epi8(a, b); } __m128i test_mm_sha_epi16(__m128i a, __m128i b) { + // CHECK-LABEL: test_mm_sha_epi16 // CHECK: @llvm.x86.xop.vpshaw - // CHECK-ASM: vpshaw %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}} return _mm_sha_epi16(a, b); } __m128i test_mm_sha_epi32(__m128i a, __m128i b) { + // CHECK-LABEL: test_mm_sha_epi32 // CHECK: @llvm.x86.xop.vpshad - // CHECK-ASM: vpshad %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}} return _mm_sha_epi32(a, b); } __m128i test_mm_sha_epi64(__m128i a, __m128i b) { + // CHECK-LABEL: test_mm_sha_epi64 // CHECK: @llvm.x86.xop.vpshaq - // CHECK-ASM: vpshaq %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}} return _mm_sha_epi64(a, b); } __m128i test_mm_com_epu8(__m128i a, __m128i b) { + // CHECK-LABEL: test_mm_com_epu8 // CHECK: @llvm.x86.xop.vpcomub - // CHECK-ASM: vpcomltub %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}} return _mm_com_epu8(a, b, 0); } __m128i test_mm_com_epu16(__m128i a, __m128i b) { + // CHECK-LABEL: test_mm_com_epu16 // CHECK: @llvm.x86.xop.vpcomuw - // CHECK-ASM: vpcomltuw %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}} return _mm_com_epu16(a, b, 0); } __m128i test_mm_com_epu32(__m128i a, __m128i b) { + // CHECK-LABEL: test_mm_com_epu32 // CHECK: @llvm.x86.xop.vpcomud - // CHECK-ASM: vpcomltud %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}} return _mm_com_epu32(a, b, 0); } __m128i test_mm_com_epu64(__m128i a, __m128i b) { + // CHECK-LABEL: test_mm_com_epu64 // CHECK: @llvm.x86.xop.vpcomuq - // CHECK-ASM: vpcomltuq %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}} return _mm_com_epu64(a, b, 0); } __m128i test_mm_com_epi8(__m128i a, __m128i b) { + // CHECK-LABEL: test_mm_com_epi8 // CHECK: @llvm.x86.xop.vpcomb - // CHECK-ASM: vpcomltb %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}} return _mm_com_epi8(a, b, 0); } __m128i test_mm_com_epi16(__m128i a, __m128i b) { + // CHECK-LABEL: test_mm_com_epi16 // CHECK: @llvm.x86.xop.vpcomw - // CHECK-ASM: vpcomltw %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}} return _mm_com_epi16(a, b, 0); } __m128i test_mm_com_epi32(__m128i a, __m128i b) { + // CHECK-LABEL: test_mm_com_epi32 // CHECK: @llvm.x86.xop.vpcomd - // CHECK-ASM: vpcomltd %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}} return _mm_com_epi32(a, b, 0); } __m128i test_mm_com_epi64(__m128i a, __m128i b) { + // CHECK-LABEL: test_mm_com_epi64 // CHECK: @llvm.x86.xop.vpcomq - // CHECK-ASM: vpcomltq %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}} return _mm_com_epi64(a, b, 0); } __m128d test_mm_permute2_pd(__m128d a, __m128d b, __m128i c) { + // CHECK-LABEL: test_mm_permute2_pd // CHECK: @llvm.x86.xop.vpermil2pd - // CHECK-ASM: vpermil2pd $0, %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}} return _mm_permute2_pd(a, b, c, 0); } __m256d test_mm256_permute2_pd(__m256d a, __m256d b, __m256i c) { + // CHECK-LABEL: test_mm256_permute2_pd // CHECK: @llvm.x86.xop.vpermil2pd.256 - // CHECK-ASM: vpermil2pd $0, %ymm{{.*}}, %ymm{{.*}}, %ymm{{.*}}, %ymm{{.*}} return _mm256_permute2_pd(a, b, c, 0); } __m128 test_mm_permute2_ps(__m128 a, __m128 b, __m128i c) { + // CHECK-LABEL: test_mm_permute2_ps // CHECK: @llvm.x86.xop.vpermil2ps - // CHECK-ASM: vpermil2ps $0, %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}}, %xmm{{.*}} return _mm_permute2_ps(a, b, c, 0); } __m256 test_mm256_permute2_ps(__m256 a, __m256 b, __m256i c) { + // CHECK-LABEL: test_mm256_permute2_ps // CHECK: @llvm.x86.xop.vpermil2ps.256 - // CHECK-ASM: vpermil2ps $0, %ymm{{.*}}, %ymm{{.*}}, %ymm{{.*}}, %ymm{{.*}} return _mm256_permute2_ps(a, b, c, 0); } __m128 test_mm_frcz_ss(__m128 a) { + // CHECK-LABEL: test_mm_frcz_ss // CHECK: @llvm.x86.xop.vfrcz.ss - // CHECK-ASM: vfrczss %xmm{{.*}}, %xmm{{.*}} return _mm_frcz_ss(a); } __m128d test_mm_frcz_sd(__m128d a) { + // CHECK-LABEL: test_mm_frcz_sd // CHECK: @llvm.x86.xop.vfrcz.sd - // CHECK-ASM: vfrczsd %xmm{{.*}}, %xmm{{.*}} return _mm_frcz_sd(a); } __m128 test_mm_frcz_ps(__m128 a) { + // CHECK-LABEL: test_mm_frcz_ps // CHECK: @llvm.x86.xop.vfrcz.ps - // CHECK-ASM: vfrczps %xmm{{.*}}, %xmm{{.*}} return _mm_frcz_ps(a); } __m128d test_mm_frcz_pd(__m128d a) { + // CHECK-LABEL: test_mm_frcz_pd // CHECK: @llvm.x86.xop.vfrcz.pd - // CHECK-ASM: vfrczpd %xmm{{.*}}, %xmm{{.*}} return _mm_frcz_pd(a); } __m256 test_mm256_frcz_ps(__m256 a) { + // CHECK-LABEL: test_mm256_frcz_ps // CHECK: @llvm.x86.xop.vfrcz.ps.256 - // CHECK-ASM: vfrczps %ymm{{.*}}, %ymm{{.*}} return _mm256_frcz_ps(a); } __m256d test_mm256_frcz_pd(__m256d a) { + // CHECK-LABEL: test_mm256_frcz_pd // CHECK: @llvm.x86.xop.vfrcz.pd.256 - // CHECK-ASM: vfrczpd %ymm{{.*}}, %ymm{{.*}} return _mm256_frcz_pd(a); }