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
);
590 in format FORMAT. Return true on success. */
593 fold_const_call_ss (real_value
*result
, combined_fn fn
,
594 const real_value
*arg
, const real_format
*format
)
600 return (real_compare (GE_EXPR
, arg
, &dconst0
)
601 && do_mpfr_arg1 (result
, mpfr_sqrt
, arg
, format
));
604 return do_mpfr_arg1 (result
, mpfr_cbrt
, arg
, format
);
607 return (real_compare (GE_EXPR
, arg
, &dconstm1
)
608 && real_compare (LE_EXPR
, arg
, &dconst1
)
609 && do_mpfr_arg1 (result
, mpfr_asin
, arg
, format
));
612 return (real_compare (GE_EXPR
, arg
, &dconstm1
)
613 && real_compare (LE_EXPR
, arg
, &dconst1
)
614 && do_mpfr_arg1 (result
, mpfr_acos
, arg
, format
));
617 return do_mpfr_arg1 (result
, mpfr_atan
, arg
, format
);
620 return do_mpfr_arg1 (result
, mpfr_asinh
, arg
, format
);
623 return (real_compare (GE_EXPR
, arg
, &dconst1
)
624 && do_mpfr_arg1 (result
, mpfr_acosh
, arg
, format
));
627 return (real_compare (GE_EXPR
, arg
, &dconstm1
)
628 && real_compare (LE_EXPR
, arg
, &dconst1
)
629 && do_mpfr_arg1 (result
, mpfr_atanh
, arg
, format
));
632 return do_mpfr_arg1 (result
, mpfr_sin
, arg
, format
);
635 return do_mpfr_arg1 (result
, mpfr_cos
, arg
, format
);
638 return do_mpfr_arg1 (result
, mpfr_tan
, arg
, format
);
641 return do_mpfr_arg1 (result
, mpfr_sinh
, arg
, format
);
644 return do_mpfr_arg1 (result
, mpfr_cosh
, arg
, format
);
647 return do_mpfr_arg1 (result
, mpfr_tanh
, arg
, format
);
650 return do_mpfr_arg1 (result
, mpfr_erf
, arg
, format
);
653 return do_mpfr_arg1 (result
, mpfr_erfc
, arg
, format
);
656 return do_mpfr_arg1 (result
, mpfr_gamma
, arg
, format
);
659 return do_mpfr_arg1 (result
, mpfr_exp
, arg
, format
);
662 return do_mpfr_arg1 (result
, mpfr_exp2
, arg
, format
);
666 return do_mpfr_arg1 (result
, mpfr_exp10
, arg
, format
);
669 return do_mpfr_arg1 (result
, mpfr_expm1
, arg
, format
);
672 return (real_compare (GT_EXPR
, arg
, &dconst0
)
673 && do_mpfr_arg1 (result
, mpfr_log
, arg
, format
));
676 return (real_compare (GT_EXPR
, arg
, &dconst0
)
677 && do_mpfr_arg1 (result
, mpfr_log2
, arg
, format
));
680 return (real_compare (GT_EXPR
, arg
, &dconst0
)
681 && do_mpfr_arg1 (result
, mpfr_log10
, arg
, format
));
684 return (real_compare (GT_EXPR
, arg
, &dconstm1
)
685 && do_mpfr_arg1 (result
, mpfr_log1p
, arg
, format
));
688 return do_mpfr_arg1 (result
, mpfr_j0
, arg
, format
);
691 return do_mpfr_arg1 (result
, mpfr_j1
, arg
, format
);
694 return (real_compare (GT_EXPR
, arg
, &dconst0
)
695 && do_mpfr_arg1 (result
, mpfr_y0
, arg
, format
));
698 return (real_compare (GT_EXPR
, arg
, &dconst0
)
699 && do_mpfr_arg1 (result
, mpfr_y1
, arg
, format
));
702 if (!REAL_VALUE_ISNAN (*arg
) || !flag_errno_math
)
704 real_floor (result
, format
, arg
);
710 if (!REAL_VALUE_ISNAN (*arg
) || !flag_errno_math
)
712 real_ceil (result
, format
, arg
);
718 real_trunc (result
, format
, arg
);
722 if (!REAL_VALUE_ISNAN (*arg
) || !flag_errno_math
)
724 real_round (result
, format
, arg
);
730 return fold_const_logb (result
, arg
, format
);
732 CASE_CFN_SIGNIFICAND
:
733 return fold_const_significand (result
, arg
, format
);
744 where FORMAT is the format of ARG and PRECISION is the number of
745 significant bits in the result. Return true on success. */
748 fold_const_call_ss (wide_int
*result
, combined_fn fn
,
749 const real_value
*arg
, unsigned int precision
,
750 const real_format
*format
)
755 if (real_isneg (arg
))
756 *result
= wi::one (precision
);
758 *result
= wi::zero (precision
);
762 /* For ilogb we don't know FP_ILOGB0, so only handle normal values.
763 Proceed iff radix == 2. In GCC, normalized significands are in
764 the range [0.5, 1.0). We want the exponent as if they were
765 [1.0, 2.0) so get the exponent and subtract 1. */
766 if (arg
->cl
== rvc_normal
&& format
->b
== 2)
768 *result
= wi::shwi (REAL_EXP (arg
) - 1, precision
);
776 return fold_const_conversion (result
, real_ceil
, arg
,
782 return fold_const_conversion (result
, real_floor
, arg
,
788 return fold_const_conversion (result
, real_round
, arg
,
794 /* Not yet folded to a constant. */
798 case CFN_BUILT_IN_FINITED32
:
799 case CFN_BUILT_IN_FINITED64
:
800 case CFN_BUILT_IN_FINITED128
:
801 case CFN_BUILT_IN_ISFINITE
:
802 *result
= wi::shwi (real_isfinite (arg
) ? 1 : 0, precision
);
806 case CFN_BUILT_IN_ISINFD32
:
807 case CFN_BUILT_IN_ISINFD64
:
808 case CFN_BUILT_IN_ISINFD128
:
809 if (real_isinf (arg
))
810 *result
= wi::shwi (arg
->sign
? -1 : 1, precision
);
812 *result
= wi::shwi (0, precision
);
816 case CFN_BUILT_IN_ISNAND32
:
817 case CFN_BUILT_IN_ISNAND64
:
818 case CFN_BUILT_IN_ISNAND128
:
819 *result
= wi::shwi (real_isnan (arg
) ? 1 : 0, precision
);
831 where ARG_TYPE is the type of ARG and PRECISION is the number of bits
832 in the result. Return true on success. */
835 fold_const_call_ss (wide_int
*result
, combined_fn fn
, const wide_int_ref
&arg
,
836 unsigned int precision
, tree arg_type
)
841 *result
= wi::shwi (wi::ffs (arg
), precision
);
847 if (wi::ne_p (arg
, 0))
849 else if (!CLZ_DEFINED_VALUE_AT_ZERO (SCALAR_INT_TYPE_MODE (arg_type
),
851 tmp
= TYPE_PRECISION (arg_type
);
852 *result
= wi::shwi (tmp
, precision
);
859 if (wi::ne_p (arg
, 0))
861 else if (!CTZ_DEFINED_VALUE_AT_ZERO (SCALAR_INT_TYPE_MODE (arg_type
),
863 tmp
= TYPE_PRECISION (arg_type
);
864 *result
= wi::shwi (tmp
, precision
);
869 *result
= wi::shwi (wi::clrsb (arg
), precision
);
873 *result
= wi::shwi (wi::popcount (arg
), precision
);
877 *result
= wi::shwi (wi::parity (arg
), precision
);
880 case CFN_BUILT_IN_BSWAP16
:
881 case CFN_BUILT_IN_BSWAP32
:
882 case CFN_BUILT_IN_BSWAP64
:
883 *result
= wide_int::from (arg
, precision
, TYPE_SIGN (arg_type
)).bswap ();
895 where FORMAT is the format of ARG and of the real and imaginary parts
896 of RESULT, passed as RESULT_REAL and RESULT_IMAG respectively. Return
900 fold_const_call_cs (real_value
*result_real
, real_value
*result_imag
,
901 combined_fn fn
, const real_value
*arg
,
902 const real_format
*format
)
907 /* cexpi(x+yi) = cos(x)+sin(y)*i. */
908 return do_mpfr_sincos (result_imag
, result_real
, arg
, format
);
919 where FORMAT is the format of RESULT and of the real and imaginary parts
920 of ARG, passed as ARG_REAL and ARG_IMAG respectively. Return true on
924 fold_const_call_sc (real_value
*result
, combined_fn fn
,
925 const real_value
*arg_real
, const real_value
*arg_imag
,
926 const real_format
*format
)
931 return do_mpfr_arg2 (result
, mpfr_hypot
, arg_real
, arg_imag
, format
);
942 where FORMAT is the format of the real and imaginary parts of RESULT
943 (RESULT_REAL and RESULT_IMAG) and of ARG (ARG_REAL and ARG_IMAG).
944 Return true on success. */
947 fold_const_call_cc (real_value
*result_real
, real_value
*result_imag
,
948 combined_fn fn
, const real_value
*arg_real
,
949 const real_value
*arg_imag
, const real_format
*format
)
954 return do_mpc_arg1 (result_real
, result_imag
, mpc_cos
,
955 arg_real
, arg_imag
, format
);
958 return do_mpc_arg1 (result_real
, result_imag
, mpc_cosh
,
959 arg_real
, arg_imag
, format
);
962 if (real_isinf (arg_real
) || real_isinf (arg_imag
))
964 real_inf (result_real
);
965 *result_imag
= dconst0
;
966 result_imag
->sign
= arg_imag
->sign
;
970 *result_real
= *arg_real
;
971 *result_imag
= *arg_imag
;
976 return do_mpc_arg1 (result_real
, result_imag
, mpc_sin
,
977 arg_real
, arg_imag
, format
);
980 return do_mpc_arg1 (result_real
, result_imag
, mpc_sinh
,
981 arg_real
, arg_imag
, format
);
984 return do_mpc_arg1 (result_real
, result_imag
, mpc_tan
,
985 arg_real
, arg_imag
, format
);
988 return do_mpc_arg1 (result_real
, result_imag
, mpc_tanh
,
989 arg_real
, arg_imag
, format
);
992 return do_mpc_arg1 (result_real
, result_imag
, mpc_log
,
993 arg_real
, arg_imag
, format
);
996 return do_mpc_arg1 (result_real
, result_imag
, mpc_sqrt
,
997 arg_real
, arg_imag
, format
);
1000 return do_mpc_arg1 (result_real
, result_imag
, mpc_asin
,
1001 arg_real
, arg_imag
, format
);
1004 return do_mpc_arg1 (result_real
, result_imag
, mpc_acos
,
1005 arg_real
, arg_imag
, format
);
1008 return do_mpc_arg1 (result_real
, result_imag
, mpc_atan
,
1009 arg_real
, arg_imag
, format
);
1012 return do_mpc_arg1 (result_real
, result_imag
, mpc_asinh
,
1013 arg_real
, arg_imag
, format
);
1016 return do_mpc_arg1 (result_real
, result_imag
, mpc_acosh
,
1017 arg_real
, arg_imag
, format
);
1020 return do_mpc_arg1 (result_real
, result_imag
, mpc_atanh
,
1021 arg_real
, arg_imag
, format
);
1024 return do_mpc_arg1 (result_real
, result_imag
, mpc_exp
,
1025 arg_real
, arg_imag
, format
);
1032 /* Subroutine of fold_const_call, with the same interface. Handle cases
1033 where the arguments and result are numerical. */
1036 fold_const_call_1 (combined_fn fn
, tree type
, tree arg
)
1038 machine_mode mode
= TYPE_MODE (type
);
1039 machine_mode arg_mode
= TYPE_MODE (TREE_TYPE (arg
));
1041 if (integer_cst_p (arg
))
1043 if (SCALAR_INT_MODE_P (mode
))
1046 if (fold_const_call_ss (&result
, fn
, wi::to_wide (arg
),
1047 TYPE_PRECISION (type
), TREE_TYPE (arg
)))
1048 return wide_int_to_tree (type
, result
);
1053 if (real_cst_p (arg
))
1055 gcc_checking_assert (SCALAR_FLOAT_MODE_P (arg_mode
));
1056 if (mode
== arg_mode
)
1059 REAL_VALUE_TYPE result
;
1060 if (fold_const_call_ss (&result
, fn
, TREE_REAL_CST_PTR (arg
),
1061 REAL_MODE_FORMAT (mode
)))
1062 return build_real (type
, result
);
1064 else if (COMPLEX_MODE_P (mode
)
1065 && GET_MODE_INNER (mode
) == arg_mode
)
1067 /* real -> complex real. */
1068 REAL_VALUE_TYPE result_real
, result_imag
;
1069 if (fold_const_call_cs (&result_real
, &result_imag
, fn
,
1070 TREE_REAL_CST_PTR (arg
),
1071 REAL_MODE_FORMAT (arg_mode
)))
1072 return build_complex (type
,
1073 build_real (TREE_TYPE (type
), result_real
),
1074 build_real (TREE_TYPE (type
), result_imag
));
1076 else if (INTEGRAL_TYPE_P (type
))
1080 if (fold_const_call_ss (&result
, fn
,
1081 TREE_REAL_CST_PTR (arg
),
1082 TYPE_PRECISION (type
),
1083 REAL_MODE_FORMAT (arg_mode
)))
1084 return wide_int_to_tree (type
, result
);
1089 if (complex_cst_p (arg
))
1091 gcc_checking_assert (COMPLEX_MODE_P (arg_mode
));
1092 machine_mode inner_mode
= GET_MODE_INNER (arg_mode
);
1093 tree argr
= TREE_REALPART (arg
);
1094 tree argi
= TREE_IMAGPART (arg
);
1095 if (mode
== arg_mode
1096 && real_cst_p (argr
)
1097 && real_cst_p (argi
))
1099 /* complex real -> complex real. */
1100 REAL_VALUE_TYPE result_real
, result_imag
;
1101 if (fold_const_call_cc (&result_real
, &result_imag
, fn
,
1102 TREE_REAL_CST_PTR (argr
),
1103 TREE_REAL_CST_PTR (argi
),
1104 REAL_MODE_FORMAT (inner_mode
)))
1105 return build_complex (type
,
1106 build_real (TREE_TYPE (type
), result_real
),
1107 build_real (TREE_TYPE (type
), result_imag
));
1109 if (mode
== inner_mode
1110 && real_cst_p (argr
)
1111 && real_cst_p (argi
))
1113 /* complex real -> real. */
1114 REAL_VALUE_TYPE result
;
1115 if (fold_const_call_sc (&result
, fn
,
1116 TREE_REAL_CST_PTR (argr
),
1117 TREE_REAL_CST_PTR (argi
),
1118 REAL_MODE_FORMAT (inner_mode
)))
1119 return build_real (type
, result
);
1127 /* Try to fold FN (ARG) to a constant. Return the constant on success,
1128 otherwise return null. TYPE is the type of the return value. */
1131 fold_const_call (combined_fn fn
, tree type
, tree arg
)
1135 case CFN_BUILT_IN_STRLEN
:
1136 if (const char *str
= c_getstr (arg
))
1137 return build_int_cst (type
, strlen (str
));
1141 CASE_FLT_FN_FLOATN_NX (CFN_BUILT_IN_NAN
):
1142 case CFN_BUILT_IN_NAND32
:
1143 case CFN_BUILT_IN_NAND64
:
1144 case CFN_BUILT_IN_NAND128
:
1145 return fold_const_builtin_nan (type
, arg
, true);
1148 CASE_FLT_FN_FLOATN_NX (CFN_BUILT_IN_NANS
):
1149 return fold_const_builtin_nan (type
, arg
, false);
1152 return fold_const_call_1 (fn
, type
, arg
);
1158 *RESULT = FN (*ARG0, *ARG1)
1160 in format FORMAT. Return true on success. */
1163 fold_const_call_sss (real_value
*result
, combined_fn fn
,
1164 const real_value
*arg0
, const real_value
*arg1
,
1165 const real_format
*format
)
1171 return do_mpfr_arg2 (result
, mpfr_remainder
, arg0
, arg1
, format
);
1174 return do_mpfr_arg2 (result
, mpfr_atan2
, arg0
, arg1
, format
);
1177 return do_mpfr_arg2 (result
, mpfr_dim
, arg0
, arg1
, format
);
1180 return do_mpfr_arg2 (result
, mpfr_hypot
, arg0
, arg1
, format
);
1183 CASE_CFN_COPYSIGN_FN
:
1185 real_copysign (result
, arg1
);
1190 return do_mpfr_arg2 (result
, mpfr_min
, arg0
, arg1
, format
);
1194 return do_mpfr_arg2 (result
, mpfr_max
, arg0
, arg1
, format
);
1197 return fold_const_pow (result
, arg0
, arg1
, format
);
1206 *RESULT = FN (*ARG0, ARG1)
1208 where FORMAT is the format of *RESULT and *ARG0. Return true on
1212 fold_const_call_sss (real_value
*result
, combined_fn fn
,
1213 const real_value
*arg0
, const wide_int_ref
&arg1
,
1214 const real_format
*format
)
1219 return fold_const_builtin_load_exponent (result
, arg0
, arg1
, format
);
1223 return (format
->b
== 2
1224 && fold_const_builtin_load_exponent (result
, arg0
, arg1
,
1228 /* Avoid the folding if flag_signaling_nans is on and
1229 operand is a signaling NaN. */
1230 if (!flag_unsafe_math_optimizations
1231 && flag_signaling_nans
1232 && REAL_VALUE_ISSIGNALING_NAN (*arg0
))
1235 real_powi (result
, format
, arg0
, arg1
.to_shwi ());
1245 *RESULT = FN (ARG0, *ARG1)
1247 where FORMAT is the format of *RESULT and *ARG1. Return true on
1251 fold_const_call_sss (real_value
*result
, combined_fn fn
,
1252 const wide_int_ref
&arg0
, const real_value
*arg1
,
1253 const real_format
*format
)
1258 return do_mpfr_arg2 (result
, mpfr_jn
, arg0
, arg1
, format
);
1261 return (real_compare (GT_EXPR
, arg1
, &dconst0
)
1262 && do_mpfr_arg2 (result
, mpfr_yn
, arg0
, arg1
, format
));
1271 RESULT = fn (ARG0, ARG1)
1273 where FORMAT is the format of the real and imaginary parts of RESULT
1274 (RESULT_REAL and RESULT_IMAG), of ARG0 (ARG0_REAL and ARG0_IMAG)
1275 and of ARG1 (ARG1_REAL and ARG1_IMAG). Return true on success. */
1278 fold_const_call_ccc (real_value
*result_real
, real_value
*result_imag
,
1279 combined_fn fn
, const real_value
*arg0_real
,
1280 const real_value
*arg0_imag
, const real_value
*arg1_real
,
1281 const real_value
*arg1_imag
, const real_format
*format
)
1286 return do_mpc_arg2 (result_real
, result_imag
, mpc_pow
,
1287 arg0_real
, arg0_imag
, arg1_real
, arg1_imag
, format
);
1294 /* Subroutine of fold_const_call, with the same interface. Handle cases
1295 where the arguments and result are numerical. */
1298 fold_const_call_1 (combined_fn fn
, tree type
, tree arg0
, tree arg1
)
1300 machine_mode mode
= TYPE_MODE (type
);
1301 machine_mode arg0_mode
= TYPE_MODE (TREE_TYPE (arg0
));
1302 machine_mode arg1_mode
= TYPE_MODE (TREE_TYPE (arg1
));
1304 if (arg0_mode
== arg1_mode
1305 && real_cst_p (arg0
)
1306 && real_cst_p (arg1
))
1308 gcc_checking_assert (SCALAR_FLOAT_MODE_P (arg0_mode
));
1309 if (mode
== arg0_mode
)
1311 /* real, real -> real. */
1312 REAL_VALUE_TYPE result
;
1313 if (fold_const_call_sss (&result
, fn
, TREE_REAL_CST_PTR (arg0
),
1314 TREE_REAL_CST_PTR (arg1
),
1315 REAL_MODE_FORMAT (mode
)))
1316 return build_real (type
, result
);
1321 if (real_cst_p (arg0
)
1322 && integer_cst_p (arg1
))
1324 gcc_checking_assert (SCALAR_FLOAT_MODE_P (arg0_mode
));
1325 if (mode
== arg0_mode
)
1327 /* real, int -> real. */
1328 REAL_VALUE_TYPE result
;
1329 if (fold_const_call_sss (&result
, fn
, TREE_REAL_CST_PTR (arg0
),
1331 REAL_MODE_FORMAT (mode
)))
1332 return build_real (type
, result
);
1337 if (integer_cst_p (arg0
)
1338 && real_cst_p (arg1
))
1340 gcc_checking_assert (SCALAR_FLOAT_MODE_P (arg1_mode
));
1341 if (mode
== arg1_mode
)
1343 /* int, real -> real. */
1344 REAL_VALUE_TYPE result
;
1345 if (fold_const_call_sss (&result
, fn
, wi::to_wide (arg0
),
1346 TREE_REAL_CST_PTR (arg1
),
1347 REAL_MODE_FORMAT (mode
)))
1348 return build_real (type
, result
);
1353 if (arg0_mode
== arg1_mode
1354 && complex_cst_p (arg0
)
1355 && complex_cst_p (arg1
))
1357 gcc_checking_assert (COMPLEX_MODE_P (arg0_mode
));
1358 machine_mode inner_mode
= GET_MODE_INNER (arg0_mode
);
1359 tree arg0r
= TREE_REALPART (arg0
);
1360 tree arg0i
= TREE_IMAGPART (arg0
);
1361 tree arg1r
= TREE_REALPART (arg1
);
1362 tree arg1i
= TREE_IMAGPART (arg1
);
1363 if (mode
== arg0_mode
1364 && real_cst_p (arg0r
)
1365 && real_cst_p (arg0i
)
1366 && real_cst_p (arg1r
)
1367 && real_cst_p (arg1i
))
1369 /* complex real, complex real -> complex real. */
1370 REAL_VALUE_TYPE result_real
, result_imag
;
1371 if (fold_const_call_ccc (&result_real
, &result_imag
, fn
,
1372 TREE_REAL_CST_PTR (arg0r
),
1373 TREE_REAL_CST_PTR (arg0i
),
1374 TREE_REAL_CST_PTR (arg1r
),
1375 TREE_REAL_CST_PTR (arg1i
),
1376 REAL_MODE_FORMAT (inner_mode
)))
1377 return build_complex (type
,
1378 build_real (TREE_TYPE (type
), result_real
),
1379 build_real (TREE_TYPE (type
), result_imag
));
1387 /* Try to fold FN (ARG0, ARG1) to a constant. Return the constant on success,
1388 otherwise return null. TYPE is the type of the return value. */
1391 fold_const_call (combined_fn fn
, tree type
, tree arg0
, tree arg1
)
1393 const char *p0
, *p1
;
1397 case CFN_BUILT_IN_STRSPN
:
1398 if ((p0
= c_getstr (arg0
)) && (p1
= c_getstr (arg1
)))
1399 return build_int_cst (type
, strspn (p0
, p1
));
1402 case CFN_BUILT_IN_STRCSPN
:
1403 if ((p0
= c_getstr (arg0
)) && (p1
= c_getstr (arg1
)))
1404 return build_int_cst (type
, strcspn (p0
, p1
));
1407 case CFN_BUILT_IN_STRCMP
:
1408 if ((p0
= c_getstr (arg0
)) && (p1
= c_getstr (arg1
)))
1409 return build_cmp_result (type
, strcmp (p0
, p1
));
1412 case CFN_BUILT_IN_STRCASECMP
:
1413 if ((p0
= c_getstr (arg0
)) && (p1
= c_getstr (arg1
)))
1415 int r
= strcmp (p0
, p1
);
1417 return build_cmp_result (type
, r
);
1421 case CFN_BUILT_IN_INDEX
:
1422 case CFN_BUILT_IN_STRCHR
:
1423 if ((p0
= c_getstr (arg0
)) && target_char_cst_p (arg1
, &c
))
1425 const char *r
= strchr (p0
, c
);
1427 return build_int_cst (type
, 0);
1428 return fold_convert (type
,
1429 fold_build_pointer_plus_hwi (arg0
, r
- p0
));
1433 case CFN_BUILT_IN_RINDEX
:
1434 case CFN_BUILT_IN_STRRCHR
:
1435 if ((p0
= c_getstr (arg0
)) && target_char_cst_p (arg1
, &c
))
1437 const char *r
= strrchr (p0
, c
);
1439 return build_int_cst (type
, 0);
1440 return fold_convert (type
,
1441 fold_build_pointer_plus_hwi (arg0
, r
- p0
));
1445 case CFN_BUILT_IN_STRSTR
:
1446 if ((p1
= c_getstr (arg1
)))
1448 if ((p0
= c_getstr (arg0
)))
1450 const char *r
= strstr (p0
, p1
);
1452 return build_int_cst (type
, 0);
1453 return fold_convert (type
,
1454 fold_build_pointer_plus_hwi (arg0
, r
- p0
));
1457 return fold_convert (type
, arg0
);
1462 return fold_const_call_1 (fn
, type
, arg0
, arg1
);
1468 *RESULT = FN (*ARG0, *ARG1, *ARG2)
1470 in format FORMAT. Return true on success. */
1473 fold_const_call_ssss (real_value
*result
, combined_fn fn
,
1474 const real_value
*arg0
, const real_value
*arg1
,
1475 const real_value
*arg2
, const real_format
*format
)
1481 return do_mpfr_arg3 (result
, mpfr_fma
, arg0
, arg1
, arg2
, format
);
1488 /* Subroutine of fold_const_call, with the same interface. Handle cases
1489 where the arguments and result are numerical. */
1492 fold_const_call_1 (combined_fn fn
, tree type
, tree arg0
, tree arg1
, tree arg2
)
1494 machine_mode mode
= TYPE_MODE (type
);
1495 machine_mode arg0_mode
= TYPE_MODE (TREE_TYPE (arg0
));
1496 machine_mode arg1_mode
= TYPE_MODE (TREE_TYPE (arg1
));
1497 machine_mode arg2_mode
= TYPE_MODE (TREE_TYPE (arg2
));
1499 if (arg0_mode
== arg1_mode
1500 && arg0_mode
== arg2_mode
1501 && real_cst_p (arg0
)
1502 && real_cst_p (arg1
)
1503 && real_cst_p (arg2
))
1505 gcc_checking_assert (SCALAR_FLOAT_MODE_P (arg0_mode
));
1506 if (mode
== arg0_mode
)
1508 /* real, real, real -> real. */
1509 REAL_VALUE_TYPE result
;
1510 if (fold_const_call_ssss (&result
, fn
, TREE_REAL_CST_PTR (arg0
),
1511 TREE_REAL_CST_PTR (arg1
),
1512 TREE_REAL_CST_PTR (arg2
),
1513 REAL_MODE_FORMAT (mode
)))
1514 return build_real (type
, result
);
1522 /* Try to fold FN (ARG0, ARG1, ARG2) to a constant. Return the constant on
1523 success, otherwise return null. TYPE is the type of the return value. */
1526 fold_const_call (combined_fn fn
, tree type
, tree arg0
, tree arg1
, tree arg2
)
1528 const char *p0
, *p1
;
1530 unsigned HOST_WIDE_INT s0
, s1
;
1534 case CFN_BUILT_IN_STRNCMP
:
1535 if (!host_size_t_cst_p (arg2
, &s2
))
1538 && !TREE_SIDE_EFFECTS (arg0
)
1539 && !TREE_SIDE_EFFECTS (arg1
))
1540 return build_int_cst (type
, 0);
1541 else if ((p0
= c_getstr (arg0
)) && (p1
= c_getstr (arg1
)))
1542 return build_int_cst (type
, strncmp (p0
, p1
, s2
));
1545 case CFN_BUILT_IN_STRNCASECMP
:
1546 if (!host_size_t_cst_p (arg2
, &s2
))
1549 && !TREE_SIDE_EFFECTS (arg0
)
1550 && !TREE_SIDE_EFFECTS (arg1
))
1551 return build_int_cst (type
, 0);
1552 else if ((p0
= c_getstr (arg0
))
1553 && (p1
= c_getstr (arg1
))
1554 && strncmp (p0
, p1
, s2
) == 0)
1555 return build_int_cst (type
, 0);
1558 case CFN_BUILT_IN_BCMP
:
1559 case CFN_BUILT_IN_MEMCMP
:
1560 if (!host_size_t_cst_p (arg2
, &s2
))
1563 && !TREE_SIDE_EFFECTS (arg0
)
1564 && !TREE_SIDE_EFFECTS (arg1
))
1565 return build_int_cst (type
, 0);
1566 if ((p0
= c_getstr (arg0
, &s0
))
1567 && (p1
= c_getstr (arg1
, &s1
))
1570 return build_cmp_result (type
, memcmp (p0
, p1
, s2
));
1573 case CFN_BUILT_IN_MEMCHR
:
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 if ((p0
= c_getstr (arg0
, &s0
))
1582 && target_char_cst_p (arg1
, &c
))
1584 const char *r
= (const char *) memchr (p0
, c
, s2
);
1586 return build_int_cst (type
, 0);
1587 return fold_convert (type
,
1588 fold_build_pointer_plus_hwi (arg0
, r
- p0
));
1593 return fold_const_call_1 (fn
, type
, arg0
, arg1
, arg2
);
1597 /* Fold a fma operation with arguments ARG[012]. */
1600 fold_fma (location_t
, tree type
, tree arg0
, tree arg1
, tree arg2
)
1602 REAL_VALUE_TYPE result
;
1603 if (real_cst_p (arg0
)
1604 && real_cst_p (arg1
)
1605 && real_cst_p (arg2
)
1606 && do_mpfr_arg3 (&result
, mpfr_fma
, TREE_REAL_CST_PTR (arg0
),
1607 TREE_REAL_CST_PTR (arg1
), TREE_REAL_CST_PTR (arg2
),
1608 REAL_MODE_FORMAT (TYPE_MODE (type
))))
1609 return build_real (type
, result
);