From patchwork Thu Jun 29 21:36:07 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Carl Love X-Patchwork-Id: 114480 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a59:994d:0:b0:3d9:f83d:47d9 with SMTP id k13csp9968212vqr; Thu, 29 Jun 2023 16:05:57 -0700 (PDT) X-Google-Smtp-Source: APBJJlF/KSAC6y37mvVYbhNrAmcCih0oqPwYDW1So8hMaRNRDll6yO30ddI44e0xjFuj0IJ8PmKH X-Received: by 2002:aa7:cfd7:0:b0:51d:a10f:4af3 with SMTP id r23-20020aa7cfd7000000b0051da10f4af3mr475844edy.11.1688079957240; Thu, 29 Jun 2023 16:05:57 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1688079957; cv=none; d=google.com; s=arc-20160816; b=eTviIRaM0zJAempbNfC7D3MWB5fl8KdNulxLxEEnIUzj7fRY8doWYiycvYkGXGPjhX R6WoC9hLG9hcjn8WAtFo+qNPZE1ww+rs5PJrBBHjBOIVP12BNcRhHRmHpBxD2UnnMz0F UrD87+aHp9p9KV9lkqnfu7hQ3BiiWJt9T4sphfwwpYtR3lnlfGpz/8B+kRyVIckPkjH9 In1imJfY7eQGbU+H7BFHX0pB0YDcvijKdninz8c6sO5fLY0m8eWo5rRFrAY5UD78GCjk iZumdZf7PxTuZaraUEGwwzBOqvH66yBvqev3D6HQkjJw15E/RTh5dol5u50i0FWPoKUM MqMg== 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=mrjRcfsn3cdijOSuHKCSB/dZBXVdbnV2xb7sd9roscE=; fh=gOMGir5H7hCPDupZ39aWmpTPeoIigOkUO38DyKZJ5rw=; b=0mMhle/ouQGLQZFe1dPpk++vi09kUDijz4yOfTcPbb0kKDB8lYl45lGWx6kx3zMeJ9 bqwV1YdZdliOfU/8HvypHlDR9cwRrTbdcTY93JOS/fSi+AYz8n9yxxbKKHOx3qO2E58M Mv7R3c9lm+YaWiYyNBCWqclRzpHTsiTb+NsQmekpwYn9z/bkhmRt6ior2SGJWtnTvSmq CjpZ+fmfCvvWeoKZi+uV81PlrLEWQ9FD2jh7pYjIlxC1lPYzxR/8s8oBwxdf63w+G7U6 uhp0D5vCdM08hHF11eklJwmYxlNf84GxxxEfN0HvStHXyuGpfDtPzSwPpuuOHw50eTuq YK1A== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@gcc.gnu.org header.s=default header.b=QSrfmCVV; 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 c8-20020aa7c988000000b0051d906df056si6442385edt.450.2023.06.29.16.05.56 for (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 29 Jun 2023 16:05:57 -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=QSrfmCVV; 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 ED6373857726 for ; Thu, 29 Jun 2023 23:05:36 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org ED6373857726 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gcc.gnu.org; s=default; t=1688079937; bh=mrjRcfsn3cdijOSuHKCSB/dZBXVdbnV2xb7sd9roscE=; h=Subject:To:Cc:Date:List-Id:List-Unsubscribe:List-Archive: List-Post:List-Help:List-Subscribe:From:Reply-To:From; b=QSrfmCVVm2eMqykxhPsvsGFQzFgvAn/NFaIjcv1zM9sOseo5SdS+EVgyiNdmbo/UX p/jY0f72CqMktlGJ32X4HLesBKLjqF2HXlHwiNwrQyIlThpPNxNjv9kyh91jsP/dSf bQM9MeiR0tqAwzImdATUcV6Ozukey73mrn5qlahY= 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 128853858D37 for ; Thu, 29 Jun 2023 23:04:44 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 128853858D37 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 35TMlJ4C006456; Thu, 29 Jun 2023 23:04:44 GMT Received: from pps.reinject (localhost [127.0.0.1]) by mx0a-001b2d01.pphosted.com (PPS) with ESMTPS id 3rhk2cr8b1-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Thu, 29 Jun 2023 23:04:43 +0000 Received: from m0356517.ppops.net (m0356517.ppops.net [127.0.0.1]) by pps.reinject (8.17.1.5/8.17.1.5) with ESMTP id 35TMldH6006883; Thu, 29 Jun 2023 23:04:42 GMT Received: from ppma03dal.us.ibm.com (b.bd.3ea9.ip4.static.sl-reverse.com [169.62.189.11]) by mx0a-001b2d01.pphosted.com (PPS) with ESMTPS id 3rhk2cr88e-11 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Thu, 29 Jun 2023 23:04:42 +0000 Received: from pps.filterd (ppma03dal.us.ibm.com [127.0.0.1]) by ppma03dal.us.ibm.com (8.17.1.19/8.17.1.19) with ESMTP id 35TD7KSD014632; Thu, 29 Jun 2023 21:36:11 GMT Received: from smtprelay06.wdc07v.mail.ibm.com ([9.208.129.118]) by ppma03dal.us.ibm.com (PPS) with ESMTPS id 3rdr45jn3y-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Thu, 29 Jun 2023 21:36:11 +0000 Received: from smtpav06.wdc07v.mail.ibm.com (smtpav06.wdc07v.mail.ibm.com [10.39.53.233]) by smtprelay06.wdc07v.mail.ibm.com (8.14.9/8.14.9/NCO v10.0) with ESMTP id 35TLa8ph65667416 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK); Thu, 29 Jun 2023 21:36:08 GMT Received: from smtpav06.wdc07v.mail.ibm.com (unknown [127.0.0.1]) by IMSVA (Postfix) with ESMTP id B13645803F; Thu, 29 Jun 2023 21:36:08 +0000 (GMT) Received: from smtpav06.wdc07v.mail.ibm.com (unknown [127.0.0.1]) by IMSVA (Postfix) with ESMTP id D2CAB58056; Thu, 29 Jun 2023 21:36:07 +0000 (GMT) Received: from li-e362e14c-2378-11b2-a85c-87d605f3c641.ibm.com (unknown [9.61.18.149]) by smtpav06.wdc07v.mail.ibm.com (Postfix) with ESMTP; Thu, 29 Jun 2023 21:36:07 +0000 (GMT) Message-ID: <2a385a78cb95e36090b6b04a673bba2883cc14ce.camel@us.ibm.com> Subject: [PATCH ver 3] rs6000: Update the vsx-vector-6.* tests. To: "Kewen.Lin" , Segher Boessenkool , gcc-patches@gcc.gnu.org, David Edelsohn Cc: cel@us.ibm.com, Peter Bergner Date: Thu, 29 Jun 2023 14:36:07 -0700 X-Mailer: Evolution 3.28.5 (3.28.5-18.el8) Mime-Version: 1.0 X-TM-AS-GCONF: 00 X-Proofpoint-GUID: 2hzw0z7NLEsDuRGgIyLYe-zRY7Jxgrge X-Proofpoint-ORIG-GUID: iMg3FEhVjjXO_S10jpJxRmM2Pljddwgj 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-29_10,2023-06-27_01,2023-05-22_02 X-Proofpoint-Spam-Details: rule=outbound_notspam policy=outbound score=0 adultscore=0 mlxscore=0 clxscore=1015 lowpriorityscore=0 mlxlogscore=999 spamscore=0 bulkscore=0 priorityscore=1501 phishscore=0 suspectscore=0 impostorscore=0 malwarescore=0 classifier=spam adjust=0 reason=mlx scancount=1 engine=8.12.0-2305260000 definitions=main-2306290209 X-Spam-Status: No, score=-11.2 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?1770080129365066291?= GCC maintainers: Ver 3. Added __attribute__ ((noipa)) to the test files. Changed some of the scan-assembler-times checks to cover multiple similar instructions. Change the function check macro to a macro to generate a function to do the test and check the results. Retested on the various processor types and BE/LE versions. 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 | 141 ++++++++++ .../powerpc/vsx-vector-6-func-2lop.c | 217 +++++++++++++++ .../powerpc/vsx-vector-6-func-2op.c | 133 +++++++++ .../powerpc/vsx-vector-6-func-3op.c | 257 ++++++++++++++++++ .../powerpc/vsx-vector-6-func-cmp-all.c | 211 ++++++++++++++ .../powerpc/vsx-vector-6-func-cmp.c | 121 +++++++++ .../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, 1080 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..52c7ae3e983 --- /dev/null +++ b/gcc/testsuite/gcc.target/powerpc/vsx-vector-6-func-1op.c @@ -0,0 +1,141 @@ +/* { 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_TEST(NAME) \ + void __attribute__ ((noipa)) \ + float_##NAME (vector float f_src, vector float f_##NAME##_expected) \ + { \ + vector float 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(); \ + } \ + } + +FLOAT_TEST (abs) +FLOAT_TEST (ceil) +FLOAT_TEST (floor) +FLOAT_TEST (nearbyint) +FLOAT_TEST (rint) +FLOAT_TEST (trunc) + +/* Macro to check the results for the various double point argument tests. */ +#define DOUBLE_TEST(NAME) \ + void __attribute__ ((noipa)) \ + double_##NAME (vector double d_src, vector double d_##NAME##_expected) \ + { \ + vector double 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(); \ + } \ + } + +DOUBLE_TEST (abs) +DOUBLE_TEST (ceil) +DOUBLE_TEST (floor) +DOUBLE_TEST (nearbyint) +DOUBLE_TEST (rint) +DOUBLE_TEST (trunc) +DOUBLE_TEST (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_src_sqrt = { 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_abs (f_src, f_abs_expected); + float_ceil (f_src, f_ceil_expected); + float_floor (f_src, f_floor_expected); + float_nearbyint (f_src, f_nearbyint_expected); + float_rint (f_src, f_rint_expected); + float_trunc (f_src, f_trunc_expected); + + /* Double argument tests. */ + double_abs (d_src, d_abs_expected); + double_ceil (d_src, d_ceil_expected); + double_floor (d_src, d_floor_expected); + double_nearbyint (d_src, d_nearbyint_expected); + double_rint (d_src, d_rint_expected); + double_trunc (d_src, d_trunc_expected); + double_sqrt (d_src_sqrt, d_sqrt_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..8e5fe2312ff --- /dev/null +++ b/gcc/testsuite/gcc.target/powerpc/vsx-vector-6-func-2lop.c @@ -0,0 +1,217 @@ +/* { 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_TEST(NAME) \ + void __attribute__ ((noipa)) \ + float_##NAME (vector float f_src_a, vector float f_src_b, \ + vector float f_##NAME##_expected) \ + { \ + int i; \ + vector float 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(); \ + } \ + } + +FLOAT_TEST (and) +FLOAT_TEST (andc) +FLOAT_TEST (nor) +FLOAT_TEST (or) +FLOAT_TEST (xor) + +#define DOUBLE_TEST(NAME) \ + void __attribute__ ((noipa)) \ + double_##NAME (vector double d_src_a, vector double d_src_b, \ + vector double d_##NAME##_expected) \ + { \ + vector double d_result = vec_##NAME (d_src_a, d_src_b); \ + int i; \ + \ + 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(); \ + } \ + } + +DOUBLE_TEST (and) +DOUBLE_TEST (andc) +DOUBLE_TEST (nor) +DOUBLE_TEST (or) +DOUBLE_TEST (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_and (f_src_a, f_src_b, f_and_expected); + float_andc (f_src_a, f_src_b, f_andc_expected); + float_nor (f_src_a, f_src_b, f_nor_expected); + float_or (f_src_a, f_src_b, f_or_expected); + float_xor (f_src_a, f_src_b, f_xor_expected); + + double_and (d_src_a, d_src_b, d_and_expected); + double_andc (d_src_a, d_src_b, d_andc_expected); + double_nor (d_src_a, d_src_b, d_nor_expected); + double_or (d_src_a, d_src_b, d_or_expected); + double_xor (d_src_a, d_src_b, 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} 22 { target le }} } */ +/* { dg-final { scan-assembler-times {\mxxlor\M} 32 { 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..25a651a1ac9 --- /dev/null +++ b/gcc/testsuite/gcc.target/powerpc/vsx-vector-6-func-2op.c @@ -0,0 +1,133 @@ +/* { 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_TEST(NAME) \ + void __attribute__ ((noipa)) \ + float_##NAME(vector float f_src_a, vector float f_src_b, \ + vector float f_##NAME##_expected) \ + { \ + vector float 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(); \ + } \ + } + +FLOAT_TEST (add) +FLOAT_TEST (div) +FLOAT_TEST (max) +FLOAT_TEST (min) +FLOAT_TEST (mul) +FLOAT_TEST (sub) + +#define DOUBLE_TEST(NAME) \ + void __attribute__ ((noipa)) \ + double_##NAME(vector double d_src_a, vector double d_src_b, \ + vector double d_##NAME##_expected) \ + { \ + vector double 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(); \ + } \ + } + +DOUBLE_TEST (add) +DOUBLE_TEST (div) +DOUBLE_TEST (max) +DOUBLE_TEST (min) +DOUBLE_TEST (mul) +DOUBLE_TEST (sub) + +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_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_add (f_src_a, f_src_b, f_add_expected); + float_div (f_src_a, f_src_b, f_div_expected); + float_max (f_src_a, f_src_b, f_max_expected); + float_min (f_src_a, f_src_b, f_min_expected); + float_mul (f_src_a, f_src_b, f_mul_expected); + float_sub (f_src_a, f_src_b, f_sub_expected); + + /* Two argument double tests. */ + double_add (d_src_a, d_src_b, d_add_expected); + double_div (d_src_a, d_src_b, d_div_expected); + double_max (d_src_a, d_src_b, d_max_expected); + double_min (d_src_a, d_src_b, d_min_expected); + double_mul (d_src_a, d_src_b, d_mul_expected); + double_sub (d_src_a, d_src_b, 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} 1 } } */ +/* { dg-final { scan-assembler-times {\mxvminsp\M} 1 } } */ +/* { dg-final { scan-assembler-times {\mxvmaxdp\M} 1 } } */ 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..955d4cea4ef --- /dev/null +++ b/gcc/testsuite/gcc.target/powerpc/vsx-vector-6-func-3op.c @@ -0,0 +1,257 @@ +/* { 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_TEST(NAME) \ + void __attribute__ ((noipa)) \ + float_##NAME(vector float f_src_a, vector float f_src_b, \ + vector float f_src_c, vector float f_##NAME##_expected) \ + { \ + vector float 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(); \ + } \ + } + +FLOAT_TEST (madd) +FLOAT_TEST (msub) + +#define DOUBLE_TEST(NAME) \ + void __attribute__ ((noipa)) \ + double_##NAME(vector double d_src_a, vector double d_src_b, \ + vector double d_src_c, vector double d_##NAME##_expected) \ + { \ + vector double 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(); \ + } \ + } + +DOUBLE_TEST (madd) +DOUBLE_TEST (msub) + +void __attribute__ ((noipa)) +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 __attribute__ ((noipa)) +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 __attribute__ ((noipa)) +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 + +} + +void abort (void); + +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_madd (f_src_a, f_src_b, f_src_c, f_madd_expected); + float_msub (f_src_a, f_src_b, f_src_c, f_msub_expected); + + double_madd (d_src_a, d_src_b, d_src_c, d_madd_expected); + double_msub (d_src_a, d_src_b, d_src_c, 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 {\mxvmaddmsp\M} 1 } } */ +/* { dg-final { scan-assembler-times {\mxvmaddmdp\M} 1 } } */ +/* { dg-final { scan-assembler-times {\mxvmsubmsp\M} 1 } } */ +/* { dg-final { scan-assembler-times {\mxvmsubmdp\M} 1 } } */ +/* { dg-final { scan-assembler-times {\m(?:v|xx)permr?\M} 1 } } */ +/* { dg-final { scan-assembler-times {\mxxsel\M} 2 } } */ 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..def18304528 --- /dev/null +++ b/gcc/testsuite/gcc.target/powerpc/vsx-vector-6-func-cmp-all.c @@ -0,0 +1,211 @@ +/* { 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_TEST(NAME) \ + void __attribute__ ((noipa)) \ + float_1arg_##NAME (vector float f_src, bool f_##NAME##_expected) \ + { \ + bool f_result = vec_##NAME (f_src); \ + \ + 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(); \ + } \ + } + +FLOAT_1ARG_TEST (all_nan) +FLOAT_1ARG_TEST (all_numeric) +FLOAT_1ARG_TEST (any_nan) +FLOAT_1ARG_TEST (any_numeric) + +#define FLOAT_2ARG_TEST(NAME) \ + void __attribute__ ((noipa)) \ + float_2arg_##NAME (vector float f_src_a, vector float f_src_b, \ + bool f_##NAME##_expected) \ + { \ + bool 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(); \ + } \ + } + +FLOAT_2ARG_TEST (all_eq) +FLOAT_2ARG_TEST (all_gt) +FLOAT_2ARG_TEST (all_ge) +FLOAT_2ARG_TEST (all_lt) +FLOAT_2ARG_TEST (all_le) +FLOAT_2ARG_TEST (any_eq) +FLOAT_2ARG_TEST (any_gt) +FLOAT_2ARG_TEST (any_ge) +FLOAT_2ARG_TEST (any_lt) +FLOAT_2ARG_TEST (any_le) + +#define DOUBLE_1ARG_TEST(NAME ) \ + void __attribute__ ((noipa)) \ + double_1arg_##NAME (vector double d_src, bool d_##NAME##_expected) \ + { \ + bool d_result = vec_##NAME (d_src); \ + \ + 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(); \ + } \ + } + +DOUBLE_1ARG_TEST (all_nan) +DOUBLE_1ARG_TEST (all_numeric) +DOUBLE_1ARG_TEST (any_nan) +DOUBLE_1ARG_TEST (any_numeric) + +#define DOUBLE_2ARG_TEST(NAME) \ + void __attribute__ ((noipa)) \ + double_2arg_##NAME (vector double d_src_a, vector double d_src_b, \ + bool d_##NAME##_expected) \ + { \ + bool 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(); \ + } \ + } + +DOUBLE_2ARG_TEST (all_eq) +DOUBLE_2ARG_TEST (all_gt) +DOUBLE_2ARG_TEST (all_ge) +DOUBLE_2ARG_TEST (all_lt) +DOUBLE_2ARG_TEST (all_le) +DOUBLE_2ARG_TEST (any_eq) +DOUBLE_2ARG_TEST (any_gt) +DOUBLE_2ARG_TEST (any_ge) +DOUBLE_2ARG_TEST (any_lt) +DOUBLE_2ARG_TEST (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_1arg_all_nan (f_src_a, f_all_nan_expected); + float_1arg_all_numeric (f_src_a, f_all_numeric_expected); + float_1arg_any_nan (f_src_a, f_any_nan_expected); + float_1arg_any_numeric (f_src_a, f_any_numeric_expected); + + float_2arg_all_eq (f_src_a, f_src_b, f_all_eq_expected); + float_2arg_all_gt (f_src_a, f_src_b, f_all_gt_expected); + float_2arg_all_ge (f_src_a, f_src_b, f_all_ge_expected); + float_2arg_all_lt (f_src_a, f_src_b, f_all_lt_expected); + float_2arg_all_le (f_src_a, f_src_b, f_all_le_expected); + float_2arg_any_eq (f_src_a, f_src_b, f_any_eq_expected); + float_2arg_any_gt (f_src_a, f_src_b, f_any_gt_expected); + float_2arg_any_ge (f_src_a, f_src_b, f_any_ge_expected); + float_2arg_any_lt (f_src_a, f_src_b, f_any_lt_expected); + float_2arg_any_le (f_src_a, f_src_b, f_any_le_expected); + + double_1arg_all_nan (d_src_a, d_all_nan_expected); + double_1arg_all_numeric (d_src_a, d_all_numeric_expected); + double_1arg_any_nan (d_src_a, d_any_nan_expected); + double_1arg_any_numeric (d_src_a, d_any_numeric_expected); + + double_2arg_all_eq (d_src_a, d_src_b, d_all_eq_expected); + double_2arg_all_gt (d_src_a, d_src_b, d_all_gt_expected); + double_2arg_all_ge (d_src_a, d_src_b, d_all_ge_expected); + double_2arg_all_lt (d_src_a, d_src_b, d_all_lt_expected); + double_2arg_all_le (d_src_a, d_src_b, d_all_le_expected); + double_2arg_any_eq (d_src_a, d_src_b, d_any_eq_expected); + double_2arg_any_gt (d_src_a, d_src_b, d_any_gt_expected); + double_2arg_any_ge (d_src_a, d_src_b, d_any_ge_expected); + double_2arg_any_lt (d_src_a, d_src_b, d_any_lt_expected); + double_2arg_any_le (d_src_a, d_src_b, d_any_le_expected); + + return 0; +} + +/* { dg-final { scan-assembler-times {\mxvcmpeqsp\M} 6 } } */ +/* { dg-final { scan-assembler-times {\mxvcmpgtsp\M} 4 } } */ +/* { dg-final { scan-assembler-times {\mxvcmpgesp\M} 4 } } */ +/* { dg-final { scan-assembler-times {\mxvcmpeqdp\M} 6 } } */ +/* { 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..80439c23995 --- /dev/null +++ b/gcc/testsuite/gcc.target/powerpc/vsx-vector-6-func-cmp.c @@ -0,0 +1,121 @@ +/* { 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_TEST(NAME) \ + void __attribute__ ((noipa)) \ + float_##NAME (vector float f_src_a, vector float f_src_b, \ + vector bool int f_##NAME##_expected) \ + { \ + vector bool int 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_##NAME##_expected[0], f_result[0]); \ + printf(" expected[1] = 0x%x; result[1] = 0x%x\n", \ + f_##NAME##_expected[1], f_result[1]); \ + printf(" expected[2] = 0x%x; result[2] = 0x%x\n", \ + f_##NAME##_expected[2], f_result[2]); \ + printf(" expected[3] = 0x%x; result[3] = 0x%x\n", \ + f_##NAME##_expected[3], f_result[3]); \ + } \ + else \ + abort(); \ + } \ + } + +FLOAT_TEST (cmpeq) +FLOAT_TEST (cmpgt) +FLOAT_TEST (cmpge) +FLOAT_TEST (cmplt) +FLOAT_TEST (cmple) + +#define DOUBLE_TEST(NAME) \ + void __attribute__ ((noipa)) \ + double_##NAME (vector double d_src_a, vector double d_src_b, \ + vector bool long long d_##NAME##_expected) \ + { \ + vector bool long long 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_##NAME##_expected[0], d_result[0]); \ + printf(" expected[1] = 0x%lx; result[1] = 0x%lx\n", \ + d_##NAME##_expected[1], d_result[1]); \ + } \ + else \ + abort(); \ + } \ + } + +DOUBLE_TEST (cmpeq) +DOUBLE_TEST (cmpgt) +DOUBLE_TEST (cmpge) +DOUBLE_TEST (cmplt) +DOUBLE_TEST (cmple) + +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_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_cmpeq (f_src_a, f_src_b, f_cmpeq_expected); + float_cmpgt (f_src_a, f_src_b, f_cmpgt_expected); + float_cmpge (f_src_a, f_src_b, f_cmpge_expected); + float_cmplt (f_src_a, f_src_b, f_cmplt_expected); + float_cmple (f_src_a, f_src_b, f_cmple_expected); + + double_cmpeq (d_src_a, d_src_b, d_cmpeq_expected); + double_cmpgt (d_src_a, d_src_b, d_cmpgt_expected); + double_cmpge (d_src_a, d_src_b, d_cmpge_expected); + double_cmplt (d_src_a, d_src_b, d_cmplt_expected); + double_cmple (d_src_a, d_src_b, 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 } } */