From patchwork Wed Jun 21 22:46:05 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Carl Love X-Patchwork-Id: 111334 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a59:994d:0:b0:3d9:f83d:47d9 with SMTP id k13csp4692940vqr; Wed, 21 Jun 2023 15:47:03 -0700 (PDT) X-Google-Smtp-Source: ACHHUZ7IM3VqsU3jyj151tILCfT+jmPiKyhrp6+CxPap8LmbKn+I318pbK8EbThUTgoL6whv09fL X-Received: by 2002:a17:906:4793:b0:974:32e:7de9 with SMTP id cw19-20020a170906479300b00974032e7de9mr15524383ejc.56.1687387623563; Wed, 21 Jun 2023 15:47:03 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1687387623; cv=none; d=google.com; s=arc-20160816; b=gqeXbHX3smpi7d0iUPA5MLA5rNeQZUKJ8PzWwnKZi+EWIwxqkfB+x8STO9FrgDHmpP XVFkizI17VGP9YjrppIJprqyR13+4EAcLXYgD7o5xho3rVDHaP/7lhmmAFjEizc7a37M J9aqtncXB+Fu3S68oJuJ6BXo+zK1+UxfB+Wo9Ccd7orWSlmGAWGve+iweQLqC+a4rrro 2bIy5+o1K030udc1HT8CJ8L+KHXdRJ5wjnID729U2yXfuSOwJAP9NKIUqI0hIqLWamwq mNC6aQXYFJjbpD8JIIzqmLfvR3RdYwb+DAp87pHBQnvh2VKJ546aiTo0UQlc+aackfof zkcQ== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=sender:errors-to:reply-to:from:list-subscribe:list-help:list-post :list-archive:list-unsubscribe:list-id:precedence :content-transfer-encoding:mime-version:date:cc:to:subject :message-id:dmarc-filter:delivered-to:dkim-signature:dkim-filter; bh=e3llqfbzukpPS+ziF6RRgUkuRcap4jprTkotlnK5qhE=; b=oQ4WnDvDxjqYUp+icUe2LRv6uJDA138UZ8BgZDFxzutxc2GCBQx3IIMZlGKCmLG7t6 LC8ldixbrj008AYHknAgUgmRBnVfAzK5ql1+qIUEGcuIf29yZt/7IAEd3dVbI9jtMz+D 4SPTftGUK2cN6VtIcT/7R9Hq6Pysafakqxz4T9Uz12hv9TmY2i1Rc7+NL56WEUjVs3Ra 7S2xPauxKbzfku4yfzT9QP6CNiOpm3cj4AkA4z3Dtz4lIzwj1BRAjOsYi2+CHdT6pwJd fFr8Dk27hWSSIIiKhqkTlmyy3Ep48a3YZDD0XpX9ikrl3jve9g58UcJep6bpka2FhoB3 Ujkw== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@gcc.gnu.org header.s=default header.b=QcAVVnEP; spf=pass (google.com: domain of gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org designates 2620:52:3:1:0:246e:9693:128c as permitted sender) smtp.mailfrom="gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org"; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=gnu.org Received: from sourceware.org (server2.sourceware.org. [2620:52:3:1:0:246e:9693:128c]) by mx.google.com with ESMTPS id d2-20020a17090648c200b0098852b6b713si177555ejt.826.2023.06.21.15.47.03 for (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 21 Jun 2023 15:47:03 -0700 (PDT) Received-SPF: pass (google.com: domain of gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org designates 2620:52:3:1:0:246e:9693:128c as permitted sender) client-ip=2620:52:3:1:0:246e:9693:128c; Authentication-Results: mx.google.com; dkim=pass header.i=@gcc.gnu.org header.s=default header.b=QcAVVnEP; spf=pass (google.com: domain of gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org designates 2620:52:3:1:0:246e:9693:128c as permitted sender) smtp.mailfrom="gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org"; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=gnu.org Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id DB45E3858C1F for ; Wed, 21 Jun 2023 22:47:01 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org DB45E3858C1F DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gcc.gnu.org; s=default; t=1687387621; bh=e3llqfbzukpPS+ziF6RRgUkuRcap4jprTkotlnK5qhE=; h=Subject:To:Cc:Date:List-Id:List-Unsubscribe:List-Archive: List-Post:List-Help:List-Subscribe:From:Reply-To:From; b=QcAVVnEPV4wY6CfahuQBOlH8riwYzwhRxtX4FiVr9npzZ5ivaXjKN15POYWOFZuqu VgXUM6HuZrtSD3NzF+7qioSZwqMMAmNei1Z4VjZs+cmOStXug6VKUt1W4fZNNvMDqi +VzHkyUQpIk6gA+GKpzqyX8D0/hhk9joFsS9eA50= X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from mx0b-001b2d01.pphosted.com (mx0b-001b2d01.pphosted.com [148.163.158.5]) by sourceware.org (Postfix) with ESMTPS id 1BE8D3858D35 for ; Wed, 21 Jun 2023 22:46:11 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 1BE8D3858D35 Received: from pps.filterd (m0356516.ppops.net [127.0.0.1]) by mx0a-001b2d01.pphosted.com (8.17.1.19/8.17.1.19) with ESMTP id 35LMk4af028407; Wed, 21 Jun 2023 22:46:10 GMT Received: from pps.reinject (localhost [127.0.0.1]) by mx0a-001b2d01.pphosted.com (PPS) with ESMTPS id 3rca0cr9s7-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Wed, 21 Jun 2023 22:46:09 +0000 Received: from m0356516.ppops.net (m0356516.ppops.net [127.0.0.1]) by pps.reinject (8.17.1.5/8.17.1.5) with ESMTP id 35LMambG026776; Wed, 21 Jun 2023 22:46:09 GMT Received: from ppma03wdc.us.ibm.com (ba.79.3fa9.ip4.static.sl-reverse.com [169.63.121.186]) by mx0a-001b2d01.pphosted.com (PPS) with ESMTPS id 3rca0cr9s1-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Wed, 21 Jun 2023 22:46:09 +0000 Received: from pps.filterd (ppma03wdc.us.ibm.com [127.0.0.1]) by ppma03wdc.us.ibm.com (8.17.1.19/8.17.1.19) with ESMTP id 35LJT4YA016016; Wed, 21 Jun 2023 22:46:08 GMT Received: from smtprelay07.dal12v.mail.ibm.com ([9.208.130.99]) by ppma03wdc.us.ibm.com (PPS) with ESMTPS id 3r94f66h5r-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Wed, 21 Jun 2023 22:46:08 +0000 Received: from smtpav01.dal12v.mail.ibm.com (smtpav01.dal12v.mail.ibm.com [10.241.53.100]) by smtprelay07.dal12v.mail.ibm.com (8.14.9/8.14.9/NCO v10.0) with ESMTP id 35LMk6s936241952 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK); Wed, 21 Jun 2023 22:46:07 GMT Received: from smtpav01.dal12v.mail.ibm.com (unknown [127.0.0.1]) by IMSVA (Postfix) with ESMTP id D14B15805D; Wed, 21 Jun 2023 22:46:06 +0000 (GMT) Received: from smtpav01.dal12v.mail.ibm.com (unknown [127.0.0.1]) by IMSVA (Postfix) with ESMTP id 3E58658058; Wed, 21 Jun 2023 22:46:06 +0000 (GMT) Received: from li-e362e14c-2378-11b2-a85c-87d605f3c641.ibm.com (unknown [9.61.18.149]) by smtpav01.dal12v.mail.ibm.com (Postfix) with ESMTP; Wed, 21 Jun 2023 22:46:06 +0000 (GMT) Message-ID: <6216c458dbb7163fea3d823cec39ef0cc9543b76.camel@us.ibm.com> Subject: [PATCH ver 2] rs6000: Update the vsx-vector-6.* tests. To: "Kewen.Lin" , Segher Boessenkool , David Edelsohn , gcc-patches@gcc.gnu.org Cc: Peter Bergner , cel@us.ibm.com Date: Wed, 21 Jun 2023 15:46:05 -0700 X-Mailer: Evolution 3.28.5 (3.28.5-18.el8) Mime-Version: 1.0 X-TM-AS-GCONF: 00 X-Proofpoint-GUID: 2jiGh7I-TQ0r--Z4Naj_LIi0VEw8ScPL X-Proofpoint-ORIG-GUID: S7yspaxQtfhp8GiJQg9jQDsb6nfTdE5J X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.254,Aquarius:18.0.957,Hydra:6.0.591,FMLib:17.11.176.26 definitions=2023-06-21_12,2023-06-16_01,2023-05-22_02 X-Proofpoint-Spam-Details: rule=outbound_notspam policy=outbound score=0 suspectscore=0 impostorscore=0 malwarescore=0 mlxlogscore=999 priorityscore=1501 spamscore=0 clxscore=1015 phishscore=0 lowpriorityscore=0 bulkscore=0 mlxscore=0 adultscore=0 classifier=spam adjust=0 reason=mlx scancount=1 engine=8.12.0-2305260000 definitions=main-2306210188 X-Spam-Status: No, score=-11.4 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+ouuuleilei=gmail.com@gcc.gnu.org Sender: "Gcc-patches" X-getmail-retrieved-from-mailbox: =?utf-8?q?INBOX?= X-GMAIL-THRID: =?utf-8?q?1767353589742600217?= X-GMAIL-MSGID: =?utf-8?q?1769354164982921152?= GCC maintainers: Ver 2. Switched to using code macros to generate the call to the builtin and test the results. Added in instruction counts for the key instruction for the builtin. Moved the tests into an additional function call to ensure the compile doesn't replace the builtin call code with the statically computed results. The compiler was doing this for a few of the simpler tests. 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. Tested the patch on Power 8 LE/BE, Power 9 LE/BE and Power 10 LE with no regresions. 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 | 156 ++++++++++ .../powerpc/vsx-vector-6-func-2lop.c | 223 ++++++++++++++ .../powerpc/vsx-vector-6-func-2op.c | 142 +++++++++ .../powerpc/vsx-vector-6-func-3op.c | 273 ++++++++++++++++++ .../powerpc/vsx-vector-6-func-cmp-all.c | 205 +++++++++++++ .../powerpc/vsx-vector-6-func-cmp.c | 130 +++++++++ .../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, 1129 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..0d4e237673b --- /dev/null +++ b/gcc/testsuite/gcc.target/powerpc/vsx-vector-6-func-1op.c @@ -0,0 +1,156 @@ +/* { dg-do run { target lp64 } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } } */ +/* { dg-options "-O2 -save-temps" } */ + +/* Functional test of the one operand vector builtins. */ + +#include +#include +#include + +#define DEBUG 0 + +void abort (void); + + /* Macro to check the results for the various floating point argument tests. + */ +#define FLOAT_CHECK(NAME) \ + f_result = vec_##NAME(f_src); \ + \ + if ((f_result[0] != f_##NAME##_expected[0]) || \ + (f_result[1] != f_##NAME##_expected[1]) || \ + (f_result[2] != f_##NAME##_expected[2]) || \ + (f_result[3] != f_##NAME##_expected[3])) \ + { \ + if (DEBUG) { \ + printf("ERROR: vec_%s (float) expected value does not match\n", \ + #NAME); \ + printf(" expected[0] = %f; result[0] = %f\n", \ + f_##NAME##_expected[0], f_result[0]); \ + printf(" expected[1] = %f; result[1] = %f\n", \ + f_##NAME##_expected[1], f_result[1]); \ + printf(" expected[2] = %f; result[2] = %f\n", \ + f_##NAME##_expected[2], f_result[2]); \ + printf(" expected[3] = %f; result[3] = %f\n", \ + f_##NAME##_expected[3], f_result[3]); \ + } else \ + abort(); \ + } + + /* Macro to check the results for the various double point argument tests. + */ +#define DOUBLE_CHECK(NAME) \ + d_result = vec_##NAME(d_src); \ + \ + if ((d_result[0] != d_##NAME##_expected[0]) \ + || (d_result[1] != d_##NAME##_expected[1])) \ + { \ + if (DEBUG) \ + { \ + printf("ERROR: vec_%s (double) expected value does not match\n", \ + #NAME); \ + printf(" expected[0] = %f; result[0] = %f\n", \ + d_##NAME##_expected[0], d_result[0]); \ + printf(" expected[1] = %f; result[1] = %f\n", \ + d_##NAME##_expected[1], d_result[1]); \ + } \ + else \ + abort(); \ + } + +void +float_tests (vector float f_src, vector float f_abs_expected, + vector float f_ceil_expected, vector float f_floor_expected, + vector float f_nearbyint_expected, vector float f_rint_expected, + vector float f_sqrt_expected, vector float f_trunc_expected) +{ + /* Some of the tests are simple enough that the compiler computes the answer + at compile time. Put the tests in a function so the compiler will generate + the code needed to perform the test. */ + vector float f_result; + + FLOAT_CHECK (abs) + FLOAT_CHECK (ceil) + FLOAT_CHECK (floor) + FLOAT_CHECK (nearbyint) + FLOAT_CHECK (rint) + FLOAT_CHECK (abs) + FLOAT_CHECK (trunc) +} + +void +double_tests (vector double d_src, vector double d_abs_expected, + vector double d_ceil_expected, vector double d_floor_expected, + vector double d_nearbyint_expected, vector double d_rint_expected, + vector double d_sqrt_expected, vector double d_trunc_expected) +{ + /* Some of the tests are simple enough that the compiler computes the answer + at compile time. Put the tests in a function so the compiler will generate + the code needed to perform the test. */ + vector double d_result; + + DOUBLE_CHECK (abs) + DOUBLE_CHECK (ceil) + DOUBLE_CHECK (floor) + DOUBLE_CHECK (nearbyint) + DOUBLE_CHECK (rint) + DOUBLE_CHECK (abs) + DOUBLE_CHECK (trunc) + + /* Need to make sure the arguments for sqrt are always positive. Do this + test last as we have to change the input for the test. */ + d_src = vec_abs (d_src); + DOUBLE_CHECK (sqrt) +} + +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_abs_src; + 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}; + + + /* Floating point argument tests. */ + float_tests (f_src, f_abs_expected, f_ceil_expected, f_floor_expected, + f_nearbyint_expected, f_rint_expected, f_sqrt_expected, + f_trunc_expected); + + /* Double argument tests. */ + double_tests (d_src, d_abs_expected, d_ceil_expected, d_floor_expected, + d_nearbyint_expected, d_rint_expected, d_sqrt_expected, + d_trunc_expected); + + return 0; +} + +/* { dg-final { scan-assembler-times {\mxvabssp\M} 1 } } */ +/* { dg-final { scan-assembler-times {\mxvrspip\M} 1 } } */ +/* { dg-final { scan-assembler-times {\mxvrspim\M} 1 } } */ +/* { dg-final { scan-assembler-times {\mxvrspi\M} 1 } } */ +/* { dg-final { scan-assembler-times {\mxvrspic\M} 1 } } */ +/* { dg-final { scan-assembler-times {\mxvrspiz\M} 1 } } */ +/* { dg-final { scan-assembler-times {\mxvabsdp\M} 1 } } */ +/* { dg-final { scan-assembler-times {\mxvrdpip\M} 1 } } */ +/* { dg-final { scan-assembler-times {\mxvrdpim\M} 1 } } */ +/* { dg-final { scan-assembler-times {\mxvrdpi\M} 1 } } */ +/* { dg-final { scan-assembler-times {\mxvrdpic\M} 1 } } */ +/* { dg-final { scan-assembler-times {\mxvrdpiz\M} 1 } } */ +/* { dg-final { scan-assembler-times {\mxvsqrtdp\M} 1 } } */ 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..2ce171a9500 --- /dev/null +++ b/gcc/testsuite/gcc.target/powerpc/vsx-vector-6-func-2lop.c @@ -0,0 +1,223 @@ +/* { dg-do run { target lp64 } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } } */ +/* { dg-options "-O2 -save-temps" } */ + +/* Functional test of the two operand logical vector builtins. */ + +#include +#include +#include + +#define DEBUG 0 + +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; + +void abort (void); + +#define FLOAT_CHECK(NAME) \ + f_result = vec_##NAME (f_src_a, f_src_b); \ + if ((f_result[0] != f_##NAME##_expected[0]) \ + || (f_result[1] != f_##NAME##_expected[1]) \ + || (f_result[2] != f_##NAME##_expected[2]) \ + || (f_result[3] != f_##NAME##_expected[3])) \ + { \ + if (DEBUG) \ + { \ + printf("ERROR: vec_%s (float) expected value does not match\n", \ + #NAME); \ + 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(); \ + } + +#define DOUBLE_CHECK(NAME) \ + d_result = vec_##NAME (d_src_a, d_src_b); \ + if ((d_result[0] != d_##NAME##_expected[0]) \ + || (d_result[1] != d_##NAME##_expected[1])) \ + { \ + if (DEBUG) \ + { \ + printf("ERROR: vec_%s (double) expected value does not match\n", \ + #NAME); \ + 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(); \ + } + +void +float_tests (vector float f_src_a, vector float f_src_b, + vector float f_and_expected, vector float f_andc_expected, + vector float f_nor_expected, vector float f_or_expected, + vector float f_xor_expected) +{ + /* Some of the tests are simple enough that the compiler computes the answer + at compile time. Put the tests in a function so the compiler will generate + the code needed to perform the test. */ + vector float f_result; + int i; + + FLOAT_CHECK (and) + FLOAT_CHECK (andc) + FLOAT_CHECK (nor) + FLOAT_CHECK (or) + FLOAT_CHECK (xor) +} + +void +double_tests (vector double d_src_a, vector double d_src_b, + vector double d_and_expected, vector double d_andc_expected, + vector double d_nor_expected, vector double d_or_expected, + vector double d_xor_expected) +{ + /* Some of the tests are simple enough that the compiler computes the answer + at compile time. Put the tests in a function so the compiler will generate + the code needed to perform the test. */ + vector double d_result; + int i; + + DOUBLE_CHECK (and) + DOUBLE_CHECK (andc) + DOUBLE_CHECK (nor) + DOUBLE_CHECK (or) + DOUBLE_CHECK (xor) +} + +int +main () { + int i; + + 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_and_expected, f_andc_expected, f_nor_expected, f_or_expected; + vector float f_xor_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_and_expected, d_andc_expected, d_nor_expected; + vector double d_or_expected, d_xor_expected; + + /* Calculate expected results. */ + /* 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_and_expected[i] = conv_exp.f[i]; + } + + /* 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_andc_expected[i] = conv_exp.f[i]; + } + + /* NOR, max */ + 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_nor_expected[i] = conv_exp.f[i]; + } + + /* OR, 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_or_expected[i] = conv_exp.f[i]; + } + + /* XOR, 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_xor_expected[i] = conv_exp.f[i]; + } + + /* AND, double */ + 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_and_expected[i] = conv_exp.d[i]; + } + + /* ANDC, double */ + 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_andc_expected[i] = conv_exp.d[i]; + } + + /* NOR, double */ + 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_nor_expected[i] = conv_exp.d[i]; + } + + /* OR, double */ + 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_or_expected[i] = conv_exp.d[i]; + } + + /* XOR, double */ + 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_xor_expected[i] = conv_exp.d[i]; + } + + /* Run tests. */ + float_tests (f_src_a, f_src_b, f_and_expected, f_andc_expected, + f_nor_expected, f_or_expected, f_xor_expected); + double_tests (d_src_a, d_src_b, d_and_expected, d_andc_expected, + d_nor_expected, d_or_expected, d_xor_expected); + + return 0; +} + +/* { dg-final { scan-assembler-times {\mxxland\M} 2 } } */ +/* { dg-final { scan-assembler-times {\mxxlandc\M} 2 } } */ +/* { dg-final { scan-assembler-times {\mxxlnor\M} 2 } } */ +/* { dg-final { scan-assembler-times {\mxxlxor\M} 2 } } */ + +/* { dg-final { scan-assembler-times {\mxxlor\M} 2 { target le }} } */ +/* { dg-final { scan-assembler-times {\mxxlor\M} 12 { target be }} } */ 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..3eb04185631 --- /dev/null +++ b/gcc/testsuite/gcc.target/powerpc/vsx-vector-6-func-2op.c @@ -0,0 +1,142 @@ +/* { dg-do run { target lp64 } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } } */ +/* { dg-options "-O2 -save-temps" } */ +/* Functional test of the two operand vector builtins. */ + +#include +#include +#include + +#define DEBUG 0 + +#define FLOAT_CHECK(NAME) \ + f_result = vec_##NAME (f_src_a, f_src_b); \ + \ + if ((f_result[0] != f_##NAME##_expected[0]) \ + || (f_result[1] != f_##NAME##_expected[1]) \ + || (f_result[2] != f_##NAME##_expected[2]) \ + || (f_result[3] != f_##NAME##_expected[3])) \ + { \ + if (DEBUG) \ + { \ + printf("ERROR: vec_%s (float) expected value does not match\n", \ + #NAME); \ + printf(" expected[0] = %f; result[0] = %f\n", \ + f_##NAME##_expected[0], f_result[0]); \ + printf(" expected[1] = %f; result[1] = %f\n", \ + f_##NAME##_expected[1], f_result[1]); \ + printf(" expected[2] = %f; result[2] = %f\n", \ + f_##NAME##_expected[2], f_result[2]); \ + printf(" expected[3] = %f; result[3] = %f\n", \ + f_##NAME##_expected[3], f_result[3]); \ + } \ + else \ + abort(); \ + } + +#define DOUBLE_CHECK(NAME) \ + d_result = vec_##NAME (d_src_a, d_src_b); \ + if ((d_result[0] != d_##NAME##_expected[0]) \ + || (d_result[1] != d_##NAME##_expected[1])) \ + { \ + if (DEBUG) \ + { \ + printf("ERROR: vec_%s(double) expected value does not match\n", \ + #NAME); \ + printf(" expected[0] = %f; result[0] = %f\n", \ + d_##NAME##_expected[0], d_result[0]); \ + printf(" expected[1] = %f; result[1] = %f\n", \ + d_##NAME##_expected[1], d_result[1]); \ + } \ + else \ + abort(); \ + } + +void abort (void); + +void +float_tests (vector float f_src_a, vector float f_src_b, + vector float f_add_expected, vector float f_div_expected, + vector float f_max_expected, vector float f_min_expected, + vector float f_mul_expected, vector float f_sub_expected) +{ + /* These tests are fairly simple, the compiler will compute the ansers at + compile time if the tests are not put into a function. */ + vector float f_result; + + FLOAT_CHECK (add) + FLOAT_CHECK (div) + FLOAT_CHECK (max) + FLOAT_CHECK (min) + FLOAT_CHECK (mul) + FLOAT_CHECK (sub) +} + +void +double_tests (vector double d_src_a, vector double d_src_b, + vector double d_add_expected, vector double d_div_expected, + vector double d_max_expected, vector double d_min_expected, + vector double d_mul_expected, vector double d_sub_expected) +{ + /* These tests are fairly simple, the compiler will compute the ansers at + compile time if the tests are not put into a function. */ + vector double d_result; + + DOUBLE_CHECK (add) + DOUBLE_CHECK (div) + DOUBLE_CHECK (max) + DOUBLE_CHECK (min) + DOUBLE_CHECK (mul) + DOUBLE_CHECK (sub) +} + +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_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_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}; + + /* Two argument float tests. */ + float_tests (f_src_a, f_src_b, f_add_expected, f_div_expected, f_max_expected, + f_min_expected, f_mul_expected, f_sub_expected); + + /* Two argument double tests. */ + double_tests (d_src_a, d_src_b, d_add_expected, d_div_expected, + d_max_expected, d_min_expected, d_mul_expected, d_sub_expected); + + return 0; +} + +/* { dg-final { scan-assembler-times {\mxvaddsp\M} 1 } } */ +/* { dg-final { scan-assembler-times {\mxvdivsp\M} 1 } } */ +/* { dg-final { scan-assembler-times {\mxvmulsp\M} 1 } } */ +/* { dg-final { scan-assembler-times {\mxvsubsp\M} 1 } } */ +/* { dg-final { scan-assembler-times {\mxvadddp\M} 1 } } */ +/* { dg-final { scan-assembler-times {\mxvdivdp\M} 1 } } */ +/* { dg-final { scan-assembler-times {\mxvmindp\M} 1 } } */ +/* { dg-final { scan-assembler-times {\mxvmuldp\M} 1 } } */ +/* { dg-final { scan-assembler-times {\mxvsubdp\M} 1 } } */ + +/* { dg-final { scan-assembler-times {\mxvmaxsp\M} 2 {target le} } } */ +/* { dg-final { scan-assembler-times {\mxvmaxsp\M} 1 {target be} } } */ + +/* { dg-final { scan-assembler-times {\mxvminsp\M} 2 {target le} } } */ +/* { dg-final { scan-assembler-times {\mxvminsp\M} 1 {target be} } } */ + +/* { dg-final { scan-assembler-times {\mxvmaxdp\M} 2 {target le} } } */ +/* { dg-final { scan-assembler-times {\mxvmaxdp\M} 1 {target be} } } */ 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..b4069ec2c7b --- /dev/null +++ b/gcc/testsuite/gcc.target/powerpc/vsx-vector-6-func-3op.c @@ -0,0 +1,273 @@ +/* { dg-do run { target lp64 } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } } */ +/* { dg-options "-O2 -save-temps" } */ + +/* Functional test of the three operand vector builtins. */ + +#include +#include +#include + +#define DEBUG 0 + +#define FLOAT_CHECK(NAME) \ + f_result = vec_##NAME (f_src_a, f_src_b, f_src_c); \ + \ + if ((f_result[0] != f_##NAME##_expected[0]) \ + || (f_result[1] != f_##NAME##_expected[1]) \ + || (f_result[2] != f_##NAME##_expected[2]) \ + || (f_result[3] != f_##NAME##_expected[3])) \ + { \ + if (DEBUG) \ + { \ + printf("ERROR: vec_%s (float) expected value does not match\n", \ + #NAME); \ + printf(" expected[0] = %f; result[0] = %f\n", \ + f_##NAME##_expected[0], f_result[0]); \ + printf(" expected[1] = %f; result[1] = %f\n", \ + f_##NAME##_expected[1], f_result[1]); \ + printf(" expected[2] = %f; result[2] = %f\n", \ + f_##NAME##_expected[2], f_result[2]); \ + printf(" expected[3] = %f; result[3] = %f\n", \ + f_##NAME##_expected[3], f_result[3]); \ + } \ + else \ + abort(); \ + } + +#define DOUBLE_CHECK(NAME) \ + d_result = vec_##NAME (d_src_a, d_src_b, d_src_c); \ + \ + if ((d_result[0] != d_##NAME##_expected[0]) \ + || (d_result[1] != d_##NAME##_expected[1])) \ + { \ + if (DEBUG) \ + { \ + printf("ERROR: vec_%s (double) expected value does not match\n", \ + #NAME); \ + printf(" expected[0] = %f; result[0] = %f\n", \ + d_##NAME##_expected[0], d_result[0]); \ + printf(" expected[1] = %f; result[1] = %f\n", \ + d_##NAME##_expected[1], d_result[1]); \ + } \ + else \ + abort(); \ + } + +void abort (void); + +void +short_tests (vector short ss_src_a, vector short ss_src_b, vector int si_src_c, + vector unsigned short us_src_a, vector unsigned short us_src_b, + vector unsigned int ui_src_c, vector int si_expected, + vector unsigned int ui_expected) +{ + /* These tests were put into a function to ensure the compiler doesn't try to + compute the results at compile time. */ + vector int si_result; + vector unsigned int ui_result; + + /* Vector 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 +} + +void +float_tests (vector float f_src_a, vector float f_src_b, vector float f_src_c, + vector float f_madd_expected, vector float f_msub_expected) +{ + /* The tests are simple enough that the compiler computes the answer at + compile time. Put the tests in a function so the compiler will generate + the code needed to perform the test. */ + vector float f_result; + + FLOAT_CHECK (madd) + FLOAT_CHECK (msub) +} + +void +double_tests (vector double d_src_a, vector double d_src_b, + vector double d_src_c, vector double d_madd_expected, + vector double d_msub_expected) +{ + /* The tests are simple enough that the compiler computes the answer at + compile time. Put the tests in a function so the compiler will generate + the code needed to perform the test. */ + vector double d_result; + + DOUBLE_CHECK (madd) + DOUBLE_CHECK (msub) +} + +void +vector_sel_test (vector double d_src_a, vector double d_src_b, + vector unsigned long long ull_src_c, + vector bool long long bll_src_c , + vector double d_selectb_expected, + vector double d_selectu_expected) +{ + vector double d_result; + + /* 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_sel (double, unsigned long long) 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_sel (double, bool long long) 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 +} + +void +vector_permute_test (vector double d_src_a, vector double d_src_b, + vector unsigned char uc_src_c, + vector double d_perm_expected) +{ + vector double d_result; + + /* 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_perm (double, 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 + +} + +int +main () { + int i; + + 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_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_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_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_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}; + + + /* Run tests. */ + short_tests (ss_src_a, ss_src_b, si_src_c, us_src_a, us_src_b, + ui_src_c, si_expected, ui_expected); + float_tests (f_src_a, f_src_b, f_src_c, f_madd_expected, f_msub_expected); + double_tests (d_src_a, d_src_b, d_src_c, d_madd_expected, d_msub_expected); + vector_sel_test (d_src_a, d_src_b, ull_src_c, bll_src_c, d_selectb_expected, + d_selectu_expected); + vector_permute_test (d_src_a, d_src_b, uc_src_c, d_perm_expected); + + return 0; +} + +/* { dg-final { scan-assembler-times {\mvmsumshs\M} 1 } } */ +/* { dg-final { scan-assembler-times {\mvmsumuhs\M} 1 } } */ +/* { dg-final { scan-assembler-times {\mxvmaddadp\M} 1 } } */ +/* { dg-final { scan-assembler-times {\mxvmaddasp\M} 2 } } */ +/* { dg-final { scan-assembler-times {\mxvmsubmsp\M} 2 } } */ +/* { dg-final { scan-assembler-times {\mvperm\M} 1 } } */ + + +/* { dg-final { scan-assembler-times {\mxvmsubmdp\M} 1 { target le }} } */ +/* { dg-final { scan-assembler-times {\mxvmsubmdp\M} 2 { target be }} } */ +/* { dg-final { scan-assembler-times {\mxvmsubadp\M} 1 { target le }} } */ +/* { dg-final { scan-assembler-times {\mxvmsubadp\M} 0 { target be }} } */ + +/* { dg-final { scan-assembler-times {\mxxpermdi\M} 17 { target le }} } */ +/* { dg-final { scan-assembler-times {\mxxpermdi\M} 16 { target be }} } */ + +/* { dg-final { scan-assembler-times {\mxxsel\M} 3 { target le }} } */ +/* { dg-final { scan-assembler-times {\mxxsel\M} 2 { target be }} } */ 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..53371d37562 --- /dev/null +++ b/gcc/testsuite/gcc.target/powerpc/vsx-vector-6-func-cmp-all.c @@ -0,0 +1,205 @@ +/* { dg-do run { target lp64 } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } } */ +/* { dg-options "-O2 -save-temps" } */ + +/* Functional test of the vector compare all builtins. */ + +#include +#include +#include +#include + +#define DEBUG 0 + +#define FLOAT_1ARG_CHECK(NAME) \ + f_result = vec_##NAME (f_src_a); \ + \ + if (f_result != f_##NAME##_expected) \ + { \ + if (DEBUG) \ + { \ + printf("ERROR: vec_%s (float) expected value does not match\n", \ + #NAME); \ + printf(" expected = %d; result = %d\n", \ + f_##NAME##_expected, f_result); \ + } \ + else \ + abort(); \ + } + +#define FLOAT_2ARG_CHECK(NAME) \ + f_result = vec_##NAME (f_src_a, f_src_b); \ + \ + if (f_result != f_##NAME##_expected) \ + { \ + if (DEBUG) \ + { \ + printf("ERROR: vec_%s (float, float) expected value does not match\n", \ + #NAME); \ + printf(" expected = %d; result = %d\n", \ + f_##NAME##_expected, f_result); \ + } \ + else \ + abort(); \ + } + +#define DOUBLE_1ARG_CHECK(NAME) \ + d_result = vec_##NAME (d_src_a); \ + \ + if (d_result != d_##NAME##_expected) \ + { \ + if (DEBUG) \ + { \ + printf("ERROR: vec_%s (double) expected value does not match\n", \ + #NAME); \ + printf(" expected = %d; result = %d\n", \ + d_##NAME##_expected, d_result); \ + } \ + else \ + abort(); \ + } + +#define DOUBLE_2ARG_CHECK(NAME) \ + d_result = vec_##NAME (d_src_a, d_src_b); \ + \ + if (d_result != d_##NAME##_expected) \ + { \ + if (DEBUG) \ + { \ + printf("ERROR: vec_%s (double, double) expected value does not match\n", \ + #NAME); \ + printf(" expected = %d; result = %d\n", \ + d_##NAME##_expected, d_result); \ + } \ + else \ + abort(); \ + } + +void +float_tests (vector float f_src_a, vector float f_src_b, bool f_all_eq_expected, + bool f_all_gt_expected, bool f_all_ge_expected, + bool f_all_lt_expected, bool f_all_le_expected, + bool f_all_nan_expected, bool f_all_numeric_expected, + bool f_any_eq_expected, bool f_any_gt_expected, + bool f_any_ge_expected, bool f_any_lt_expected, + bool f_any_le_expected, bool f_any_nan_expected, + bool f_any_numeric_expected) +{ + /* Some of the tests are simple enough that the compiler computes the answer + at compile time. Put the tests in a function so the compiler will generate + the code needed to perform the test. */ + bool f_result; + + FLOAT_1ARG_CHECK (all_nan) + FLOAT_1ARG_CHECK (all_numeric) + FLOAT_1ARG_CHECK (any_nan) + FLOAT_1ARG_CHECK (any_numeric) + + FLOAT_2ARG_CHECK (all_eq) + FLOAT_2ARG_CHECK (all_gt) + FLOAT_2ARG_CHECK (all_ge) + FLOAT_2ARG_CHECK (all_lt) + FLOAT_2ARG_CHECK (all_le) + FLOAT_2ARG_CHECK (any_eq) + FLOAT_2ARG_CHECK (any_gt) + FLOAT_2ARG_CHECK (any_ge) + FLOAT_2ARG_CHECK (any_lt) + FLOAT_2ARG_CHECK (any_le) +} + +void +double_tests (vector double d_src_a, vector double d_src_b, + bool d_all_eq_expected, bool d_all_gt_expected, + bool d_all_ge_expected, bool d_all_lt_expected, + bool d_all_le_expected, bool d_all_nan_expected, + bool d_all_numeric_expected, bool d_any_eq_expected, + bool d_any_gt_expected, bool d_any_ge_expected, + bool d_any_lt_expected, bool d_any_le_expected, + bool d_any_nan_expected, bool d_any_numeric_expected) +{ + /* Some of the tests are simple enough that the compiler computes the answer + at compile time. Put the tests in a function so the compiler will generate + the code needed to perform the test. */ + bool d_result; + + DOUBLE_1ARG_CHECK (all_nan) + DOUBLE_1ARG_CHECK (all_numeric) + DOUBLE_1ARG_CHECK (any_nan) + DOUBLE_1ARG_CHECK (any_numeric) + + DOUBLE_2ARG_CHECK (all_eq) + DOUBLE_2ARG_CHECK (all_gt) + DOUBLE_2ARG_CHECK (all_ge) + DOUBLE_2ARG_CHECK (all_lt) + DOUBLE_2ARG_CHECK (all_le) + DOUBLE_2ARG_CHECK (any_eq) + DOUBLE_2ARG_CHECK (any_gt) + DOUBLE_2ARG_CHECK (any_ge) + DOUBLE_2ARG_CHECK (any_lt) + DOUBLE_2ARG_CHECK (any_le) +} + +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_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; + + /* Run tests. */ + float_tests (f_src_a, f_src_b, f_all_eq_expected, f_all_gt_expected, + f_all_ge_expected, f_all_lt_expected, f_all_le_expected, + f_all_nan_expected, f_all_numeric_expected, f_any_eq_expected, + f_any_gt_expected, f_any_ge_expected, f_any_lt_expected, + f_any_le_expected, f_any_nan_expected, f_any_numeric_expected); + + double_tests (d_src_a, d_src_b, d_all_eq_expected, d_all_gt_expected, + d_all_ge_expected, d_all_lt_expected, d_all_le_expected, + d_all_nan_expected, d_all_numeric_expected, d_any_eq_expected, + d_any_gt_expected, d_any_ge_expected, d_any_lt_expected, + d_any_le_expected, d_any_nan_expected, d_any_numeric_expected); + + return 0; +} + +/* { dg-final { scan-assembler-times {\mxvcmpeqsp\M} 4 } } */ +/* { dg-final { scan-assembler-times {\mxvcmpgtsp\M} 4 } } */ +/* { dg-final { scan-assembler-times {\mxvcmpgesp\M} 4 } } */ +/* { dg-final { scan-assembler-times {\mxvcmpeqdp\M} 4 } } */ +/* { dg-final { scan-assembler-times {\mxvcmpgedp\M} 4 } } */ +/* { dg-final { scan-assembler-times {\mxvcmpgtdp\M} 4 } } */ + + 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..fee60c895c7 --- /dev/null +++ b/gcc/testsuite/gcc.target/powerpc/vsx-vector-6-func-cmp.c @@ -0,0 +1,130 @@ +/* { dg-do run { target lp64 } } */ +/* { dg-skip-if "" { powerpc*-*-darwin* } } */ +/* { dg-options "-O2 -save-temps" } */ + +/* Functional test of the vector compare builtins. */ + +#include +#include +#include + +#define DEBUG 0 + +#define FLOAT_CHECK(NAME) \ + f_result = vec_##NAME (f_src_a, f_src_b); \ + \ + if ((f_result[0] != f_##NAME##_expected[0]) \ + || (f_result[1] != f_##NAME##_expected[1]) \ + || (f_result[2] != f_##NAME##_expected[2]) \ + || (f_result[3] != f_##NAME##_expected[3])) \ + { \ + if (DEBUG) \ + { \ + printf("ERROR: vec_%s (float) expected value does not match\n", \ + #NAME); \ + 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(); \ + } + +#define DOUBLE_CHECK(NAME) \ + d_result = vec_##NAME (d_src_a, d_src_b); \ + \ + if ((d_result[0] != d_##NAME##_expected[0]) \ + || (d_result[1] != d_##NAME##_expected[1])) \ + { \ + if (DEBUG) \ + { \ + printf("ERROR: vec_%s (double) expected value does not match\n", \ + #NAME); \ + 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(); \ + } + +void abort (void); + +void float_tests (vector float f_src_a, vector float f_src_b, + vector bool int f_cmpeq_expected, + vector bool int f_cmpgt_expected, + vector bool int f_cmpge_expected, + vector bool int f_cmplt_expected, + vector bool int f_cmple_expected) +{ + /* The tests are simple enough that the compiler computes the answer at + compile time. Put the tests in a function so the compiler will generate + the code needed to perform the test. */ + vector bool int f_result; + + FLOAT_CHECK (cmpeq) + FLOAT_CHECK (cmpgt) + FLOAT_CHECK (cmpge) + FLOAT_CHECK (cmplt) + FLOAT_CHECK (cmple) +} + +void double_tests (vector double d_src_a, vector double d_src_b, + vector bool long long d_cmpeq_expected, + vector bool long long d_cmpgt_expected, + vector bool long long d_cmpge_expected, + vector bool long long d_cmplt_expected, + vector bool long long d_cmple_expected) +{ + /* The tests are simple enough that the compiler computes the answer at + compile time. Put the tests in a function so the compiler will generate + the code needed to perform the test. */ + vector bool long long d_result; + + DOUBLE_CHECK (cmpeq) + DOUBLE_CHECK (cmpgt) + DOUBLE_CHECK (cmpge) + DOUBLE_CHECK (cmplt) + DOUBLE_CHECK (cmple) +} + +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_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_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}; + + float_tests (f_src_a, f_src_b, f_cmpeq_expected, f_cmpgt_expected, + f_cmpge_expected, f_cmplt_expected, f_cmple_expected); + + double_tests (d_src_a, d_src_b, d_cmpeq_expected, d_cmpgt_expected, + d_cmpge_expected, d_cmplt_expected, d_cmple_expected); + return 0; +} + +/* { dg-final { scan-assembler-times {\mxvcmpeqsp\M} 1 } } */ +/* { dg-final { scan-assembler-times {\mxvcmpgtsp\M} 2 } } */ +/* { dg-final { scan-assembler-times {\mxvcmpgesp\M} 2 } } */ +/* { dg-final { scan-assembler-times {\mxvcmpeqdp\M} 1 } } */ +/* { dg-final { scan-assembler-times {\mxvcmpgedp\M} 2 } } */ +/* { dg-final { scan-assembler-times {\mxvcmpgtdp\M} 2 } } */ 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 } } */