1 /* Constant folding for calls to built-in and internal functions.
2 Copyright (C) 1988-2017 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"
34 /* Functions that test for certain constant types, abstracting away the
35 decision about whether to check for overflow. */
38 integer_cst_p (tree t
)
40 return TREE_CODE (t
) == INTEGER_CST
&& !TREE_OVERFLOW (t
);
46 return TREE_CODE (t
) == REAL_CST
&& !TREE_OVERFLOW (t
);
50 complex_cst_p (tree t
)
52 return TREE_CODE (t
) == COMPLEX_CST
;
55 /* Return true if ARG is a constant in the range of the host size_t.
56 Store it in *SIZE_OUT if so. */
59 host_size_t_cst_p (tree t
, size_t *size_out
)
61 if (types_compatible_p (size_type_node
, TREE_TYPE (t
))
63 && (wi::min_precision (wi::to_wide (t
), UNSIGNED
)
64 <= sizeof (size_t) * CHAR_BIT
))
66 *size_out
= tree_to_uhwi (t
);
72 /* RES is the result of a comparison in which < 0 means "less", 0 means
73 "equal" and > 0 means "more". Canonicalize it to -1, 0 or 1 and
74 return it in type TYPE. */
77 build_cmp_result (tree type
, int res
)
79 return build_int_cst (type
, res
< 0 ? -1 : res
> 0 ? 1 : 0);
82 /* M is the result of trying to constant-fold an expression (starting
83 with clear MPFR flags) and INEXACT says whether the result in M is
84 exact or inexact. Return true if M can be used as a constant-folded
85 result in format FORMAT, storing the value in *RESULT if so. */
88 do_mpfr_ckconv (real_value
*result
, mpfr_srcptr m
, bool inexact
,
89 const real_format
*format
)
91 /* Proceed iff we get a normal number, i.e. not NaN or Inf and no
92 overflow/underflow occurred. If -frounding-math, proceed iff the
93 result of calling FUNC was exact. */
94 if (!mpfr_number_p (m
)
96 || mpfr_underflow_p ()
97 || (flag_rounding_math
&& inexact
))
101 real_from_mpfr (&tmp
, m
, format
, GMP_RNDN
);
103 /* Proceed iff GCC's REAL_VALUE_TYPE can hold the MPFR values.
104 If the REAL_VALUE_TYPE is zero but the mpft_t is not, then we
105 underflowed in the conversion. */
106 if (!real_isfinite (&tmp
)
107 || ((tmp
.cl
== rvc_zero
) != (mpfr_zero_p (m
) != 0)))
110 real_convert (result
, format
, &tmp
);
111 return real_identical (result
, &tmp
);
118 in format FORMAT, given that FUNC is the MPFR implementation of f.
119 Return true on success. */
122 do_mpfr_arg1 (real_value
*result
,
123 int (*func
) (mpfr_ptr
, mpfr_srcptr
, mpfr_rnd_t
),
124 const real_value
*arg
, const real_format
*format
)
126 /* To proceed, MPFR must exactly represent the target floating point
127 format, which only happens when the target base equals two. */
128 if (format
->b
!= 2 || !real_isfinite (arg
))
131 int prec
= format
->p
;
132 mp_rnd_t rnd
= format
->round_towards_zero
? GMP_RNDZ
: GMP_RNDN
;
135 mpfr_init2 (m
, prec
);
136 mpfr_from_real (m
, arg
, GMP_RNDN
);
138 bool inexact
= func (m
, m
, rnd
);
139 bool ok
= do_mpfr_ckconv (result
, m
, inexact
, format
);
147 *RESULT_SIN = sin (*ARG);
148 *RESULT_COS = cos (*ARG);
150 for format FORMAT. Return true on success. */
153 do_mpfr_sincos (real_value
*result_sin
, real_value
*result_cos
,
154 const real_value
*arg
, const real_format
*format
)
156 /* To proceed, MPFR must exactly represent the target floating point
157 format, which only happens when the target base equals two. */
158 if (format
->b
!= 2 || !real_isfinite (arg
))
161 int prec
= format
->p
;
162 mp_rnd_t rnd
= format
->round_towards_zero
? GMP_RNDZ
: GMP_RNDN
;
165 mpfr_inits2 (prec
, m
, ms
, mc
, NULL
);
166 mpfr_from_real (m
, arg
, GMP_RNDN
);
168 bool inexact
= mpfr_sin_cos (ms
, mc
, m
, rnd
);
169 bool ok
= (do_mpfr_ckconv (result_sin
, ms
, inexact
, format
)
170 && do_mpfr_ckconv (result_cos
, mc
, inexact
, format
));
171 mpfr_clears (m
, ms
, mc
, NULL
);
178 *RESULT = f (*ARG0, *ARG1)
180 in format FORMAT, given that FUNC is the MPFR implementation of f.
181 Return true on success. */
184 do_mpfr_arg2 (real_value
*result
,
185 int (*func
) (mpfr_ptr
, mpfr_srcptr
, mpfr_srcptr
, mpfr_rnd_t
),
186 const real_value
*arg0
, const real_value
*arg1
,
187 const real_format
*format
)
189 /* To proceed, MPFR must exactly represent the target floating point
190 format, which only happens when the target base equals two. */
191 if (format
->b
!= 2 || !real_isfinite (arg0
) || !real_isfinite (arg1
))
194 int prec
= format
->p
;
195 mp_rnd_t rnd
= format
->round_towards_zero
? GMP_RNDZ
: GMP_RNDN
;
198 mpfr_inits2 (prec
, m0
, m1
, NULL
);
199 mpfr_from_real (m0
, arg0
, GMP_RNDN
);
200 mpfr_from_real (m1
, arg1
, GMP_RNDN
);
202 bool inexact
= func (m0
, m0
, m1
, rnd
);
203 bool ok
= do_mpfr_ckconv (result
, m0
, inexact
, format
);
204 mpfr_clears (m0
, m1
, NULL
);
211 *RESULT = f (ARG0, *ARG1)
213 in format FORMAT, given that FUNC is the MPFR implementation of f.
214 Return true on success. */
217 do_mpfr_arg2 (real_value
*result
,
218 int (*func
) (mpfr_ptr
, long, mpfr_srcptr
, mp_rnd_t
),
219 const wide_int_ref
&arg0
, const real_value
*arg1
,
220 const real_format
*format
)
222 if (format
->b
!= 2 || !real_isfinite (arg1
))
225 int prec
= format
->p
;
226 mp_rnd_t rnd
= format
->round_towards_zero
? GMP_RNDZ
: GMP_RNDN
;
229 mpfr_init2 (m
, prec
);
230 mpfr_from_real (m
, arg1
, GMP_RNDN
);
232 bool inexact
= func (m
, arg0
.to_shwi (), m
, rnd
);
233 bool ok
= do_mpfr_ckconv (result
, m
, inexact
, format
);
241 *RESULT = f (*ARG0, *ARG1, *ARG2)
243 in format FORMAT, given that FUNC is the MPFR implementation of f.
244 Return true on success. */
247 do_mpfr_arg3 (real_value
*result
,
248 int (*func
) (mpfr_ptr
, mpfr_srcptr
, mpfr_srcptr
,
249 mpfr_srcptr
, mpfr_rnd_t
),
250 const real_value
*arg0
, const real_value
*arg1
,
251 const real_value
*arg2
, const real_format
*format
)
253 /* To proceed, MPFR must exactly represent the target floating point
254 format, which only happens when the target base equals two. */
256 || !real_isfinite (arg0
)
257 || !real_isfinite (arg1
)
258 || !real_isfinite (arg2
))
261 int prec
= format
->p
;
262 mp_rnd_t rnd
= format
->round_towards_zero
? GMP_RNDZ
: GMP_RNDN
;
265 mpfr_inits2 (prec
, m0
, m1
, m2
, NULL
);
266 mpfr_from_real (m0
, arg0
, GMP_RNDN
);
267 mpfr_from_real (m1
, arg1
, GMP_RNDN
);
268 mpfr_from_real (m2
, arg2
, GMP_RNDN
);
270 bool inexact
= func (m0
, m0
, m1
, m2
, rnd
);
271 bool ok
= do_mpfr_ckconv (result
, m0
, inexact
, format
);
272 mpfr_clears (m0
, m1
, m2
, NULL
);
277 /* M is the result of trying to constant-fold an expression (starting
278 with clear MPFR flags) and INEXACT says whether the result in M is
279 exact or inexact. Return true if M can be used as a constant-folded
280 result in which the real and imaginary parts have format FORMAT.
281 Store those parts in *RESULT_REAL and *RESULT_IMAG if so. */
284 do_mpc_ckconv (real_value
*result_real
, real_value
*result_imag
,
285 mpc_srcptr m
, bool inexact
, const real_format
*format
)
287 /* Proceed iff we get a normal number, i.e. not NaN or Inf and no
288 overflow/underflow occurred. If -frounding-math, proceed iff the
289 result of calling FUNC was exact. */
290 if (!mpfr_number_p (mpc_realref (m
))
291 || !mpfr_number_p (mpc_imagref (m
))
292 || mpfr_overflow_p ()
293 || mpfr_underflow_p ()
294 || (flag_rounding_math
&& inexact
))
297 REAL_VALUE_TYPE tmp_real
, tmp_imag
;
298 real_from_mpfr (&tmp_real
, mpc_realref (m
), format
, GMP_RNDN
);
299 real_from_mpfr (&tmp_imag
, mpc_imagref (m
), format
, GMP_RNDN
);
301 /* Proceed iff GCC's REAL_VALUE_TYPE can hold the MPFR values.
302 If the REAL_VALUE_TYPE is zero but the mpft_t is not, then we
303 underflowed in the conversion. */
304 if (!real_isfinite (&tmp_real
)
305 || !real_isfinite (&tmp_imag
)
306 || (tmp_real
.cl
== rvc_zero
) != (mpfr_zero_p (mpc_realref (m
)) != 0)
307 || (tmp_imag
.cl
== rvc_zero
) != (mpfr_zero_p (mpc_imagref (m
)) != 0))
310 real_convert (result_real
, format
, &tmp_real
);
311 real_convert (result_imag
, format
, &tmp_imag
);
313 return (real_identical (result_real
, &tmp_real
)
314 && real_identical (result_imag
, &tmp_imag
));
321 in format FORMAT, given that FUNC is the mpc implementation of f.
322 Return true on success. Both RESULT and ARG are represented as
323 real and imaginary pairs. */
326 do_mpc_arg1 (real_value
*result_real
, real_value
*result_imag
,
327 int (*func
) (mpc_ptr
, mpc_srcptr
, mpc_rnd_t
),
328 const real_value
*arg_real
, const real_value
*arg_imag
,
329 const real_format
*format
)
331 /* To proceed, MPFR must exactly represent the target floating point
332 format, which only happens when the target base equals two. */
334 || !real_isfinite (arg_real
)
335 || !real_isfinite (arg_imag
))
338 int prec
= format
->p
;
339 mpc_rnd_t crnd
= format
->round_towards_zero
? MPC_RNDZZ
: MPC_RNDNN
;
343 mpfr_from_real (mpc_realref (m
), arg_real
, GMP_RNDN
);
344 mpfr_from_real (mpc_imagref (m
), arg_imag
, GMP_RNDN
);
346 bool inexact
= func (m
, m
, crnd
);
347 bool ok
= do_mpc_ckconv (result_real
, result_imag
, m
, inexact
, format
);
355 RESULT = f (ARG0, ARG1)
357 in format FORMAT, given that FUNC is the mpc implementation of f.
358 Return true on success. RESULT, ARG0 and ARG1 are represented as
359 real and imaginary pairs. */
362 do_mpc_arg2 (real_value
*result_real
, real_value
*result_imag
,
363 int (*func
)(mpc_ptr
, mpc_srcptr
, mpc_srcptr
, mpc_rnd_t
),
364 const real_value
*arg0_real
, const real_value
*arg0_imag
,
365 const real_value
*arg1_real
, const real_value
*arg1_imag
,
366 const real_format
*format
)
368 if (!real_isfinite (arg0_real
)
369 || !real_isfinite (arg0_imag
)
370 || !real_isfinite (arg1_real
)
371 || !real_isfinite (arg1_imag
))
374 int prec
= format
->p
;
375 mpc_rnd_t crnd
= format
->round_towards_zero
? MPC_RNDZZ
: MPC_RNDNN
;
378 mpc_init2 (m0
, prec
);
379 mpc_init2 (m1
, prec
);
380 mpfr_from_real (mpc_realref (m0
), arg0_real
, GMP_RNDN
);
381 mpfr_from_real (mpc_imagref (m0
), arg0_imag
, GMP_RNDN
);
382 mpfr_from_real (mpc_realref (m1
), arg1_real
, GMP_RNDN
);
383 mpfr_from_real (mpc_imagref (m1
), arg1_imag
, GMP_RNDN
);
385 bool inexact
= func (m0
, m0
, m1
, crnd
);
386 bool ok
= do_mpc_ckconv (result_real
, result_imag
, m0
, inexact
, format
);
395 *RESULT = logb (*ARG)
397 in format FORMAT. Return true on success. */
400 fold_const_logb (real_value
*result
, const real_value
*arg
,
401 const real_format
*format
)
406 /* If arg is +-NaN, then return it. */
411 /* If arg is +-Inf, then return +Inf. */
417 /* Zero may set errno and/or raise an exception. */
421 /* For normal numbers, proceed iff radix == 2. In GCC,
422 normalized significands are in the range [0.5, 1.0). We
423 want the exponent as if they were [1.0, 2.0) so get the
424 exponent and subtract 1. */
427 real_from_integer (result
, format
, REAL_EXP (arg
) - 1, SIGNED
);
437 *RESULT = significand (*ARG)
439 in format FORMAT. Return true on success. */
442 fold_const_significand (real_value
*result
, const real_value
*arg
,
443 const real_format
*format
)
450 /* If arg is +-0, +-Inf or +-NaN, then return it. */
455 /* For normal numbers, proceed iff radix == 2. */
459 /* In GCC, normalized significands are in the range [0.5, 1.0).
460 We want them to be [1.0, 2.0) so set the exponent to 1. */
461 SET_REAL_EXP (result
, 1);
473 where FORMAT is the format of *ARG and PRECISION is the number of
474 significant bits in the result. Return true on success. */
477 fold_const_conversion (wide_int
*result
,
478 void (*fn
) (real_value
*, format_helper
,
480 const real_value
*arg
, unsigned int precision
,
481 const real_format
*format
)
483 if (!real_isfinite (arg
))
487 fn (&rounded
, format
, arg
);
490 *result
= real_to_integer (&rounded
, &fail
, precision
);
496 *RESULT = pow (*ARG0, *ARG1)
498 in format FORMAT. Return true on success. */
501 fold_const_pow (real_value
*result
, const real_value
*arg0
,
502 const real_value
*arg1
, const real_format
*format
)
504 if (do_mpfr_arg2 (result
, mpfr_pow
, arg0
, arg1
, format
))
507 /* Check for an integer exponent. */
508 REAL_VALUE_TYPE cint1
;
509 HOST_WIDE_INT n1
= real_to_integer (arg1
);
510 real_from_integer (&cint1
, VOIDmode
, n1
, SIGNED
);
511 /* Attempt to evaluate pow at compile-time, unless this should
512 raise an exception. */
513 if (real_identical (arg1
, &cint1
)
515 || (!flag_trapping_math
&& !flag_errno_math
)
516 || !real_equal (arg0
, &dconst0
)))
518 bool inexact
= real_powi (result
, format
, arg0
, n1
);
519 /* Avoid the folding if flag_signaling_nans is on. */
520 if (flag_unsafe_math_optimizations
522 && !(flag_signaling_nans
523 && REAL_VALUE_ISSIGNALING_NAN (*arg0
))))
532 *RESULT = ldexp (*ARG0, ARG1)
534 in format FORMAT. Return true on success. */
537 fold_const_builtin_load_exponent (real_value
*result
, const real_value
*arg0
,
538 const wide_int_ref
&arg1
,
539 const real_format
*format
)
541 /* Bound the maximum adjustment to twice the range of the
542 mode's valid exponents. Use abs to ensure the range is
543 positive as a sanity check. */
544 int max_exp_adj
= 2 * labs (format
->emax
- format
->emin
);
546 /* The requested adjustment must be inside this range. This
547 is a preliminary cap to avoid things like overflow, we
548 may still fail to compute the result for other reasons. */
549 if (wi::les_p (arg1
, -max_exp_adj
) || wi::ges_p (arg1
, max_exp_adj
))
552 /* Don't perform operation if we honor signaling NaNs and
553 operand is a signaling NaN. */
554 if (!flag_unsafe_math_optimizations
555 && flag_signaling_nans
556 && REAL_VALUE_ISSIGNALING_NAN (*arg0
))
559 REAL_VALUE_TYPE initial_result
;
560 real_ldexp (&initial_result
, arg0
, arg1
.to_shwi ());
562 /* Ensure we didn't overflow. */
563 if (real_isinf (&initial_result
))
566 /* Only proceed if the target mode can hold the
568 *result
= real_value_truncate (format
, initial_result
);
569 return real_equal (&initial_result
, result
);
572 /* Fold a call to __builtin_nan or __builtin_nans with argument ARG and
573 return type TYPE. QUIET is true if a quiet rather than signalling
577 fold_const_builtin_nan (tree type
, tree arg
, bool quiet
)
579 REAL_VALUE_TYPE real
;
580 const char *str
= c_getstr (arg
);
581 if (str
&& real_nan (&real
, str
, quiet
, TYPE_MODE (type
)))
582 return build_real (type
, real
);
586 /* Fold a call to IFN_REDUC_<CODE> (ARG), returning a value of type TYPE. */
589 fold_const_reduction (tree type
, tree arg
, tree_code code
)
591 if (TREE_CODE (arg
) != VECTOR_CST
)
594 tree res
= VECTOR_CST_ELT (arg
, 0);
595 unsigned int nelts
= VECTOR_CST_NELTS (arg
);
596 for (unsigned int i
= 1; i
< nelts
; i
++)
598 res
= const_binop (code
, type
, res
, VECTOR_CST_ELT (arg
, i
));
599 if (res
== NULL_TREE
|| !CONSTANT_CLASS_P (res
))
609 in format FORMAT. Return true on success. */
612 fold_const_call_ss (real_value
*result
, combined_fn fn
,
613 const real_value
*arg
, const real_format
*format
)
619 return (real_compare (GE_EXPR
, arg
, &dconst0
)
620 && do_mpfr_arg1 (result
, mpfr_sqrt
, arg
, format
));
623 return do_mpfr_arg1 (result
, mpfr_cbrt
, arg
, format
);
626 return (real_compare (GE_EXPR
, arg
, &dconstm1
)
627 && real_compare (LE_EXPR
, arg
, &dconst1
)
628 && do_mpfr_arg1 (result
, mpfr_asin
, arg
, format
));
631 return (real_compare (GE_EXPR
, arg
, &dconstm1
)
632 && real_compare (LE_EXPR
, arg
, &dconst1
)
633 && do_mpfr_arg1 (result
, mpfr_acos
, arg
, format
));
636 return do_mpfr_arg1 (result
, mpfr_atan
, arg
, format
);
639 return do_mpfr_arg1 (result
, mpfr_asinh
, arg
, format
);
642 return (real_compare (GE_EXPR
, arg
, &dconst1
)
643 && do_mpfr_arg1 (result
, mpfr_acosh
, arg
, format
));
646 return (real_compare (GE_EXPR
, arg
, &dconstm1
)
647 && real_compare (LE_EXPR
, arg
, &dconst1
)
648 && do_mpfr_arg1 (result
, mpfr_atanh
, arg
, format
));
651 return do_mpfr_arg1 (result
, mpfr_sin
, arg
, format
);
654 return do_mpfr_arg1 (result
, mpfr_cos
, arg
, format
);
657 return do_mpfr_arg1 (result
, mpfr_tan
, arg
, format
);
660 return do_mpfr_arg1 (result
, mpfr_sinh
, arg
, format
);
663 return do_mpfr_arg1 (result
, mpfr_cosh
, arg
, format
);
666 return do_mpfr_arg1 (result
, mpfr_tanh
, arg
, format
);
669 return do_mpfr_arg1 (result
, mpfr_erf
, arg
, format
);
672 return do_mpfr_arg1 (result
, mpfr_erfc
, arg
, format
);
675 return do_mpfr_arg1 (result
, mpfr_gamma
, arg
, format
);
678 return do_mpfr_arg1 (result
, mpfr_exp
, arg
, format
);
681 return do_mpfr_arg1 (result
, mpfr_exp2
, arg
, format
);
685 return do_mpfr_arg1 (result
, mpfr_exp10
, arg
, format
);
688 return do_mpfr_arg1 (result
, mpfr_expm1
, arg
, format
);
691 return (real_compare (GT_EXPR
, arg
, &dconst0
)
692 && do_mpfr_arg1 (result
, mpfr_log
, arg
, format
));
695 return (real_compare (GT_EXPR
, arg
, &dconst0
)
696 && do_mpfr_arg1 (result
, mpfr_log2
, arg
, format
));
699 return (real_compare (GT_EXPR
, arg
, &dconst0
)
700 && do_mpfr_arg1 (result
, mpfr_log10
, arg
, format
));
703 return (real_compare (GT_EXPR
, arg
, &dconstm1
)
704 && do_mpfr_arg1 (result
, mpfr_log1p
, arg
, format
));
707 return do_mpfr_arg1 (result
, mpfr_j0
, arg
, format
);
710 return do_mpfr_arg1 (result
, mpfr_j1
, arg
, format
);
713 return (real_compare (GT_EXPR
, arg
, &dconst0
)
714 && do_mpfr_arg1 (result
, mpfr_y0
, arg
, format
));
717 return (real_compare (GT_EXPR
, arg
, &dconst0
)
718 && do_mpfr_arg1 (result
, mpfr_y1
, arg
, format
));
721 if (!REAL_VALUE_ISNAN (*arg
) || !flag_errno_math
)
723 real_floor (result
, format
, arg
);
729 if (!REAL_VALUE_ISNAN (*arg
) || !flag_errno_math
)
731 real_ceil (result
, format
, arg
);
737 real_trunc (result
, format
, arg
);
741 if (!REAL_VALUE_ISNAN (*arg
) || !flag_errno_math
)
743 real_round (result
, format
, arg
);
749 return fold_const_logb (result
, arg
, format
);
751 CASE_CFN_SIGNIFICAND
:
752 return fold_const_significand (result
, arg
, format
);
763 where FORMAT is the format of ARG and PRECISION is the number of
764 significant bits in the result. Return true on success. */
767 fold_const_call_ss (wide_int
*result
, combined_fn fn
,
768 const real_value
*arg
, unsigned int precision
,
769 const real_format
*format
)
774 if (real_isneg (arg
))
775 *result
= wi::one (precision
);
777 *result
= wi::zero (precision
);
781 /* For ilogb we don't know FP_ILOGB0, so only handle normal values.
782 Proceed iff radix == 2. In GCC, normalized significands are in
783 the range [0.5, 1.0). We want the exponent as if they were
784 [1.0, 2.0) so get the exponent and subtract 1. */
785 if (arg
->cl
== rvc_normal
&& format
->b
== 2)
787 *result
= wi::shwi (REAL_EXP (arg
) - 1, precision
);
795 return fold_const_conversion (result
, real_ceil
, arg
,
801 return fold_const_conversion (result
, real_floor
, arg
,
807 return fold_const_conversion (result
, real_round
, arg
,
813 /* Not yet folded to a constant. */
817 case CFN_BUILT_IN_FINITED32
:
818 case CFN_BUILT_IN_FINITED64
:
819 case CFN_BUILT_IN_FINITED128
:
820 case CFN_BUILT_IN_ISFINITE
:
821 *result
= wi::shwi (real_isfinite (arg
) ? 1 : 0, precision
);
825 case CFN_BUILT_IN_ISINFD32
:
826 case CFN_BUILT_IN_ISINFD64
:
827 case CFN_BUILT_IN_ISINFD128
:
828 if (real_isinf (arg
))
829 *result
= wi::shwi (arg
->sign
? -1 : 1, precision
);
831 *result
= wi::shwi (0, precision
);
835 case CFN_BUILT_IN_ISNAND32
:
836 case CFN_BUILT_IN_ISNAND64
:
837 case CFN_BUILT_IN_ISNAND128
:
838 *result
= wi::shwi (real_isnan (arg
) ? 1 : 0, precision
);
850 where ARG_TYPE is the type of ARG and PRECISION is the number of bits
851 in the result. Return true on success. */
854 fold_const_call_ss (wide_int
*result
, combined_fn fn
, const wide_int_ref
&arg
,
855 unsigned int precision
, tree arg_type
)
860 *result
= wi::shwi (wi::ffs (arg
), precision
);
866 if (wi::ne_p (arg
, 0))
868 else if (!CLZ_DEFINED_VALUE_AT_ZERO (SCALAR_INT_TYPE_MODE (arg_type
),
870 tmp
= TYPE_PRECISION (arg_type
);
871 *result
= wi::shwi (tmp
, precision
);
878 if (wi::ne_p (arg
, 0))
880 else if (!CTZ_DEFINED_VALUE_AT_ZERO (SCALAR_INT_TYPE_MODE (arg_type
),
882 tmp
= TYPE_PRECISION (arg_type
);
883 *result
= wi::shwi (tmp
, precision
);
888 *result
= wi::shwi (wi::clrsb (arg
), precision
);
892 *result
= wi::shwi (wi::popcount (arg
), precision
);
896 *result
= wi::shwi (wi::parity (arg
), precision
);
899 case CFN_BUILT_IN_BSWAP16
:
900 case CFN_BUILT_IN_BSWAP32
:
901 case CFN_BUILT_IN_BSWAP64
:
902 *result
= wide_int::from (arg
, precision
, TYPE_SIGN (arg_type
)).bswap ();
914 where FORMAT is the format of ARG and of the real and imaginary parts
915 of RESULT, passed as RESULT_REAL and RESULT_IMAG respectively. Return
919 fold_const_call_cs (real_value
*result_real
, real_value
*result_imag
,
920 combined_fn fn
, const real_value
*arg
,
921 const real_format
*format
)
926 /* cexpi(x+yi) = cos(x)+sin(y)*i. */
927 return do_mpfr_sincos (result_imag
, result_real
, arg
, format
);
938 where FORMAT is the format of RESULT and of the real and imaginary parts
939 of ARG, passed as ARG_REAL and ARG_IMAG respectively. Return true on
943 fold_const_call_sc (real_value
*result
, combined_fn fn
,
944 const real_value
*arg_real
, const real_value
*arg_imag
,
945 const real_format
*format
)
950 return do_mpfr_arg2 (result
, mpfr_hypot
, arg_real
, arg_imag
, format
);
961 where FORMAT is the format of the real and imaginary parts of RESULT
962 (RESULT_REAL and RESULT_IMAG) and of ARG (ARG_REAL and ARG_IMAG).
963 Return true on success. */
966 fold_const_call_cc (real_value
*result_real
, real_value
*result_imag
,
967 combined_fn fn
, const real_value
*arg_real
,
968 const real_value
*arg_imag
, const real_format
*format
)
973 return do_mpc_arg1 (result_real
, result_imag
, mpc_cos
,
974 arg_real
, arg_imag
, format
);
977 return do_mpc_arg1 (result_real
, result_imag
, mpc_cosh
,
978 arg_real
, arg_imag
, format
);
981 if (real_isinf (arg_real
) || real_isinf (arg_imag
))
983 real_inf (result_real
);
984 *result_imag
= dconst0
;
985 result_imag
->sign
= arg_imag
->sign
;
989 *result_real
= *arg_real
;
990 *result_imag
= *arg_imag
;
995 return do_mpc_arg1 (result_real
, result_imag
, mpc_sin
,
996 arg_real
, arg_imag
, format
);
999 return do_mpc_arg1 (result_real
, result_imag
, mpc_sinh
,
1000 arg_real
, arg_imag
, format
);
1003 return do_mpc_arg1 (result_real
, result_imag
, mpc_tan
,
1004 arg_real
, arg_imag
, format
);
1007 return do_mpc_arg1 (result_real
, result_imag
, mpc_tanh
,
1008 arg_real
, arg_imag
, format
);
1011 return do_mpc_arg1 (result_real
, result_imag
, mpc_log
,
1012 arg_real
, arg_imag
, format
);
1015 return do_mpc_arg1 (result_real
, result_imag
, mpc_sqrt
,
1016 arg_real
, arg_imag
, format
);
1019 return do_mpc_arg1 (result_real
, result_imag
, mpc_asin
,
1020 arg_real
, arg_imag
, format
);
1023 return do_mpc_arg1 (result_real
, result_imag
, mpc_acos
,
1024 arg_real
, arg_imag
, format
);
1027 return do_mpc_arg1 (result_real
, result_imag
, mpc_atan
,
1028 arg_real
, arg_imag
, format
);
1031 return do_mpc_arg1 (result_real
, result_imag
, mpc_asinh
,
1032 arg_real
, arg_imag
, format
);
1035 return do_mpc_arg1 (result_real
, result_imag
, mpc_acosh
,
1036 arg_real
, arg_imag
, format
);
1039 return do_mpc_arg1 (result_real
, result_imag
, mpc_atanh
,
1040 arg_real
, arg_imag
, format
);
1043 return do_mpc_arg1 (result_real
, result_imag
, mpc_exp
,
1044 arg_real
, arg_imag
, format
);
1051 /* Subroutine of fold_const_call, with the same interface. Handle cases
1052 where the arguments and result are numerical. */
1055 fold_const_call_1 (combined_fn fn
, tree type
, tree arg
)
1057 machine_mode mode
= TYPE_MODE (type
);
1058 machine_mode arg_mode
= TYPE_MODE (TREE_TYPE (arg
));
1060 if (integer_cst_p (arg
))
1062 if (SCALAR_INT_MODE_P (mode
))
1065 if (fold_const_call_ss (&result
, fn
, wi::to_wide (arg
),
1066 TYPE_PRECISION (type
), TREE_TYPE (arg
)))
1067 return wide_int_to_tree (type
, result
);
1072 if (real_cst_p (arg
))
1074 gcc_checking_assert (SCALAR_FLOAT_MODE_P (arg_mode
));
1075 if (mode
== arg_mode
)
1078 REAL_VALUE_TYPE result
;
1079 if (fold_const_call_ss (&result
, fn
, TREE_REAL_CST_PTR (arg
),
1080 REAL_MODE_FORMAT (mode
)))
1081 return build_real (type
, result
);
1083 else if (COMPLEX_MODE_P (mode
)
1084 && GET_MODE_INNER (mode
) == arg_mode
)
1086 /* real -> complex real. */
1087 REAL_VALUE_TYPE result_real
, result_imag
;
1088 if (fold_const_call_cs (&result_real
, &result_imag
, fn
,
1089 TREE_REAL_CST_PTR (arg
),
1090 REAL_MODE_FORMAT (arg_mode
)))
1091 return build_complex (type
,
1092 build_real (TREE_TYPE (type
), result_real
),
1093 build_real (TREE_TYPE (type
), result_imag
));
1095 else if (INTEGRAL_TYPE_P (type
))
1099 if (fold_const_call_ss (&result
, fn
,
1100 TREE_REAL_CST_PTR (arg
),
1101 TYPE_PRECISION (type
),
1102 REAL_MODE_FORMAT (arg_mode
)))
1103 return wide_int_to_tree (type
, result
);
1108 if (complex_cst_p (arg
))
1110 gcc_checking_assert (COMPLEX_MODE_P (arg_mode
));
1111 machine_mode inner_mode
= GET_MODE_INNER (arg_mode
);
1112 tree argr
= TREE_REALPART (arg
);
1113 tree argi
= TREE_IMAGPART (arg
);
1114 if (mode
== arg_mode
1115 && real_cst_p (argr
)
1116 && real_cst_p (argi
))
1118 /* complex real -> complex real. */
1119 REAL_VALUE_TYPE result_real
, result_imag
;
1120 if (fold_const_call_cc (&result_real
, &result_imag
, fn
,
1121 TREE_REAL_CST_PTR (argr
),
1122 TREE_REAL_CST_PTR (argi
),
1123 REAL_MODE_FORMAT (inner_mode
)))
1124 return build_complex (type
,
1125 build_real (TREE_TYPE (type
), result_real
),
1126 build_real (TREE_TYPE (type
), result_imag
));
1128 if (mode
== inner_mode
1129 && real_cst_p (argr
)
1130 && real_cst_p (argi
))
1132 /* complex real -> real. */
1133 REAL_VALUE_TYPE result
;
1134 if (fold_const_call_sc (&result
, fn
,
1135 TREE_REAL_CST_PTR (argr
),
1136 TREE_REAL_CST_PTR (argi
),
1137 REAL_MODE_FORMAT (inner_mode
)))
1138 return build_real (type
, result
);
1146 /* Try to fold FN (ARG) to a constant. Return the constant on success,
1147 otherwise return null. TYPE is the type of the return value. */
1150 fold_const_call (combined_fn fn
, tree type
, tree arg
)
1154 case CFN_BUILT_IN_STRLEN
:
1155 if (const char *str
= c_getstr (arg
))
1156 return build_int_cst (type
, strlen (str
));
1160 CASE_FLT_FN_FLOATN_NX (CFN_BUILT_IN_NAN
):
1161 case CFN_BUILT_IN_NAND32
:
1162 case CFN_BUILT_IN_NAND64
:
1163 case CFN_BUILT_IN_NAND128
:
1164 return fold_const_builtin_nan (type
, arg
, true);
1167 CASE_FLT_FN_FLOATN_NX (CFN_BUILT_IN_NANS
):
1168 return fold_const_builtin_nan (type
, arg
, false);
1170 case CFN_REDUC_PLUS
:
1171 return fold_const_reduction (type
, arg
, PLUS_EXPR
);
1174 return fold_const_reduction (type
, arg
, MAX_EXPR
);
1177 return fold_const_reduction (type
, arg
, MIN_EXPR
);
1180 return fold_const_call_1 (fn
, type
, arg
);
1186 *RESULT = FN (*ARG0, *ARG1)
1188 in format FORMAT. Return true on success. */
1191 fold_const_call_sss (real_value
*result
, combined_fn fn
,
1192 const real_value
*arg0
, const real_value
*arg1
,
1193 const real_format
*format
)
1199 return do_mpfr_arg2 (result
, mpfr_remainder
, arg0
, arg1
, format
);
1202 return do_mpfr_arg2 (result
, mpfr_atan2
, arg0
, arg1
, format
);
1205 return do_mpfr_arg2 (result
, mpfr_dim
, arg0
, arg1
, format
);
1208 return do_mpfr_arg2 (result
, mpfr_hypot
, arg0
, arg1
, format
);
1211 CASE_CFN_COPYSIGN_FN
:
1213 real_copysign (result
, arg1
);
1218 return do_mpfr_arg2 (result
, mpfr_min
, arg0
, arg1
, format
);
1222 return do_mpfr_arg2 (result
, mpfr_max
, arg0
, arg1
, format
);
1225 return fold_const_pow (result
, arg0
, arg1
, format
);
1234 *RESULT = FN (*ARG0, ARG1)
1236 where FORMAT is the format of *RESULT and *ARG0. Return true on
1240 fold_const_call_sss (real_value
*result
, combined_fn fn
,
1241 const real_value
*arg0
, const wide_int_ref
&arg1
,
1242 const real_format
*format
)
1247 return fold_const_builtin_load_exponent (result
, arg0
, arg1
, format
);
1251 return (format
->b
== 2
1252 && fold_const_builtin_load_exponent (result
, arg0
, arg1
,
1256 /* Avoid the folding if flag_signaling_nans is on and
1257 operand is a signaling NaN. */
1258 if (!flag_unsafe_math_optimizations
1259 && flag_signaling_nans
1260 && REAL_VALUE_ISSIGNALING_NAN (*arg0
))
1263 real_powi (result
, format
, arg0
, arg1
.to_shwi ());
1273 *RESULT = FN (ARG0, *ARG1)
1275 where FORMAT is the format of *RESULT and *ARG1. Return true on
1279 fold_const_call_sss (real_value
*result
, combined_fn fn
,
1280 const wide_int_ref
&arg0
, const real_value
*arg1
,
1281 const real_format
*format
)
1286 return do_mpfr_arg2 (result
, mpfr_jn
, arg0
, arg1
, format
);
1289 return (real_compare (GT_EXPR
, arg1
, &dconst0
)
1290 && do_mpfr_arg2 (result
, mpfr_yn
, arg0
, arg1
, format
));
1299 RESULT = fn (ARG0, ARG1)
1301 where FORMAT is the format of the real and imaginary parts of RESULT
1302 (RESULT_REAL and RESULT_IMAG), of ARG0 (ARG0_REAL and ARG0_IMAG)
1303 and of ARG1 (ARG1_REAL and ARG1_IMAG). Return true on success. */
1306 fold_const_call_ccc (real_value
*result_real
, real_value
*result_imag
,
1307 combined_fn fn
, const real_value
*arg0_real
,
1308 const real_value
*arg0_imag
, const real_value
*arg1_real
,
1309 const real_value
*arg1_imag
, const real_format
*format
)
1314 return do_mpc_arg2 (result_real
, result_imag
, mpc_pow
,
1315 arg0_real
, arg0_imag
, arg1_real
, arg1_imag
, format
);
1322 /* Subroutine of fold_const_call, with the same interface. Handle cases
1323 where the arguments and result are numerical. */
1326 fold_const_call_1 (combined_fn fn
, tree type
, tree arg0
, tree arg1
)
1328 machine_mode mode
= TYPE_MODE (type
);
1329 machine_mode arg0_mode
= TYPE_MODE (TREE_TYPE (arg0
));
1330 machine_mode arg1_mode
= TYPE_MODE (TREE_TYPE (arg1
));
1332 if (arg0_mode
== arg1_mode
1333 && real_cst_p (arg0
)
1334 && real_cst_p (arg1
))
1336 gcc_checking_assert (SCALAR_FLOAT_MODE_P (arg0_mode
));
1337 if (mode
== arg0_mode
)
1339 /* real, real -> real. */
1340 REAL_VALUE_TYPE result
;
1341 if (fold_const_call_sss (&result
, fn
, TREE_REAL_CST_PTR (arg0
),
1342 TREE_REAL_CST_PTR (arg1
),
1343 REAL_MODE_FORMAT (mode
)))
1344 return build_real (type
, result
);
1349 if (real_cst_p (arg0
)
1350 && integer_cst_p (arg1
))
1352 gcc_checking_assert (SCALAR_FLOAT_MODE_P (arg0_mode
));
1353 if (mode
== arg0_mode
)
1355 /* real, int -> real. */
1356 REAL_VALUE_TYPE result
;
1357 if (fold_const_call_sss (&result
, fn
, TREE_REAL_CST_PTR (arg0
),
1359 REAL_MODE_FORMAT (mode
)))
1360 return build_real (type
, result
);
1365 if (integer_cst_p (arg0
)
1366 && real_cst_p (arg1
))
1368 gcc_checking_assert (SCALAR_FLOAT_MODE_P (arg1_mode
));
1369 if (mode
== arg1_mode
)
1371 /* int, real -> real. */
1372 REAL_VALUE_TYPE result
;
1373 if (fold_const_call_sss (&result
, fn
, wi::to_wide (arg0
),
1374 TREE_REAL_CST_PTR (arg1
),
1375 REAL_MODE_FORMAT (mode
)))
1376 return build_real (type
, result
);
1381 if (arg0_mode
== arg1_mode
1382 && complex_cst_p (arg0
)
1383 && complex_cst_p (arg1
))
1385 gcc_checking_assert (COMPLEX_MODE_P (arg0_mode
));
1386 machine_mode inner_mode
= GET_MODE_INNER (arg0_mode
);
1387 tree arg0r
= TREE_REALPART (arg0
);
1388 tree arg0i
= TREE_IMAGPART (arg0
);
1389 tree arg1r
= TREE_REALPART (arg1
);
1390 tree arg1i
= TREE_IMAGPART (arg1
);
1391 if (mode
== arg0_mode
1392 && real_cst_p (arg0r
)
1393 && real_cst_p (arg0i
)
1394 && real_cst_p (arg1r
)
1395 && real_cst_p (arg1i
))
1397 /* complex real, complex real -> complex real. */
1398 REAL_VALUE_TYPE result_real
, result_imag
;
1399 if (fold_const_call_ccc (&result_real
, &result_imag
, fn
,
1400 TREE_REAL_CST_PTR (arg0r
),
1401 TREE_REAL_CST_PTR (arg0i
),
1402 TREE_REAL_CST_PTR (arg1r
),
1403 TREE_REAL_CST_PTR (arg1i
),
1404 REAL_MODE_FORMAT (inner_mode
)))
1405 return build_complex (type
,
1406 build_real (TREE_TYPE (type
), result_real
),
1407 build_real (TREE_TYPE (type
), result_imag
));
1415 /* Try to fold FN (ARG0, ARG1) to a constant. Return the constant on success,
1416 otherwise return null. TYPE is the type of the return value. */
1419 fold_const_call (combined_fn fn
, tree type
, tree arg0
, tree arg1
)
1421 const char *p0
, *p1
;
1425 case CFN_BUILT_IN_STRSPN
:
1426 if ((p0
= c_getstr (arg0
)) && (p1
= c_getstr (arg1
)))
1427 return build_int_cst (type
, strspn (p0
, p1
));
1430 case CFN_BUILT_IN_STRCSPN
:
1431 if ((p0
= c_getstr (arg0
)) && (p1
= c_getstr (arg1
)))
1432 return build_int_cst (type
, strcspn (p0
, p1
));
1435 case CFN_BUILT_IN_STRCMP
:
1436 if ((p0
= c_getstr (arg0
)) && (p1
= c_getstr (arg1
)))
1437 return build_cmp_result (type
, strcmp (p0
, p1
));
1440 case CFN_BUILT_IN_STRCASECMP
:
1441 if ((p0
= c_getstr (arg0
)) && (p1
= c_getstr (arg1
)))
1443 int r
= strcmp (p0
, p1
);
1445 return build_cmp_result (type
, r
);
1449 case CFN_BUILT_IN_INDEX
:
1450 case CFN_BUILT_IN_STRCHR
:
1451 if ((p0
= c_getstr (arg0
)) && target_char_cst_p (arg1
, &c
))
1453 const char *r
= strchr (p0
, c
);
1455 return build_int_cst (type
, 0);
1456 return fold_convert (type
,
1457 fold_build_pointer_plus_hwi (arg0
, r
- p0
));
1461 case CFN_BUILT_IN_RINDEX
:
1462 case CFN_BUILT_IN_STRRCHR
:
1463 if ((p0
= c_getstr (arg0
)) && target_char_cst_p (arg1
, &c
))
1465 const char *r
= strrchr (p0
, c
);
1467 return build_int_cst (type
, 0);
1468 return fold_convert (type
,
1469 fold_build_pointer_plus_hwi (arg0
, r
- p0
));
1473 case CFN_BUILT_IN_STRSTR
:
1474 if ((p1
= c_getstr (arg1
)))
1476 if ((p0
= c_getstr (arg0
)))
1478 const char *r
= strstr (p0
, p1
);
1480 return build_int_cst (type
, 0);
1481 return fold_convert (type
,
1482 fold_build_pointer_plus_hwi (arg0
, r
- p0
));
1485 return fold_convert (type
, arg0
);
1490 return fold_const_call_1 (fn
, type
, arg0
, arg1
);
1496 *RESULT = FN (*ARG0, *ARG1, *ARG2)
1498 in format FORMAT. Return true on success. */
1501 fold_const_call_ssss (real_value
*result
, combined_fn fn
,
1502 const real_value
*arg0
, const real_value
*arg1
,
1503 const real_value
*arg2
, const real_format
*format
)
1509 return do_mpfr_arg3 (result
, mpfr_fma
, arg0
, arg1
, arg2
, format
);
1516 /* Subroutine of fold_const_call, with the same interface. Handle cases
1517 where the arguments and result are numerical. */
1520 fold_const_call_1 (combined_fn fn
, tree type
, tree arg0
, tree arg1
, tree arg2
)
1522 machine_mode mode
= TYPE_MODE (type
);
1523 machine_mode arg0_mode
= TYPE_MODE (TREE_TYPE (arg0
));
1524 machine_mode arg1_mode
= TYPE_MODE (TREE_TYPE (arg1
));
1525 machine_mode arg2_mode
= TYPE_MODE (TREE_TYPE (arg2
));
1527 if (arg0_mode
== arg1_mode
1528 && arg0_mode
== arg2_mode
1529 && real_cst_p (arg0
)
1530 && real_cst_p (arg1
)
1531 && real_cst_p (arg2
))
1533 gcc_checking_assert (SCALAR_FLOAT_MODE_P (arg0_mode
));
1534 if (mode
== arg0_mode
)
1536 /* real, real, real -> real. */
1537 REAL_VALUE_TYPE result
;
1538 if (fold_const_call_ssss (&result
, fn
, TREE_REAL_CST_PTR (arg0
),
1539 TREE_REAL_CST_PTR (arg1
),
1540 TREE_REAL_CST_PTR (arg2
),
1541 REAL_MODE_FORMAT (mode
)))
1542 return build_real (type
, result
);
1550 /* Try to fold FN (ARG0, ARG1, ARG2) to a constant. Return the constant on
1551 success, otherwise return null. TYPE is the type of the return value. */
1554 fold_const_call (combined_fn fn
, tree type
, tree arg0
, tree arg1
, tree arg2
)
1556 const char *p0
, *p1
;
1558 unsigned HOST_WIDE_INT s0
, s1
;
1562 case CFN_BUILT_IN_STRNCMP
:
1563 if (!host_size_t_cst_p (arg2
, &s2
))
1566 && !TREE_SIDE_EFFECTS (arg0
)
1567 && !TREE_SIDE_EFFECTS (arg1
))
1568 return build_int_cst (type
, 0);
1569 else if ((p0
= c_getstr (arg0
)) && (p1
= c_getstr (arg1
)))
1570 return build_int_cst (type
, strncmp (p0
, p1
, s2
));
1573 case CFN_BUILT_IN_STRNCASECMP
:
1574 if (!host_size_t_cst_p (arg2
, &s2
))
1577 && !TREE_SIDE_EFFECTS (arg0
)
1578 && !TREE_SIDE_EFFECTS (arg1
))
1579 return build_int_cst (type
, 0);
1580 else if ((p0
= c_getstr (arg0
))
1581 && (p1
= c_getstr (arg1
))
1582 && strncmp (p0
, p1
, s2
) == 0)
1583 return build_int_cst (type
, 0);
1586 case CFN_BUILT_IN_BCMP
:
1587 case CFN_BUILT_IN_MEMCMP
:
1588 if (!host_size_t_cst_p (arg2
, &s2
))
1591 && !TREE_SIDE_EFFECTS (arg0
)
1592 && !TREE_SIDE_EFFECTS (arg1
))
1593 return build_int_cst (type
, 0);
1594 if ((p0
= c_getstr (arg0
, &s0
))
1595 && (p1
= c_getstr (arg1
, &s1
))
1598 return build_cmp_result (type
, memcmp (p0
, p1
, s2
));
1601 case CFN_BUILT_IN_MEMCHR
:
1602 if (!host_size_t_cst_p (arg2
, &s2
))
1605 && !TREE_SIDE_EFFECTS (arg0
)
1606 && !TREE_SIDE_EFFECTS (arg1
))
1607 return build_int_cst (type
, 0);
1608 if ((p0
= c_getstr (arg0
, &s0
))
1610 && target_char_cst_p (arg1
, &c
))
1612 const char *r
= (const char *) memchr (p0
, c
, s2
);
1614 return build_int_cst (type
, 0);
1615 return fold_convert (type
,
1616 fold_build_pointer_plus_hwi (arg0
, r
- p0
));
1621 return fold_const_call_1 (fn
, type
, arg0
, arg1
, arg2
);
1625 /* Fold a fma operation with arguments ARG[012]. */
1628 fold_fma (location_t
, tree type
, tree arg0
, tree arg1
, tree arg2
)
1630 REAL_VALUE_TYPE result
;
1631 if (real_cst_p (arg0
)
1632 && real_cst_p (arg1
)
1633 && real_cst_p (arg2
)
1634 && do_mpfr_arg3 (&result
, mpfr_fma
, TREE_REAL_CST_PTR (arg0
),
1635 TREE_REAL_CST_PTR (arg1
), TREE_REAL_CST_PTR (arg2
),
1636 REAL_MODE_FORMAT (TYPE_MODE (type
))))
1637 return build_real (type
, result
);