From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: by sourceware.org (Postfix, from userid 2140) id E99993857C74; Wed, 7 Oct 2020 10:49:59 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org E99993857C74 Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit From: Alexandre Oliva To: gcc-cvs@gcc.gnu.org Subject: [gcc(refs/users/aoliva/heads/testme)] improve sincos type inference X-Act-Checkin: gcc X-Git-Author: Alexandre Oliva X-Git-Refname: refs/users/aoliva/heads/testme X-Git-Oldrev: 0f8d4b89ea91525c22a2b5f84e8b5d13bd69b0c8 X-Git-Newrev: 28511c67f64a9484ff0e4a8cd7fd75dce0decfa2 Message-Id: <20201007104959.E99993857C74@sourceware.org> Date: Wed, 7 Oct 2020 10:49:59 +0000 (GMT) X-BeenThere: gcc-cvs@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gcc-cvs mailing list List-Unsubscribe: , List-Archive: List-Help: List-Subscribe: , X-List-Received-Date: Wed, 07 Oct 2020 10:50:00 -0000 https://gcc.gnu.org/g:28511c67f64a9484ff0e4a8cd7fd75dce0decfa2 commit 28511c67f64a9484ff0e4a8cd7fd75dce0decfa2 Author: Alexandre Oliva Date: Wed Oct 7 07:39:30 2020 -0300 improve sincos type inference Diff: --- gcc/builtins.c | 145 +++++++++++++++++++++++++++++++++++++++++++++++ gcc/builtins.h | 1 + gcc/tree-ssa-math-opts.c | 25 +++----- 3 files changed, 155 insertions(+), 16 deletions(-) diff --git a/gcc/builtins.c b/gcc/builtins.c index f91266e4240..578960c9f20 100644 --- a/gcc/builtins.c +++ b/gcc/builtins.c @@ -2278,6 +2278,10 @@ mathfn_built_in_2 (tree type, combined_fn fn) return END_BUILTINS; } +#undef CASE_MATHFN +#undef CASE_MATHFN_FLOATN +#undef CASE_MATHFN_REENT + /* Return mathematic function equivalent to FN but operating directly on TYPE, if available. If IMPLICIT_P is true use the implicit builtin declaration, otherwise use the explicit declaration. If we can't do the conversion, @@ -2313,6 +2317,147 @@ mathfn_built_in (tree type, enum built_in_function fn) return mathfn_built_in_1 (type, as_combined_fn (fn), /*implicit=*/ 1); } +/* Return the type associated with a built in function, i.e., the one + to be passed to mathfn_built_in to get the type-specific + function. */ + +tree +mathfn_built_in_type (combined_fn fn) +{ +#define CASE_MATHFN(MATHFN) \ + case BUILT_IN_##MATHFN: \ + return double_type_node; \ + case BUILT_IN_##MATHFN##F: \ + return float_type_node; \ + case BUILT_IN_##MATHFN##L: \ + return long_double_type_node; + +#define CASE_MATHFN_FLOATN(MATHFN) \ + CASE_MATHFN(MATHFN) \ + case BUILT_IN_##MATHFN##F16: \ + return float16_type_node; \ + case BUILT_IN_##MATHFN##F32: \ + return float32_type_node; \ + case BUILT_IN_##MATHFN##F64: \ + return float64_type_node; \ + case BUILT_IN_##MATHFN##F128: \ + return float128_type_node; \ + case BUILT_IN_##MATHFN##F32X: \ + return float32x_type_node; \ + case BUILT_IN_##MATHFN##F64X: \ + return float64x_type_node; \ + case BUILT_IN_##MATHFN##F128X: \ + return float128x_type_node; + +/* Similar to above, but appends _R after any F/L suffix. */ +#define CASE_MATHFN_REENT(MATHFN) \ + case BUILT_IN_##MATHFN##_R: \ + return double_type_node; \ + case BUILT_IN_##MATHFN##F_R: \ + return float_type_node; \ + case BUILT_IN_##MATHFN##L_R: \ + return long_double_type_node; + + switch (fn) + { + CASE_MATHFN (ACOS) + CASE_MATHFN (ACOSH) + CASE_MATHFN (ASIN) + CASE_MATHFN (ASINH) + CASE_MATHFN (ATAN) + CASE_MATHFN (ATAN2) + CASE_MATHFN (ATANH) + CASE_MATHFN (CBRT) + CASE_MATHFN_FLOATN (CEIL) + CASE_MATHFN (CEXPI) + CASE_MATHFN_FLOATN (COPYSIGN) + CASE_MATHFN (COS) + CASE_MATHFN (COSH) + CASE_MATHFN (DREM) + CASE_MATHFN (ERF) + CASE_MATHFN (ERFC) + CASE_MATHFN (EXP) + CASE_MATHFN (EXP10) + CASE_MATHFN (EXP2) + CASE_MATHFN (EXPM1) + CASE_MATHFN (FABS) + CASE_MATHFN (FDIM) + CASE_MATHFN_FLOATN (FLOOR) + CASE_MATHFN_FLOATN (FMA) + CASE_MATHFN_FLOATN (FMAX) + CASE_MATHFN_FLOATN (FMIN) + CASE_MATHFN (FMOD) + CASE_MATHFN (FREXP) + CASE_MATHFN (GAMMA) + CASE_MATHFN_REENT (GAMMA) /* GAMMA_R */ + CASE_MATHFN (HUGE_VAL) + CASE_MATHFN (HYPOT) + CASE_MATHFN (ILOGB) + CASE_MATHFN (ICEIL) + CASE_MATHFN (IFLOOR) + CASE_MATHFN (INF) + CASE_MATHFN (IRINT) + CASE_MATHFN (IROUND) + CASE_MATHFN (ISINF) + CASE_MATHFN (J0) + CASE_MATHFN (J1) + CASE_MATHFN (JN) + CASE_MATHFN (LCEIL) + CASE_MATHFN (LDEXP) + CASE_MATHFN (LFLOOR) + CASE_MATHFN (LGAMMA) + CASE_MATHFN_REENT (LGAMMA) /* LGAMMA_R */ + CASE_MATHFN (LLCEIL) + CASE_MATHFN (LLFLOOR) + CASE_MATHFN (LLRINT) + CASE_MATHFN (LLROUND) + CASE_MATHFN (LOG) + CASE_MATHFN (LOG10) + CASE_MATHFN (LOG1P) + CASE_MATHFN (LOG2) + CASE_MATHFN (LOGB) + CASE_MATHFN (LRINT) + CASE_MATHFN (LROUND) + CASE_MATHFN (MODF) + CASE_MATHFN (NAN) + CASE_MATHFN (NANS) + CASE_MATHFN_FLOATN (NEARBYINT) + CASE_MATHFN (NEXTAFTER) + CASE_MATHFN (NEXTTOWARD) + CASE_MATHFN (POW) + CASE_MATHFN (POWI) + CASE_MATHFN (POW10) + CASE_MATHFN (REMAINDER) + CASE_MATHFN (REMQUO) + CASE_MATHFN_FLOATN (RINT) + CASE_MATHFN_FLOATN (ROUND) + CASE_MATHFN_FLOATN (ROUNDEVEN) + CASE_MATHFN (SCALB) + CASE_MATHFN (SCALBLN) + CASE_MATHFN (SCALBN) + CASE_MATHFN (SIGNBIT) + CASE_MATHFN (SIGNIFICAND) + CASE_MATHFN (SIN) + CASE_MATHFN (SINCOS) + CASE_MATHFN (SINH) + CASE_MATHFN_FLOATN (SQRT) + CASE_MATHFN (TAN) + CASE_MATHFN (TANH) + CASE_MATHFN (TGAMMA) + CASE_MATHFN_FLOATN (TRUNC) + CASE_MATHFN (Y0) + CASE_MATHFN (Y1) + CASE_MATHFN (YN) + + default: + return NULL_TREE; + } + +#undef CASE_MATHFN +#undef CASE_MATHFN_FLOATN +#undef CASE_MATHFN_REENT +} + /* If BUILT_IN_NORMAL function FNDECL has an associated internal function, return its code, otherwise return IFN_LAST. Note that this function only tests whether the function is defined in internals.def, not whether diff --git a/gcc/builtins.h b/gcc/builtins.h index 504c618b851..72012a28e03 100644 --- a/gcc/builtins.h +++ b/gcc/builtins.h @@ -109,6 +109,7 @@ extern void expand_builtin_setjmp_receiver (rtx); extern void expand_builtin_update_setjmp_buf (rtx); extern tree mathfn_built_in (tree, enum built_in_function fn); extern tree mathfn_built_in (tree, combined_fn); +extern tree mathfn_built_in_type (combined_fn); extern rtx builtin_strncpy_read_str (void *, HOST_WIDE_INT, scalar_int_mode); extern rtx builtin_memset_read_str (void *, HOST_WIDE_INT, scalar_int_mode); extern rtx expand_builtin_saveregs (void); diff --git a/gcc/tree-ssa-math-opts.c b/gcc/tree-ssa-math-opts.c index faba007ce4c..1c02ac1e635 100644 --- a/gcc/tree-ssa-math-opts.c +++ b/gcc/tree-ssa-math-opts.c @@ -1171,31 +1171,24 @@ execute_cse_sincos_1 (tree name) continue; } - tree t = TREE_VALUE (TYPE_ARG_TYPES (gimple_call_fntype (use_stmt))); + tree t = mathfn_built_in_type (gimple_call_combined_fn (use_stmt)); if (!type) - type = t; - else if (t != type) { - if (!tree_nop_conversion_p (type, t)) - return false; - /* If there is more than one type to choose from, prefer one - that has a CEXPI builtin. */ - else if (!fndecl - && (fndecl = mathfn_built_in (t, BUILT_IN_CEXPI))) - type = t; + type = t; + t = TREE_TYPE (name); } + /* This checks that NAME has the right type in the first round, + and, in subsequent rounds, that the built_in type is the same + type. */ + if (type != t && !tree_nop_conversion_p (type, t)) + return false; } if (seen_cos + seen_sin + seen_cexpi <= 1) return false; - if (type != TREE_TYPE (name) - && !tree_nop_conversion_p (type, TREE_TYPE (name))) - return false; - /* Simply insert cexpi at the beginning of top_bb but not earlier than the name def statement. */ - if (!fndecl) - fndecl = mathfn_built_in (type, BUILT_IN_CEXPI); + fndecl = mathfn_built_in (type, BUILT_IN_CEXPI); if (!fndecl) return false; stmt = gimple_build_call (fndecl, 1, name);