* Michael Meissner:

> +enum reverse_cond_t {
> +  REVERSE_COND_ORDERED_OK,
> +  REVERSE_COND_NO_ORDERED
> +};

This should probably be something 
like

enum reverse_cond_t {
  ordered_ok,
  no_ordered,
};

to inhibit implicit conversion to integer types and bool.

(Completely untested.)

> +
>  extern enum rtx_code rs6000_reverse_condition (machine_mode,
> -                                            enum rtx_code);
> +                                            enum rtx_code,
> +                                            enum reverse_cond_t);
>  extern rtx rs6000_emit_eqne (machine_mode, rtx, rtx, rtx);
>  extern rtx rs6000_emit_fp_cror (rtx_code, machine_mode, rtx);
>  extern void rs6000_emit_sCOND (machine_mode, rtx[]);
> diff --git a/gcc/config/rs6000/rs6000.cc b/gcc/config/rs6000/rs6000.cc
> index f9f9a0b931d..c2235d917ad 100644
> --- a/gcc/config/rs6000/rs6000.cc
> +++ b/gcc/config/rs6000/rs6000.cc
> @@ -15360,17 +15360,38 @@ rs6000_print_patchable_function_entry (FILE *file,
>  }
>  
>  enum rtx_code
> -rs6000_reverse_condition (machine_mode mode, enum rtx_code code)
> +rs6000_reverse_condition (machine_mode mode,
> +                       enum rtx_code code,
> +                       enum reverse_cond_t ordered_cmp_ok)
>  {
>    /* Reversal of FP compares takes care -- an ordered compare
> -     becomes an unordered compare and vice versa.  */
> -  if (mode == CCFPmode
> -      && (!flag_finite_math_only
> -       || code == UNLT || code == UNLE || code == UNGT || code == UNGE
> -       || code == UNEQ || code == LTGT))
> -    return reverse_condition_maybe_unordered (code);
> -  else
> -    return reverse_condition (code);
> +     becomes an unordered compare and vice versa.
> +
> +     However, this is not safe for ordered comparisons (i.e. for isgreater,
> +     etc.)  starting with the power9 because ifcvt.cc will want to create a 
> fp
> +     cmove, and the x{s,v}cmp{eq,gt,ge}{dp,qp} instructions will trap if one 
> of
> +     the arguments is a signalling NaN.  */
> +
> +  if (mode == CCFPmode)
> +    {
> +      /* If NaNs are allowed, don't allow the reversal of floating point
> +      comparisons when the comparison is used in the context of a floating
> +      point conditional move when REVERSE_COND_NO_ORDERED is passed.  We do
> +      allow the comparsion to be reversed for explicit jumps when
> +      REVERSE_COND_ORDERED_OK is passed.  */
> +      if (!flag_finite_math_only)
> +     return (ordered_cmp_ok == REVERSE_COND_NO_ORDERED

That would turn into

  ordered_cmp_ok == reverse_cond_t::no_ordered

(Note that identifiers ending in _t are reserved by POSIX.)

Reply via email to