Changes since v1[1]: - Fixed english spelling; - Fixed code-style; - Changed match operand predicate in feclearexcept and feraiseexcept; - Changed testcase options; - Minor changes in test code to be C90 compatible; - Other minor changes sugested by Segher; - Changed subject line tag (not sure if I tagged correctly or should include optabs: also)
There is one pending question raised by Segher, It is about adding documentation, I am not sure if it is needed and if so, where it should be. I will quote the relevant part of the conversation[2] from the v1 thread for context: > > > +OPTAB_D (fegetround_optab, "fegetround$a") > > > +OPTAB_D (feclearexcept_optab, "feclearexcept$a") > > > +OPTAB_D (feraiseexcept_optab, "feraiseexcept$a") > >␣ > > Should those be documented somewhere? (In gcc/doc/ somewhere). > > I am lost on that one. I took a look on the docs (I hope looking on the > online docs was good enough) and I didn't find a place where i feel it > sits well. On the PowerPC target specific sections (6.60.22 Basic > PowerPC Built-in Functions), I didn't found it mentioning builtins that > are optimizations for the standard library functions, but we do have > many of these for Power. Then, on the generic section (6.59 Other > Built-in Functions Provided by GCC) it mentions C99 functions that have > builtins but it seems like it mentions builtins that have target > independent implementation, or at least it dos not say that some > builtins may be implemented on only some targets. And in this case > there is no implementation (for now) for any other target that is not > PowerPc. > > So, I don't know if or where this should be documented. tested on top of master (c5a6c2237a1156dc43fa32c938fc32acdfc2bff9) on the following plataforms with no regression: - powerpc64le-linux-gnu (Power 9) - powerpc64le-linux-gnu (Power 8) [1] https://gcc.gnu.org/pipermail/gcc-patches/2020-August/552024.html [2] https://gcc.gnu.org/pipermail/gcc-patches/2020-September/553295.html ---- 8< ---- This optimizations were originally in glibc, but was removed and sugested that they were a good fit as gcc builtins[1]. The associated bugreport: PR target/94193 [1] https://sourceware.org/legacy-ml/libc-alpha/2020-03/msg00047.html https://sourceware.org/legacy-ml/libc-alpha/2020-03/msg00080.html 2020-08-13 Raoni Fassina Firmino <ra...@linux.ibm.com> gcc/ChangeLog: * builtins.c (expand_builtin_fegetround): New function. (expand_builtin_feclear_feraise_except): New function. (expand_builtin): Add cases for BUILT_IN_FEGETROUND, BUILT_IN_FECLEAREXCEPT and BUILT_IN_FERAISEEXCEPT * config/rs6000/rs6000.md (fegetroundsi): New pattern. (feclearexceptsi): New Pattern. (feraiseexceptsi): New Pattern. * optabs.def (fegetround_optab): New optab. (feclearexcept_optab): New optab. (feraiseexcept_optab): New optab. gcc/testsuite/ChangeLog: * gcc.target/powerpc/builtin-feclearexcept-feraiseexcept-1.c: New test. * gcc.target/powerpc/builtin-feclearexcept-feraiseexcept-2.c: New test. * gcc.target/powerpc/builtin-fegetround.c: New test. Signed-off-by: Raoni Fassina Firmino <ra...@linux.ibm.com> FIX: patch_v1 (2) --- gcc/builtins.c | 76 ++++++++++ gcc/config/rs6000/rs6000.md | 82 +++++++++++ gcc/optabs.def | 4 + .../builtin-feclearexcept-feraiseexcept-1.c | 68 +++++++++ .../builtin-feclearexcept-feraiseexcept-2.c | 133 ++++++++++++++++++ .../gcc.target/powerpc/builtin-fegetround.c | 36 +++++ 6 files changed, 399 insertions(+) create mode 100644 gcc/testsuite/gcc.target/powerpc/builtin-feclearexcept-feraiseexcept-1.c create mode 100644 gcc/testsuite/gcc.target/powerpc/builtin-feclearexcept-feraiseexcept-2.c create mode 100644 gcc/testsuite/gcc.target/powerpc/builtin-fegetround.c diff --git a/gcc/builtins.c b/gcc/builtins.c index 97f1a184dc6..a6f6141edb7 100644 --- a/gcc/builtins.c +++ b/gcc/builtins.c @@ -115,6 +115,9 @@ static rtx expand_builtin_mathfn_3 (tree, rtx, rtx); static rtx expand_builtin_mathfn_ternary (tree, rtx, rtx); static rtx expand_builtin_interclass_mathfn (tree, rtx); static rtx expand_builtin_sincos (tree); +static rtx expand_builtin_fegetround (tree, rtx, machine_mode); +static rtx expand_builtin_feclear_feraise_except (tree, rtx, machine_mode, + optab); static rtx expand_builtin_cexpi (tree, rtx); static rtx expand_builtin_int_roundingfn (tree, rtx); static rtx expand_builtin_int_roundingfn_2 (tree, rtx); @@ -2701,6 +2704,59 @@ expand_builtin_sincos (tree exp) return const0_rtx; } +/* Expand call EXP to the fegetround builtin (from C99 venv.h), returning the + result and setting it in TARGET. Otherwise return NULL_RTX on failure. */ +static rtx +expand_builtin_fegetround (tree exp, rtx target, machine_mode target_mode) +{ + if (!validate_arglist (exp, VOID_TYPE)) + return NULL_RTX; + + insn_code icode = direct_optab_handler (fegetround_optab, SImode); + if (icode == CODE_FOR_nothing) + return NULL_RTX; + + if (target == 0 + || GET_MODE (target) != target_mode + || ! (*insn_data[icode].operand[0].predicate) (target, target_mode)) + target = gen_reg_rtx (target_mode); + + rtx pat = GEN_FCN (icode) (target); + if (! pat) + return NULL_RTX; + emit_insn (pat); + + return target; +} + +/* Expand call EXP to either feclearexcept or feraiseexcept builtins (from C99 + fenv.h), returning the result and setting it in TARGET. Otherwise return + NULL_RTX on failure. */ +static rtx +expand_builtin_feclear_feraise_except (tree exp, rtx target, + machine_mode target_mode, optab op_optab) +{ + if (!validate_arglist (exp, INTEGER_TYPE, VOID_TYPE)) + return NULL_RTX; + rtx op0 = expand_normal (CALL_EXPR_ARG (exp, 0)); + + insn_code icode = direct_optab_handler (op_optab, SImode); + if (icode == CODE_FOR_nothing) + return NULL_RTX; + + if (target == 0 + || GET_MODE (target) != target_mode + || ! (*insn_data[icode].operand[0].predicate) (target, target_mode)) + target = gen_reg_rtx (target_mode); + + rtx pat = GEN_FCN (icode) (target, op0); + if (!pat) + return NULL_RTX; + emit_insn (pat); + + return target; +} + /* Expand a call to the internal cexpi builtin to the sincos math function. EXP is the expression that is a call to the builtin function; if convenient, the result should be placed in TARGET. */ @@ -8290,6 +8346,26 @@ expand_builtin (tree exp, rtx target, rtx subtarget, machine_mode mode, return target; break; + case BUILT_IN_FEGETROUND: + target = expand_builtin_fegetround (exp, target, target_mode); + if (target) + return target; + break; + + case BUILT_IN_FECLEAREXCEPT: + target = expand_builtin_feclear_feraise_except (exp, target, target_mode, + feclearexcept_optab); + if (target) + return target; + break; + + case BUILT_IN_FERAISEEXCEPT: + target = expand_builtin_feclear_feraise_except (exp, target, target_mode, + feraiseexcept_optab); + if (target) + return target; + break; + case BUILT_IN_APPLY_ARGS: return expand_builtin_apply_args (); diff --git a/gcc/config/rs6000/rs6000.md b/gcc/config/rs6000/rs6000.md index 43b620ae1c0..c19908040d1 100644 --- a/gcc/config/rs6000/rs6000.md +++ b/gcc/config/rs6000/rs6000.md @@ -6565,6 +6565,88 @@ [(set_attr "type" "fpload") (set_attr "length" "8") (set_attr "isa" "*,p8v,p8v")]) + +;; int __builtin_fegetround() +(define_expand "fegetroundsi" + [(use (match_operand:SI 0 "gpc_reg_operand"))] + "TARGET_HARD_FLOAT" +{ + rtx tmp_df = gen_reg_rtx (DFmode); + emit_insn (gen_rs6000_mffsl (tmp_df)); + + rtx tmp_di = simplify_gen_subreg (DImode, tmp_df, DFmode, 0); + rtx tmp_di_2 = gen_reg_rtx (DImode); + emit_insn (gen_anddi3 (tmp_di_2, tmp_di, GEN_INT (3))); + rtx tmp_si = gen_reg_rtx (SImode); + tmp_si = simplify_gen_subreg (SImode, tmp_di_2, DImode, 0); + emit_move_insn (operands[0], tmp_si); + DONE; +}) + +;; int feclearexcept(int excepts) +;; +;; This expansion for the C99 function only works when excepts is a +;; constant know at compile time and specifying only one of +;; FE_INEXACT, FE_DIVBYZERO, FE_UNDERFLOW and FE_OVERFLOW flags. +;; It doesn't handle values out of range, and always returns 0. +;; Note that FE_INVALID is unsuported because it maps to more than +;; one bit on FPSCR register. +;; Because of these restrictions, this only expands on the desired cases. +(define_expand "feclearexceptsi" + [(use (match_operand:SI 1 "const_int_operand" "n")) + (set (match_operand:SI 0 "gpc_reg_operand") + (const_int 0))] + "TARGET_HARD_FLOAT" +{ + switch (INTVAL (operands[1])) + { + case 0x2000000: /* FE_INEXACT */ + case 0x4000000: /* FE_DIVBYZERO */ + case 0x8000000: /* FE_UNDERFLOW */ + case 0x10000000: /* FE_OVERFLOW */ + break; + default: + FAIL; + } + + rtx tmp = gen_rtx_CONST_INT (SImode, __builtin_clz (INTVAL (operands[1]))); + emit_insn (gen_rs6000_mtfsb0 (tmp)); + emit_move_insn (operands[0], const0_rtx); + DONE; +}) + +;; int fegraiseexcept(int excepts) +;; +;; This expansion for the C99 function only works when excepts is a +;; constant know at compile time and specifying only one of +;; FE_INEXACT, FE_DIVBYZERO, FE_UNDERFLOW and FE_OVERFLOW flags. +;; It doesn't handle values out of range, and always returns 0. +;; Note that FE_INVALID is unsupported because it maps to more than +;; one bit on FPSCR register. +;; Because of these restrictions, this only expands on the desired cases. +(define_expand "feraiseexceptsi" + [(use (match_operand:SI 1 "const_int_operand" "n")) + (set (match_operand:SI 0 "gpc_reg_operand") + (const_int 0))] + "TARGET_HARD_FLOAT" +{ + switch (INTVAL (operands[1])) + { + case 0x2000000: /* FE_INEXACT */ + case 0x4000000: /* FE_DIVBYZERO */ + case 0x8000000: /* FE_UNDERFLOW */ + case 0x10000000: /* FE_OVERFLOW */ + break; + default: + FAIL; + } + + rtx tmp = gen_rtx_CONST_INT (SImode, __builtin_clz (INTVAL (operands[1]))); + emit_insn (gen_rs6000_mtfsb1 (tmp)); + emit_move_insn (operands[0], const0_rtx); + DONE; +}) + ;; Define the TImode operations that can be done in a small number ;; of instructions. The & constraints are to prevent the register diff --git a/gcc/optabs.def b/gcc/optabs.def index 78409aa1453..987ee0f79dc 100644 --- a/gcc/optabs.def +++ b/gcc/optabs.def @@ -318,6 +318,10 @@ OPTAB_D (sinh_optab, "sinh$a2") OPTAB_D (tan_optab, "tan$a2") OPTAB_D (tanh_optab, "tanh$a2") +OPTAB_D (fegetround_optab, "fegetround$a") +OPTAB_D (feclearexcept_optab, "feclearexcept$a") +OPTAB_D (feraiseexcept_optab, "feraiseexcept$a") + /* C99 implementations of fmax/fmin. */ OPTAB_D (fmax_optab, "fmax$a3") OPTAB_D (fmin_optab, "fmin$a3") diff --git a/gcc/testsuite/gcc.target/powerpc/builtin-feclearexcept-feraiseexcept-1.c b/gcc/testsuite/gcc.target/powerpc/builtin-feclearexcept-feraiseexcept-1.c new file mode 100644 index 00000000000..a2977d188e5 --- /dev/null +++ b/gcc/testsuite/gcc.target/powerpc/builtin-feclearexcept-feraiseexcept-1.c @@ -0,0 +1,68 @@ +/* { dg-do run } */ +/* { dg-require-effective-target fenv_exceptions } */ +/* { dg-options "-lm -fno-builtin" } */ + +/* This testcase ensures that the builtins expand with the matching arguments + * or otherwise fallback gracefull to a function call, and don't ICE during + * compilation. */ + +#include <fenv.h> + +/* We use __builtin_* version to avoid the function be replaced by glibc that + * may have an inline optimization for it in fenv.h. */ +int +main () +{ + int rsi = 0; + long rsl = 0; + short rss = 0; + char rsc = 0; + + unsigned int rui = 0; + unsigned long rul = 0; + unsigned short rus = 0; + unsigned char ruc = 0; + + int e = FE_DIVBYZERO; + + __builtin_feclearexcept(e); // CALL + __builtin_feclearexcept(0); // CALL + __builtin_feclearexcept(FE_ALL_EXCEPT); // CALL + __builtin_feclearexcept(FE_INVALID); // CALL + __builtin_feclearexcept(FE_INEXACT | FE_DIVBYZERO); // CALL + __builtin_feclearexcept(FE_INEXACT); // EXPAND + __builtin_feclearexcept(FE_DIVBYZERO); // EXPAND + __builtin_feclearexcept(FE_UNDERFLOW); // EXPAND + __builtin_feclearexcept(FE_OVERFLOW); // EXPAND + + rsi = __builtin_feclearexcept(FE_DIVBYZERO); // EXPAND + rsl = __builtin_feclearexcept(FE_DIVBYZERO); // EXPAND + rss = __builtin_feclearexcept(FE_DIVBYZERO); // EXPAND + rsc = __builtin_feclearexcept(FE_DIVBYZERO); // EXPAND + rui = __builtin_feclearexcept(FE_DIVBYZERO); // EXPAND + rul = __builtin_feclearexcept(FE_DIVBYZERO); // EXPAND + rus = __builtin_feclearexcept(FE_DIVBYZERO); // EXPAND + ruc = __builtin_feclearexcept(FE_DIVBYZERO); // EXPAND + + + __builtin_feraiseexcept(e); // CALL + __builtin_feraiseexcept(0); // CALL + __builtin_feraiseexcept(FE_ALL_EXCEPT); // CALL + __builtin_feraiseexcept(FE_INVALID); // CALL + __builtin_feraiseexcept(FE_INEXACT | FE_DIVBYZERO); // CALL + __builtin_feraiseexcept(FE_INEXACT); // EXPAND + __builtin_feraiseexcept(FE_DIVBYZERO); // EXPAND + __builtin_feraiseexcept(FE_UNDERFLOW); // EXPAND + __builtin_feraiseexcept(FE_OVERFLOW); // EXPAND + + rsi = __builtin_feraiseexcept(FE_DIVBYZERO); // EXPAND + rsl = __builtin_feraiseexcept(FE_DIVBYZERO); // EXPAND + rss = __builtin_feraiseexcept(FE_DIVBYZERO); // EXPAND + rsc = __builtin_feraiseexcept(FE_DIVBYZERO); // EXPAND + rui = __builtin_feraiseexcept(FE_DIVBYZERO); // EXPAND + rul = __builtin_feraiseexcept(FE_DIVBYZERO); // EXPAND + rus = __builtin_feraiseexcept(FE_DIVBYZERO); // EXPAND + ruc = __builtin_feraiseexcept(FE_DIVBYZERO); // EXPAND + + return 0; +} diff --git a/gcc/testsuite/gcc.target/powerpc/builtin-feclearexcept-feraiseexcept-2.c b/gcc/testsuite/gcc.target/powerpc/builtin-feclearexcept-feraiseexcept-2.c new file mode 100644 index 00000000000..4eb2a63d48f --- /dev/null +++ b/gcc/testsuite/gcc.target/powerpc/builtin-feclearexcept-feraiseexcept-2.c @@ -0,0 +1,133 @@ +/* { dg-do run } */ +/* { dg-require-effective-target fenv_exceptions } */ +/* { dg-options "-lm -fno-builtin" } */ + +/* This testcase ensures that the builtins are correctly expanded and match the + * expected result. */ + +#include <fenv.h> + +#ifdef DEBUG +#include <stdio.h> +#define INFO(...) printf(__VA_ARGS__) +#define FAIL(v, e, x, s, f) \ + printf("ERROR [l %d] testing %s(%x): %s returned %x," \ + " expecected %x\n", __LINE__, s, x, f, v, e) +#else +void abort (void); +#define INFO(...) +#define FAIL(v, e, x, s, f) abort() +#endif + +/* We use __builtin_* version to avoid the function be replaced by glibc that + * may have an inline optimization for it in fenv.h. */ +int +main () +{ + char *s = 0; + int e = 0; + int raised = 0; + + s = "FE_ALL_EXCEPT"; + e = FE_ALL_EXCEPT; + INFO("test: %s(%x)\n", s, e); + + feclearexcept(FE_ALL_EXCEPT); + __builtin_feraiseexcept(FE_ALL_EXCEPT); + raised = fetestexcept(FE_ALL_EXCEPT); + if (raised != e) + FAIL(raised, e, e, s, "__builtin_feraiseexcept"); + + feraiseexcept(FE_ALL_EXCEPT); + __builtin_feclearexcept(FE_ALL_EXCEPT); + raised = fetestexcept(FE_ALL_EXCEPT); + if (raised == FE_ALL_EXCEPT & ~e) + FAIL(raised, FE_ALL_EXCEPT & ~e, e, s, "__builtin_feclearexcept"); + + + s = "FE_DIVBYZERO"; + e = FE_DIVBYZERO; + INFO("test: %s(%x)\n", s, e); + + feclearexcept(FE_ALL_EXCEPT); + __builtin_feraiseexcept(FE_DIVBYZERO); + raised = fetestexcept(FE_ALL_EXCEPT); + if (raised != e) + FAIL(raised, e, e, s, "__builtin_feraiseexcept"); + + feraiseexcept(FE_ALL_EXCEPT); + __builtin_feclearexcept(FE_DIVBYZERO); + raised = fetestexcept(FE_ALL_EXCEPT); + if (raised == FE_ALL_EXCEPT & ~e) + FAIL(raised, FE_ALL_EXCEPT & ~e, e, s, "__builtin_feclearexcept"); + + + s = "FE_INEXACT"; + e = FE_INEXACT; + INFO("test: %s(%x)\n", s, e); + + feclearexcept(FE_ALL_EXCEPT); + __builtin_feraiseexcept(FE_INEXACT); + raised = fetestexcept(FE_ALL_EXCEPT); + if (raised != e) + FAIL(raised, e, e, s, "__builtin_feraiseexcept"); + + feraiseexcept(FE_ALL_EXCEPT); + __builtin_feclearexcept(FE_INEXACT); + raised = fetestexcept(FE_ALL_EXCEPT); + if (raised == FE_ALL_EXCEPT & ~e) + FAIL(raised, FE_ALL_EXCEPT & ~e, e, s, "__builtin_feclearexcept"); + + + s = "FE_OVERFLOW"; + e = FE_OVERFLOW; + INFO("test: %s(%x)\n", s, e); + + feclearexcept(FE_ALL_EXCEPT); + __builtin_feraiseexcept(FE_OVERFLOW); + raised = fetestexcept(FE_ALL_EXCEPT); + if (raised != e) + FAIL(raised, e, e, s, "__builtin_feraiseexcept"); + + feraiseexcept(FE_ALL_EXCEPT); + __builtin_feclearexcept(FE_OVERFLOW); + raised = fetestexcept(FE_ALL_EXCEPT); + if (raised == FE_ALL_EXCEPT & ~e) + FAIL(raised, FE_ALL_EXCEPT & ~e, e, s, "__builtin_feclearexcept"); + + + s = "FE_UNDERFLOW"; + e = FE_UNDERFLOW; + INFO("test: %s(%x)\n", s, e); + + feclearexcept(FE_ALL_EXCEPT); + __builtin_feraiseexcept(FE_UNDERFLOW); + raised = fetestexcept(FE_ALL_EXCEPT); + if (raised != e) + FAIL(raised, e, e, s, "__builtin_feraiseexcept"); + + feraiseexcept(FE_ALL_EXCEPT); + __builtin_feclearexcept(FE_UNDERFLOW); + raised = fetestexcept(FE_ALL_EXCEPT); + if (raised == FE_ALL_EXCEPT & ~e) + FAIL(raised, FE_ALL_EXCEPT & ~e, e, s, "__builtin_feclearexcept"); + + + s = "FE_INVALID"; + e = FE_INVALID; + INFO("test: %s(%x)\n", s, e); + + feclearexcept(FE_ALL_EXCEPT); + __builtin_feraiseexcept(FE_INVALID); + raised = fetestexcept(FE_ALL_EXCEPT); + if (raised != e) + FAIL(raised, e, e, s, "__builtin_feraiseexcept"); + + feraiseexcept(FE_ALL_EXCEPT); + __builtin_feclearexcept(FE_INVALID); + raised = fetestexcept(FE_ALL_EXCEPT); + if (raised == FE_ALL_EXCEPT & ~e) + FAIL(raised, FE_ALL_EXCEPT & ~e, e, s, "__builtin_feclearexcept"); + + return 0; +} diff --git a/gcc/testsuite/gcc.target/powerpc/builtin-fegetround.c b/gcc/testsuite/gcc.target/powerpc/builtin-fegetround.c new file mode 100644 index 00000000000..c3649f874a5 --- /dev/null +++ b/gcc/testsuite/gcc.target/powerpc/builtin-fegetround.c @@ -0,0 +1,36 @@ +/* { dg-do run } */ +/* { dg-require-effective-target fenv_exceptions } */ +/* { dg-options "-lm -fno-builtin" } */ + +/* This testcase ensures that the builtins is correctly expanded and match the + * expected result from the standard function. */ + +#include <fenv.h> + +#ifdef DEBUG +#include <stdio.h> +#define FAIL(v, e) printf("ERROR, __builtin_fegetround() returned %d," \ + " not the expecected value %d\n", v, e); +#else +void abort (void); +#define FAIL(v, e) abort() +#endif + +/* We use __builtin_* version to avoid the function be replaced by glibc that + * may have an inline optimization for it in fenv.h. */ +int +main () +{ + int i, rounding, expected; + const int rm[] = {FE_TONEAREST, FE_TOWARDZERO, FE_UPWARD, FE_DOWNWARD}; + for (i = 0; i < sizeof(rm); i++) + { + fesetround(rm[i]); + rounding = __builtin_fegetround(); + expected = fegetround(); + if (rounding != expected) + FAIL(rounding, expected); + } + + return 0; +} -- 2.26.2