From patchwork Tue May 30 20:46:54 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Carl Love X-Patchwork-Id: 70337 Return-Path: X-Original-To: patchwork@sourceware.org Delivered-To: patchwork@sourceware.org Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 0279B3856614 for ; Tue, 30 May 2023 20:47:40 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 0279B3856614 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gcc.gnu.org; s=default; t=1685479660; bh=MdWfoPqJaigy2J6jvJjGWO6oMu9hyYCXOUxBHLCleCs=; h=Subject:To:Cc:Date:List-Id:List-Unsubscribe:List-Archive: List-Post:List-Help:List-Subscribe:From:Reply-To:From; b=KR868cVEj1vDKXc8znDlg5grksbtA2kDAo1R9usm/h4dsS4txcgCuwwxRfPCqrjPt DEaB0oe6ZwCtdYmai3xOriMFGckA6RhaoLr3lthRjr4Ufm65FjFIySibPEaXGQ0gPa 4C+z92HyvilOUJp+twT52opGQfEUL62wXLuIwOEU= X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from mx0a-001b2d01.pphosted.com (mx0a-001b2d01.pphosted.com [148.163.156.1]) by sourceware.org (Postfix) with ESMTPS id DE7823858D20 for ; Tue, 30 May 2023 20:47:00 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org DE7823858D20 Received: from pps.filterd (m0356517.ppops.net [127.0.0.1]) by mx0a-001b2d01.pphosted.com (8.17.1.19/8.17.1.19) with ESMTP id 34UJjFdQ014049; Tue, 30 May 2023 20:46:59 GMT Received: from ppma04wdc.us.ibm.com (1a.90.2fa9.ip4.static.sl-reverse.com [169.47.144.26]) by mx0a-001b2d01.pphosted.com (PPS) with ESMTPS id 3qwjej9xnn-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Tue, 30 May 2023 20:46:59 +0000 Received: from pps.filterd (ppma04wdc.us.ibm.com [127.0.0.1]) by ppma04wdc.us.ibm.com (8.17.1.19/8.17.1.19) with ESMTP id 34UH7V22013968; Tue, 30 May 2023 20:46:58 GMT Received: from smtprelay03.dal12v.mail.ibm.com ([9.208.130.98]) by ppma04wdc.us.ibm.com (PPS) with ESMTPS id 3qu9g5rhxg-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Tue, 30 May 2023 20:46:57 +0000 Received: from smtpav05.wdc07v.mail.ibm.com (smtpav05.wdc07v.mail.ibm.com [10.39.53.232]) by smtprelay03.dal12v.mail.ibm.com (8.14.9/8.14.9/NCO v10.0) with ESMTP id 34UKkt2n4915918 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK); Tue, 30 May 2023 20:46:56 GMT Received: from smtpav05.wdc07v.mail.ibm.com (unknown [127.0.0.1]) by IMSVA (Postfix) with ESMTP id A786758053; Tue, 30 May 2023 20:46:55 +0000 (GMT) Received: from smtpav05.wdc07v.mail.ibm.com (unknown [127.0.0.1]) by IMSVA (Postfix) with ESMTP id DC6C958059; Tue, 30 May 2023 20:46:54 +0000 (GMT) Received: from li-e362e14c-2378-11b2-a85c-87d605f3c641.ibm.com (unknown [9.163.31.184]) by smtpav05.wdc07v.mail.ibm.com (Postfix) with ESMTP; Tue, 30 May 2023 20:46:54 +0000 (GMT) Message-ID: <5197d0d8ab5e975ed7e1e928820769e5921f5796.camel@us.ibm.com> Subject: [PATCH] rs6000: Update the vsx-vector-6.* tests. To: "Kewen.Lin" , Segher Boessenkool , gcc-patches@gcc.gnu.org Cc: cel@us.ibm.com, Peter Bergner Date: Tue, 30 May 2023 13:46:54 -0700 X-Mailer: Evolution 3.28.5 (3.28.5-18.el8) Mime-Version: 1.0 X-TM-AS-GCONF: 00 X-Proofpoint-ORIG-GUID: fY4nK9nzciNmRmL4B5PsH1kbbQ4ZXTBi X-Proofpoint-GUID: fY4nK9nzciNmRmL4B5PsH1kbbQ4ZXTBi X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.254,Aquarius:18.0.957,Hydra:6.0.573,FMLib:17.11.176.26 definitions=2023-05-30_16,2023-05-30_01,2023-05-22_02 X-Proofpoint-Spam-Details: rule=outbound_notspam policy=outbound score=0 bulkscore=0 suspectscore=0 adultscore=0 lowpriorityscore=0 clxscore=1015 spamscore=0 phishscore=0 impostorscore=0 mlxscore=0 priorityscore=1501 mlxlogscore=980 malwarescore=0 classifier=spam adjust=0 reason=mlx scancount=1 engine=8.12.0-2304280000 definitions=main-2305300167 X-Spam-Status: No, score=-11.1 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_EF, GIT_PATCH_0, KAM_SHORT, RCVD_IN_MSPIKE_H5, RCVD_IN_MSPIKE_WL, SPF_HELO_NONE, SPF_NONE, TXREP, T_SCC_BODY_TEXT_LINE autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org X-BeenThere: gcc-patches@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gcc-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-Patchwork-Original-From: Carl Love via Gcc-patches From: Carl Love Reply-To: Carl Love Errors-To: gcc-patches-bounces+patchwork=sourceware.org@gcc.gnu.org Sender: "Gcc-patches" GCC maintainers: The following patch takes the tests in vsx-vector-6-p7.h, vsx-vector- 6-p8.h, vsx-vector-6-p9.h and reorganizes them into a series of smaller test files by functionality rather than processor version. The patch has been tested on Power 10 with no regressions. Please let me know if this patch is acceptable for mainline. Thanks. Carl ------------------------------------------ rs6000: Update the vsx-vector-6.* tests. The vsx-vector-6.h file is included into the processor specific test files vsx-vector-6.p7.c, vsx-vector-6.p8.c, and vsx-vector-6.p9.c. The .h file contains a large number of vsx vector builtin tests. The processor specific files contain the number of instructions that the tests are expected to generate for that processor. The tests are compile only. The tests are broken up into a seriers of files for related tests. The new tests are runnable tests to verify the builtin argument types and the functional correctness of each test rather then verifying the type and number of instructions generated. gcc/testsuite/ * gcc.target/powerpc/vsx-vector-6-1op.c: New test file. * gcc.target/powerpc/vsx-vector-6-2lop.c: New test file. * gcc.target/powerpc/vsx-vector-6-2op.c: New test file. * gcc.target/powerpc/vsx-vector-6-3op.c: New test file. * gcc.target/powerpc/vsx-vector-6-cmp-all.c: New test file. * gcc.target/powerpc/vsx-vector-6-cmp.c: New test file. * gcc.target/powerpc/vsx-vector-6.h: Remove test file. * gcc.target/powerpc/vsx-vector-6-p7.h: Remove test file. * gcc.target/powerpc/vsx-vector-6-p8.h: Remove test file. * gcc.target/powerpc/vsx-vector-6-p9.h: Remove test file. --- .../powerpc/vsx-vector-6-func-1op.c | 319 +++++++++++++ .../powerpc/vsx-vector-6-func-2lop.c | 305 +++++++++++++ .../powerpc/vsx-vector-6-func-2op.c | 278 ++++++++++++ .../powerpc/vsx-vector-6-func-3op.c | 229 ++++++++++ .../powerpc/vsx-vector-6-func-cmp-all.c | 429 ++++++++++++++++++ .../powerpc/vsx-vector-6-func-cmp.c | 237 ++++++++++ .../gcc.target/powerpc/vsx-vector-6.h | 154 ------- .../gcc.target/powerpc/vsx-vector-6.p7.c | 43 -- .../gcc.target/powerpc/vsx-vector-6.p8.c | 43 -- .../gcc.target/powerpc/vsx-vector-6.p9.c | 42 -- 10 files changed, 1797 insertions(+), 282 deletions(-) create mode 100644 gcc/testsuite/gcc.target/powerpc/vsx-vector-6-func-1op.c create mode 100644 gcc/testsuite/gcc.target/powerpc/vsx-vector-6-func-2lop.c create mode 100644 gcc/testsuite/gcc.target/powerpc/vsx-vector-6-func-2op.c create mode 100644 gcc/testsuite/gcc.target/powerpc/vsx-vector-6-func-3op.c create mode 100644 gcc/testsuite/gcc.target/powerpc/vsx-vector-6-func-cmp-all.c create mode 100644 gcc/testsuite/gcc.target/powerpc/vsx-vector-6-func-cmp.c delete mode 100644 gcc/testsuite/gcc.target/powerpc/vsx-vector-6.h delete mode 100644 gcc/testsuite/gcc.target/powerpc/vsx-vector-6.p7.c delete mode 100644 gcc/testsuite/gcc.target/powerpc/vsx-vector-6.p8.c delete mode 100644 gcc/testsuite/gcc.target/powerpc/vsx-vector-6.p9.c diff --git a/gcc/testsuite/gcc.target/powerpc/vsx-vector-6-func-1op.c b/gcc/testsuite/gcc.target/powerpc/vsx-vector-6-func-1op.c new file mode 100644 index 00000000000..90a360ea158 --- /dev/null +++ b/gcc/testsuite/gcc.target/powerpc/vsx-vector-6-func-1op.c @@ -0,0 +1,319 @@ +/* { dg-do compile { target lp64 } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } } */ +/* { dg-options "-O2 -mdejagnu-cpu=power7" } */ + +/* Functional test of the one operand vector builtins. */ + +#include +#include +#include + +#define DEBUG 0 + +void abort (void); + +int +main () { + int i; + vector float f_src = { 125.44, 23.04, -338.56, 17.64}; + vector float f_result; + vector float f_abs_expected = { 125.44, 23.04, 338.56, 17.64}; + vector float f_ceil_expected = { 126.0, 24.0, -338, 18.0}; + vector float f_floor_expected = { 125.0, 23.0, -339, 17.0}; + vector float f_nearbyint_expected = { 125.0, 23.0, -339, 18.0}; + vector float f_rint_expected = { 125.0, 23.0, -339, 18.0}; + vector float f_sqrt_expected = { 11.2, 4.8, 18.4, 4.2}; + vector float f_trunc_expected = { 125.0, 23.0, -338, 17}; + + vector double d_src = { 125.44, -338.56}; + vector double d_result; + vector double d_abs_expected = { 125.44, 338.56}; + vector double d_ceil_expected = { 126.0, -338.0}; + vector double d_floor_expected = { 125.0, -339.0}; + vector double d_nearbyint_expected = { 125.0, -339.0}; + vector double d_rint_expected = { 125.0, -339.0}; + vector double d_sqrt_expected = { 11.2, 18.4}; + vector double d_trunc_expected = { 125.0, -338.0}; + + /* Abs, float */ + f_result = vec_abs (f_src); + + if ((f_result[0] != f_abs_expected[0]) + || (f_result[1] != f_abs_expected[1]) + || (f_result[2] != f_abs_expected[2]) + || (f_result[3] != f_abs_expected[3])) +#if DEBUG + { + printf("ERROR: vec_abs (float) expected value does not match\n"); + printf(" expected[0] = %f; result[0] = %f\n", + f_abs_expected[0], f_result[0]); + printf(" expected[1] = %f; result[1] = %f\n", + f_abs_expected[1], f_result[1]); + printf(" expected[2] = %f; result[2] = %f\n", + f_abs_expected[2], f_result[2]); + printf(" expected[3] = %f; result[3] = %f\n", + f_abs_expected[3], f_result[3]); + } +#else + abort(); +#endif + + /* Ceiling, float */ + f_result = vec_ceil (f_src); + + if ((f_result[0] != f_ceil_expected[0]) + || (f_result[1] != f_ceil_expected[1]) + || (f_result[2] != f_ceil_expected[2]) + || (f_result[3] != f_ceil_expected[3])) +#if DEBUG + { + printf("ERROR: vec_ceil (float) expected value does not match\n"); + printf(" expected[0] = %f; result[0] = %f\n", + f_ceil_expected[0], f_result[0]); + printf(" expected[1] = %f; result[1] = %f\n", + f_ceil_expected[1], f_result[1]); + printf(" expected[2] = %f; result[2] = %f\n", + f_ceil_expected[2], f_result[2]); + printf(" expected[3] = %f; result[3] = %f\n", + f_ceil_expected[3], f_result[3]); + } +#else + abort(); +#endif + + /* Floor, float */ + f_result = vec_floor (f_src); + + if ((f_result[0] != f_floor_expected[0]) + || (f_result[1] != f_floor_expected[1]) + || (f_result[2] != f_floor_expected[2]) + || (f_result[3] != f_floor_expected[3])) +#if DEBUG + { + printf("ERROR: vec_floor (float) expected value does not match\n"); + printf(" expected[0] = %f; result[0] = %f\n", + f_floor_expected[0], f_result[0]); + printf(" expected[1] = %f; result[1] = %f\n", + f_floor_expected[1], f_result[1]); + printf(" expected[2] = %f; result[2] = %f\n", + f_floor_expected[2], f_result[2]); + printf(" expected[3] = %f; result[3] = %f\n", + f_floor_expected[3], f_result[3]); + } +#else + abort(); +#endif + + /* Nearby int, float */ + f_result = vec_nearbyint (f_src); + + if ((f_result[0] != f_nearbyint_expected[0]) + || (f_result[1] != f_nearbyint_expected[1]) + || (f_result[2] != f_nearbyint_expected[2]) + || (f_result[3] != f_nearbyint_expected[3])) +#if DEBUG + { + printf("ERROR: vec_nearby (float) expected value does not match\n"); + printf(" expected[0] = %f; result[0] = %f\n", + f_nearbyint_expected[0], f_result[0]); + printf(" expected[1] = %f; result[1] = %f\n", + f_nearbyint_expected[1], f_result[1]); + printf(" expected[2] = %f; result[2] = %f\n", + f_nearbyint_expected[2], f_result[2]); + printf(" expected[3] = %f; result[3] = %f\n", + f_nearbyint_expected[3], f_result[3]); + } +#else + abort(); +#endif + + /* Round, float */ + f_result = vec_rint (f_src); + + if ((f_result[0] != f_rint_expected[0]) + || (f_result[1] != f_rint_expected[1]) + || (f_result[2] != f_rint_expected[2]) + || (f_result[3] != f_rint_expected[3])) +#if DEBUG + { + printf("ERROR: vec_rint (float) expected value does not match\n"); + printf(" expected[0] = %f; result[0] = %f\n", + f_rint_expected[0], f_result[0]); + printf(" expected[1] = %f; result[1] = %f\n", + f_rint_expected[1], f_result[1]); + printf(" expected[2] = %f; result[2] = %f\n", + f_rint_expected[2], f_result[2]); + printf(" expected[3] = %f; result[3] = %f\n", + f_rint_expected[3], f_result[3]); + } +#else + abort(); +#endif + + /* Square, float */ + f_result = vec_sqrt (vec_abs(f_src)); + + if ((f_result[0] != f_sqrt_expected[0]) + || (f_result[1] != f_sqrt_expected[1]) + || (f_result[2] != f_sqrt_expected[2]) + || (f_result[3] != f_sqrt_expected[3])) +#if DEBUG + { + printf("ERROR: vec_sqrt (float) expected value does not match\n"); + printf(" expected[0] = %f; result[0] = %f\n", + f_sqrt_expected[0], f_result[0]); + printf(" expected[1] = %f; result[1] = %f\n", + f_sqrt_expected[1], f_result[1]); + printf(" expected[2] = %f; result[2] = %f\n", + f_sqrt_expected[2], f_result[2]); + printf(" expected[3] = %f; result[3] = %f\n", + f_sqrt_expected[3], f_result[3]); + } +#else + abort(); +#endif + + /* Truncate, float */ + f_result = vec_trunc (f_src); + + if ((f_result[0] != f_trunc_expected[0]) + || (f_result[1] != f_trunc_expected[1]) + || (f_result[2] != f_trunc_expected[2]) + || (f_result[3] != f_trunc_expected[3])) +#if DEBUG + { + printf("ERROR: vec_trunc (float) expected value does not match\n"); + printf(" expected[0] = %f; result[0] = %f\n", + f_trunc_expected[0], f_result[0]); + printf(" expected[1] = %f; result[1] = %f\n", + f_trunc_expected[1], f_result[1]); + printf(" expected[2] = %f; result[2] = %f\n", + f_trunc_expected[2], f_result[2]); + printf(" expected[3] = %f; result[3] = %f\n", + f_trunc_expected[3], f_result[3]); + } +#else + abort(); +#endif + + + /* ABS, double */ + d_result = vec_abs (d_src); + + if ((d_result[0] != d_abs_expected[0]) || (d_result[1] != d_abs_expected[1])) +#if DEBUG + { + printf("ERROR: vec_abs (double) expected value does not match\n"); + printf(" expected[0] = %f; result[0] = %f\n", + d_abs_expected[0], d_result[0]); + printf(" expected[1] = %f; result[1] = %f\n", + d_abs_expected[1], d_result[1]); + } +#else + abort(); +#endif + + /* CEIL, double */ + d_result = vec_ceil (d_src); + + if ((d_result[0] != d_ceil_expected[0]) + || (d_result[1] != d_ceil_expected[1])) +#if DEBUG + { + printf("ERROR: vec_ceil (double) expected value does not match\n"); + printf(" expected[0] = %f; result[0] = %f\n", + d_ceil_expected[0], d_result[0]); + printf(" expected[1] = %f; result[1] = %f\n", + d_ceil_expected[1], d_result[1]); + } +#else + abort(); +#endif + + /* Floor, double */ + d_result = vec_floor (d_src); + + if ((d_result[0] != d_floor_expected[0]) + || (d_result[1] != d_floor_expected[1])) +#if DEBUG + { + printf("ERROR: vec_floor (double) expected value does not match\n"); + printf(" expected[0] = %f; result[0] = %f\n", + d_floor_expected[0], d_result[0]); + printf(" expected[1] = %f; result[1] = %f\n", + d_floor_expected[1], d_result[1]); + } +#else + abort(); +#endif + + /* Nearby int, double */ + d_result = vec_nearbyint (d_src); + + if ((d_result[0] != d_nearbyint_expected[0]) + || (d_result[1] != d_nearbyint_expected[1])) +#if DEBUG + { + printf("ERROR: vec_nearbyint (double) expected value does not match\n"); + printf(" expected[0] = %f; result[0] = %f\n", + d_nearbyint_expected[0], d_result[0]); + printf(" expected[1] = %f; result[1] = %f\n", + d_nearbyint_expected[1], d_result[1]); + } +#else + abort(); +#endif + + /* Round int, double */ + d_result = vec_rint (d_src); + + if ((d_result[0] != d_rint_expected[0]) + || (d_result[1] != d_rint_expected[1])) +#if DEBUG + { + printf("ERROR: vec_rint (double) expected value does not match\n"); + printf(" expected[0] = %f; result[0] = %f\n", + d_rint_expected[0], d_result[0]); + printf(" expected[1] = %f; result[1] = %f\n", + d_rint_expected[1], d_result[1]); + } +#else + abort(); +#endif + + /* Square root, double */ + d_result = vec_sqrt (vec_abs(d_src)); + + if ((d_result[0] != d_sqrt_expected[0]) + || (d_result[1] != d_sqrt_expected[1])) +#if DEBUG + { + printf("ERROR: vec_sqrt (double) expected value does not match\n"); + printf(" expected[0] = %f; result[0] = %f\n", + d_sqrt_expected[0], d_result[0]); + printf(" expected[1] = %f; result[1] = %f\n", + d_sqrt_expected[1], d_result[1]); + } +#else + abort(); +#endif + + /* Truncate, double */ + d_result = vec_trunc (d_src); + + if ((d_result[0] != d_trunc_expected[0]) + || (d_result[1] != d_trunc_expected[1])) +#if DEBUG + { + printf("ERROR: vec_trunc (double) expected value does not match\n"); + printf(" expected[0] = %f; result[0] = %f\n", + d_trunc_expected[0], d_result[0]); + printf(" expected[1] = %f; result[1] = %f\n", + d_trunc_expected[1], d_result[1]); + } +#else + abort(); +#endif + + return 0; +} diff --git a/gcc/testsuite/gcc.target/powerpc/vsx-vector-6-func-2lop.c b/gcc/testsuite/gcc.target/powerpc/vsx-vector-6-func-2lop.c new file mode 100644 index 00000000000..1055a8d7252 --- /dev/null +++ b/gcc/testsuite/gcc.target/powerpc/vsx-vector-6-func-2lop.c @@ -0,0 +1,305 @@ +/* { dg-do compile { target lp64 } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } } */ +/* { dg-options "-O2 -mdejagnu-cpu=power7" } */ + +/* Functional test of the two operand logical vector builtins. */ + +#include +#include +#include + +#define DEBUG 0 + +void abort (void); + +int +main () { + int i; + + union conv_t { + vector float f; + vector unsigned int u; + vector double d; + vector unsigned long ul; + } conv_result, conv_exp, conv_src_a, conv_src_b; + + + vector float f_src_a = { 1.0, 2.0, 3.0, 4.0}; + vector float f_src_b = { 1.0, 3.0, -3.0, 2.0}; + vector float f_result; + vector float f_expected; + + vector double d_src_a = { 8.0, 10.0}; + vector double d_src_b = { 12.0, 2.0}; + vector double d_result; + vector double d_expected; + + /* AND, float */ + for (i = 0; i < 4; i++) + { + conv_src_a.f[i] = f_src_a[i]; + conv_src_b.f[i] = f_src_b[i]; + conv_exp.u[i] = conv_src_a.u[i] & conv_src_b.u[i]; + f_expected[i] = conv_exp.f[i]; + } + + f_result = vec_and (f_src_a, f_src_b); + if ((f_result[0] != f_expected[0]) + || (f_result[1] != f_expected[1]) + || (f_result[2] != f_expected[2]) + || (f_result[3] != f_expected[3])) + { +#if DEBUG + printf("ERROR: vec_and (float) expected value does not match\n"); + for (i = 0; i < 4; i++) + { + conv_result.f[i] = f_result[i]; + printf(" expected[%d] = 0x%x; result[%d] = 0x%x\n", i, + conv_exp.u[i], i, conv_result.u[i]); + } +#else + abort(); +#endif + } + + /* ANDC, float */ + for (i = 0; i < 4; i++) + { + conv_src_a.f[i] = f_src_a[i]; + conv_src_b.f[i] = f_src_b[i]; + conv_exp.u[i] = conv_src_a.u[i] & ~conv_src_b.u[i]; + f_expected[i] = conv_exp.f[i]; + } + + f_result = vec_andc (f_src_a, f_src_b); + + if ((f_result[0] != f_expected[0]) + || (f_result[1] != f_expected[1]) + || (f_result[2] != f_expected[2]) + || (f_result[3] != f_expected[3])) + { +#if DEBUG + printf("ERROR: vec_andc (float) expected value does not match\n"); + for (i = 0; i < 4; i++) + { + conv_result.f[i] = f_result[i]; + printf(" expected[%d] = 0x%x; result[%d] = 0x%x\n", i, + conv_exp.u[i], i, conv_result.u[i]); + } +#else + abort(); +#endif + } + + /* NOR, max */ + f_result = vec_nor (f_src_a, f_src_b); + for (i = 0; i < 4; i++) + { + conv_src_a.f[i] = f_src_a[i]; + conv_src_b.f[i] = f_src_b[i]; + conv_exp.u[i] = ~(conv_src_a.u[i] | conv_src_b.u[i]); + f_expected[i] = conv_exp.f[i]; + } + + if ((f_result[0] != f_expected[0]) + || (f_result[1] != f_expected[1]) + || (f_result[2] != f_expected[2]) + || (f_result[3] != f_expected[3])) + { +#if DEBUG + printf("ERROR: vec_nor (float) expected value does not match\n"); + for (i = 0; i < 4; i++) + { + conv_result.f[i] = f_result[i]; + printf(" expected[%d] = 0x%x; result[%d] = 0x%x\n", i, + conv_exp.u[i], i, conv_result.u[i]); + } +#else + abort(); +#endif + } + + /* OR, float */ + f_result = vec_or (f_src_a, f_src_b); + for (i = 0; i < 4; i++) + { + conv_src_a.f[i] = f_src_a[i]; + conv_src_b.f[i] = f_src_b[i]; + conv_exp.u[i] = conv_src_a.u[i] | conv_src_b.u[i]; + f_expected[i] = conv_exp.f[i]; + } + + if ((f_result[0] != f_expected[0]) + || (f_result[1] != f_expected[1]) + || (f_result[2] != f_expected[2]) + || (f_result[3] != f_expected[3])) + { +#if DEBUG + printf("ERROR: vec_or (float) expected value does not match\n"); + for (i = 0; i < 4; i++) + { + conv_result.f[i] = f_result[i]; + printf(" expected[%d] = 0x%x; result[%d] = 0x%x\n", i, + conv_exp.u[i], i, conv_result.u); + } +#else + abort(); +#endif + } + + /* XOR, float */ + f_result = vec_xor (f_src_a, f_src_b); + for (i = 0; i < 4; i++) + { + conv_src_a.f[i] = f_src_a[i]; + conv_src_b.f[i] = f_src_b[i]; + conv_exp.u[i] = conv_src_a.u[i] ^ conv_src_b.u[i]; + f_expected[i] = conv_exp.f[i]; + } + + if ((f_result[0] != f_expected[0]) + || (f_result[1] != f_expected[1]) + || (f_result[2] != f_expected[2]) + || (f_result[3] != f_expected[3])) + { +#if DEBUG + printf("ERROR: vec_xor (float) expected value does not match\n"); + for (i = 0; i < 4; i++) + { + conv_result.f[i] = f_result[i]; + printf(" expected[%d] = 0x%x; result[%d] = 0x%x\n", i, + conv_exp.u[i], i, conv_result.u); + } +#else + abort(); +#endif + } + + /* AND, double */ + d_result = vec_and (d_src_a, d_src_b); + for (i = 0; i < 2; i++) + { + conv_src_a.d[i] = d_src_a[i]; + conv_src_b.d[i] = d_src_b[i]; + conv_exp.ul[i] = conv_src_a.ul[i] & conv_src_b.ul[i]; + d_expected[i] = conv_exp.d[i]; + } + + if ((d_result[0] != d_expected[0]) || (d_result[1] != d_expected[1])) + { +#if DEBUG + printf("ERROR: vec_and (double) expected value does not match\n"); + for (i = 0; i < 2; i++) + { + conv_result.d[i] = d_result[i]; + printf(" expected[%d] = 0x%lx; result[%d] = 0x%lx\n", i, + conv_exp.ul, i, conv_result.ul); + } +#else + abort(); +#endif + } + + /* ANDC, double */ + d_result = vec_andc (d_src_a, d_src_b); + for (i = 0; i < 2; i++) + { + conv_src_a.d[i] = d_src_a[i]; + conv_src_b.d[i] = d_src_b[i]; + conv_exp.ul[i] = conv_src_a.ul[i] & ~conv_src_b.ul[i]; + d_expected[i] = conv_exp.d[i]; + } + + if ((d_result[0] != d_expected[0]) || (d_result[1] != d_expected[1])) + { +#if DEBUG + printf("ERROR: vec_andc (double) expected value does not match\n"); + for (i = 0; i < 4; i++) + { + conv_result.d[i] = d_result[i]; + printf(" expected[%d] = 0x%lx; result[%d] = 0x%lx\n", i, + conv_exp.ul[i], i, conv_result.ul); + } +#else + abort(); +#endif + } + + /* NOR, double */ + d_result = vec_nor (d_src_a, d_src_b); + for (i = 0; i < 2; i++) + { + conv_src_a.d[i] = d_src_a[i]; + conv_src_b.d[i] = d_src_b[i]; + conv_exp.ul[i] = ~(conv_src_a.ul[i] | conv_src_b.ul[i]); + d_expected[i] = conv_exp.d[i]; + } + + if ((d_result[0] != d_expected[0]) || (d_result[1] != d_expected[1])) + { +#if DEBUG + printf("ERROR: vec_nor (double) expected value does not match\n"); + for (i = 0; i < 2; i++) + { + conv_result.d[i] = d_result[i]; + printf(" expected[%d] = 0x%lx; result[%d] = 0x%lx\n", i, + conv_exp.ul, i, conv_result.ul); + } +#else + abort(); +#endif + } + + /* OR, double */ + d_result = vec_or (d_src_a, d_src_b); + for (i = 0; i < 2; i++) + { + conv_src_a.d[i] = d_src_a[i]; + conv_src_b.d[i] = d_src_b[i]; + conv_exp.ul[i] = conv_src_a.ul[i] | conv_src_b.ul[i]; + d_expected[i] = conv_exp.d[i]; + } + + if ((d_result[0] != d_expected[0]) || (d_result[1] != d_expected[1])) + { +#if DEBUG + printf("ERROR: vec_or (double) expected value does not match\n"); + for (i = 0; i < 2; i++) + { + conv_result.f[i] = f_result[i]; + printf(" expected[%d] = 0x%lx; result[%d] = 0x%lx\n", i, + conv_exp.ul, i, conv_result.ul); + } +#else + abort(); +#endif + } + + /* XOR, double */ + d_result = vec_xor (d_src_a, d_src_b); + for (i = 0; i < 2; i++) + { + conv_src_a.d[i] = d_src_a[i]; + conv_src_b.d[i] = d_src_b[i]; + conv_exp.ul[i] = conv_src_a.ul[i] ^ conv_src_b.ul[i]; + d_expected[i] = conv_exp.d[i]; + } + + if ((d_result[0] != d_expected[0]) || (d_result[1] != d_expected[1])) + { +#if DEBUG + printf("ERROR: vec_xor (double) expected value does not match\n"); + for (i = 0; i < 2; i++) + { + conv_result.d[i] = f_result[i]; + printf(" expected[%d] = 0x%lx; result[%d] = 0x%lx\n", i, + conv_exp.ul, i, conv_result.ul); + } +#else + abort(); +#endif + } + + return 0; +} + diff --git a/gcc/testsuite/gcc.target/powerpc/vsx-vector-6-func-2op.c b/gcc/testsuite/gcc.target/powerpc/vsx-vector-6-func-2op.c new file mode 100644 index 00000000000..0ee703b8e04 --- /dev/null +++ b/gcc/testsuite/gcc.target/powerpc/vsx-vector-6-func-2op.c @@ -0,0 +1,278 @@ +/* { dg-do compile { target lp64 } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } } */ +/* { dg-options "-O2 -mdejagnu-cpu=power7" } */ +/* Functional test of the two operand vector builtins. */ + +#include +#include +#include + +#define DEBUG 0 + +void abort (void); + +int +main () { + int i; + vector float f_src_a = { 126.0, 23.0, -338.0, 17.0}; + vector float f_src_b = { 2.00, -4.0, 1.0, 4.0}; + vector float f_result; + vector float f_add_expected = { 128.0, 19.0, -337.0, 21.0}; + vector float f_div_expected = { 63.0, -5.75, -338, 4.25}; + vector float f_max_expected = { 126.0, 23.0, 1.0, 17.0}; + vector float f_min_expected = { 2.0, -4.0, -338.0, 4.0}; + vector float f_mul_expected = { 252, -92.0, -338, 68.0}; + vector float f_sub_expected = { 124.0, 27.0, -339.0, 13.0}; + + vector double d_src_a = { 125.44, -338.56}; + vector double d_src_b = { 4.0, -2.0}; + vector double d_result; + vector double d_add_expected = { 129.44, -340.56}; + vector double d_div_expected = { 31.360000, 169.280000}; + vector double d_max_expected = { 125.44, -2.0}; + vector double d_min_expected = { 4.0, -338.56}; + vector double d_mul_expected = { 501.760000, 677.120000}; + vector double d_sub_expected = { 121.440000, -336.560000}; + + /* Add, float */ + f_result = vec_add (f_src_a, f_src_b); + + if ((f_result[0] != f_add_expected[0]) + || (f_result[1] != f_add_expected[1]) + || (f_result[2] != f_add_expected[2]) + || (f_result[3] != f_add_expected[3])) +#if DEBUG + { + printf("ERROR: vec_add (float) expected value does not match\n"); + printf(" expected[0] = %f; result[0] = %f\n", + f_add_expected[0], f_result[0]); + printf(" expected[1] = %f; result[1] = %f\n", + f_add_expected[1], f_result[1]); + printf(" expected[2] = %f; result[2] = %f\n", + f_add_expected[2], f_result[2]); + printf(" expected[3] = %f; result[3] = %f\n", + f_add_expected[3], f_result[3]); + } +#else + abort(); +#endif + + /* Divide, float */ + f_result = vec_div (f_src_a, f_src_b); + + if ((f_result[0] != f_div_expected[0]) + || (f_result[1] != f_div_expected[1]) + || (f_result[2] != f_div_expected[2]) + || (f_result[3] != f_div_expected[3])) +#if DEBUG + { + printf("ERROR: vec_div (float) expected value does not match\n"); + printf(" expected[0] = %f; result[0] = %f\n", + f_div_expected[0], f_result[0]); + printf(" expected[1] = %f; result[1] = %f\n", + f_div_expected[1], f_result[1]); + printf(" expected[2] = %f; result[2] = %f\n", + f_div_expected[2], f_result[2]); + printf(" expected[3] = %f; result[3] = %f\n", + f_div_expected[3], f_result[3]); + } +#else + abort(); +#endif + + /* Floor, max */ + f_result = vec_max (f_src_a, f_src_b); + + if ((f_result[0] != f_max_expected[0]) + || (f_result[1] != f_max_expected[1]) + || (f_result[2] != f_max_expected[2]) + || (f_result[3] != f_max_expected[3])) +#if DEBUG + { + printf("ERROR: vec_max(float) expected value does not match\n"); + printf(" expected[0] = %f; result[0] = %f\n", + f_max_expected[0], f_result[0]); + printf(" expected[1] = %f; result[1] = %f\n", + f_max_expected[1], f_result[1]); + printf(" expected[2] = %f; result[2] = %f\n", + f_max_expected[2], f_result[2]); + printf(" expected[3] = %f; result[3] = %f\n", + f_max_expected[3], f_result[3]); + } +#else + abort(); +#endif + + /* Minimum, float */ + f_result = vec_min (f_src_a, f_src_b); + + if ((f_result[0] != f_min_expected[0]) + || (f_result[1] != f_min_expected[1]) + || (f_result[2] != f_min_expected[2]) + || (f_result[3] != f_min_expected[3])) +#if DEBUG + { + printf("ERROR: vec_min (float) expected value does not match\n"); + printf(" expected[0] = %f; result[0] = %f\n", + f_min_expected[0], f_result[0]); + printf(" expected[1] = %f; result[1] = %f\n", + f_min_expected[1], f_result[1]); + printf(" expected[2] = %f; result[2] = %f\n", + f_min_expected[2], f_result[2]); + printf(" expected[3] = %f; result[3] = %f\n", + f_min_expected[3], f_result[3]); + } +#else + abort(); +#endif + + /* Multiply, float */ + f_result = vec_mul (f_src_a, f_src_b); + + if ((f_result[0] != f_mul_expected[0]) + || (f_result[1] != f_mul_expected[1]) + || (f_result[2] != f_mul_expected[2]) + || (f_result[3] != f_mul_expected[3])) +#if DEBUG + { + printf("ERROR: vec_mult (float) expected value does not match\n"); + printf(" expected[0] = %f; result[0] = %f\n", + f_mul_expected[0], f_result[0]); + printf(" expected[1] = %f; result[1] = %f\n", + f_mul_expected[1], f_result[1]); + printf(" expected[2] = %f; result[2] = %f\n", + f_mul_expected[2], f_result[2]); + printf(" expected[3] = %f; result[3] = %f\n", + f_mul_expected[3], f_result[3]); + } +#else + abort(); +#endif + + /* Subtract, float */ + f_result = vec_sub (f_src_a, f_src_b); + + if ((f_result[0] != f_sub_expected[0]) + || (f_result[1] != f_sub_expected[1]) + || (f_result[2] != f_sub_expected[2]) + || (f_result[3] != f_sub_expected[3])) +#if DEBUG + { + printf("ERROR: vec_sub (float) expected value does not match\n"); + printf(" expected[0] = %f; result[0] = %f\n", + f_sub_expected[0], f_result[0]); + printf(" expected[1] = %f; result[1] = %f\n", + f_sub_expected[1], f_result[1]); + printf(" expected[2] = %f; result[2] = %f\n", + f_sub_expected[2], f_result[2]); + printf(" expected[3] = %f; result[3] = %f\n", + f_sub_expected[3], f_result[3]); + } +#else + abort(); +#endif + + + + /* Add, double */ + d_result = vec_add (d_src_a, d_src_b); + + if ((d_result[0] != d_add_expected[0]) || (d_result[1] != d_add_expected[1])) +#if DEBUG + { + printf("ERROR: vec_add (double) expected value does not match\n"); + printf(" expected[0] = %f; result[0] = %f\n", + d_add_expected[0], d_result[0]); + printf(" expected[1] = %f; result[1] = %f\n", + d_add_expected[1], d_result[1]); + } +#else + abort(); +#endif + + /* Divide, double */ + d_result = vec_div (d_src_a, d_src_b); + + if ((d_result[0] != d_div_expected[0]) + || (d_result[1] != d_div_expected[1])) +#if DEBUG + { + printf("ERROR: vec_div (double) expected value does not match\n"); + printf(" expected[0] = %f; result[0] = %f\n", + d_div_expected[0], d_result[0]); + printf(" expected[1] = %f; result[1] = %f\n", + d_div_expected[1], d_result[1]); + } +#else + abort(); +#endif + + /* Max */ + d_result = vec_max (d_src_a, d_src_b); + + if ((d_result[0] != d_max_expected[0]) + || (d_result[1] != d_max_expected[1])) +#if DEBUG + { + printf("ERROR: vec_max (double) expected value does not match\n"); + printf(" expected[0] = %f; result[0] = %f\n", + d_max_expected[0], d_result[0]); + printf(" expected[1] = %f; result[1] = %f\n", + d_max_expected[1], d_result[1]); + } +#else + abort(); +#endif + + /* Nearby min */ + d_result = vec_min (d_src_a, d_src_b); + + if ((d_result[0] != d_min_expected[0]) || (d_result[1] != d_min_expected[1])) +#if DEBUG + { + printf("ERROR: vec_min (double) expected value does not match\n"); + printf(" expected[0] = %f; result[0] = %f\n", + d_min_expected[0], d_result[0]); + printf(" expected[1] = %f; result[1] = %f\n", + d_min_expected[1], d_result[1]); + } +#else + abort(); +#endif + + /* Multiply, double */ + d_result = vec_mul (d_src_a, d_src_b); + + if ((d_result[0] != d_mul_expected[0]) + || (d_result[1] != d_mul_expected[1])) +#if DEBUG + { + printf("ERROR: vec_mul (double) expected value does not match\n"); + printf(" expected[0] = %f; result[0] = %f\n", + d_mul_expected[0], d_result[0]); + printf(" expected[1] = %f; result[1] = %f\n", + d_mul_expected[1], d_result[1]); + } +#else + abort(); +#endif + + /* Subract root, double */ + d_result = vec_sub (d_src_a, d_src_b); + + if ((d_result[0] != d_sub_expected[0]) + || (d_result[1] != d_sub_expected[1])) +#if DEBUG + { + printf("ERROR: vec_sub (double) expected value does not match\n"); + printf(" expected[0] = %f; result[0] = %f\n", + d_sub_expected[0], d_result[0]); + printf(" expected[1] = %f; result[1] = %f\n", + d_sub_expected[1], d_result[1]); + } +#else + abort(); +#endif + + return 0; +} diff --git a/gcc/testsuite/gcc.target/powerpc/vsx-vector-6-func-3op.c b/gcc/testsuite/gcc.target/powerpc/vsx-vector-6-func-3op.c new file mode 100644 index 00000000000..a2127455f79 --- /dev/null +++ b/gcc/testsuite/gcc.target/powerpc/vsx-vector-6-func-3op.c @@ -0,0 +1,229 @@ +/* { dg-do compile { target lp64 } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } } */ +/* { dg-options "-O2 -mdejagnu-cpu=power7" } */ + +/* Functional test of the three operand vector builtins. */ + +#include +#include +#include + +#define DEBUG 0 + +void abort (void); + +int +main () { + int i; + + // vector unsigned char uc_src_c = {0xF, 0xE, 0xD, 0xC, 0xB, 0xA, 0x9, 0x8, + // 0x7, 0x6, 0x5, 0x4, 0x3, 0x2, 0x1, 0x0}; + vector unsigned char uc_src_c = {0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, + 0x8, 0x9, 0xA, 0xB, 0xC, 0xD, 0xE, 0xF}; + vector short ss_src_a = { 1, 2, 3, 4, 5, 6, 7, 8}; + vector short ss_src_b = { -10, 20, 30, 40, 50, 60, 70, 80}; + vector int si_src_c = { 13, -27, 39, 48}; + vector int si_result; + vector int si_expected = {43, 223, 649, 1178}; + vector unsigned short us_src_a = { 31, 32, 33, 34, 1, 2, 3, 4}; + vector unsigned short us_src_b = { 11, 7, 30, 90, 39, 48, 28, 64}; + vector unsigned int ui_src_c = { 13, 17, 39, 91}; + + vector unsigned int ui_result; + vector unsigned int ui_expected = {578, 4067, 174, 431}; + vector float f_src_a = { 126.0, 23.0, -338.0, 17.0}; + vector float f_src_b = { 2.0, -4.0, 1.0, 4.0}; + vector float f_src_c = { 6.0, -8.0, 7.0, 5.0}; + vector float f_result; + vector float f_madd_expected = { 258.0, -100.0, -331.0, 73.0}; + vector float f_msub_expected = { 246.0, -84.0, -345.0, 63.0}; + + vector unsigned long long ull_src_c = {0xFFFFFFFFFFFFFFFF, + 0xFFFFFFFFFFFFFFFF}; + vector bool long long bll_src_c = {0, 0}; + vector double d_src_a = { 125.44, -338.56}; + vector double d_src_b = { 4.0, -2.0}; + vector double d_src_c = { 7.0, -3.0}; + vector double d_result; + vector double d_madd_expected = { 508.76, 674.12}; + vector double d_msub_expected = { 494.76, 680.12}; + vector double d_selectb_expected = { 125.44, -338.56}; + vector double d_selectu_expected = { 4.0, -2.0}; + vector double d_perm_expected = { 125.44, -338.56}; + + /* Vecotr multiply-sum saturated */ + ui_result = vec_msums (us_src_a, us_src_b, ui_src_c); + if ((ui_result[0] != ui_expected[0]) + || (ui_result[1] != ui_expected[1]) + || (ui_result[2] != ui_expected[2]) + || (ui_result[3] != ui_expected[3])) +#if DEBUG + { + printf("ERROR: vec_msums (unsigned) expected value does not match\n"); + printf(" expected[0] = %d; result[0] = %d\n", + ui_expected[0], ui_result[0]); + printf(" expected[1] = %d; result[1] = %d\n", + ui_expected[1], ui_result[1]); + printf(" expected[2] = %d; result[2] = %d\n", + ui_expected[2], ui_result[2]); + printf(" expected[3] = %d; result[3] = %d\n", + ui_expected[3], ui_result[3]); + } +#else + abort(); +#endif + + si_result = vec_msums (ss_src_a, ss_src_b, si_src_c); + if ((si_result[0] != si_expected[0]) + || (si_result[1] != si_expected[1]) + || (si_result[2] != si_expected[2]) + || (si_result[3] != si_expected[3])) +#if DEBUG + { + printf("ERROR: vec_msums (signed) expected value does not match\n"); + printf(" expected[0] = %d; result[0] = %d\n", + si_expected[0], si_result[0]); + printf(" expected[1] = %d; result[1] = %d\n", + si_expected[1], si_result[1]); + printf(" expected[2] = %d; result[2] = %d\n", + si_expected[2], si_result[2]); + printf(" expected[3] = %d; result[3] = %d\n", + si_expected[3], si_result[3]); + } +#else + abort(); +#endif + + /* Add, float */ + f_result = vec_madd (f_src_a, f_src_b, f_src_c); + + if ((f_result[0] != f_madd_expected[0]) + || (f_result[1] != f_madd_expected[1]) + || (f_result[2] != f_madd_expected[2]) + || (f_result[3] != f_madd_expected[3])) +#if DEBUG + { + printf("ERROR: vec_madd (float) expected value does not match\n"); + printf(" expected[0] = %f; result[0] = %f\n", + f_madd_expected[0], f_result[0]); + printf(" expected[1] = %f; result[1] = %f\n", + f_madd_expected[1], f_result[1]); + printf(" expected[2] = %f; result[2] = %f\n", + f_madd_expected[2], f_result[2]); + printf(" expected[3] = %f; result[3] = %f\n", + f_madd_expected[3], f_result[3]); + } +#else + abort(); +#endif + + /* Subtract, float */ + f_result = vec_msub (f_src_a, f_src_b, f_src_c); + + if ((f_result[0] != f_msub_expected[0]) + || (f_result[1] != f_msub_expected[1]) + || (f_result[2] != f_msub_expected[2]) + || (f_result[3] != f_msub_expected[3])) +#if DEBUG + { + printf("ERROR: vec_msub (float) expected value does not match\n"); + printf(" expected[0] = %f; result[0] = %f\n", + f_msub_expected[0], f_result[0]); + printf(" expected[1] = %f; result[1] = %f\n", + f_msub_expected[1], f_result[1]); + printf(" expected[2] = %f; result[2] = %f\n", + f_msub_expected[2], f_result[2]); + printf(" expected[3] = %f; result[3] = %f\n", + f_msub_expected[3], f_result[3]); + } +#else + abort(); +#endif + + + /* Add, double */ + d_result = vec_madd (d_src_a, d_src_b, d_src_c); + + if ((d_result[0] != d_madd_expected[0]) + || (d_result[1] != d_madd_expected[1])) +#if DEBUG + { + printf("ERROR: vec_madd (double) expected value does not match\n"); + printf(" expected[0] = %f; result[0] = %f\n", + d_madd_expected[0], d_result[0]); + printf(" expected[1] = %f; result[1] = %f\n", + d_madd_expected[1], d_result[1]); + } +#else + abort(); +#endif + + /* Subract root, double */ + d_result = vec_msub (d_src_a, d_src_b, d_src_c); + + if ((d_result[0] != d_msub_expected[0]) + || (d_result[1] != d_msub_expected[1])) +#if DEBUG + { + printf("ERROR: vec_msub (double) expected value does not match\n"); + printf(" expected[0] = %f; result[0] = %f\n", + d_msub_expected[0], d_result[0]); + printf(" expected[1] = %f; result[1] = %f\n", + d_msub_expected[1], d_result[1]); + } +#else + abort(); +#endif + + /* Vector select */ + d_result = vec_sel (d_src_a, d_src_b, ull_src_c); + + if ((d_result[0] != d_selectu_expected[0]) + || (d_result[1] != d_selectu_expected[1])) +#if DEBUG + { + printf("ERROR: vec_msub (double, unsigned) expected value does not match\n"); + printf(" expected[0] = %f; result[0] = %f\n", + d_selectu_expected[0], d_result[0]); + printf(" expected[1] = %f; result[1] = %f\n", + d_selectu_expected[1], d_result[1]); + } +#else + abort(); +#endif + + d_result = vec_sel (d_src_a, d_src_b, bll_src_c); + + if ((d_result[0] != d_selectb_expected[0]) + || (d_result[1] != d_selectb_expected[1])) +#if DEBUG + { + printf("ERROR: vec_msub (double, bool) expected value does not match\n"); + printf(" expected[0] = %f; result[0] = %f\n", + d_selectb_expected[0], d_result[0]); + printf(" expected[1] = %f; result[1] = %f\n", + d_selectb_expected[1], d_result[1]); + } +#else + abort(); +#endif + + /* Vector permute */ + d_result = vec_perm (d_src_a, d_src_b, uc_src_c); + + if ((d_result[0] != d_perm_expected[0]) + || (d_result[1] != d_perm_expected[1])) +#if DEBUG + { + printf("ERROR: vec_perf (unsigned char) expected value does not match\n"); + printf(" expected[0] = %f; result[0] = %f\n", + d_perm_expected[0], d_result[0]); + printf(" expected[1] = %f; result[1] = %f\n", + d_perm_expected[1], d_result[1]); + } +#else + abort(); +#endif + + return 0; +} diff --git a/gcc/testsuite/gcc.target/powerpc/vsx-vector-6-func-cmp-all.c b/gcc/testsuite/gcc.target/powerpc/vsx-vector-6-func-cmp-all.c new file mode 100644 index 00000000000..4558918058e --- /dev/null +++ b/gcc/testsuite/gcc.target/powerpc/vsx-vector-6-func-cmp-all.c @@ -0,0 +1,429 @@ +/* { dg-do compile { target lp64 } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } } */ +/* { dg-options "-O2 -mdejagnu-cpu=power7" } */ + +/* Functional test of the vector compare all builtins. */ + +#include +#include +#include +#include + +#define DEBUG 0 + +void abort (void); + +int +main () { + int i; + vector float f_src_a = {126.0, 23.0, -338.0, 17.0}; + vector float f_src_b = {2.00, 23.0, 1.0, 4.0}; + bool f_result; + bool f_all_eq_expected = 0; + bool f_all_gt_expected = 0; + bool f_all_ge_expected = 0; + bool f_all_lt_expected = 0; + bool f_all_le_expected = 0; + bool f_all_nan_expected = 0; + bool f_all_numeric_expected = 1; + bool f_any_eq_expected = 1; + bool f_any_gt_expected = 1; + bool f_any_ge_expected = 1; + bool f_any_lt_expected = 1; + bool f_any_le_expected = 1; + bool f_any_nan_expected = 0; + bool f_any_numeric_expected = 1; + + vector double d_src_a = { 125.44, -338.56}; + vector double d_src_b = d_src_a; + bool d_result; + bool d_all_eq_expected = 1; + bool d_all_gt_expected = 0; + bool d_all_ge_expected = 1; + bool d_all_lt_expected = 0; + bool d_all_le_expected = 1; + bool d_all_nan_expected = 0; + bool d_all_numeric_expected = 1; + bool d_any_eq_expected = 1; + bool d_any_gt_expected = 0; + bool d_any_ge_expected = 1; + bool d_any_lt_expected = 0; + bool d_any_le_expected = 1; + bool d_any_nan_expected = 0; + bool d_any_numeric_expected = 1; + + /* Compare all equal, float */ + f_result = vec_all_eq (f_src_a, f_src_b); + + if (f_result != f_all_eq_expected) +#if DEBUG + { + printf("ERROR: vec_all_eq (float) expected value does not match\n"); + printf(" expected = %d; result = %d\n", + f_all_eq_expected, f_result); + } +#else + abort(); +#endif + + /* Compare all greater than, float */ + f_result = vec_all_gt (f_src_a, f_src_b); + + if (f_result != f_all_gt_expected) +#if DEBUG + { + printf("ERROR: vec_all_gt (float) expected value does not match\n"); + printf(" expected = %d; result = %d\n", + f_all_gt_expected, f_result); + } +#else + abort(); +#endif + + /* Compare all greater than or equal, float */ + f_result = vec_all_ge (f_src_a, f_src_b); + + if (f_result != f_all_ge_expected) +#if DEBUG + { + printf("ERROR: vec_all_ge(float) expected value does not match\n"); + printf(" expected] = %d; result = %d\n", f_all_ge_expected, f_result); + } +#else + abort(); +#endif + + /* Compare all less than, float */ + f_result = vec_all_lt (f_src_a, f_src_b); + + if (f_result != f_all_lt_expected) +#if DEBUG + { + printf("ERROR: vec_all_lt (float) expected value does not match\n"); + printf(" expected = %d; result = %d\n", f_all_lt_expected, f_result); + } +#else + abort(); +#endif + + /* Compare all less than or equal, float */ + f_result = vec_all_le (f_src_a, f_src_b); + + if (f_result != f_all_le_expected) +#if DEBUG + { + printf("ERROR: vec_all_le (float) expected value does not match\n"); + printf(" expected = %d; result = %d\n", f_all_le_expected, f_result); + } +#else + abort(); +#endif + + /* All NaN, float */ + f_result = vec_all_nan (f_src_a); + + if (f_result != f_all_nan_expected) +#if DEBUG + { + printf("ERROR: vec_all_le (float) expected value does not match\n"); + printf(" expected = %d; result = %d\n", f_all_nan_expected, f_result); + } +#else + abort(); +#endif + + /* All numeric, float */ + f_result = vec_all_numeric (f_src_a); + + if (f_result != f_all_numeric_expected) +#if DEBUG + { + printf("ERROR: vec_all_numeric (float) expected value does not match\n"); + printf(" expected = %d; result = %d\n", f_all_numeric_expected, + f_result); + } +#else + abort(); +#endif + + + /* Compare any equal, float */ + f_result = vec_any_eq (f_src_a, f_src_b); + + if (f_result != f_any_eq_expected) +#if DEBUG + { + printf("ERROR: vec_any_eq (float) expected value does not match\n"); + printf(" expected = %d; result = %d\n", + f_any_eq_expected, f_result); + } +#else + abort(); +#endif + + /* Compare any greater than, float */ + f_result = vec_any_gt (f_src_a, f_src_b); + + if (f_result != f_any_gt_expected) +#if DEBUG + { + printf("ERROR: vec_any_gt (float) expected value does not match\n"); + printf(" expected = %d; result = %d\n", + f_any_gt_expected, f_result); + } +#else + abort(); +#endif + + /* Compare any greater than or equal, float */ + f_result = vec_any_ge (f_src_a, f_src_b); + + if (f_result != f_any_ge_expected) +#if DEBUG + { + printf("ERROR: vec_any_ge(float) expected value does not match\n"); + printf(" expected] = %d; result = %d\n", f_any_ge_expected, f_result); + } +#else + abort(); +#endif + + /* Compare any less than, float */ + f_result = vec_any_lt (f_src_a, f_src_b); + + if (f_result != f_any_lt_expected) +#if DEBUG + { + printf("ERROR: vec_any_lt (float) expected value does not match\n"); + printf(" expected = %d; result = %d\n", f_any_lt_expected, f_result); + } +#else + abort(); +#endif + + /* Compare any less than or equal, float */ + f_result = vec_any_le (f_src_a, f_src_b); + + if (f_result != f_any_le_expected) +#if DEBUG + { + printf("ERROR: vec_any_le (float) expected value does not match\n"); + printf(" expected = %d; result = %d\n", f_any_le_expected, f_result); + } +#else + abort(); +#endif + + /* Any NaN, float */ + f_result = vec_any_nan (f_src_a); + + if (f_result != f_any_nan_expected) +#if DEBUG + { + printf("ERROR: vec_any_le (float) expected value does not match\n"); + printf(" expected = %d; result = %d\n", f_any_nan_expected, f_result); + } +#else + abort(); +#endif + + /* Any numeric, float */ + f_result = vec_any_numeric (f_src_a); + + if (f_result != f_any_numeric_expected) +#if DEBUG + { + printf("ERROR: vec_any_numeric (float) expected value does not match\n"); + printf(" expected = %d; result = %d\n", f_any_numeric_expected, + f_result); + } +#else + abort(); +#endif + + /* Compare all equal, double */ + d_result = vec_all_eq (d_src_a, d_src_b); + + if (d_result != d_all_eq_expected) +#if DEBUG + { + printf("ERROR: vec_all_eq (double) expected value does not match\n"); + printf(" expected] = %d; result = %d\n", d_all_eq_expected, d_result); + } +#else + abort(); +#endif + + /* Compare all greater than, double */ + d_result = vec_all_gt (d_src_a, d_src_b); + + if (d_result != d_all_gt_expected) +#if DEBUG + { + printf("ERROR: vec_all_gt (double) expected value does not match\n"); + printf(" expected = %d; result = %d\n", d_all_gt_expected, d_result); + } +#else + abort(); +#endif + + /* Compare all greater than or equal, double */ + d_result = vec_all_ge (d_src_a, d_src_b); + + if (d_result != d_all_ge_expected) +#if DEBUG + { + printf("ERROR: vec_all_ge (double) expected value does not match\n"); + printf(" expected] = %d; result = %d\n", d_all_gt_expected, d_result); + } +#else + abort(); +#endif + + /* Compare all less than, double */ + d_result = vec_all_lt (d_src_a, d_src_b); + + if (d_result != d_all_lt_expected) +#if DEBUG + { + printf("ERROR: vec_all_lt (double) expected value does not match\n"); + printf(" expected = %d; result = %d\n", d_all_lt_expected, d_result); + } +#else + abort(); +#endif + + /* Compare all less than or equal, double */ + d_result = vec_all_le (d_src_a, d_src_b); + + if (d_result != d_all_le_expected) +#if DEBUG + { + printf("ERROR: vec_all_le (double) expected value does not match\n"); + printf(" expected = %d; result = %d\n", d_all_le_expected, d_result); + } +#else + abort(); +#endif + + /* All NaN, double */ + d_result = vec_all_nan (d_src_a); + + if (d_result != d_all_nan_expected) +#if DEBUG + { + printf("ERROR: vec_all_nan (double) expected value does not match\n"); + printf(" expected = %d; result = %d\n", d_all_nan_expected, d_result); + } +#else + abort(); +#endif + + /* All numeric double */ + d_result = vec_all_numeric (d_src_a); + + if (d_result != d_all_numeric_expected) +#if DEBUG + { + printf("ERROR: vec_all_numeric (double) expected value does not match\n"); + printf(" expected = %d; result = %d\n", d_all_numeric_expected, + d_result); + } +#else + abort(); +#endif + + /* Compare any equal, double */ + d_result = vec_any_eq (d_src_a, d_src_b); + + if (d_result != d_any_eq_expected) +#if DEBUG + { + printf("ERROR: vec_any_eq (double) expected value does not match\n"); + printf(" expected] = %d; result = %d\n", d_any_eq_expected, d_result); + } +#else + abort(); +#endif + + /* Compare any greater than, double */ + d_result = vec_any_gt (d_src_a, d_src_b); + + if (d_result != d_any_gt_expected) +#if DEBUG + { + printf("ERROR: vec_any_gt (double) expected value does not match\n"); + printf(" expected = %d; result = %d\n", d_any_gt_expected, d_result); + } +#else + abort(); +#endif + + /* Compare any greater than or equal, double */ + d_result = vec_any_ge (d_src_a, d_src_b); + + if (d_result != d_any_ge_expected) +#if DEBUG + { + printf("ERROR: vec_any_ge (double) expected value does not match\n"); + printf(" expected] = %d; result = %d\n", d_any_gt_expected, d_result); + } +#else + abort(); +#endif + + /* Compare any less than, double */ + d_result = vec_any_lt (d_src_a, d_src_b); + + if (d_result != d_any_lt_expected) +#if DEBUG + { + printf("ERROR: vec_any_lt (double) expected value does not match\n"); + printf(" expected = %d; result = %d\n", d_any_lt_expected, d_result); + } +#else + abort(); +#endif + + /* Compare any less than or equal, double */ + d_result = vec_any_le (d_src_a, d_src_b); + + if (d_result != d_any_le_expected) +#if DEBUG + { + printf("ERROR: vec_any_le (double) expected value does not match\n"); + printf(" expected = %d; result = %d\n", d_any_le_expected, d_result); + } +#else + abort(); +#endif + + /* Any NaN, float */ + d_result = vec_any_nan (d_src_a); + + if (d_result != d_any_nan_expected) +#if DEBUG + { + printf("ERROR: vec_any_nan (double) expected value does not match\n"); + printf(" expected = %d; result = %d\n", d_any_nan_expected, d_result); + } +#else + abort(); +#endif + + /* Any numeric, double */ + d_result = vec_any_numeric (d_src_a); + + if (d_result != d_any_numeric_expected) +#if DEBUG + { + printf("ERROR: vec_any_numeric (double) expected value does not match\n"); + printf(" expected = %d; result = %d\n", d_any_numeric_expected, + d_result); + } +#else + abort(); +#endif + + return 0; +} diff --git a/gcc/testsuite/gcc.target/powerpc/vsx-vector-6-func-cmp.c b/gcc/testsuite/gcc.target/powerpc/vsx-vector-6-func-cmp.c new file mode 100644 index 00000000000..3c2c1861754 --- /dev/null +++ b/gcc/testsuite/gcc.target/powerpc/vsx-vector-6-func-cmp.c @@ -0,0 +1,237 @@ +/* { dg-do compile { target lp64 } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } } */ +/* { dg-options "-O2 -mdejagnu-cpu=power7" } */ + +/* Functional test of the vector compare builtins. */ + +#include +#include +#include + +#define DEBUG 0 + +void abort (void); + +int +main () { + int i; + vector float f_src_a = { 126.0, 23.0, -338.0, 17.0}; + vector float f_src_b = { 2.00, 23.0, 1.0, 4.0}; + vector bool int f_result; + vector bool int f_cmpeq_expected = {0x0, 0xFFFFFFFF, 0x0, 0x0}; + vector bool int f_cmpgt_expected = {0xFFFFFFFF, 0x0, 0x0, 0xFFFFFFFF}; + vector bool int f_cmpge_expected = {0xFFFFFFFF, 0xFFFFFFFF, 0x0, 0xFFFFFFFF}; + vector bool int f_cmplt_expected = {0x0, 0x0, 0xFFFFFFFF, 0x0}; + vector bool int f_cmple_expected = {0x0, 0xFFFFFFFF, 0xFFFFFFFF, 0x0}; + + vector double d_src_a = { 125.44, -338.56}; + vector double d_src_b = { 4.0, -338.56}; + vector bool long long d_result; + vector bool long long d_cmpeq_expected = {0x0, 0xFFFFFFFFFFFFFFFF}; + vector bool long long d_cmpgt_expected = {0xFFFFFFFFFFFFFFFF, 0x0}; + vector bool long long d_cmpge_expected = {0xFFFFFFFFFFFFFFFF, + 0xFFFFFFFFFFFFFFFF}; + vector bool long long d_cmplt_expected = {0x0, 0x0}; + vector bool long long d_cmple_expected = {0x0, 0xFFFFFFFFFFFFFFFF}; + + /* Compare equal, float */ + f_result = vec_cmpeq (f_src_a, f_src_b); + + if ((f_result[0] != f_cmpeq_expected[0]) + || (f_result[1] != f_cmpeq_expected[1]) + || (f_result[2] != f_cmpeq_expected[2]) + || (f_result[3] != f_cmpeq_expected[3])) +#if DEBUG + { + printf("ERROR: vec_cmpeq (float) expected value does not match\n"); + printf(" expected[0] = 0x%x; result[0] =0x%x\n", + f_cmpeq_expected[0], f_result[0]); + printf(" expected[1] = 0x%x; result[1] = 0x%x\n", + f_cmpeq_expected[1], f_result[1]); + printf(" expected[2] = 0x%x; result[2] = 0x%x\n", + f_cmpeq_expected[2], f_result[2]); + printf(" expected[3] = 0x%x; result[3] = 0x%x\n", + f_cmpeq_expected[3], f_result[3]); + } +#else + abort(); +#endif + + /* Compare greater than, float */ + f_result = vec_cmpgt (f_src_a, f_src_b); + + if ((f_result[0] != f_cmpgt_expected[0]) + || (f_result[1] != f_cmpgt_expected[1]) + || (f_result[2] != f_cmpgt_expected[2]) + || (f_result[3] != f_cmpgt_expected[3])) +#if DEBUG + { + printf("ERROR: vec_cmpgt (float) expected value does not match\n"); + printf(" expected[0] = 0x%x; result[0] = 0x%x\n", + f_cmpgt_expected[0], f_result[0]); + printf(" expected[1] = 0x%x; result[1] = 0x%x\n", + f_cmpgt_expected[1], f_result[1]); + printf(" expected[2] = 0x%x; result[2] = 0x%x\n", + f_cmpgt_expected[2], f_result[2]); + printf(" expected[3] = 0x%x; result[3] = 0x%x\n", + f_cmpgt_expected[3], f_result[3]); + } +#else + abort(); +#endif + + /* Compare greater than or equal, float */ + f_result = vec_cmpge (f_src_a, f_src_b); + + if ((f_result[0] != f_cmpge_expected[0]) + || (f_result[1] != f_cmpge_expected[1]) + || (f_result[2] != f_cmpge_expected[2]) + || (f_result[3] != f_cmpge_expected[3])) +#if DEBUG + { + printf("ERROR: vec_cmpge(float) expected value does not match\n"); + printf(" expected[0] = 0x%x; result[0] = 0x%x\n", + f_cmpge_expected[0], f_result[0]); + printf(" expected[1] = 0x%x; result[1] = 0x%x\n", + f_cmpge_expected[1], f_result[1]); + printf(" expected[2] = 0x%x; result[2] = 0x%x\n", + f_cmpge_expected[2], f_result[2]); + printf(" expected[3] = 0x%x; result[3] = 0x%x\n", + f_cmpge_expected[3], f_result[3]); + } +#else + abort(); +#endif + + /* Compare less than, float */ + f_result = vec_cmplt (f_src_a, f_src_b); + + if ((f_result[0] != f_cmplt_expected[0]) + || (f_result[1] != f_cmplt_expected[1]) + || (f_result[2] != f_cmplt_expected[2]) + || (f_result[3] != f_cmplt_expected[3])) +#if DEBUG + { + printf("ERROR: vec_cmplt (float) expected value does not match\n"); + printf(" expected[0] = 0x%x; result[0] = 0x%x\n", + f_cmplt_expected[0], f_result[0]); + printf(" expected[1] = 0x%x; result[1] = 0x%x\n", + f_cmplt_expected[1], f_result[1]); + printf(" expected[2] = 0x%x; result[2] = 0x%x\n", + f_cmplt_expected[2], f_result[2]); + printf(" expected[3] = 0x%x; result[3] = 0x%x\n", + f_cmplt_expected[3], f_result[3]); + } +#else + abort(); +#endif + + /* Compare less than or equal, float */ + f_result = vec_cmple (f_src_a, f_src_b); + + if ((f_result[0] != f_cmple_expected[0]) + || (f_result[1] != f_cmple_expected[1]) + || (f_result[2] != f_cmple_expected[2]) + || (f_result[3] != f_cmple_expected[3])) +#if DEBUG + { + printf("ERROR: vec_cmple (float) expected value does not match\n"); + printf(" expected[0] = 0x%x; result[0] = 0x%x\n", + f_cmple_expected[0], f_result[0]); + printf(" expected[1] = 0x%x; result[1] = 0x%x\n", + f_cmple_expected[1], f_result[1]); + printf(" expected[2] = 0x%x; result[2] = 0x%x\n", + f_cmple_expected[2], f_result[2]); + printf(" expected[3] = 0x%x; result[3] = 0x%x\n", + f_cmple_expected[3], f_result[3]); + } +#else + abort(); +#endif + + + /* Compare equal, double */ + d_result = vec_cmpeq (d_src_a, d_src_b); + + if ((d_result[0] != d_cmpeq_expected[0]) || (d_result[1] != d_cmpeq_expected[1])) +#if DEBUG + { + printf("ERROR: vec_cmpeq (double) expected value does not match\n"); + printf(" expected[0] = 0x%lx; result[0] = 0x%lx\n", + d_cmpeq_expected[0], d_result[0]); + printf(" expected[1] = 0x%lx; result[1] = 0x%lx\n", + d_cmpeq_expected[1], d_result[1]); + } +#else + abort(); +#endif + + /* Compare greater than, double */ + d_result = vec_cmpgt (d_src_a, d_src_b); + + if ((d_result[0] != d_cmpgt_expected[0]) + || (d_result[1] != d_cmpgt_expected[1])) +#if DEBUG + { + printf("ERROR: vec_cmpgt (double) expected value does not match\n"); + printf(" expected[0] = 0x%lx; result[0] = 0x%lx\n", + d_cmpgt_expected[0], d_result[0]); + printf(" expected[1] = 0x%lx; result[1] = 0x%lx\n", + d_cmpgt_expected[1], d_result[1]); + } +#else + abort(); +#endif + + /* Compare greater than or equal, double */ + d_result = vec_cmpge (d_src_a, d_src_b); + + if ((d_result[0] != d_cmpge_expected[0]) + || (d_result[1] != d_cmpge_expected[1])) +#if DEBUG + { + printf("ERROR: vec_cmpge (double) expected value does not match\n"); + printf(" expected[0] = 0x%lx; result[0] = 0x%lx\n", + d_cmpgt_expected[0], d_result[0]); + printf(" expected[1] = 0x%lx; result[1] = 0x%lx\n", + d_cmpgt_expected[1], d_result[1]); + } +#else + abort(); +#endif + + /* Compare less than, double */ + d_result = vec_cmplt (d_src_a, d_src_b); + + if ((d_result[0] != d_cmplt_expected[0]) + || (d_result[1] != d_cmplt_expected[1])) +#if DEBUG + { + printf("ERROR: vec_cmplt (double) expected value does not match\n"); + printf(" expected[0] = 0x%lx; result[0] = 0x%lx\n", + d_cmplt_expected[0], d_result[0]); + printf(" expected[1] = 0x%lx; result[1] = 0x%lx\n", + d_cmplt_expected[1], d_result[1]); + } +#else + abort(); +#endif + + /* Compare less than or equal, double */ + d_result = vec_cmple (d_src_a, d_src_b); + + if ((d_result[0] != d_cmple_expected[0]) + || (d_result[1] != d_cmple_expected[1])) +#if DEBUG + { + printf("ERROR: vec_cmple (double) expected value does not match\n"); + printf(" expected[0] = 0x%lx; result[0] = 0x%lx\n", + d_cmple_expected[0], d_result[0]); + printf(" expected[1] = 0x%lx; result[1] = 0x%lx\n", + d_cmple_expected[1], d_result[1]); + } +#else + abort(); +#endif + return 0; +} diff --git a/gcc/testsuite/gcc.target/powerpc/vsx-vector-6.h b/gcc/testsuite/gcc.target/powerpc/vsx-vector-6.h deleted file mode 100644 index 0106e8d2901..00000000000 --- a/gcc/testsuite/gcc.target/powerpc/vsx-vector-6.h +++ /dev/null @@ -1,154 +0,0 @@ -/* This test code is included into vsx-vector-6.p7.c, vsx-vector-6.p8.c - and vsx-vector-6.p9.c. The .c files have the tests for the number - of instructions generated for each cpu type. */ - -#include - -typedef struct { - vector double d; - vector float f; - vector long sl; - vector int si; - vector short ss; - vector char sc; - vector unsigned int ui; - vector unsigned short int us; - vector unsigned char uc; - vector bool long long bll; - vector bool long bl; - vector bool int bi; - vector bool short bs; - vector bool char bc; -} opnd_t; - -void -func_1op (opnd_t *dst, opnd_t *src) -{ - dst[0].d = vec_abs (src[0].d); - dst[1].d = vec_ceil (src[1].d); - dst[2].d = vec_floor (src[2].d); - dst[3].d = vec_nearbyint (src[3].d); - dst[4].d = vec_rint (src[4].d); - dst[5].d = vec_sqrt (src[5].d); - dst[6].d = vec_trunc (src[6].d); - dst[7].f = vec_trunc (src[7].f); -} - -void -func_2op (opnd_t *dst, opnd_t *src0, opnd_t *src1) -{ - dst[0].d = vec_add (src0[0].d, src1[0].d); - dst[1].d = vec_div (src0[1].d, src1[1].d); - dst[2].d = vec_max (src0[2].d, src1[2].d); - dst[3].uc = vec_max (src0[3].uc, src1[3].uc); - dst[4].d = vec_min (src0[4].d, src1[4].d); - dst[5].d = vec_mul (src0[5].d, src1[5].d); - dst[6].d = vec_sub (src0[6].d, src1[6].d); -} - -void -func_2lop (opnd_t *dst, opnd_t *src0, opnd_t *src1) -{ - dst[0].d = vec_and (src0[0].d, src1[0].d); - dst[1].d = vec_and (src0[1].d, src1[1].bl); - dst[2].d = vec_and (src0[2].bl, src1[2].d); - - dst[3].d = vec_andc (src0[3].d, src1[3].d); - dst[4].d = vec_andc (src0[4].d, src1[4].bl); - dst[5].d = vec_andc (src0[5].bl, src1[5].d); - dst[6].d = vec_andc (src0[6].bll, src1[6].d); - dst[7].d = vec_andc (src0[7].d, src1[7].bll); - dst[8].bi = vec_andc (src0[8].bi, src1[8].bi); - dst[9].bs = vec_andc (src0[9].bs, src1[9].bs); - dst[10].bc = vec_andc (src0[10].bc, src1[10].bc); - dst[11].f = vec_andc (src0[11].f, src1[11].f); - dst[12].f = vec_andc (src0[12].bi, src1[12].f); - dst[13].f = vec_andc (src0[13].f, src1[13].bi); - dst[14].d = vec_andc (src0[14].bll, src1[14].d); - dst[15].d = vec_andc (src0[15].d, src1[15].bll); - - dst[16].d = vec_nor (src0[16].d, src1[16].d); - dst[17].f = vec_nor (src0[17].f, src1[17].f); - dst[18].bi = vec_nor (src0[18].bi, src1[18].bi); - dst[19].bs = vec_nor (src0[19].bs, src1[19].bs); - dst[20].bc = vec_nor (src0[20].bc, src1[20].bc); - - dst[21].d = vec_or (src0[21].d, src1[21].d); - dst[22].d = vec_or (src0[22].d, src1[22].bl); - dst[23].d = vec_or (src0[23].bl, src1[23].d); - dst[24].d = vec_or (src0[24].bll, src1[24].d); - dst[25].d = vec_or (src0[25].d, src1[25].bll); - dst[26].f = vec_or (src0[26].f, src1[26].f); - dst[27].bi = vec_or (src0[27].bi, src1[27].bi); - dst[28].bs = vec_or (src0[28].bs, src1[28].bs); - dst[29].bc = vec_or (src0[29].bc, src1[29].bc); - - dst[30].d = vec_xor (src0[30].d, src1[30].d); - dst[31].d = vec_xor (src0[31].d, src1[31].bl); - dst[32].d = vec_xor (src0[32].bl, src1[32].d); -} - -void -func_cmp (opnd_t *dst, opnd_t *src0, opnd_t *src1) -{ - dst[0].bl = vec_cmpeq (src0[0].d, src1[0].d); - dst[1].bl = vec_cmpgt (src0[1].d, src1[1].d); - dst[2].bl = vec_cmpge (src0[2].d, src1[2].d); - dst[3].bl = vec_cmplt (src0[3].d, src1[3].d); - dst[4].bl = vec_cmple (src0[4].d, src1[4].d); -} - -void -func_all_cmp (int *dst, opnd_t *src0, opnd_t *src1) -{ - dst[0] = vec_all_eq (src0[0].d, src1[0].d); - dst[1] = vec_all_ge (src0[1].d, src1[1].d); - dst[2] = vec_all_gt (src0[2].d, src1[2].d); - dst[3] = vec_all_le (src0[3].d, src1[3].d); - dst[4] = vec_all_lt (src0[4].d, src1[4].d); - dst[5] = vec_all_nan (src0[5].d); - dst[6] = vec_all_ne (src0[6].d, src1[6].d); - dst[7] = vec_all_nge (src0[7].d, src1[7].d); - dst[8] = vec_all_ngt (src0[8].d, src1[8].d); - dst[9] = vec_all_nle (src0[9].d, src1[9].d); - dst[10] = vec_all_nlt (src0[10].d, src1[10].d); - dst[11] = vec_all_numeric (src0[11].d); - dst[12] = vec_any_eq (src0[12].d, src1[12].d); - dst[13] = vec_any_ge (src0[13].d, src1[13].d); - dst[14] = vec_any_gt (src0[14].d, src1[14].d); - dst[15] = vec_any_le (src0[15].d, src1[15].d); - dst[16] = vec_any_lt (src0[16].d, src1[16].d); - dst[17] = vec_any_nan (src0[17].d); - dst[18] = vec_any_ne (src0[18].d, src1[18].d); - dst[19] = vec_any_nge (src0[19].d, src1[19].d); - dst[20] = vec_any_ngt (src0[20].d, src1[20].d); - dst[21] = vec_any_nle (src0[21].d, src1[21].d); - dst[22] = vec_any_nlt (src0[22].d, src1[22].d); - dst[23] = vec_any_numeric (src0[23].d); -} - -void -func_3op (opnd_t *dst, opnd_t *src0, opnd_t *src1, opnd_t *src2) -{ - dst[0].d = vec_madd (src0[0].d, src1[0].d, src2[0].d); - dst[1].d = vec_msub (src0[1].d, src1[1].d, src2[1].d); - dst[2].d = vec_nmadd (src0[2].d, src1[2].d, src2[2].d); - dst[3].d = vec_nmsub (src0[3].d, src1[3].d, src2[3].d); - - dst[4].f = vec_madd (src0[4].f, src1[4].f, src2[4].f); - dst[5].f = vec_msub (src0[5].f, src1[5].f, src2[5].f); - dst[6].f = vec_nmsub (src0[6].f, src1[6].f, src2[6].f); - dst[7].f = vec_nmadd (src0[7].f, src1[7].f, src2[7].f); - -#if defined (__BIG_ENDIAN__) || defined (_ARCH_PWR9) - dst[8].d = vec_perm (src0[8].d, src1[8].d, src2[8].uc); -#else - dst[8].d = vec_perm (src0[8].d, src1[8].d, ~src2[8].uc); -#endif - - dst[9].d = vec_sel (src0[9].d, src1[9].d, src2[9].d); - dst[10].d = vec_sel (src0[10].d, src1[10].d, src2[10].bl); - - dst[11].si = vec_msums(src0[11].ss, src1[11].ss, src2[11].si); - dst[12].ui = vec_msums(src0[12].us, src1[12].us, src2[12].ui); -} diff --git a/gcc/testsuite/gcc.target/powerpc/vsx-vector-6.p7.c b/gcc/testsuite/gcc.target/powerpc/vsx-vector-6.p7.c deleted file mode 100644 index ff560dd8d4f..00000000000 --- a/gcc/testsuite/gcc.target/powerpc/vsx-vector-6.p7.c +++ /dev/null @@ -1,43 +0,0 @@ -/* { dg-do compile { target lp64 } } */ -/* { dg-skip-if "" { powerpc*-*-darwin* } } */ -/* { dg-require-effective-target powerpc_vsx_ok } */ -/* { dg-options "-O2 -mdejagnu-cpu=power7" } */ - -/* Source code for the test in vsx-vector-6.h */ -#include "vsx-vector-6.h" - -/* { dg-final { scan-assembler-times {\mvmaxub\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mvmsumshs\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mvmsumuhs\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mvperm\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mxvabsdp\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mxvadddp\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mxvcmpeqdp\M} 9 } } */ -/* { dg-final { scan-assembler-times {\mxvcmpgedp\M} 10 } } */ -/* { dg-final { scan-assembler-times {\mxvcmpgtdp\M} 10 } } */ -/* { dg-final { scan-assembler-times {\mxvdivdp\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mxvmadd[am]dp\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mxvmadd[am]sp\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mxvmaxdp\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mxvmindp\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mxvmsub[am]dp\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mxvmsub[am]sp\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mxvmuldp\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mxvnmadd[am]dp\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mxvnmadd[am]sp\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mxvnmsub[am]dp\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mxvnmsub[am]sp\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mxvrdpi\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mxvrdpic\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mxvrdpim\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mxvrdpip\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mxvrdpiz\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mxvrspiz\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mxvsqrtdp\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mxvsubdp\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mxxland\M} 3 } } */ -/* { dg-final { scan-assembler-times {\mxxlandc\M} 13 } } */ -/* { dg-final { scan-assembler-times {\mxxlnor\M} 5 } } */ -/* { dg-final { scan-assembler-times {\mxxlor\M} 9 } } */ -/* { dg-final { scan-assembler-times {\mxxlxor\M} 3 } } */ -/* { dg-final { scan-assembler-times {\mxxsel\M} 2 } } */ diff --git a/gcc/testsuite/gcc.target/powerpc/vsx-vector-6.p8.c b/gcc/testsuite/gcc.target/powerpc/vsx-vector-6.p8.c deleted file mode 100644 index 49f5bf52af5..00000000000 --- a/gcc/testsuite/gcc.target/powerpc/vsx-vector-6.p8.c +++ /dev/null @@ -1,43 +0,0 @@ -/* { dg-do compile { target lp64 } } */ -/* { dg-skip-if "" { powerpc*-*-darwin* } } */ -/* { dg-require-effective-target powerpc_p8vector_ok } */ -/* { dg-options "-O2 -mdejagnu-cpu=power8" } */ - -/* Source code for the test in vsx-vector-6.h */ -#include "vsx-vector-6.h" - -/* { dg-final { scan-assembler-times {\mvmaxub\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mvmsumshs\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mvmsumuhs\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mvperm\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mxvabsdp\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mxvadddp\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mxvcmpeqdp\M} 9 } } */ -/* { dg-final { scan-assembler-times {\mxvcmpgedp\M} 10 } } */ -/* { dg-final { scan-assembler-times {\mxvcmpgtdp\M} 10 } } */ -/* { dg-final { scan-assembler-times {\mxvdivdp\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mxvmadd[am]dp\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mxvmadd[am]sp\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mxvmaxdp\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mxvmindp\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mxvmsub[am]dp\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mxvmsub[am]sp\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mxvmuldp\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mxvnmadd[am]dp\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mxvnmadd[am]sp\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mxvnmsub[am]dp\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mxvnmsub[am]sp\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mxvrdpi\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mxvrdpic\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mxvrdpim\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mxvrdpip\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mxvrdpiz\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mxvrspiz\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mxvsqrtdp\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mxvsubdp\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mxxland\M} 3 } } */ -/* { dg-final { scan-assembler-times {\mxxlandc\M} 13 } } */ -/* { dg-final { scan-assembler-times {\mxxlnor\M} 5 } } */ -/* { dg-final { scan-assembler-times {\mxxlor\M} 9 } } */ -/* { dg-final { scan-assembler-times {\mxxlxor\M} 3 } } */ -/* { dg-final { scan-assembler-times {\mxxsel\M} 2 } } */ diff --git a/gcc/testsuite/gcc.target/powerpc/vsx-vector-6.p9.c b/gcc/testsuite/gcc.target/powerpc/vsx-vector-6.p9.c deleted file mode 100644 index 3fdd9f62a4c..00000000000 --- a/gcc/testsuite/gcc.target/powerpc/vsx-vector-6.p9.c +++ /dev/null @@ -1,42 +0,0 @@ -/* { dg-do compile { target lp64 } } */ -/* { dg-skip-if "" { powerpc*-*-darwin* } } */ -/* { dg-require-effective-target powerpc_p9vector_ok } */ -/* { dg-options "-O2 -mdejagnu-cpu=power9" } */ - -/* Source code for the test in vsx-vector-6.h */ -#include "vsx-vector-6.h" - -/* { dg-final { scan-assembler-times {\mvmaxub\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mvmsumshs\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mvmsumuhs\M} 1 } } */ -/* { dg-final { scan-assembler-times {\m(?:v|xx)permr?\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mxvabsdp\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mxvadddp\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mxvcmpeqdp\M} 9 } } */ -/* { dg-final { scan-assembler-times {\mxvcmpgedp\M} 10 } } */ -/* { dg-final { scan-assembler-times {\mxvcmpgtdp\M} 10 } } */ -/* { dg-final { scan-assembler-times {\mxvdivdp\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mxvmadd[am]dp\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mxvmadd[am]sp\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mxvmaxdp\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mxvmindp\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mxvmsub[am]sp\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mxvmuldp\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mxvnmadd[am]dp\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mxvnmadd[am]sp\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mxvnmsub[am]dp\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mxvnmsub[am]sp\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mxvrdpi\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mxvrdpic\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mxvrdpim\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mxvrdpip\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mxvrdpiz\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mxvrspiz\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mxvsqrtdp\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mxvmsub[am]dp\M} 1 } } */ -/* { dg-final { scan-assembler-times {\mxxland\M} 3 } } */ -/* { dg-final { scan-assembler-times {\mxxlandc\M} 13 } } */ -/* { dg-final { scan-assembler-times {\mxxlnor\M} 5 } } */ -/* { dg-final { scan-assembler-times {\mxxlor\M} 9 } } */ -/* { dg-final { scan-assembler-times {\mxxlxor\M} 3 } } */ -/* { dg-final { scan-assembler-times {\mxxsel\M} 2 } } */