From patchwork Fri Dec 3 18:22:55 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Bill Schmidt X-Patchwork-Id: 48475 Return-Path: X-Original-To: patchwork@sourceware.org Delivered-To: patchwork@sourceware.org Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 679123858430 for ; Fri, 3 Dec 2021 18:28:14 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 679123858430 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gcc.gnu.org; s=default; t=1638556094; bh=Tqo2qJFygdDOuFNCFCjZUfb0eX7UIZEZ9/Nq6dEQXcE=; h=To:Subject:Date:In-Reply-To:References:In-Reply-To:References: List-Id:List-Unsubscribe:List-Archive:List-Post:List-Help: List-Subscribe:From:Reply-To:Cc:From; b=ByAQlYt/DibQQfLW3UFxkF4Z/v3T5O3qHke4w+udnw7rVXylnPHtvmIsSV0W4jtL2 /uVh6k0AcQ5Knu75BSxDncRUgbplFJQthps3Ot38kuYZjivNkDhNtFyOfq/cLp539q PDLzdSWQ599wd+Lbc9QqiJ7X+DTDOcIFmT2RZiOA= 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 EA0FA3858414; Fri, 3 Dec 2021 18:23:53 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org EA0FA3858414 Received: from pps.filterd (m0098409.ppops.net [127.0.0.1]) by mx0a-001b2d01.pphosted.com (8.16.1.2/8.16.1.2) with SMTP id 1B3ILfXg020526; Fri, 3 Dec 2021 18:23:52 GMT Received: from ppma02dal.us.ibm.com (a.bd.3ea9.ip4.static.sl-reverse.com [169.62.189.10]) by mx0a-001b2d01.pphosted.com with ESMTP id 3cqrevg1a2-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Fri, 03 Dec 2021 18:23:52 +0000 Received: from pps.filterd (ppma02dal.us.ibm.com [127.0.0.1]) by ppma02dal.us.ibm.com (8.16.1.2/8.16.1.2) with SMTP id 1B3IN3XZ023732; Fri, 3 Dec 2021 18:23:51 GMT Received: from b01cxnp23032.gho.pok.ibm.com (b01cxnp23032.gho.pok.ibm.com [9.57.198.27]) by ppma02dal.us.ibm.com with ESMTP id 3cn5f1wx8g-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Fri, 03 Dec 2021 18:23:51 +0000 Received: from b01ledav001.gho.pok.ibm.com (b01ledav001.gho.pok.ibm.com [9.57.199.106]) by b01cxnp23032.gho.pok.ibm.com (8.14.9/8.14.9/NCO v10.0) with ESMTP id 1B3INnjV656064 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK); Fri, 3 Dec 2021 18:23:50 GMT Received: from b01ledav001.gho.pok.ibm.com (unknown [127.0.0.1]) by IMSVA (Postfix) with ESMTP id D37DC28065; Fri, 3 Dec 2021 18:23:49 +0000 (GMT) Received: from b01ledav001.gho.pok.ibm.com (unknown [127.0.0.1]) by IMSVA (Postfix) with ESMTP id A6F882805A; Fri, 3 Dec 2021 18:23:49 +0000 (GMT) Received: from makalu-lp1.aus.stglabs.ibm.com (unknown [9.40.192.155]) by b01ledav001.gho.pok.ibm.com (Postfix) with ESMTP; Fri, 3 Dec 2021 18:23:49 +0000 (GMT) Received: from makalu-lp1.aus.stglabs.ibm.com (localhost [127.0.0.1]) by makalu-lp1.aus.stglabs.ibm.com (Postfix) with ESMTP id 660B3CBFA8; Fri, 3 Dec 2021 12:23:49 -0600 (CST) Received: (from wschmidt@localhost) by makalu-lp1.aus.stglabs.ibm.com (8.14.7/8.14.7/Submit) id 1B3INnNE022665; Fri, 3 Dec 2021 12:23:49 -0600 To: gcc-patches@gcc.gnu.org Subject: [PATCH 5/6] rs6000: Rename functions with "new" in their names Date: Fri, 3 Dec 2021 12:22:55 -0600 Message-Id: <28d8a61cff8e73deffe4c4c0a7d75bfe42959783.1638554381.git.wschmidt@linux.ibm.com> X-Mailer: git-send-email 1.8.3.1 In-Reply-To: References: In-Reply-To: References: X-TM-AS-GCONF: 00 X-Proofpoint-GUID: wpWGnCoQaKTMM-ToUH-0KOY5pjxzMNCl X-Proofpoint-ORIG-GUID: wpWGnCoQaKTMM-ToUH-0KOY5pjxzMNCl X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.205,Aquarius:18.0.790,Hydra:6.0.425,FMLib:17.11.62.513 definitions=2021-12-03_07,2021-12-02_01,2021-12-02_01 X-Proofpoint-Spam-Details: rule=outbound_notspam policy=outbound score=0 spamscore=0 clxscore=1015 priorityscore=1501 suspectscore=0 mlxlogscore=999 malwarescore=0 mlxscore=0 impostorscore=0 adultscore=0 phishscore=0 lowpriorityscore=0 bulkscore=0 classifier=spam adjust=0 reason=mlx scancount=1 engine=8.12.0-2110150000 definitions=main-2112030115 X-Spam-Status: No, score=-11.1 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_EF, GIT_PATCH_0, RCVD_IN_MSPIKE_H2, SPF_HELO_NONE, SPF_NONE, TXREP autolearn=ham autolearn_force=no version=3.4.4 X-Spam-Checker-Version: SpamAssassin 3.4.4 (2020-01-24) 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: Bill Schmidt via Gcc-patches From: Bill Schmidt Reply-To: Bill Schmidt Cc: dje@gcc.gnu.org, Bill Schmidt , segher@kernel.crashing.org Errors-To: gcc-patches-bounces+patchwork=sourceware.org@gcc.gnu.org Sender: "Gcc-patches" From: Bill Schmidt Hi! While we had two sets of built-in functionality at the same time, I put "new" in the names of quite a few functions. Time to undo that. Bootstrapped and tested on powerpc64le-linux-gnu with no regressions. Is this okay for trunk? Thanks! Bill 2021-12-02 Bill Schmidt gcc/ * config/rs6000/rs6000-c.c (altivec_resolve_new_overloaded_builtin): Remove forward declaration. (rs6000_new_builtin_type_compatible): Rename to rs6000_builtin_type_compatible. (rs6000_builtin_type_compatible): Remove. (altivec_resolve_overloaded_builtin): Remove. (altivec_build_new_resolved_builtin): Rename to altivec_build_resolved_builtin. (altivec_resolve_new_overloaded_builtin): Rename to altivec_resolve_overloaded_builtin. Remove static keyword. Adjust called function names. * config/rs6000/rs6000-call.c (rs6000_expand_new_builtin): Remove forward declaration. (rs6000_gimple_fold_new_builtin): Likewise. (rs6000_invalid_new_builtin): Rename to rs6000_invalid_builtin. (rs6000_gimple_fold_builtin): Remove. (rs6000_new_builtin_valid_without_lhs): Rename to rs6000_builtin_valid_without_lhs. (rs6000_new_builtin_is_supported): Rename to rs6000_builtin_is_supported. (rs6000_gimple_fold_new_mma_builtin): Rename to rs6000_gimple_fold_mma_builtin. (rs6000_gimple_fold_new_builtin): Rename to rs6000_gimple_fold_builtin. Remove static keyword. Adjust called function names. (rs6000_expand_builtin): Remove. (new_cpu_expand_builtin): Rename to cpu_expand_builtin. (new_mma_expand_builtin): Rename to mma_expand_builtin. (new_htm_spr_num): Rename to htm_spr_num. (new_htm_expand_builtin): Rename to htm_expand_builtin. Change name of called function. (rs6000_expand_new_builtin): Rename to rs6000_expand_builtin. Remove static keyword. Adjust called function names. (rs6000_new_builtin_decl): Rename to rs6000_builtin_decl. Remove static keyword. (rs6000_builtin_decl): Remove. * config/rs6000/rs6000-gen-builtins.c (write_decls): In gnerated code, rename rs6000_new_builtin_is_supported to rs6000_builtin_is_supported. * config/rs6000/rs6000-internal.h (rs6000_invalid_new_builtin): Rename to rs6000_invalid_builtin. * config/rs6000/rs6000.c (rs6000_new_builtin_vectorized_function): Rename to rs6000_builtin_vectorized_function. (rs6000_new_builtin_md_vectorized_function): Rename to rs6000_builtin_md_vectorized_function. (rs6000_builtin_vectorized_function): Remove. (rs6000_builtin_md_vectorized_function): Remove. --- gcc/config/rs6000/rs6000-c.c | 120 +++++++++--------------- gcc/config/rs6000/rs6000-call.c | 99 ++++++------------- gcc/config/rs6000/rs6000-gen-builtins.c | 3 +- gcc/config/rs6000/rs6000-internal.h | 2 +- gcc/config/rs6000/rs6000.c | 31 ++---- 5 files changed, 80 insertions(+), 175 deletions(-) diff --git a/gcc/config/rs6000/rs6000-c.c b/gcc/config/rs6000/rs6000-c.c index d44edf585aa..f790c72d621 100644 --- a/gcc/config/rs6000/rs6000-c.c +++ b/gcc/config/rs6000/rs6000-c.c @@ -37,9 +37,6 @@ #include "rs6000-internal.h" -static tree altivec_resolve_new_overloaded_builtin (location_t, tree, void *); - - /* Handle the machine specific pragma longcall. Its syntax is # pragma longcall ( TOGGLE ) @@ -817,7 +814,7 @@ is_float128_p (tree t) /* Return true iff ARGTYPE can be compatibly passed as PARMTYPE. */ static bool -rs6000_new_builtin_type_compatible (tree parmtype, tree argtype) +rs6000_builtin_type_compatible (tree parmtype, tree argtype) { if (parmtype == error_mark_node) return false; @@ -840,23 +837,6 @@ rs6000_new_builtin_type_compatible (tree parmtype, tree argtype) return lang_hooks.types_compatible_p (parmtype, argtype); } -static inline bool -rs6000_builtin_type_compatible (tree t, int id) -{ - tree builtin_type; - builtin_type = rs6000_builtin_type (id); - if (t == error_mark_node) - return false; - if (INTEGRAL_TYPE_P (t) && INTEGRAL_TYPE_P (builtin_type)) - return true; - else if (TARGET_IEEEQUAD && TARGET_LONG_DOUBLE_128 - && is_float128_p (t) && is_float128_p (builtin_type)) - return true; - else - return lang_hooks.types_compatible_p (t, builtin_type); -} - - /* In addition to calling fold_convert for EXPR of type TYPE, also call c_fully_fold to remove any C_MAYBE_CONST_EXPRs that could be hiding there (PR47197). */ @@ -873,16 +853,6 @@ fully_fold_convert (tree type, tree expr) return result; } -/* Implementation of the resolve_overloaded_builtin target hook, to - support Altivec's overloaded builtins. */ - -tree -altivec_resolve_overloaded_builtin (location_t loc, tree fndecl, - void *passed_arglist) -{ - return altivec_resolve_new_overloaded_builtin (loc, fndecl, passed_arglist); -} - /* Build a tree for a function call to an Altivec non-overloaded builtin. The overloaded builtin that matched the types and args is described by DESC. The N arguments are given in ARGS, respectively. @@ -891,10 +861,9 @@ altivec_resolve_overloaded_builtin (location_t loc, tree fndecl, a small exception for vec_{all,any}_{ge,le} predicates. */ static tree -altivec_build_new_resolved_builtin (tree *args, int n, tree fntype, - tree ret_type, - rs6000_gen_builtins bif_id, - rs6000_gen_builtins ovld_id) +altivec_build_resolved_builtin (tree *args, int n, tree fntype, tree ret_type, + rs6000_gen_builtins bif_id, + rs6000_gen_builtins ovld_id) { tree argtypes = TYPE_ARG_TYPES (fntype); tree arg_type[MAX_OVLD_ARGS]; @@ -963,9 +932,9 @@ altivec_build_new_resolved_builtin (tree *args, int n, tree fntype, support Altivec's overloaded builtins. FIXME: This code needs to be brutally factored. */ -static tree -altivec_resolve_new_overloaded_builtin (location_t loc, tree fndecl, - void *passed_arglist) +tree +altivec_resolve_overloaded_builtin (location_t loc, tree fndecl, + void *passed_arglist) { vec *arglist = static_cast *> (passed_arglist); unsigned int nargs = vec_safe_length (arglist); @@ -1096,7 +1065,7 @@ altivec_resolve_new_overloaded_builtin (location_t loc, tree fndecl, vec *params = make_tree_vector (); vec_safe_push (params, arg0); vec_safe_push (params, arg1); - tree call = altivec_resolve_new_overloaded_builtin + tree call = altivec_resolve_overloaded_builtin (loc, rs6000_builtin_decls_x[RS6000_OVLD_VEC_CMPEQ], params); /* Use save_expr to ensure that operands used more than once @@ -1106,7 +1075,7 @@ altivec_resolve_new_overloaded_builtin (location_t loc, tree fndecl, params = make_tree_vector (); vec_safe_push (params, call); vec_safe_push (params, call); - return altivec_resolve_new_overloaded_builtin + return altivec_resolve_overloaded_builtin (loc, rs6000_builtin_decls_x[RS6000_OVLD_VEC_NOR], params); } /* Other types are errors. */ @@ -1165,9 +1134,8 @@ altivec_resolve_new_overloaded_builtin (location_t loc, tree fndecl, add_sub_builtin = rs6000_builtin_decls_x[RS6000_OVLD_VEC_SUB]; tree call - = altivec_resolve_new_overloaded_builtin (loc, - add_sub_builtin, - params); + = altivec_resolve_overloaded_builtin (loc, add_sub_builtin, + params); tree const1 = build_int_cstu (TREE_TYPE (arg0_type), 1); tree ones_vector = build_vector_from_val (arg0_type, const1); tree and_expr = fold_build2_loc (loc, BIT_AND_EXPR, arg0_type, @@ -1175,9 +1143,8 @@ altivec_resolve_new_overloaded_builtin (location_t loc, tree fndecl, params = make_tree_vector (); vec_safe_push (params, call); vec_safe_push (params, and_expr); - return altivec_resolve_new_overloaded_builtin (loc, - add_sub_builtin, - params); + return altivec_resolve_overloaded_builtin (loc, add_sub_builtin, + params); } /* For {un}signed __int128s use the vaddeuqm/vsubeuqm instruction directly. */ @@ -1244,9 +1211,8 @@ altivec_resolve_new_overloaded_builtin (location_t loc, tree fndecl, else as_c_builtin = rs6000_builtin_decls_x[RS6000_OVLD_VEC_SUBC]; - tree call1 = altivec_resolve_new_overloaded_builtin (loc, - as_c_builtin, - params); + tree call1 = altivec_resolve_overloaded_builtin (loc, as_c_builtin, + params); params = make_tree_vector (); vec_safe_push (params, arg0); vec_safe_push (params, arg1); @@ -1256,9 +1222,8 @@ altivec_resolve_new_overloaded_builtin (location_t loc, tree fndecl, else as_builtin = rs6000_builtin_decls_x[RS6000_OVLD_VEC_SUB]; - tree call2 = altivec_resolve_new_overloaded_builtin (loc, - as_builtin, - params); + tree call2 = altivec_resolve_overloaded_builtin (loc, as_builtin, + params); tree const1 = build_int_cstu (TREE_TYPE (arg0_type), 1); tree ones_vector = build_vector_from_val (arg0_type, const1); tree and_expr = fold_build2_loc (loc, BIT_AND_EXPR, arg0_type, @@ -1266,14 +1231,14 @@ altivec_resolve_new_overloaded_builtin (location_t loc, tree fndecl, params = make_tree_vector (); vec_safe_push (params, call2); vec_safe_push (params, and_expr); - call2 = altivec_resolve_new_overloaded_builtin (loc, as_c_builtin, - params); + call2 = altivec_resolve_overloaded_builtin (loc, as_c_builtin, + params); params = make_tree_vector (); vec_safe_push (params, call1); vec_safe_push (params, call2); tree or_builtin = rs6000_builtin_decls_x[RS6000_OVLD_VEC_OR]; - return altivec_resolve_new_overloaded_builtin (loc, or_builtin, - params); + return altivec_resolve_overloaded_builtin (loc, or_builtin, + params); } /* For {un}signed __int128s use the vaddecuq/vsubbecuq instructions. This occurs through normal processing. */ @@ -1779,17 +1744,17 @@ altivec_resolve_new_overloaded_builtin (location_t loc, tree fndecl, tree parmtype0 = TREE_VALUE (TYPE_ARG_TYPES (fntype)); tree parmtype1 = TREE_VALUE (TREE_CHAIN (TYPE_ARG_TYPES (fntype))); - if (rs6000_new_builtin_type_compatible (types[0], parmtype0) - && rs6000_new_builtin_type_compatible (types[1], parmtype1)) + if (rs6000_builtin_type_compatible (types[0], parmtype0) + && rs6000_builtin_type_compatible (types[1], parmtype1)) { if (rs6000_builtin_decl (instance->bifid, false) != error_mark_node - && rs6000_new_builtin_is_supported (instance->bifid)) + && rs6000_builtin_is_supported (instance->bifid)) { tree ret_type = TREE_TYPE (instance->fntype); - return altivec_build_new_resolved_builtin (args, n, fntype, - ret_type, - instance->bifid, - fcode); + return altivec_build_resolved_builtin (args, n, fntype, + ret_type, + instance->bifid, + fcode); } else unsupported_builtin = true; @@ -1837,17 +1802,17 @@ altivec_resolve_new_overloaded_builtin (location_t loc, tree fndecl, tree parmtype0 = TREE_VALUE (TYPE_ARG_TYPES (fntype)); tree parmtype1 = TREE_VALUE (TREE_CHAIN (TYPE_ARG_TYPES (fntype))); - if (rs6000_new_builtin_type_compatible (types[0], parmtype0) - && rs6000_new_builtin_type_compatible (types[1], parmtype1)) + if (rs6000_builtin_type_compatible (types[0], parmtype0) + && rs6000_builtin_type_compatible (types[1], parmtype1)) { if (rs6000_builtin_decl (instance->bifid, false) != error_mark_node - && rs6000_new_builtin_is_supported (instance->bifid)) + && rs6000_builtin_is_supported (instance->bifid)) { tree ret_type = TREE_TYPE (instance->fntype); - return altivec_build_new_resolved_builtin (args, n, fntype, - ret_type, - instance->bifid, - fcode); + return altivec_build_resolved_builtin (args, n, fntype, + ret_type, + instance->bifid, + fcode); } else unsupported_builtin = true; @@ -1869,8 +1834,7 @@ altivec_resolve_new_overloaded_builtin (location_t loc, tree fndecl, arg_i++) { tree parmtype = TREE_VALUE (nextparm); - if (!rs6000_new_builtin_type_compatible (types[arg_i], - parmtype)) + if (!rs6000_builtin_type_compatible (types[arg_i], parmtype)) { mismatch = true; break; @@ -1881,16 +1845,16 @@ altivec_resolve_new_overloaded_builtin (location_t loc, tree fndecl, if (mismatch) continue; - supported = rs6000_new_builtin_is_supported (instance->bifid); + supported = rs6000_builtin_is_supported (instance->bifid); if (rs6000_builtin_decl (instance->bifid, false) != error_mark_node && supported) { tree fntype = rs6000_builtin_info_x[instance->bifid].fntype; tree ret_type = TREE_TYPE (instance->fntype); - return altivec_build_new_resolved_builtin (args, n, fntype, - ret_type, - instance->bifid, - fcode); + return altivec_build_resolved_builtin (args, n, fntype, + ret_type, + instance->bifid, + fcode); } else { @@ -1908,7 +1872,7 @@ altivec_resolve_new_overloaded_builtin (location_t loc, tree fndecl, /* Indicate that the instantiation of the overloaded builtin name is not available with the target flags in effect. */ rs6000_gen_builtins fcode = (rs6000_gen_builtins) instance->bifid; - rs6000_invalid_new_builtin (fcode); + rs6000_invalid_builtin (fcode); /* Provide clarity of the relationship between the overload and the instantiation. */ const char *internal_name diff --git a/gcc/config/rs6000/rs6000-call.c b/gcc/config/rs6000/rs6000-call.c index 619f936668e..bc035d69731 100644 --- a/gcc/config/rs6000/rs6000-call.c +++ b/gcc/config/rs6000/rs6000-call.c @@ -167,9 +167,6 @@ static const struct { "arch_3_1", PPC_FEATURE2_ARCH_3_1, 1 }, { "mma", PPC_FEATURE2_MMA, 1 }, }; - -static rtx rs6000_expand_new_builtin (tree, rtx, rtx, machine_mode, int); -static bool rs6000_gimple_fold_new_builtin (gimple_stmt_iterator *gsi); /* Nonzero if we can use a floating-point register to pass this arg. */ #define USE_FP_FOR_ARG_P(CUM,MODE) \ @@ -3258,7 +3255,7 @@ altivec_expand_vec_ext_builtin (tree exp, rtx target) appropriate target options being set. */ void -rs6000_invalid_new_builtin (enum rs6000_gen_builtins fncode) +rs6000_invalid_builtin (enum rs6000_gen_builtins fncode) { size_t j = (size_t) fncode; const char *name = rs6000_builtin_info_x[j].bifname; @@ -3479,20 +3476,11 @@ fold_mergeeo_helper (gimple_stmt_iterator *gsi, gimple *stmt, int use_odd) gsi_replace (gsi, g, true); } -/* Fold a machine-dependent built-in in GIMPLE. (For folding into - a constant, use rs6000_fold_builtin.) */ - -bool -rs6000_gimple_fold_builtin (gimple_stmt_iterator *gsi) -{ - return rs6000_gimple_fold_new_builtin (gsi); -} - /* Helper function to sort out which built-ins may be valid without having a LHS. */ static bool -rs6000_new_builtin_valid_without_lhs (enum rs6000_gen_builtins fn_code, - tree fndecl) +rs6000_builtin_valid_without_lhs (enum rs6000_gen_builtins fn_code, + tree fndecl) { if (TREE_TYPE (TREE_TYPE (fndecl)) == void_type_node) return true; @@ -3520,7 +3508,7 @@ rs6000_new_builtin_valid_without_lhs (enum rs6000_gen_builtins fn_code, /* Check whether a builtin function is supported in this target configuration. */ bool -rs6000_new_builtin_is_supported (enum rs6000_gen_builtins fncode) +rs6000_builtin_is_supported (enum rs6000_gen_builtins fncode) { switch (rs6000_builtin_info_x[(size_t) fncode].enable) { @@ -3576,8 +3564,8 @@ rs6000_new_builtin_is_supported (enum rs6000_gen_builtins fncode) __vector_quad arguments into pass-by-value arguments, leading to more efficient code generation. */ static bool -rs6000_gimple_fold_new_mma_builtin (gimple_stmt_iterator *gsi, - rs6000_gen_builtins fn_code) +rs6000_gimple_fold_mma_builtin (gimple_stmt_iterator *gsi, + rs6000_gen_builtins fn_code) { gimple *stmt = gsi_stmt (*gsi); size_t fncode = (size_t) fn_code; @@ -3776,8 +3764,8 @@ rs6000_gimple_fold_new_mma_builtin (gimple_stmt_iterator *gsi, /* Fold a machine-dependent built-in in GIMPLE. (For folding into a constant, use rs6000_fold_builtin.) */ -static bool -rs6000_gimple_fold_new_builtin (gimple_stmt_iterator *gsi) +bool +rs6000_gimple_fold_builtin (gimple_stmt_iterator *gsi) { gimple *stmt = gsi_stmt (*gsi); tree fndecl = gimple_call_fndecl (stmt); @@ -3796,23 +3784,23 @@ rs6000_gimple_fold_new_builtin (gimple_stmt_iterator *gsi) : "nothing"; if (TARGET_DEBUG_BUILTIN) - fprintf (stderr, "rs6000_gimple_fold_new_builtin %d %s %s\n", + fprintf (stderr, "rs6000_gimple_fold_builtin %d %s %s\n", fn_code, fn_name1, fn_name2); if (!rs6000_fold_gimple) return false; /* Prevent gimple folding for code that does not have a LHS, unless it is - allowed per the rs6000_new_builtin_valid_without_lhs helper function. */ + allowed per the rs6000_builtin_valid_without_lhs helper function. */ if (!gimple_call_lhs (stmt) - && !rs6000_new_builtin_valid_without_lhs (fn_code, fndecl)) + && !rs6000_builtin_valid_without_lhs (fn_code, fndecl)) return false; /* Don't fold invalid builtins, let rs6000_expand_builtin diagnose it. */ - if (!rs6000_new_builtin_is_supported (fn_code)) + if (!rs6000_builtin_is_supported (fn_code)) return false; - if (rs6000_gimple_fold_new_mma_builtin (gsi, fn_code)) + if (rs6000_gimple_fold_mma_builtin (gsi, fn_code)) return true; switch (fn_code) @@ -4755,20 +4743,6 @@ rs6000_gimple_fold_new_builtin (gimple_stmt_iterator *gsi) return false; } -/* Expand an expression EXP that calls a built-in function, - with result going to TARGET if that's convenient - (and in mode MODE if that's convenient). - SUBTARGET may be used as the target for computing one of EXP's operands. - IGNORE is nonzero if the value is to be ignored. */ - -rtx -rs6000_expand_builtin (tree exp, rtx target, rtx subtarget ATTRIBUTE_UNUSED, - machine_mode mode ATTRIBUTE_UNUSED, - int ignore ATTRIBUTE_UNUSED) -{ - return rs6000_expand_new_builtin (exp, target, subtarget, mode, ignore); -} - /* Expand ALTIVEC_BUILTIN_MASK_FOR_LOAD. */ rtx rs6000_expand_ldst_mask (rtx target, tree arg0) @@ -4803,8 +4777,8 @@ rs6000_expand_ldst_mask (rtx target, tree arg0) /* Expand the CPU builtin in FCODE and store the result in TARGET. */ static rtx -new_cpu_expand_builtin (enum rs6000_gen_builtins fcode, - tree exp ATTRIBUTE_UNUSED, rtx target) +cpu_expand_builtin (enum rs6000_gen_builtins fcode, + tree exp ATTRIBUTE_UNUSED, rtx target) { /* __builtin_cpu_init () is a nop, so expand to nothing. */ if (fcode == RS6000_BIF_CPU_INIT) @@ -5206,8 +5180,8 @@ stv_expand_builtin (insn_code icode, rtx *op, /* Expand the MMA built-in in EXP, and return it. */ static rtx -new_mma_expand_builtin (tree exp, rtx target, insn_code icode, - rs6000_gen_builtins fcode) +mma_expand_builtin (tree exp, rtx target, insn_code icode, + rs6000_gen_builtins fcode) { tree fndecl = TREE_OPERAND (CALL_EXPR_FN (exp), 0); bool void_func = TREE_TYPE (TREE_TYPE (fndecl)) == void_type_node; @@ -5319,7 +5293,7 @@ new_mma_expand_builtin (tree exp, rtx target, insn_code icode, /* Return the appropriate SPR number associated with the given builtin. */ static inline HOST_WIDE_INT -new_htm_spr_num (enum rs6000_gen_builtins code) +htm_spr_num (enum rs6000_gen_builtins code) { if (code == RS6000_BIF_GET_TFHAR || code == RS6000_BIF_SET_TFHAR) @@ -5338,8 +5312,8 @@ new_htm_spr_num (enum rs6000_gen_builtins code) /* Expand the HTM builtin in EXP and store the result in TARGET. Return the expanded rtx. */ static rtx -new_htm_expand_builtin (bifdata *bifaddr, rs6000_gen_builtins fcode, - tree exp, rtx target) +htm_expand_builtin (bifdata *bifaddr, rs6000_gen_builtins fcode, + tree exp, rtx target) { if (!TARGET_POWERPC64 && (fcode == RS6000_BIF_TABORTDC @@ -5425,7 +5399,7 @@ new_htm_expand_builtin (bifdata *bifaddr, rs6000_gen_builtins fcode, if (uses_spr) { machine_mode mode = TARGET_POWERPC64 ? DImode : SImode; - op[nopnds++] = gen_rtx_CONST_INT (mode, new_htm_spr_num (fcode)); + op[nopnds++] = gen_rtx_CONST_INT (mode, htm_spr_num (fcode)); } /* If this builtin accesses a CR field, then pass in a scratch CR field as the last operand. */ @@ -5497,11 +5471,9 @@ new_htm_expand_builtin (bifdata *bifaddr, rs6000_gen_builtins fcode, SUBTARGET may be used as the target for computing one of EXP's operands. IGNORE is nonzero if the value is to be ignored. Use the new builtin infrastructure. */ -static rtx -rs6000_expand_new_builtin (tree exp, rtx target, - rtx /* subtarget */, - machine_mode /* mode */, - int ignore) +rtx +rs6000_expand_builtin (tree exp, rtx target, rtx /* subtarget */, + machine_mode /* mode */, int ignore) { tree fndecl = TREE_OPERAND (CALL_EXPR_FN (exp), 0); enum rs6000_gen_builtins fcode @@ -5610,7 +5582,7 @@ rs6000_expand_new_builtin (tree exp, rtx target, || (e == ENB_P10_64 && TARGET_POWER10 && TARGET_POWERPC64) || (e == ENB_MMA && TARGET_MMA))) { - rs6000_invalid_new_builtin (fcode); + rs6000_invalid_builtin (fcode); return expand_call (exp, target, ignore); } @@ -5629,7 +5601,7 @@ rs6000_expand_new_builtin (tree exp, rtx target, } if (bif_is_cpu (*bifaddr)) - return new_cpu_expand_builtin (fcode, exp, target); + return cpu_expand_builtin (fcode, exp, target); if (bif_is_init (*bifaddr)) return altivec_expand_vec_init_builtin (TREE_TYPE (exp), exp, target); @@ -5644,7 +5616,7 @@ rs6000_expand_new_builtin (tree exp, rtx target, return altivec_expand_predicate_builtin (icode, exp, target); if (bif_is_htm (*bifaddr)) - return new_htm_expand_builtin (bifaddr, fcode, exp, target); + return htm_expand_builtin (bifaddr, fcode, exp, target); if (bif_is_32bit (*bifaddr) && TARGET_32BIT) { @@ -5830,7 +5802,7 @@ rs6000_expand_new_builtin (tree exp, rtx target, return lxvrze_expand_builtin (target, icode, op, mode[0], mode[1]); if (bif_is_mma (*bifaddr)) - return new_mma_expand_builtin (exp, target, icode, fcode); + return mma_expand_builtin (exp, target, icode, fcode); if (fcode == RS6000_BIF_PACK_IF && TARGET_LONG_DOUBLE_128 @@ -6355,8 +6327,8 @@ rs6000_init_builtins (void) return; } -static tree -rs6000_new_builtin_decl (unsigned code, bool /* initialize_p */) +tree +rs6000_builtin_decl (unsigned code, bool /* initialize_p */) { rs6000_gen_builtins fcode = (rs6000_gen_builtins) code; @@ -6366,17 +6338,6 @@ rs6000_new_builtin_decl (unsigned code, bool /* initialize_p */) return rs6000_builtin_decls_x[code]; } -/* Returns the rs6000 builtin decl for CODE. Note that we don't check - the builtin mask here since there could be some #pragma/attribute - target functions and the rs6000_builtin_mask could be wrong when - this checking happens, though it will be updated properly later. */ - -tree -rs6000_builtin_decl (unsigned code, bool initialize_p ATTRIBUTE_UNUSED) -{ - return rs6000_new_builtin_decl (code, initialize_p); -} - /* Return the internal arg pointer used for function incoming arguments. When -fsplit-stack, the arg pointer is r12 so we need to copy it to a pseudo in order for it to be preserved over calls diff --git a/gcc/config/rs6000/rs6000-gen-builtins.c b/gcc/config/rs6000/rs6000-gen-builtins.c index 9c61b7d9fe6..114289a0034 100644 --- a/gcc/config/rs6000/rs6000-gen-builtins.c +++ b/gcc/config/rs6000/rs6000-gen-builtins.c @@ -2375,8 +2375,7 @@ write_decls (void) fprintf (header_file, "extern void rs6000_init_generated_builtins ();\n\n"); fprintf (header_file, - "extern bool rs6000_new_builtin_is_supported " - "(rs6000_gen_builtins);\n"); + "extern bool rs6000_builtin_is_supported (rs6000_gen_builtins);\n"); fprintf (header_file, "extern tree rs6000_builtin_decl (unsigned, " "bool ATTRIBUTE_UNUSED);\n\n"); diff --git a/gcc/config/rs6000/rs6000-internal.h b/gcc/config/rs6000/rs6000-internal.h index a880fd37618..49904b3f33d 100644 --- a/gcc/config/rs6000/rs6000-internal.h +++ b/gcc/config/rs6000/rs6000-internal.h @@ -142,7 +142,7 @@ extern void rs6000_output_mi_thunk (FILE *file, extern bool rs6000_output_addr_const_extra (FILE *file, rtx x); extern bool rs6000_gimple_fold_builtin (gimple_stmt_iterator *gsi); extern tree rs6000_build_builtin_va_list (void); -extern void rs6000_invalid_new_builtin (rs6000_gen_builtins fncode); +extern void rs6000_invalid_builtin (rs6000_gen_builtins fncode); extern void rs6000_va_start (tree valist, rtx nextarg); extern tree rs6000_gimplify_va_arg (tree valist, tree type, gimple_seq *pre_p, gimple_seq *post_p); diff --git a/gcc/config/rs6000/rs6000.c b/gcc/config/rs6000/rs6000.c index f5116289a7f..bc17c53760d 100644 --- a/gcc/config/rs6000/rs6000.c +++ b/gcc/config/rs6000/rs6000.c @@ -5568,14 +5568,14 @@ rs6000_loop_unroll_adjust (unsigned nunroll, struct loop *loop) Implement targetm.vectorize.builtin_vectorized_function. */ static tree -rs6000_new_builtin_vectorized_function (unsigned int fn, tree type_out, - tree type_in) +rs6000_builtin_vectorized_function (unsigned int fn, tree type_out, + tree type_in) { machine_mode in_mode, out_mode; int in_n, out_n; if (TARGET_DEBUG_BUILTIN) - fprintf (stderr, "rs6000_new_builtin_vectorized_function (%s, %s, %s)\n", + fprintf (stderr, "rs6000_builtin_vectorized_function (%s, %s, %s)\n", combined_fn_name (combined_fn (fn)), GET_MODE_NAME (TYPE_MODE (type_out)), GET_MODE_NAME (TYPE_MODE (type_in))); @@ -5700,15 +5700,15 @@ rs6000_new_builtin_vectorized_function (unsigned int fn, tree type_out, /* Implement targetm.vectorize.builtin_md_vectorized_function. */ static tree -rs6000_new_builtin_md_vectorized_function (tree fndecl, tree type_out, - tree type_in) +rs6000_builtin_md_vectorized_function (tree fndecl, tree type_out, + tree type_in) { machine_mode in_mode, out_mode; int in_n, out_n; if (TARGET_DEBUG_BUILTIN) fprintf (stderr, - "rs6000_new_builtin_md_vectorized_function (%s, %s, %s)\n", + "rs6000_builtin_md_vectorized_function (%s, %s, %s)\n", IDENTIFIER_POINTER (DECL_NAME (fndecl)), GET_MODE_NAME (TYPE_MODE (type_out)), GET_MODE_NAME (TYPE_MODE (type_in))); @@ -5918,25 +5918,6 @@ rs6000_builtin_vectorized_libmass (combined_fn fn, tree type_out, return new_fndecl; } -/* Returns a function decl for a vectorized version of the builtin function - with builtin function code FN and the result vector type TYPE, or NULL_TREE - if it is not available. */ - -static tree -rs6000_builtin_vectorized_function (unsigned int fn, tree type_out, - tree type_in) -{ - return rs6000_new_builtin_vectorized_function (fn, type_out, type_in); -} - -/* Implement TARGET_VECTORIZE_BUILTIN_MD_VECTORIZED_FUNCTION. */ - -static tree -rs6000_builtin_md_vectorized_function (tree fndecl, tree type_out, - tree type_in) -{ - return rs6000_new_builtin_md_vectorized_function (fndecl, type_out, type_in); -} /* Default CPU string for rs6000*_file_start functions. */ static const char *rs6000_default_cpu;