1 /* Constant folding for calls to built-in and internal functions.
2 Copyright (C) 1988-2019 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
22 #include "coretypes.h"
25 #include "stor-layout.h"
27 #include "fold-const.h"
28 #include "fold-const-call.h"
29 #include "case-cfn-macros.h"
30 #include "tm.h" /* For C[LT]Z_DEFINED_AT_ZERO. */
32 #include "gimple-expr.h"
33 #include "tree-vector-builder.h"
35 /* Functions that test for certain constant types, abstracting away the
36 decision about whether to check for overflow. */
39 integer_cst_p (tree t
)
41 return TREE_CODE (t
) == INTEGER_CST
&& !TREE_OVERFLOW (t
);
47 return TREE_CODE (t
) == REAL_CST
&& !TREE_OVERFLOW (t
);
51 complex_cst_p (tree t
)
53 return TREE_CODE (t
) == COMPLEX_CST
;
56 /* Return true if ARG is a constant in the range of the host size_t.
57 Store it in *SIZE_OUT if so. */
60 host_size_t_cst_p (tree t
, size_t *size_out
)
62 if (types_compatible_p (size_type_node
, TREE_TYPE (t
))
64 && (wi::min_precision (wi::to_wide (t
), UNSIGNED
)
65 <= sizeof (size_t) * CHAR_BIT
))
67 *size_out
= tree_to_uhwi (t
);
73 /* RES is the result of a comparison in which < 0 means "less", 0 means
74 "equal" and > 0 means "more". Canonicalize it to -1, 0 or 1 and
75 return it in type TYPE. */
78 build_cmp_result (tree type
, int res
)
80 return build_int_cst (type
, res
< 0 ? -1 : res
> 0 ? 1 : 0);
83 /* M is the result of trying to constant-fold an expression (starting
84 with clear MPFR flags) and INEXACT says whether the result in M is
85 exact or inexact. Return true if M can be used as a constant-folded
86 result in format FORMAT, storing the value in *RESULT if so. */
89 do_mpfr_ckconv (real_value
*result
, mpfr_srcptr m
, bool inexact
,
90 const real_format
*format
)
92 /* Proceed iff we get a normal number, i.e. not NaN or Inf and no
93 overflow/underflow occurred. If -frounding-math, proceed iff the
94 result of calling FUNC was exact. */
95 if (!mpfr_number_p (m
)
97 || mpfr_underflow_p ()
98 || (flag_rounding_math
&& inexact
))
102 real_from_mpfr (&tmp
, m
, format
, GMP_RNDN
);
104 /* Proceed iff GCC's REAL_VALUE_TYPE can hold the MPFR values.
105 If the REAL_VALUE_TYPE is zero but the mpft_t is not, then we
106 underflowed in the conversion. */
107 if (!real_isfinite (&tmp
)
108 || ((tmp
.cl
== rvc_zero
) != (mpfr_zero_p (m
) != 0)))
111 real_convert (result
, format
, &tmp
);
112 return real_identical (result
, &tmp
);
119 in format FORMAT, given that FUNC is the MPFR implementation of f.
120 Return true on success. */
123 do_mpfr_arg1 (real_value
*result
,
124 int (*func
) (mpfr_ptr
, mpfr_srcptr
, mpfr_rnd_t
),
125 const real_value
*arg
, const real_format
*format
)
127 /* To proceed, MPFR must exactly represent the target floating point
128 format, which only happens when the target base equals two. */
129 if (format
->b
!= 2 || !real_isfinite (arg
))
132 int prec
= format
->p
;
133 mp_rnd_t rnd
= format
->round_towards_zero
? GMP_RNDZ
: GMP_RNDN
;
136 mpfr_init2 (m
, prec
);
137 mpfr_from_real (m
, arg
, GMP_RNDN
);
139 bool inexact
= func (m
, m
, rnd
);
140 bool ok
= do_mpfr_ckconv (result
, m
, inexact
, format
);
148 *RESULT_SIN = sin (*ARG);
149 *RESULT_COS = cos (*ARG);
151 for format FORMAT. Return true on success. */
154 do_mpfr_sincos (real_value
*result_sin
, real_value
*result_cos
,
155 const real_value
*arg
, const real_format
*format
)
157 /* To proceed, MPFR must exactly represent the target floating point
158 format, which only happens when the target base equals two. */
159 if (format
->b
!= 2 || !real_isfinite (arg
))
162 int prec
= format
->p
;
163 mp_rnd_t rnd
= format
->round_towards_zero
? GMP_RNDZ
: GMP_RNDN
;
166 mpfr_inits2 (prec
, m
, ms
, mc
, NULL
);
167 mpfr_from_real (m
, arg
, GMP_RNDN
);
169 bool inexact
= mpfr_sin_cos (ms
, mc
, m
, rnd
);
170 bool ok
= (do_mpfr_ckconv (result_sin
, ms
, inexact
, format
)
171 && do_mpfr_ckconv (result_cos
, mc
, inexact
, format
));
172 mpfr_clears (m
, ms
, mc
, NULL
);
179 *RESULT = f (*ARG0, *ARG1)
181 in format FORMAT, given that FUNC is the MPFR implementation of f.
182 Return true on success. */
185 do_mpfr_arg2 (real_value
*result
,
186 int (*func
) (mpfr_ptr
, mpfr_srcptr
, mpfr_srcptr
, mpfr_rnd_t
),
187 const real_value
*arg0
, const real_value
*arg1
,
188 const real_format
*format
)
190 /* To proceed, MPFR must exactly represent the target floating point
191 format, which only happens when the target base equals two. */
192 if (format
->b
!= 2 || !real_isfinite (arg0
) || !real_isfinite (arg1
))
195 int prec
= format
->p
;
196 mp_rnd_t rnd
= format
->round_towards_zero
? GMP_RNDZ
: GMP_RNDN
;
199 mpfr_inits2 (prec
, m0
, m1
, NULL
);
200 mpfr_from_real (m0
, arg0
, GMP_RNDN
);
201 mpfr_from_real (m1
, arg1
, GMP_RNDN
);
203 bool inexact
= func (m0
, m0
, m1
, rnd
);
204 bool ok
= do_mpfr_ckconv (result
, m0
, inexact
, format
);
205 mpfr_clears (m0
, m1
, NULL
);
212 *RESULT = f (ARG0, *ARG1)
214 in format FORMAT, given that FUNC is the MPFR implementation of f.
215 Return true on success. */
218 do_mpfr_arg2 (real_value
*result
,
219 int (*func
) (mpfr_ptr
, long, mpfr_srcptr
, mp_rnd_t
),
220 const wide_int_ref
&arg0
, const real_value
*arg1
,
221 const real_format
*format
)
223 if (format
->b
!= 2 || !real_isfinite (arg1
))
226 int prec
= format
->p
;
227 mp_rnd_t rnd
= format
->round_towards_zero
? GMP_RNDZ
: GMP_RNDN
;
230 mpfr_init2 (m
, prec
);
231 mpfr_from_real (m
, arg1
, GMP_RNDN
);
233 bool inexact
= func (m
, arg0
.to_shwi (), m
, rnd
);
234 bool ok
= do_mpfr_ckconv (result
, m
, inexact
, format
);
242 *RESULT = f (*ARG0, *ARG1, *ARG2)
244 in format FORMAT, given that FUNC is the MPFR implementation of f.
245 Return true on success. */
248 do_mpfr_arg3 (real_value
*result
,
249 int (*func
) (mpfr_ptr
, mpfr_srcptr
, mpfr_srcptr
,
250 mpfr_srcptr
, mpfr_rnd_t
),
251 const real_value
*arg0
, const real_value
*arg1
,
252 const real_value
*arg2
, const real_format
*format
)
254 /* To proceed, MPFR must exactly represent the target floating point
255 format, which only happens when the target base equals two. */
257 || !real_isfinite (arg0
)
258 || !real_isfinite (arg1
)
259 || !real_isfinite (arg2
))
262 int prec
= format
->p
;
263 mp_rnd_t rnd
= format
->round_towards_zero
? GMP_RNDZ
: GMP_RNDN
;
266 mpfr_inits2 (prec
, m0
, m1
, m2
, NULL
);
267 mpfr_from_real (m0
, arg0
, GMP_RNDN
);
268 mpfr_from_real (m1
, arg1
, GMP_RNDN
);
269 mpfr_from_real (m2
, arg2
, GMP_RNDN
);
271 bool inexact
= func (m0
, m0
, m1
, m2
, rnd
);
272 bool ok
= do_mpfr_ckconv (result
, m0
, inexact
, format
);
273 mpfr_clears (m0
, m1
, m2
, NULL
);
278 /* M is the result of trying to constant-fold an expression (starting
279 with clear MPFR flags) and INEXACT says whether the result in M is
280 exact or inexact. Return true if M can be used as a constant-folded
281 result in which the real and imaginary parts have format FORMAT.
282 Store those parts in *RESULT_REAL and *RESULT_IMAG if so. */
285 do_mpc_ckconv (real_value
*result_real
, real_value
*result_imag
,
286 mpc_srcptr m
, bool inexact
, const real_format
*format
)
288 /* Proceed iff we get a normal number, i.e. not NaN or Inf and no
289 overflow/underflow occurred. If -frounding-math, proceed iff the
290 result of calling FUNC was exact. */
291 if (!mpfr_number_p (mpc_realref (m
))
292 || !mpfr_number_p (mpc_imagref (m
))
293 || mpfr_overflow_p ()
294 || mpfr_underflow_p ()
295 || (flag_rounding_math
&& inexact
))
298 REAL_VALUE_TYPE tmp_real
, tmp_imag
;
299 real_from_mpfr (&tmp_real
, mpc_realref (m
), format
, GMP_RNDN
);
300 real_from_mpfr (&tmp_imag
, mpc_imagref (m
), format
, GMP_RNDN
);
302 /* Proceed iff GCC's REAL_VALUE_TYPE can hold the MPFR values.
303 If the REAL_VALUE_TYPE is zero but the mpft_t is not, then we
304 underflowed in the conversion. */
305 if (!real_isfinite (&tmp_real
)
306 || !real_isfinite (&tmp_imag
)
307 || (tmp_real
.cl
== rvc_zero
) != (mpfr_zero_p (mpc_realref (m
)) != 0)
308 || (tmp_imag
.cl
== rvc_zero
) != (mpfr_zero_p (mpc_imagref (m
)) != 0))
311 real_convert (result_real
, format
, &tmp_real
);
312 real_convert (result_imag
, format
, &tmp_imag
);
314 return (real_identical (result_real
, &tmp_real
)
315 && real_identical (result_imag
, &tmp_imag
));
322 in format FORMAT, given that FUNC is the mpc implementation of f.
323 Return true on success. Both RESULT and ARG are represented as
324 real and imaginary pairs. */
327 do_mpc_arg1 (real_value
*result_real
, real_value
*result_imag
,
328 int (*func
) (mpc_ptr
, mpc_srcptr
, mpc_rnd_t
),
329 const real_value
*arg_real
, const real_value
*arg_imag
,
330 const real_format
*format
)
332 /* To proceed, MPFR must exactly represent the target floating point
333 format, which only happens when the target base equals two. */
335 || !real_isfinite (arg_real
)
336 || !real_isfinite (arg_imag
))
339 int prec
= format
->p
;
340 mpc_rnd_t crnd
= format
->round_towards_zero
? MPC_RNDZZ
: MPC_RNDNN
;
344 mpfr_from_real (mpc_realref (m
), arg_real
, GMP_RNDN
);
345 mpfr_from_real (mpc_imagref (m
), arg_imag
, GMP_RNDN
);
347 bool inexact
= func (m
, m
, crnd
);
348 bool ok
= do_mpc_ckconv (result_real
, result_imag
, m
, inexact
, format
);
356 RESULT = f (ARG0, ARG1)
358 in format FORMAT, given that FUNC is the mpc implementation of f.
359 Return true on success. RESULT, ARG0 and ARG1 are represented as
360 real and imaginary pairs. */
363 do_mpc_arg2 (real_value
*result_real
, real_value
*result_imag
,
364 int (*func
)(mpc_ptr
, mpc_srcptr
, mpc_srcptr
, mpc_rnd_t
),
365 const real_value
*arg0_real
, const real_value
*arg0_imag
,
366 const real_value
*arg1_real
, const real_value
*arg1_imag
,
367 const real_format
*format
)
369 if (!real_isfinite (arg0_real
)
370 || !real_isfinite (arg0_imag
)
371 || !real_isfinite (arg1_real
)
372 || !real_isfinite (arg1_imag
))
375 int prec
= format
->p
;
376 mpc_rnd_t crnd
= format
->round_towards_zero
? MPC_RNDZZ
: MPC_RNDNN
;
379 mpc_init2 (m0
, prec
);
380 mpc_init2 (m1
, prec
);
381 mpfr_from_real (mpc_realref (m0
), arg0_real
, GMP_RNDN
);
382 mpfr_from_real (mpc_imagref (m0
), arg0_imag
, GMP_RNDN
);
383 mpfr_from_real (mpc_realref (m1
), arg1_real
, GMP_RNDN
);
384 mpfr_from_real (mpc_imagref (m1
), arg1_imag
, GMP_RNDN
);
386 bool inexact
= func (m0
, m0
, m1
, crnd
);
387 bool ok
= do_mpc_ckconv (result_real
, result_imag
, m0
, inexact
, format
);
396 *RESULT = logb (*ARG)
398 in format FORMAT. Return true on success. */
401 fold_const_logb (real_value
*result
, const real_value
*arg
,
402 const real_format
*format
)
407 /* If arg is +-NaN, then return it. */
412 /* If arg is +-Inf, then return +Inf. */
418 /* Zero may set errno and/or raise an exception. */
422 /* For normal numbers, proceed iff radix == 2. In GCC,
423 normalized significands are in the range [0.5, 1.0). We
424 want the exponent as if they were [1.0, 2.0) so get the
425 exponent and subtract 1. */
428 real_from_integer (result
, format
, REAL_EXP (arg
) - 1, SIGNED
);
438 *RESULT = significand (*ARG)
440 in format FORMAT. Return true on success. */
443 fold_const_significand (real_value
*result
, const real_value
*arg
,
444 const real_format
*format
)
451 /* If arg is +-0, +-Inf or +-NaN, then return it. */
456 /* For normal numbers, proceed iff radix == 2. */
460 /* In GCC, normalized significands are in the range [0.5, 1.0).
461 We want them to be [1.0, 2.0) so set the exponent to 1. */
462 SET_REAL_EXP (result
, 1);
474 where FORMAT is the format of *ARG and PRECISION is the number of
475 significant bits in the result. Return true on success. */
478 fold_const_conversion (wide_int
*result
,
479 void (*fn
) (real_value
*, format_helper
,
481 const real_value
*arg
, unsigned int precision
,
482 const real_format
*format
)
484 if (!real_isfinite (arg
))
488 fn (&rounded
, format
, arg
);
491 *result
= real_to_integer (&rounded
, &fail
, precision
);
497 *RESULT = pow (*ARG0, *ARG1)
499 in format FORMAT. Return true on success. */
502 fold_const_pow (real_value
*result
, const real_value
*arg0
,
503 const real_value
*arg1
, const real_format
*format
)
505 if (do_mpfr_arg2 (result
, mpfr_pow
, arg0
, arg1
, format
))
508 /* Check for an integer exponent. */
509 REAL_VALUE_TYPE cint1
;
510 HOST_WIDE_INT n1
= real_to_integer (arg1
);
511 real_from_integer (&cint1
, VOIDmode
, n1
, SIGNED
);
512 /* Attempt to evaluate pow at compile-time, unless this should
513 raise an exception. */
514 if (real_identical (arg1
, &cint1
)
516 || (!flag_trapping_math
&& !flag_errno_math
)
517 || !real_equal (arg0
, &dconst0
)))
519 bool inexact
= real_powi (result
, format
, arg0
, n1
);
520 /* Avoid the folding if flag_signaling_nans is on. */
521 if (flag_unsafe_math_optimizations
523 && !(flag_signaling_nans
524 && REAL_VALUE_ISSIGNALING_NAN (*arg0
))))
533 *RESULT = nextafter (*ARG0, *ARG1)
537 *RESULT = nexttoward (*ARG0, *ARG1)
539 in format FORMAT. Return true on success. */
542 fold_const_nextafter (real_value
*result
, const real_value
*arg0
,
543 const real_value
*arg1
, const real_format
*format
)
545 if (REAL_VALUE_ISSIGNALING_NAN (*arg0
)
546 || REAL_VALUE_ISSIGNALING_NAN (*arg1
))
549 /* Don't handle composite modes, nor decimal, nor modes without
550 inf or denorm at least for now. */
551 if (format
->pnan
< format
->p
554 || !format
->has_denorm
)
557 if (real_nextafter (result
, format
, arg0
, arg1
)
558 /* If raising underflow or overflow and setting errno to ERANGE,
559 fail if we care about those side-effects. */
560 && (flag_trapping_math
|| flag_errno_math
))
562 /* Similarly for nextafter (0, 1) raising underflow. */
563 else if (flag_trapping_math
564 && arg0
->cl
== rvc_zero
565 && result
->cl
!= rvc_zero
)
568 real_convert (result
, format
, result
);
575 *RESULT = ldexp (*ARG0, ARG1)
577 in format FORMAT. Return true on success. */
580 fold_const_builtin_load_exponent (real_value
*result
, const real_value
*arg0
,
581 const wide_int_ref
&arg1
,
582 const real_format
*format
)
584 /* Bound the maximum adjustment to twice the range of the
585 mode's valid exponents. Use abs to ensure the range is
586 positive as a sanity check. */
587 int max_exp_adj
= 2 * labs (format
->emax
- format
->emin
);
589 /* The requested adjustment must be inside this range. This
590 is a preliminary cap to avoid things like overflow, we
591 may still fail to compute the result for other reasons. */
592 if (wi::les_p (arg1
, -max_exp_adj
) || wi::ges_p (arg1
, max_exp_adj
))
595 /* Don't perform operation if we honor signaling NaNs and
596 operand is a signaling NaN. */
597 if (!flag_unsafe_math_optimizations
598 && flag_signaling_nans
599 && REAL_VALUE_ISSIGNALING_NAN (*arg0
))
602 REAL_VALUE_TYPE initial_result
;
603 real_ldexp (&initial_result
, arg0
, arg1
.to_shwi ());
605 /* Ensure we didn't overflow. */
606 if (real_isinf (&initial_result
))
609 /* Only proceed if the target mode can hold the
611 *result
= real_value_truncate (format
, initial_result
);
612 return real_equal (&initial_result
, result
);
615 /* Fold a call to __builtin_nan or __builtin_nans with argument ARG and
616 return type TYPE. QUIET is true if a quiet rather than signalling
620 fold_const_builtin_nan (tree type
, tree arg
, bool quiet
)
622 REAL_VALUE_TYPE real
;
623 const char *str
= c_getstr (arg
);
624 if (str
&& real_nan (&real
, str
, quiet
, TYPE_MODE (type
)))
625 return build_real (type
, real
);
629 /* Fold a call to IFN_REDUC_<CODE> (ARG), returning a value of type TYPE. */
632 fold_const_reduction (tree type
, tree arg
, tree_code code
)
634 unsigned HOST_WIDE_INT nelts
;
635 if (TREE_CODE (arg
) != VECTOR_CST
636 || !VECTOR_CST_NELTS (arg
).is_constant (&nelts
))
639 tree res
= VECTOR_CST_ELT (arg
, 0);
640 for (unsigned HOST_WIDE_INT i
= 1; i
< nelts
; i
++)
642 res
= const_binop (code
, type
, res
, VECTOR_CST_ELT (arg
, i
));
643 if (res
== NULL_TREE
|| !CONSTANT_CLASS_P (res
))
649 /* Fold a call to IFN_VEC_CONVERT (ARG) returning TYPE. */
652 fold_const_vec_convert (tree ret_type
, tree arg
)
654 enum tree_code code
= NOP_EXPR
;
655 tree arg_type
= TREE_TYPE (arg
);
656 if (TREE_CODE (arg
) != VECTOR_CST
)
659 gcc_checking_assert (VECTOR_TYPE_P (ret_type
) && VECTOR_TYPE_P (arg_type
));
661 if (INTEGRAL_TYPE_P (TREE_TYPE (ret_type
))
662 && SCALAR_FLOAT_TYPE_P (TREE_TYPE (arg_type
)))
663 code
= FIX_TRUNC_EXPR
;
664 else if (INTEGRAL_TYPE_P (TREE_TYPE (arg_type
))
665 && SCALAR_FLOAT_TYPE_P (TREE_TYPE (ret_type
)))
668 tree_vector_builder elts
;
669 elts
.new_unary_operation (ret_type
, arg
, true);
670 unsigned int count
= elts
.encoded_nelts ();
671 for (unsigned int i
= 0; i
< count
; ++i
)
673 tree elt
= fold_unary (code
, TREE_TYPE (ret_type
),
674 VECTOR_CST_ELT (arg
, i
));
675 if (elt
== NULL_TREE
|| !CONSTANT_CLASS_P (elt
))
677 elts
.quick_push (elt
);
680 return elts
.build ();
687 in format FORMAT. Return true on success. */
690 fold_const_call_ss (real_value
*result
, combined_fn fn
,
691 const real_value
*arg
, const real_format
*format
)
697 return (real_compare (GE_EXPR
, arg
, &dconst0
)
698 && do_mpfr_arg1 (result
, mpfr_sqrt
, arg
, format
));
701 return do_mpfr_arg1 (result
, mpfr_cbrt
, arg
, format
);
704 return (real_compare (GE_EXPR
, arg
, &dconstm1
)
705 && real_compare (LE_EXPR
, arg
, &dconst1
)
706 && do_mpfr_arg1 (result
, mpfr_asin
, arg
, format
));
709 return (real_compare (GE_EXPR
, arg
, &dconstm1
)
710 && real_compare (LE_EXPR
, arg
, &dconst1
)
711 && do_mpfr_arg1 (result
, mpfr_acos
, arg
, format
));
714 return do_mpfr_arg1 (result
, mpfr_atan
, arg
, format
);
717 return do_mpfr_arg1 (result
, mpfr_asinh
, arg
, format
);
720 return (real_compare (GE_EXPR
, arg
, &dconst1
)
721 && do_mpfr_arg1 (result
, mpfr_acosh
, arg
, format
));
724 return (real_compare (GE_EXPR
, arg
, &dconstm1
)
725 && real_compare (LE_EXPR
, arg
, &dconst1
)
726 && do_mpfr_arg1 (result
, mpfr_atanh
, arg
, format
));
729 return do_mpfr_arg1 (result
, mpfr_sin
, arg
, format
);
732 return do_mpfr_arg1 (result
, mpfr_cos
, arg
, format
);
735 return do_mpfr_arg1 (result
, mpfr_tan
, arg
, format
);
738 return do_mpfr_arg1 (result
, mpfr_sinh
, arg
, format
);
741 return do_mpfr_arg1 (result
, mpfr_cosh
, arg
, format
);
744 return do_mpfr_arg1 (result
, mpfr_tanh
, arg
, format
);
747 return do_mpfr_arg1 (result
, mpfr_erf
, arg
, format
);
750 return do_mpfr_arg1 (result
, mpfr_erfc
, arg
, format
);
753 return do_mpfr_arg1 (result
, mpfr_gamma
, arg
, format
);
756 return do_mpfr_arg1 (result
, mpfr_exp
, arg
, format
);
759 return do_mpfr_arg1 (result
, mpfr_exp2
, arg
, format
);
763 return do_mpfr_arg1 (result
, mpfr_exp10
, arg
, format
);
766 return do_mpfr_arg1 (result
, mpfr_expm1
, arg
, format
);
769 return (real_compare (GT_EXPR
, arg
, &dconst0
)
770 && do_mpfr_arg1 (result
, mpfr_log
, arg
, format
));
773 return (real_compare (GT_EXPR
, arg
, &dconst0
)
774 && do_mpfr_arg1 (result
, mpfr_log2
, arg
, format
));
777 return (real_compare (GT_EXPR
, arg
, &dconst0
)
778 && do_mpfr_arg1 (result
, mpfr_log10
, arg
, format
));
781 return (real_compare (GT_EXPR
, arg
, &dconstm1
)
782 && do_mpfr_arg1 (result
, mpfr_log1p
, arg
, format
));
785 return do_mpfr_arg1 (result
, mpfr_j0
, arg
, format
);
788 return do_mpfr_arg1 (result
, mpfr_j1
, arg
, format
);
791 return (real_compare (GT_EXPR
, arg
, &dconst0
)
792 && do_mpfr_arg1 (result
, mpfr_y0
, arg
, format
));
795 return (real_compare (GT_EXPR
, arg
, &dconst0
)
796 && do_mpfr_arg1 (result
, mpfr_y1
, arg
, format
));
800 if (!REAL_VALUE_ISNAN (*arg
) || !flag_errno_math
)
802 real_floor (result
, format
, arg
);
809 if (!REAL_VALUE_ISNAN (*arg
) || !flag_errno_math
)
811 real_ceil (result
, format
, arg
);
818 real_trunc (result
, format
, arg
);
823 if (!REAL_VALUE_ISNAN (*arg
) || !flag_errno_math
)
825 real_round (result
, format
, arg
);
831 return fold_const_logb (result
, arg
, format
);
833 CASE_CFN_SIGNIFICAND
:
834 return fold_const_significand (result
, arg
, format
);
845 where FORMAT is the format of ARG and PRECISION is the number of
846 significant bits in the result. Return true on success. */
849 fold_const_call_ss (wide_int
*result
, combined_fn fn
,
850 const real_value
*arg
, unsigned int precision
,
851 const real_format
*format
)
856 if (real_isneg (arg
))
857 *result
= wi::one (precision
);
859 *result
= wi::zero (precision
);
863 /* For ilogb we don't know FP_ILOGB0, so only handle normal values.
864 Proceed iff radix == 2. In GCC, normalized significands are in
865 the range [0.5, 1.0). We want the exponent as if they were
866 [1.0, 2.0) so get the exponent and subtract 1. */
867 if (arg
->cl
== rvc_normal
&& format
->b
== 2)
869 *result
= wi::shwi (REAL_EXP (arg
) - 1, precision
);
877 return fold_const_conversion (result
, real_ceil
, arg
,
883 return fold_const_conversion (result
, real_floor
, arg
,
889 return fold_const_conversion (result
, real_round
, arg
,
895 /* Not yet folded to a constant. */
899 case CFN_BUILT_IN_FINITED32
:
900 case CFN_BUILT_IN_FINITED64
:
901 case CFN_BUILT_IN_FINITED128
:
902 case CFN_BUILT_IN_ISFINITE
:
903 *result
= wi::shwi (real_isfinite (arg
) ? 1 : 0, precision
);
907 case CFN_BUILT_IN_ISINFD32
:
908 case CFN_BUILT_IN_ISINFD64
:
909 case CFN_BUILT_IN_ISINFD128
:
910 if (real_isinf (arg
))
911 *result
= wi::shwi (arg
->sign
? -1 : 1, precision
);
913 *result
= wi::shwi (0, precision
);
917 case CFN_BUILT_IN_ISNAND32
:
918 case CFN_BUILT_IN_ISNAND64
:
919 case CFN_BUILT_IN_ISNAND128
:
920 *result
= wi::shwi (real_isnan (arg
) ? 1 : 0, precision
);
932 where ARG_TYPE is the type of ARG and PRECISION is the number of bits
933 in the result. Return true on success. */
936 fold_const_call_ss (wide_int
*result
, combined_fn fn
, const wide_int_ref
&arg
,
937 unsigned int precision
, tree arg_type
)
942 *result
= wi::shwi (wi::ffs (arg
), precision
);
948 if (wi::ne_p (arg
, 0))
950 else if (!CLZ_DEFINED_VALUE_AT_ZERO (SCALAR_INT_TYPE_MODE (arg_type
),
952 tmp
= TYPE_PRECISION (arg_type
);
953 *result
= wi::shwi (tmp
, precision
);
960 if (wi::ne_p (arg
, 0))
962 else if (!CTZ_DEFINED_VALUE_AT_ZERO (SCALAR_INT_TYPE_MODE (arg_type
),
964 tmp
= TYPE_PRECISION (arg_type
);
965 *result
= wi::shwi (tmp
, precision
);
970 *result
= wi::shwi (wi::clrsb (arg
), precision
);
974 *result
= wi::shwi (wi::popcount (arg
), precision
);
978 *result
= wi::shwi (wi::parity (arg
), precision
);
981 case CFN_BUILT_IN_BSWAP16
:
982 case CFN_BUILT_IN_BSWAP32
:
983 case CFN_BUILT_IN_BSWAP64
:
984 *result
= wide_int::from (arg
, precision
, TYPE_SIGN (arg_type
)).bswap ();
996 where FORMAT is the format of ARG and of the real and imaginary parts
997 of RESULT, passed as RESULT_REAL and RESULT_IMAG respectively. Return
1001 fold_const_call_cs (real_value
*result_real
, real_value
*result_imag
,
1002 combined_fn fn
, const real_value
*arg
,
1003 const real_format
*format
)
1008 /* cexpi(x+yi) = cos(x)+sin(y)*i. */
1009 return do_mpfr_sincos (result_imag
, result_real
, arg
, format
);
1020 where FORMAT is the format of RESULT and of the real and imaginary parts
1021 of ARG, passed as ARG_REAL and ARG_IMAG respectively. Return true on
1025 fold_const_call_sc (real_value
*result
, combined_fn fn
,
1026 const real_value
*arg_real
, const real_value
*arg_imag
,
1027 const real_format
*format
)
1032 return do_mpfr_arg2 (result
, mpfr_hypot
, arg_real
, arg_imag
, format
);
1043 where FORMAT is the format of the real and imaginary parts of RESULT
1044 (RESULT_REAL and RESULT_IMAG) and of ARG (ARG_REAL and ARG_IMAG).
1045 Return true on success. */
1048 fold_const_call_cc (real_value
*result_real
, real_value
*result_imag
,
1049 combined_fn fn
, const real_value
*arg_real
,
1050 const real_value
*arg_imag
, const real_format
*format
)
1055 return do_mpc_arg1 (result_real
, result_imag
, mpc_cos
,
1056 arg_real
, arg_imag
, format
);
1059 return do_mpc_arg1 (result_real
, result_imag
, mpc_cosh
,
1060 arg_real
, arg_imag
, format
);
1063 if (real_isinf (arg_real
) || real_isinf (arg_imag
))
1065 real_inf (result_real
);
1066 *result_imag
= dconst0
;
1067 result_imag
->sign
= arg_imag
->sign
;
1071 *result_real
= *arg_real
;
1072 *result_imag
= *arg_imag
;
1077 return do_mpc_arg1 (result_real
, result_imag
, mpc_sin
,
1078 arg_real
, arg_imag
, format
);
1081 return do_mpc_arg1 (result_real
, result_imag
, mpc_sinh
,
1082 arg_real
, arg_imag
, format
);
1085 return do_mpc_arg1 (result_real
, result_imag
, mpc_tan
,
1086 arg_real
, arg_imag
, format
);
1089 return do_mpc_arg1 (result_real
, result_imag
, mpc_tanh
,
1090 arg_real
, arg_imag
, format
);
1093 return do_mpc_arg1 (result_real
, result_imag
, mpc_log
,
1094 arg_real
, arg_imag
, format
);
1097 return do_mpc_arg1 (result_real
, result_imag
, mpc_sqrt
,
1098 arg_real
, arg_imag
, format
);
1101 return do_mpc_arg1 (result_real
, result_imag
, mpc_asin
,
1102 arg_real
, arg_imag
, format
);
1105 return do_mpc_arg1 (result_real
, result_imag
, mpc_acos
,
1106 arg_real
, arg_imag
, format
);
1109 return do_mpc_arg1 (result_real
, result_imag
, mpc_atan
,
1110 arg_real
, arg_imag
, format
);
1113 return do_mpc_arg1 (result_real
, result_imag
, mpc_asinh
,
1114 arg_real
, arg_imag
, format
);
1117 return do_mpc_arg1 (result_real
, result_imag
, mpc_acosh
,
1118 arg_real
, arg_imag
, format
);
1121 return do_mpc_arg1 (result_real
, result_imag
, mpc_atanh
,
1122 arg_real
, arg_imag
, format
);
1125 return do_mpc_arg1 (result_real
, result_imag
, mpc_exp
,
1126 arg_real
, arg_imag
, format
);
1133 /* Subroutine of fold_const_call, with the same interface. Handle cases
1134 where the arguments and result are numerical. */
1137 fold_const_call_1 (combined_fn fn
, tree type
, tree arg
)
1139 machine_mode mode
= TYPE_MODE (type
);
1140 machine_mode arg_mode
= TYPE_MODE (TREE_TYPE (arg
));
1142 if (integer_cst_p (arg
))
1144 if (SCALAR_INT_MODE_P (mode
))
1147 if (fold_const_call_ss (&result
, fn
, wi::to_wide (arg
),
1148 TYPE_PRECISION (type
), TREE_TYPE (arg
)))
1149 return wide_int_to_tree (type
, result
);
1154 if (real_cst_p (arg
))
1156 gcc_checking_assert (SCALAR_FLOAT_MODE_P (arg_mode
));
1157 if (mode
== arg_mode
)
1160 REAL_VALUE_TYPE result
;
1161 if (fold_const_call_ss (&result
, fn
, TREE_REAL_CST_PTR (arg
),
1162 REAL_MODE_FORMAT (mode
)))
1163 return build_real (type
, result
);
1165 else if (COMPLEX_MODE_P (mode
)
1166 && GET_MODE_INNER (mode
) == arg_mode
)
1168 /* real -> complex real. */
1169 REAL_VALUE_TYPE result_real
, result_imag
;
1170 if (fold_const_call_cs (&result_real
, &result_imag
, fn
,
1171 TREE_REAL_CST_PTR (arg
),
1172 REAL_MODE_FORMAT (arg_mode
)))
1173 return build_complex (type
,
1174 build_real (TREE_TYPE (type
), result_real
),
1175 build_real (TREE_TYPE (type
), result_imag
));
1177 else if (INTEGRAL_TYPE_P (type
))
1181 if (fold_const_call_ss (&result
, fn
,
1182 TREE_REAL_CST_PTR (arg
),
1183 TYPE_PRECISION (type
),
1184 REAL_MODE_FORMAT (arg_mode
)))
1185 return wide_int_to_tree (type
, result
);
1190 if (complex_cst_p (arg
))
1192 gcc_checking_assert (COMPLEX_MODE_P (arg_mode
));
1193 machine_mode inner_mode
= GET_MODE_INNER (arg_mode
);
1194 tree argr
= TREE_REALPART (arg
);
1195 tree argi
= TREE_IMAGPART (arg
);
1196 if (mode
== arg_mode
1197 && real_cst_p (argr
)
1198 && real_cst_p (argi
))
1200 /* complex real -> complex real. */
1201 REAL_VALUE_TYPE result_real
, result_imag
;
1202 if (fold_const_call_cc (&result_real
, &result_imag
, fn
,
1203 TREE_REAL_CST_PTR (argr
),
1204 TREE_REAL_CST_PTR (argi
),
1205 REAL_MODE_FORMAT (inner_mode
)))
1206 return build_complex (type
,
1207 build_real (TREE_TYPE (type
), result_real
),
1208 build_real (TREE_TYPE (type
), result_imag
));
1210 if (mode
== inner_mode
1211 && real_cst_p (argr
)
1212 && real_cst_p (argi
))
1214 /* complex real -> real. */
1215 REAL_VALUE_TYPE result
;
1216 if (fold_const_call_sc (&result
, fn
,
1217 TREE_REAL_CST_PTR (argr
),
1218 TREE_REAL_CST_PTR (argi
),
1219 REAL_MODE_FORMAT (inner_mode
)))
1220 return build_real (type
, result
);
1228 /* Try to fold FN (ARG) to a constant. Return the constant on success,
1229 otherwise return null. TYPE is the type of the return value. */
1232 fold_const_call (combined_fn fn
, tree type
, tree arg
)
1236 case CFN_BUILT_IN_STRLEN
:
1237 if (const char *str
= c_getstr (arg
))
1238 return build_int_cst (type
, strlen (str
));
1242 CASE_FLT_FN_FLOATN_NX (CFN_BUILT_IN_NAN
):
1243 case CFN_BUILT_IN_NAND32
:
1244 case CFN_BUILT_IN_NAND64
:
1245 case CFN_BUILT_IN_NAND128
:
1246 return fold_const_builtin_nan (type
, arg
, true);
1249 CASE_FLT_FN_FLOATN_NX (CFN_BUILT_IN_NANS
):
1250 return fold_const_builtin_nan (type
, arg
, false);
1252 case CFN_REDUC_PLUS
:
1253 return fold_const_reduction (type
, arg
, PLUS_EXPR
);
1256 return fold_const_reduction (type
, arg
, MAX_EXPR
);
1259 return fold_const_reduction (type
, arg
, MIN_EXPR
);
1262 return fold_const_reduction (type
, arg
, BIT_AND_EXPR
);
1265 return fold_const_reduction (type
, arg
, BIT_IOR_EXPR
);
1268 return fold_const_reduction (type
, arg
, BIT_XOR_EXPR
);
1270 case CFN_VEC_CONVERT
:
1271 return fold_const_vec_convert (type
, arg
);
1274 return fold_const_call_1 (fn
, type
, arg
);
1278 /* Fold a call to IFN_FOLD_LEFT_<CODE> (ARG0, ARG1), returning a value
1282 fold_const_fold_left (tree type
, tree arg0
, tree arg1
, tree_code code
)
1284 if (TREE_CODE (arg1
) != VECTOR_CST
)
1287 unsigned HOST_WIDE_INT nelts
;
1288 if (!VECTOR_CST_NELTS (arg1
).is_constant (&nelts
))
1291 for (unsigned HOST_WIDE_INT i
= 0; i
< nelts
; i
++)
1293 arg0
= const_binop (code
, type
, arg0
, VECTOR_CST_ELT (arg1
, i
));
1294 if (arg0
== NULL_TREE
|| !CONSTANT_CLASS_P (arg0
))
1302 *RESULT = FN (*ARG0, *ARG1)
1304 in format FORMAT. Return true on success. */
1307 fold_const_call_sss (real_value
*result
, combined_fn fn
,
1308 const real_value
*arg0
, const real_value
*arg1
,
1309 const real_format
*format
)
1315 return do_mpfr_arg2 (result
, mpfr_remainder
, arg0
, arg1
, format
);
1318 return do_mpfr_arg2 (result
, mpfr_atan2
, arg0
, arg1
, format
);
1321 return do_mpfr_arg2 (result
, mpfr_dim
, arg0
, arg1
, format
);
1324 return do_mpfr_arg2 (result
, mpfr_hypot
, arg0
, arg1
, format
);
1327 CASE_CFN_COPYSIGN_FN
:
1329 real_copysign (result
, arg1
);
1334 return do_mpfr_arg2 (result
, mpfr_min
, arg0
, arg1
, format
);
1338 return do_mpfr_arg2 (result
, mpfr_max
, arg0
, arg1
, format
);
1341 return fold_const_pow (result
, arg0
, arg1
, format
);
1344 CASE_CFN_NEXTTOWARD
:
1345 return fold_const_nextafter (result
, arg0
, arg1
, format
);
1354 *RESULT = FN (*ARG0, ARG1)
1356 where FORMAT is the format of *RESULT and *ARG0. Return true on
1360 fold_const_call_sss (real_value
*result
, combined_fn fn
,
1361 const real_value
*arg0
, const wide_int_ref
&arg1
,
1362 const real_format
*format
)
1367 return fold_const_builtin_load_exponent (result
, arg0
, arg1
, format
);
1371 return (format
->b
== 2
1372 && fold_const_builtin_load_exponent (result
, arg0
, arg1
,
1376 /* Avoid the folding if flag_signaling_nans is on and
1377 operand is a signaling NaN. */
1378 if (!flag_unsafe_math_optimizations
1379 && flag_signaling_nans
1380 && REAL_VALUE_ISSIGNALING_NAN (*arg0
))
1383 real_powi (result
, format
, arg0
, arg1
.to_shwi ());
1393 *RESULT = FN (ARG0, *ARG1)
1395 where FORMAT is the format of *RESULT and *ARG1. Return true on
1399 fold_const_call_sss (real_value
*result
, combined_fn fn
,
1400 const wide_int_ref
&arg0
, const real_value
*arg1
,
1401 const real_format
*format
)
1406 return do_mpfr_arg2 (result
, mpfr_jn
, arg0
, arg1
, format
);
1409 return (real_compare (GT_EXPR
, arg1
, &dconst0
)
1410 && do_mpfr_arg2 (result
, mpfr_yn
, arg0
, arg1
, format
));
1419 RESULT = fn (ARG0, ARG1)
1421 where FORMAT is the format of the real and imaginary parts of RESULT
1422 (RESULT_REAL and RESULT_IMAG), of ARG0 (ARG0_REAL and ARG0_IMAG)
1423 and of ARG1 (ARG1_REAL and ARG1_IMAG). Return true on success. */
1426 fold_const_call_ccc (real_value
*result_real
, real_value
*result_imag
,
1427 combined_fn fn
, const real_value
*arg0_real
,
1428 const real_value
*arg0_imag
, const real_value
*arg1_real
,
1429 const real_value
*arg1_imag
, const real_format
*format
)
1434 return do_mpc_arg2 (result_real
, result_imag
, mpc_pow
,
1435 arg0_real
, arg0_imag
, arg1_real
, arg1_imag
, format
);
1442 /* Subroutine of fold_const_call, with the same interface. Handle cases
1443 where the arguments and result are numerical. */
1446 fold_const_call_1 (combined_fn fn
, tree type
, tree arg0
, tree arg1
)
1448 machine_mode mode
= TYPE_MODE (type
);
1449 machine_mode arg0_mode
= TYPE_MODE (TREE_TYPE (arg0
));
1450 machine_mode arg1_mode
= TYPE_MODE (TREE_TYPE (arg1
));
1452 if (mode
== arg0_mode
1453 && real_cst_p (arg0
)
1454 && real_cst_p (arg1
))
1456 gcc_checking_assert (SCALAR_FLOAT_MODE_P (arg0_mode
));
1457 REAL_VALUE_TYPE result
;
1458 if (arg0_mode
== arg1_mode
)
1460 /* real, real -> real. */
1461 if (fold_const_call_sss (&result
, fn
, TREE_REAL_CST_PTR (arg0
),
1462 TREE_REAL_CST_PTR (arg1
),
1463 REAL_MODE_FORMAT (mode
)))
1464 return build_real (type
, result
);
1466 else if (arg1_mode
== TYPE_MODE (long_double_type_node
))
1469 CASE_CFN_NEXTTOWARD
:
1470 /* real, long double -> real. */
1471 if (fold_const_call_sss (&result
, fn
, TREE_REAL_CST_PTR (arg0
),
1472 TREE_REAL_CST_PTR (arg1
),
1473 REAL_MODE_FORMAT (mode
)))
1474 return build_real (type
, result
);
1482 if (real_cst_p (arg0
)
1483 && integer_cst_p (arg1
))
1485 gcc_checking_assert (SCALAR_FLOAT_MODE_P (arg0_mode
));
1486 if (mode
== arg0_mode
)
1488 /* real, int -> real. */
1489 REAL_VALUE_TYPE result
;
1490 if (fold_const_call_sss (&result
, fn
, TREE_REAL_CST_PTR (arg0
),
1492 REAL_MODE_FORMAT (mode
)))
1493 return build_real (type
, result
);
1498 if (integer_cst_p (arg0
)
1499 && real_cst_p (arg1
))
1501 gcc_checking_assert (SCALAR_FLOAT_MODE_P (arg1_mode
));
1502 if (mode
== arg1_mode
)
1504 /* int, real -> real. */
1505 REAL_VALUE_TYPE result
;
1506 if (fold_const_call_sss (&result
, fn
, wi::to_wide (arg0
),
1507 TREE_REAL_CST_PTR (arg1
),
1508 REAL_MODE_FORMAT (mode
)))
1509 return build_real (type
, result
);
1514 if (arg0_mode
== arg1_mode
1515 && complex_cst_p (arg0
)
1516 && complex_cst_p (arg1
))
1518 gcc_checking_assert (COMPLEX_MODE_P (arg0_mode
));
1519 machine_mode inner_mode
= GET_MODE_INNER (arg0_mode
);
1520 tree arg0r
= TREE_REALPART (arg0
);
1521 tree arg0i
= TREE_IMAGPART (arg0
);
1522 tree arg1r
= TREE_REALPART (arg1
);
1523 tree arg1i
= TREE_IMAGPART (arg1
);
1524 if (mode
== arg0_mode
1525 && real_cst_p (arg0r
)
1526 && real_cst_p (arg0i
)
1527 && real_cst_p (arg1r
)
1528 && real_cst_p (arg1i
))
1530 /* complex real, complex real -> complex real. */
1531 REAL_VALUE_TYPE result_real
, result_imag
;
1532 if (fold_const_call_ccc (&result_real
, &result_imag
, fn
,
1533 TREE_REAL_CST_PTR (arg0r
),
1534 TREE_REAL_CST_PTR (arg0i
),
1535 TREE_REAL_CST_PTR (arg1r
),
1536 TREE_REAL_CST_PTR (arg1i
),
1537 REAL_MODE_FORMAT (inner_mode
)))
1538 return build_complex (type
,
1539 build_real (TREE_TYPE (type
), result_real
),
1540 build_real (TREE_TYPE (type
), result_imag
));
1548 /* Try to fold FN (ARG0, ARG1) to a constant. Return the constant on success,
1549 otherwise return null. TYPE is the type of the return value. */
1552 fold_const_call (combined_fn fn
, tree type
, tree arg0
, tree arg1
)
1554 const char *p0
, *p1
;
1558 case CFN_BUILT_IN_STRSPN
:
1559 if ((p0
= c_getstr (arg0
)) && (p1
= c_getstr (arg1
)))
1560 return build_int_cst (type
, strspn (p0
, p1
));
1563 case CFN_BUILT_IN_STRCSPN
:
1564 if ((p0
= c_getstr (arg0
)) && (p1
= c_getstr (arg1
)))
1565 return build_int_cst (type
, strcspn (p0
, p1
));
1568 case CFN_BUILT_IN_STRCMP
:
1569 if ((p0
= c_getstr (arg0
)) && (p1
= c_getstr (arg1
)))
1570 return build_cmp_result (type
, strcmp (p0
, p1
));
1573 case CFN_BUILT_IN_STRCASECMP
:
1574 if ((p0
= c_getstr (arg0
)) && (p1
= c_getstr (arg1
)))
1576 int r
= strcmp (p0
, p1
);
1578 return build_cmp_result (type
, r
);
1582 case CFN_BUILT_IN_INDEX
:
1583 case CFN_BUILT_IN_STRCHR
:
1584 if ((p0
= c_getstr (arg0
)) && target_char_cst_p (arg1
, &c
))
1586 const char *r
= strchr (p0
, c
);
1588 return build_int_cst (type
, 0);
1589 return fold_convert (type
,
1590 fold_build_pointer_plus_hwi (arg0
, r
- p0
));
1594 case CFN_BUILT_IN_RINDEX
:
1595 case CFN_BUILT_IN_STRRCHR
:
1596 if ((p0
= c_getstr (arg0
)) && target_char_cst_p (arg1
, &c
))
1598 const char *r
= strrchr (p0
, c
);
1600 return build_int_cst (type
, 0);
1601 return fold_convert (type
,
1602 fold_build_pointer_plus_hwi (arg0
, r
- p0
));
1606 case CFN_BUILT_IN_STRSTR
:
1607 if ((p1
= c_getstr (arg1
)))
1609 if ((p0
= c_getstr (arg0
)))
1611 const char *r
= strstr (p0
, p1
);
1613 return build_int_cst (type
, 0);
1614 return fold_convert (type
,
1615 fold_build_pointer_plus_hwi (arg0
, r
- p0
));
1618 return fold_convert (type
, arg0
);
1622 case CFN_FOLD_LEFT_PLUS
:
1623 return fold_const_fold_left (type
, arg0
, arg1
, PLUS_EXPR
);
1626 return fold_const_call_1 (fn
, type
, arg0
, arg1
);
1632 *RESULT = FN (*ARG0, *ARG1, *ARG2)
1634 in format FORMAT. Return true on success. */
1637 fold_const_call_ssss (real_value
*result
, combined_fn fn
,
1638 const real_value
*arg0
, const real_value
*arg1
,
1639 const real_value
*arg2
, const real_format
*format
)
1645 return do_mpfr_arg3 (result
, mpfr_fma
, arg0
, arg1
, arg2
, format
);
1649 real_value new_arg2
= real_value_negate (arg2
);
1650 return do_mpfr_arg3 (result
, mpfr_fma
, arg0
, arg1
, &new_arg2
, format
);
1655 real_value new_arg0
= real_value_negate (arg0
);
1656 return do_mpfr_arg3 (result
, mpfr_fma
, &new_arg0
, arg1
, arg2
, format
);
1661 real_value new_arg0
= real_value_negate (arg0
);
1662 real_value new_arg2
= real_value_negate (arg2
);
1663 return do_mpfr_arg3 (result
, mpfr_fma
, &new_arg0
, arg1
,
1672 /* Subroutine of fold_const_call, with the same interface. Handle cases
1673 where the arguments and result are numerical. */
1676 fold_const_call_1 (combined_fn fn
, tree type
, tree arg0
, tree arg1
, tree arg2
)
1678 machine_mode mode
= TYPE_MODE (type
);
1679 machine_mode arg0_mode
= TYPE_MODE (TREE_TYPE (arg0
));
1680 machine_mode arg1_mode
= TYPE_MODE (TREE_TYPE (arg1
));
1681 machine_mode arg2_mode
= TYPE_MODE (TREE_TYPE (arg2
));
1683 if (arg0_mode
== arg1_mode
1684 && arg0_mode
== arg2_mode
1685 && real_cst_p (arg0
)
1686 && real_cst_p (arg1
)
1687 && real_cst_p (arg2
))
1689 gcc_checking_assert (SCALAR_FLOAT_MODE_P (arg0_mode
));
1690 if (mode
== arg0_mode
)
1692 /* real, real, real -> real. */
1693 REAL_VALUE_TYPE result
;
1694 if (fold_const_call_ssss (&result
, fn
, TREE_REAL_CST_PTR (arg0
),
1695 TREE_REAL_CST_PTR (arg1
),
1696 TREE_REAL_CST_PTR (arg2
),
1697 REAL_MODE_FORMAT (mode
)))
1698 return build_real (type
, result
);
1706 /* Try to fold FN (ARG0, ARG1, ARG2) to a constant. Return the constant on
1707 success, otherwise return null. TYPE is the type of the return value. */
1710 fold_const_call (combined_fn fn
, tree type
, tree arg0
, tree arg1
, tree arg2
)
1712 const char *p0
, *p1
;
1714 unsigned HOST_WIDE_INT s0
, s1
;
1718 case CFN_BUILT_IN_STRNCMP
:
1719 if (!host_size_t_cst_p (arg2
, &s2
))
1722 && !TREE_SIDE_EFFECTS (arg0
)
1723 && !TREE_SIDE_EFFECTS (arg1
))
1724 return build_int_cst (type
, 0);
1725 else if ((p0
= c_getstr (arg0
)) && (p1
= c_getstr (arg1
)))
1726 return build_int_cst (type
, strncmp (p0
, p1
, s2
));
1729 case CFN_BUILT_IN_STRNCASECMP
:
1730 if (!host_size_t_cst_p (arg2
, &s2
))
1733 && !TREE_SIDE_EFFECTS (arg0
)
1734 && !TREE_SIDE_EFFECTS (arg1
))
1735 return build_int_cst (type
, 0);
1736 else if ((p0
= c_getstr (arg0
))
1737 && (p1
= c_getstr (arg1
))
1738 && strncmp (p0
, p1
, s2
) == 0)
1739 return build_int_cst (type
, 0);
1742 case CFN_BUILT_IN_BCMP
:
1743 case CFN_BUILT_IN_MEMCMP
:
1744 if (!host_size_t_cst_p (arg2
, &s2
))
1747 && !TREE_SIDE_EFFECTS (arg0
)
1748 && !TREE_SIDE_EFFECTS (arg1
))
1749 return build_int_cst (type
, 0);
1750 if ((p0
= c_getstr (arg0
, &s0
))
1751 && (p1
= c_getstr (arg1
, &s1
))
1754 return build_cmp_result (type
, memcmp (p0
, p1
, s2
));
1757 case CFN_BUILT_IN_MEMCHR
:
1758 if (!host_size_t_cst_p (arg2
, &s2
))
1761 && !TREE_SIDE_EFFECTS (arg0
)
1762 && !TREE_SIDE_EFFECTS (arg1
))
1763 return build_int_cst (type
, 0);
1764 if ((p0
= c_getstr (arg0
, &s0
))
1766 && target_char_cst_p (arg1
, &c
))
1768 const char *r
= (const char *) memchr (p0
, c
, s2
);
1770 return build_int_cst (type
, 0);
1771 return fold_convert (type
,
1772 fold_build_pointer_plus_hwi (arg0
, r
- p0
));
1777 return fold_const_call_1 (fn
, type
, arg0
, arg1
, arg2
);