gcc/fold-const-call.c

   1 /* Constant folding for calls to built-in and internal functions.
   2    Copyright (C) 1988-2017 Free Software Foundation, Inc.
   3
   4 This file is part of GCC.
   5
   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
   9 version.
  10
  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
  14 for more details.
  15
  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/>.  */
  19
  20 #include "config.h"
  21 #include "system.h"
  22 #include "coretypes.h"
  23 #include "realmpfr.h"
  24 #include "tree.h"
  25 #include "stor-layout.h"
  26 #include "options.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.  */
  31 #include "builtins.h"
  32 #include "gimple-expr.h"
  33
  34 /* Functions that test for certain constant types, abstracting away the
  35    decision about whether to check for overflow.  */
  36
  37 static inline bool
  38 integer_cst_p (tree t)
  39 {
  40   return TREE_CODE (t) == INTEGER_CST && !TREE_OVERFLOW (t);
  41 }
  42
  43 static inline bool
  44 real_cst_p (tree t)
  45 {
  46   return TREE_CODE (t) == REAL_CST && !TREE_OVERFLOW (t);
  47 }
  48
  49 static inline bool
  50 complex_cst_p (tree t)
  51 {
  52   return TREE_CODE (t) == COMPLEX_CST;
  53 }
  54
  55 /* Return true if ARG is a constant in the range of the host size_t.
  56    Store it in *SIZE_OUT if so.  */
  57
  58 static inline bool
  59 host_size_t_cst_p (tree t, size_t *size_out)
  60 {
  61   if (types_compatible_p (size_type_node, TREE_TYPE (t))
  62       && integer_cst_p (t)
  63       && (wi::min_precision (wi::to_wide (t), UNSIGNED)
  64           <= sizeof (size_t) * CHAR_BIT))
  65     {
  66       *size_out = tree_to_uhwi (t);
  67       return true;
  68     }
  69   return false;
  70 }
  71
  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.  */
  75
  76 tree
  77 build_cmp_result (tree type, int res)
  78 {
  79   return build_int_cst (type, res < 0 ? -1 : res > 0 ? 1 : 0);
  80 }
  81
  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.  */
  86
  87 static bool
  88 do_mpfr_ckconv (real_value *result, mpfr_srcptr m, bool inexact,
  89                 const real_format *format)
  90 {
  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)
  95       || mpfr_overflow_p ()
  96       || mpfr_underflow_p ()
  97       || (flag_rounding_math && inexact))
  98     return false;
  99
 100   REAL_VALUE_TYPE tmp;
 101   real_from_mpfr (&tmp, m, format, GMP_RNDN);
 102
 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)))
 108     return false;
 109
 110   real_convert (result, format, &tmp);
 111   return real_identical (result, &tmp);
 112 }
 113
 114 /* Try to evaluate:
 115
 116       *RESULT = f (*ARG)
 117
 118    in format FORMAT, given that FUNC is the MPFR implementation of f.
 119    Return true on success.  */
 120
 121 static bool
 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)
 125 {
 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))
 129     return false;
 130
 131   int prec = format->p;
 132   mp_rnd_t rnd = format->round_towards_zero ? GMP_RNDZ : GMP_RNDN;
 133   mpfr_t m;
 134
 135   mpfr_init2 (m, prec);
 136   mpfr_from_real (m, arg, GMP_RNDN);
 137   mpfr_clear_flags ();
 138   bool inexact = func (m, m, rnd);
 139   bool ok = do_mpfr_ckconv (result, m, inexact, format);
 140   mpfr_clear (m);
 141
 142   return ok;
 143 }
 144
 145 /* Try to evaluate:
 146
 147       *RESULT_SIN = sin (*ARG);
 148       *RESULT_COS = cos (*ARG);
 149
 150    for format FORMAT.  Return true on success.  */
 151
 152 static bool
 153 do_mpfr_sincos (real_value *result_sin, real_value *result_cos,
 154                 const real_value *arg, const real_format *format)
 155 {
 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))
 159     return false;
 160
 161   int prec = format->p;
 162   mp_rnd_t rnd = format->round_towards_zero ? GMP_RNDZ : GMP_RNDN;
 163   mpfr_t m, ms, mc;
 164
 165   mpfr_inits2 (prec, m, ms, mc, NULL);
 166   mpfr_from_real (m, arg, GMP_RNDN);
 167   mpfr_clear_flags ();
 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);
 172
 173   return ok;
 174 }
 175
 176 /* Try to evaluate:
 177
 178       *RESULT = f (*ARG0, *ARG1)
 179
 180    in format FORMAT, given that FUNC is the MPFR implementation of f.
 181    Return true on success.  */
 182
 183 static bool
 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)
 188 {
 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))
 192     return false;
 193
 194   int prec = format->p;
 195   mp_rnd_t rnd = format->round_towards_zero ? GMP_RNDZ : GMP_RNDN;
 196   mpfr_t m0, m1;
 197
 198   mpfr_inits2 (prec, m0, m1, NULL);
 199   mpfr_from_real (m0, arg0, GMP_RNDN);
 200   mpfr_from_real (m1, arg1, GMP_RNDN);
 201   mpfr_clear_flags ();
 202   bool inexact = func (m0, m0, m1, rnd);
 203   bool ok = do_mpfr_ckconv (result, m0, inexact, format);
 204   mpfr_clears (m0, m1, NULL);
 205
 206   return ok;
 207 }
 208
 209 /* Try to evaluate:
 210
 211       *RESULT = f (ARG0, *ARG1)
 212
 213    in format FORMAT, given that FUNC is the MPFR implementation of f.
 214    Return true on success.  */
 215
 216 static bool
 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)
 221 {
 222   if (format->b != 2 || !real_isfinite (arg1))
 223     return false;
 224
 225   int prec = format->p;
 226   mp_rnd_t rnd = format->round_towards_zero ? GMP_RNDZ : GMP_RNDN;
 227   mpfr_t m;
 228
 229   mpfr_init2 (m, prec);
 230   mpfr_from_real (m, arg1, GMP_RNDN);
 231   mpfr_clear_flags ();
 232   bool inexact = func (m, arg0.to_shwi (), m, rnd);
 233   bool ok = do_mpfr_ckconv (result, m, inexact, format);
 234   mpfr_clear (m);
 235
 236   return ok;
 237 }
 238
 239 /* Try to evaluate:
 240
 241       *RESULT = f (*ARG0, *ARG1, *ARG2)
 242
 243    in format FORMAT, given that FUNC is the MPFR implementation of f.
 244    Return true on success.  */
 245
 246 static bool
 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)
 252 {
 253   /* To proceed, MPFR must exactly represent the target floating point
 254      format, which only happens when the target base equals two.  */
 255   if (format->b != 2
 256       || !real_isfinite (arg0)
 257       || !real_isfinite (arg1)
 258       || !real_isfinite (arg2))
 259     return false;
 260
 261   int prec = format->p;
 262   mp_rnd_t rnd = format->round_towards_zero ? GMP_RNDZ : GMP_RNDN;
 263   mpfr_t m0, m1, m2;
 264
 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);
 269   mpfr_clear_flags ();
 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);
 273
 274   return ok;
 275 }
 276
 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.  */
 282
 283 static bool
 284 do_mpc_ckconv (real_value *result_real, real_value *result_imag,
 285                mpc_srcptr m, bool inexact, const real_format *format)
 286 {
 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))
 295     return false;
 296
 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);
 300
 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))
 308     return false;
 309
 310   real_convert (result_real, format, &tmp_real);
 311   real_convert (result_imag, format, &tmp_imag);
 312
 313   return (real_identical (result_real, &tmp_real)
 314           && real_identical (result_imag, &tmp_imag));
 315 }
 316
 317 /* Try to evaluate:
 318
 319       RESULT = f (ARG)
 320
 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.  */
 324
 325 static bool
 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)
 330 {
 331   /* To proceed, MPFR must exactly represent the target floating point
 332      format, which only happens when the target base equals two.  */
 333   if (format->b != 2
 334       || !real_isfinite (arg_real)
 335       || !real_isfinite (arg_imag))
 336     return false;
 337
 338   int prec = format->p;
 339   mpc_rnd_t crnd = format->round_towards_zero ? MPC_RNDZZ : MPC_RNDNN;
 340   mpc_t m;
 341
 342   mpc_init2 (m, prec);
 343   mpfr_from_real (mpc_realref (m), arg_real, GMP_RNDN);
 344   mpfr_from_real (mpc_imagref (m), arg_imag, GMP_RNDN);
 345   mpfr_clear_flags ();
 346   bool inexact = func (m, m, crnd);
 347   bool ok = do_mpc_ckconv (result_real, result_imag, m, inexact, format);
 348   mpc_clear (m);
 349
 350   return ok;
 351 }
 352
 353 /* Try to evaluate:
 354
 355       RESULT = f (ARG0, ARG1)
 356
 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.  */
 360
 361 static bool
 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)
 367 {
 368   if (!real_isfinite (arg0_real)
 369       || !real_isfinite (arg0_imag)
 370       || !real_isfinite (arg1_real)
 371       || !real_isfinite (arg1_imag))
 372     return false;
 373
 374   int prec = format->p;
 375   mpc_rnd_t crnd = format->round_towards_zero ? MPC_RNDZZ : MPC_RNDNN;
 376   mpc_t m0, m1;
 377
 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);
 384   mpfr_clear_flags ();
 385   bool inexact = func (m0, m0, m1, crnd);
 386   bool ok = do_mpc_ckconv (result_real, result_imag, m0, inexact, format);
 387   mpc_clear (m0);
 388   mpc_clear (m1);
 389
 390   return ok;
 391 }
 392
 393 /* Try to evaluate:
 394
 395       *RESULT = logb (*ARG)
 396
 397    in format FORMAT.  Return true on success.  */
 398
 399 static bool
 400 fold_const_logb (real_value *result, const real_value *arg,
 401                  const real_format *format)
 402 {
 403   switch (arg->cl)
 404     {
 405     case rvc_nan:
 406       /* If arg is +-NaN, then return it.  */
 407       *result = *arg;
 408       return true;
 409
 410     case rvc_inf:
 411       /* If arg is +-Inf, then return +Inf.  */
 412       *result = *arg;
 413       result->sign = 0;
 414       return true;
 415
 416     case rvc_zero:
 417       /* Zero may set errno and/or raise an exception.  */
 418       return false;
 419
 420     case rvc_normal:
 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.  */
 425       if (format->b == 2)
 426         {
 427           real_from_integer (result, format, REAL_EXP (arg) - 1, SIGNED);
 428           return true;
 429         }
 430       return false;
 431     }
 432   gcc_unreachable ();
 433 }
 434
 435 /* Try to evaluate:
 436
 437       *RESULT = significand (*ARG)
 438
 439    in format FORMAT.  Return true on success.  */
 440
 441 static bool
 442 fold_const_significand (real_value *result, const real_value *arg,
 443                         const real_format *format)
 444 {
 445   switch (arg->cl)
 446     {
 447     case rvc_zero:
 448     case rvc_nan:
 449     case rvc_inf:
 450       /* If arg is +-0, +-Inf or +-NaN, then return it.  */
 451       *result = *arg;
 452       return true;
 453
 454     case rvc_normal:
 455       /* For normal numbers, proceed iff radix == 2.  */
 456       if (format->b == 2)
 457         {
 458           *result = *arg;
 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);
 462           return true;
 463         }
 464       return false;
 465     }
 466   gcc_unreachable ();
 467 }
 468
 469 /* Try to evaluate:
 470
 471       *RESULT = f (*ARG)
 472
 473    where FORMAT is the format of *ARG and PRECISION is the number of
 474    significant bits in the result.  Return true on success.  */
 475
 476 static bool
 477 fold_const_conversion (wide_int *result,
 478                        void (*fn) (real_value *, format_helper,
 479                                    const real_value *),
 480                        const real_value *arg, unsigned int precision,
 481                        const real_format *format)
 482 {
 483   if (!real_isfinite (arg))
 484     return false;
 485
 486   real_value rounded;
 487   fn (&rounded, format, arg);
 488
 489   bool fail = false;
 490   *result = real_to_integer (&rounded, &fail, precision);
 491   return !fail;
 492 }
 493
 494 /* Try to evaluate:
 495
 496       *RESULT = pow (*ARG0, *ARG1)
 497
 498    in format FORMAT.  Return true on success.  */
 499
 500 static bool
 501 fold_const_pow (real_value *result, const real_value *arg0,
 502                 const real_value *arg1, const real_format *format)
 503 {
 504   if (do_mpfr_arg2 (result, mpfr_pow, arg0, arg1, format))
 505     return true;
 506
 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)
 514       && (n1 > 0
 515           || (!flag_trapping_math && !flag_errno_math)
 516           || !real_equal (arg0, &dconst0)))
 517     {
 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
 521           || (!inexact
 522               && !(flag_signaling_nans
 523                    && REAL_VALUE_ISSIGNALING_NAN (*arg0))))
 524         return true;
 525     }
 526
 527   return false;
 528 }
 529
 530 /* Try to evaluate:
 531
 532       *RESULT = ldexp (*ARG0, ARG1)
 533
 534    in format FORMAT.  Return true on success.  */
 535
 536 static bool
 537 fold_const_builtin_load_exponent (real_value *result, const real_value *arg0,
 538                                   const wide_int_ref &arg1,
 539                                   const real_format *format)
 540 {
 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);
 545
 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))
 550     return false;
 551
 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))
 557     return false;
 558
 559   REAL_VALUE_TYPE initial_result;
 560   real_ldexp (&initial_result, arg0, arg1.to_shwi ());
 561
 562   /* Ensure we didn't overflow.  */
 563   if (real_isinf (&initial_result))
 564     return false;
 565
 566   /* Only proceed if the target mode can hold the
 567      resulting value.  */
 568   *result = real_value_truncate (format, initial_result);
 569   return real_equal (&initial_result, result);
 570 }
 571
 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
 574    NaN is required.  */
 575
 576 static tree
 577 fold_const_builtin_nan (tree type, tree arg, bool quiet)
 578 {
 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);
 583   return NULL_TREE;
 584 }
 585
 586 /* Try to evaluate:
 587
 588       *RESULT = FN (*ARG)
 589
 590    in format FORMAT.  Return true on success.  */
 591
 592 static bool
 593 fold_const_call_ss (real_value *result, combined_fn fn,
 594                     const real_value *arg, const real_format *format)
 595 {
 596   switch (fn)
 597     {
 598     CASE_CFN_SQRT:
 599       return (real_compare (GE_EXPR, arg, &dconst0)
 600               && do_mpfr_arg1 (result, mpfr_sqrt, arg, format));
 601
 602     CASE_CFN_CBRT:
 603       return do_mpfr_arg1 (result, mpfr_cbrt, arg, format);
 604
 605     CASE_CFN_ASIN:
 606       return (real_compare (GE_EXPR, arg, &dconstm1)
 607               && real_compare (LE_EXPR, arg, &dconst1)
 608               && do_mpfr_arg1 (result, mpfr_asin, arg, format));
 609
 610     CASE_CFN_ACOS:
 611       return (real_compare (GE_EXPR, arg, &dconstm1)
 612               && real_compare (LE_EXPR, arg, &dconst1)
 613               && do_mpfr_arg1 (result, mpfr_acos, arg, format));
 614
 615     CASE_CFN_ATAN:
 616       return do_mpfr_arg1 (result, mpfr_atan, arg, format);
 617
 618     CASE_CFN_ASINH:
 619       return do_mpfr_arg1 (result, mpfr_asinh, arg, format);
 620
 621     CASE_CFN_ACOSH:
 622       return (real_compare (GE_EXPR, arg, &dconst1)
 623               && do_mpfr_arg1 (result, mpfr_acosh, arg, format));
 624
 625     CASE_CFN_ATANH:
 626       return (real_compare (GE_EXPR, arg, &dconstm1)
 627               && real_compare (LE_EXPR, arg, &dconst1)
 628               && do_mpfr_arg1 (result, mpfr_atanh, arg, format));
 629
 630     CASE_CFN_SIN:
 631       return do_mpfr_arg1 (result, mpfr_sin, arg, format);
 632
 633     CASE_CFN_COS:
 634       return do_mpfr_arg1 (result, mpfr_cos, arg, format);
 635
 636     CASE_CFN_TAN:
 637       return do_mpfr_arg1 (result, mpfr_tan, arg, format);
 638
 639     CASE_CFN_SINH:
 640       return do_mpfr_arg1 (result, mpfr_sinh, arg, format);
 641
 642     CASE_CFN_COSH:
 643       return do_mpfr_arg1 (result, mpfr_cosh, arg, format);
 644
 645     CASE_CFN_TANH:
 646       return do_mpfr_arg1 (result, mpfr_tanh, arg, format);
 647
 648     CASE_CFN_ERF:
 649       return do_mpfr_arg1 (result, mpfr_erf, arg, format);
 650
 651     CASE_CFN_ERFC:
 652       return do_mpfr_arg1 (result, mpfr_erfc, arg, format);
 653
 654     CASE_CFN_TGAMMA:
 655       return do_mpfr_arg1 (result, mpfr_gamma, arg, format);
 656
 657     CASE_CFN_EXP:
 658       return do_mpfr_arg1 (result, mpfr_exp, arg, format);
 659
 660     CASE_CFN_EXP2:
 661       return do_mpfr_arg1 (result, mpfr_exp2, arg, format);
 662
 663     CASE_CFN_EXP10:
 664     CASE_CFN_POW10:
 665       return do_mpfr_arg1 (result, mpfr_exp10, arg, format);
 666
 667     CASE_CFN_EXPM1:
 668       return do_mpfr_arg1 (result, mpfr_expm1, arg, format);
 669
 670     CASE_CFN_LOG:
 671       return (real_compare (GT_EXPR, arg, &dconst0)
 672               && do_mpfr_arg1 (result, mpfr_log, arg, format));
 673
 674     CASE_CFN_LOG2:
 675       return (real_compare (GT_EXPR, arg, &dconst0)
 676               && do_mpfr_arg1 (result, mpfr_log2, arg, format));
 677
 678     CASE_CFN_LOG10:
 679       return (real_compare (GT_EXPR, arg, &dconst0)
 680               && do_mpfr_arg1 (result, mpfr_log10, arg, format));
 681
 682     CASE_CFN_LOG1P:
 683       return (real_compare (GT_EXPR, arg, &dconstm1)
 684               && do_mpfr_arg1 (result, mpfr_log1p, arg, format));
 685
 686     CASE_CFN_J0:
 687       return do_mpfr_arg1 (result, mpfr_j0, arg, format);
 688
 689     CASE_CFN_J1:
 690       return do_mpfr_arg1 (result, mpfr_j1, arg, format);
 691
 692     CASE_CFN_Y0:
 693       return (real_compare (GT_EXPR, arg, &dconst0)
 694               && do_mpfr_arg1 (result, mpfr_y0, arg, format));
 695
 696     CASE_CFN_Y1:
 697       return (real_compare (GT_EXPR, arg, &dconst0)
 698               && do_mpfr_arg1 (result, mpfr_y1, arg, format));
 699
 700     CASE_CFN_FLOOR:
 701       if (!REAL_VALUE_ISNAN (*arg) || !flag_errno_math)
 702         {
 703           real_floor (result, format, arg);
 704           return true;
 705         }
 706       return false;
 707
 708     CASE_CFN_CEIL:
 709       if (!REAL_VALUE_ISNAN (*arg) || !flag_errno_math)
 710         {
 711           real_ceil (result, format, arg);
 712           return true;
 713         }
 714       return false;
 715
 716     CASE_CFN_TRUNC:
 717       real_trunc (result, format, arg);
 718       return true;
 719
 720     CASE_CFN_ROUND:
 721       if (!REAL_VALUE_ISNAN (*arg) || !flag_errno_math)
 722         {
 723           real_round (result, format, arg);
 724           return true;
 725         }
 726       return false;
 727
 728     CASE_CFN_LOGB:
 729       return fold_const_logb (result, arg, format);
 730
 731     CASE_CFN_SIGNIFICAND:
 732       return fold_const_significand (result, arg, format);
 733
 734     default:
 735       return false;
 736     }
 737 }
 738
 739 /* Try to evaluate:
 740
 741       *RESULT = FN (*ARG)
 742
 743    where FORMAT is the format of ARG and PRECISION is the number of
 744    significant bits in the result.  Return true on success.  */
 745
 746 static bool
 747 fold_const_call_ss (wide_int *result, combined_fn fn,
 748                     const real_value *arg, unsigned int precision,
 749                     const real_format *format)
 750 {
 751   switch (fn)
 752     {
 753     CASE_CFN_SIGNBIT:
 754       if (real_isneg (arg))
 755         *result = wi::one (precision);
 756       else
 757         *result = wi::zero (precision);
 758       return true;
 759
 760     CASE_CFN_ILOGB:
 761       /* For ilogb we don't know FP_ILOGB0, so only handle normal values.
 762          Proceed iff radix == 2.  In GCC, normalized significands are in
 763          the range [0.5, 1.0).  We want the exponent as if they were
 764          [1.0, 2.0) so get the exponent and subtract 1.  */
 765       if (arg->cl == rvc_normal && format->b == 2)
 766         {
 767           *result = wi::shwi (REAL_EXP (arg) - 1, precision);
 768           return true;
 769         }
 770       return false;
 771
 772     CASE_CFN_ICEIL:
 773     CASE_CFN_LCEIL:
 774     CASE_CFN_LLCEIL:
 775       return fold_const_conversion (result, real_ceil, arg,
 776                                     precision, format);
 777
 778     CASE_CFN_LFLOOR:
 779     CASE_CFN_IFLOOR:
 780     CASE_CFN_LLFLOOR:
 781       return fold_const_conversion (result, real_floor, arg,
 782                                     precision, format);
 783
 784     CASE_CFN_IROUND:
 785     CASE_CFN_LROUND:
 786     CASE_CFN_LLROUND:
 787       return fold_const_conversion (result, real_round, arg,
 788                                     precision, format);
 789
 790     CASE_CFN_IRINT:
 791     CASE_CFN_LRINT:
 792     CASE_CFN_LLRINT:
 793       /* Not yet folded to a constant.  */
 794       return false;
 795
 796     CASE_CFN_FINITE:
 797     case CFN_BUILT_IN_FINITED32:
 798     case CFN_BUILT_IN_FINITED64:
 799     case CFN_BUILT_IN_FINITED128:
 800     case CFN_BUILT_IN_ISFINITE:
 801       *result = wi::shwi (real_isfinite (arg) ? 1 : 0, precision);
 802       return true;
 803
 804     CASE_CFN_ISINF:
 805     case CFN_BUILT_IN_ISINFD32:
 806     case CFN_BUILT_IN_ISINFD64:
 807     case CFN_BUILT_IN_ISINFD128:
 808       if (real_isinf (arg))
 809         *result = wi::shwi (arg->sign ? -1 : 1, precision);
 810       else
 811         *result = wi::shwi (0, precision);
 812       return true;
 813
 814     CASE_CFN_ISNAN:
 815     case CFN_BUILT_IN_ISNAND32:
 816     case CFN_BUILT_IN_ISNAND64:
 817     case CFN_BUILT_IN_ISNAND128:
 818       *result = wi::shwi (real_isnan (arg) ? 1 : 0, precision);
 819       return true;
 820
 821     default:
 822       return false;
 823     }
 824 }
 825
 826 /* Try to evaluate:
 827
 828       *RESULT = FN (ARG)
 829
 830    where ARG_TYPE is the type of ARG and PRECISION is the number of bits
 831    in the result.  Return true on success.  */
 832
 833 static bool
 834 fold_const_call_ss (wide_int *result, combined_fn fn, const wide_int_ref &arg,
 835                     unsigned int precision, tree arg_type)
 836 {
 837   switch (fn)
 838     {
 839     CASE_CFN_FFS:
 840       *result = wi::shwi (wi::ffs (arg), precision);
 841       return true;
 842
 843     CASE_CFN_CLZ:
 844       {
 845         int tmp;
 846         if (wi::ne_p (arg, 0))
 847           tmp = wi::clz (arg);
 848         else if (!CLZ_DEFINED_VALUE_AT_ZERO (SCALAR_INT_TYPE_MODE (arg_type),
 849                                              tmp))
 850           tmp = TYPE_PRECISION (arg_type);
 851         *result = wi::shwi (tmp, precision);
 852         return true;
 853       }
 854
 855     CASE_CFN_CTZ:
 856       {
 857         int tmp;
 858         if (wi::ne_p (arg, 0))
 859           tmp = wi::ctz (arg);
 860         else if (!CTZ_DEFINED_VALUE_AT_ZERO (SCALAR_INT_TYPE_MODE (arg_type),
 861                                              tmp))
 862           tmp = TYPE_PRECISION (arg_type);
 863         *result = wi::shwi (tmp, precision);
 864         return true;
 865       }
 866
 867     CASE_CFN_CLRSB:
 868       *result = wi::shwi (wi::clrsb (arg), precision);
 869       return true;
 870
 871     CASE_CFN_POPCOUNT:
 872       *result = wi::shwi (wi::popcount (arg), precision);
 873       return true;
 874
 875     CASE_CFN_PARITY:
 876       *result = wi::shwi (wi::parity (arg), precision);
 877       return true;
 878
 879     case CFN_BUILT_IN_BSWAP16:
 880     case CFN_BUILT_IN_BSWAP32:
 881     case CFN_BUILT_IN_BSWAP64:
 882       *result = wide_int::from (arg, precision, TYPE_SIGN (arg_type)).bswap ();
 883       return true;
 884
 885     default:
 886       return false;
 887     }
 888 }
 889
 890 /* Try to evaluate:
 891
 892       RESULT = FN (*ARG)
 893
 894    where FORMAT is the format of ARG and of the real and imaginary parts
 895    of RESULT, passed as RESULT_REAL and RESULT_IMAG respectively.  Return
 896    true on success.  */
 897
 898 static bool
 899 fold_const_call_cs (real_value *result_real, real_value *result_imag,
 900                     combined_fn fn, const real_value *arg,
 901                     const real_format *format)
 902 {
 903   switch (fn)
 904     {
 905     CASE_CFN_CEXPI:
 906       /* cexpi(x+yi) = cos(x)+sin(y)*i.  */
 907       return do_mpfr_sincos (result_imag, result_real, arg, format);
 908
 909     default:
 910       return false;
 911     }
 912 }
 913
 914 /* Try to evaluate:
 915
 916       *RESULT = fn (ARG)
 917
 918    where FORMAT is the format of RESULT and of the real and imaginary parts
 919    of ARG, passed as ARG_REAL and ARG_IMAG respectively.  Return true on
 920    success.  */
 921
 922 static bool
 923 fold_const_call_sc (real_value *result, combined_fn fn,
 924                     const real_value *arg_real, const real_value *arg_imag,
 925                     const real_format *format)
 926 {
 927   switch (fn)
 928     {
 929     CASE_CFN_CABS:
 930       return do_mpfr_arg2 (result, mpfr_hypot, arg_real, arg_imag, format);
 931
 932     default:
 933       return false;
 934     }
 935 }
 936
 937 /* Try to evaluate:
 938
 939       RESULT = fn (ARG)
 940
 941    where FORMAT is the format of the real and imaginary parts of RESULT
 942    (RESULT_REAL and RESULT_IMAG) and of ARG (ARG_REAL and ARG_IMAG).
 943    Return true on success.  */
 944
 945 static bool
 946 fold_const_call_cc (real_value *result_real, real_value *result_imag,
 947                     combined_fn fn, const real_value *arg_real,
 948                     const real_value *arg_imag, const real_format *format)
 949 {
 950   switch (fn)
 951     {
 952     CASE_CFN_CCOS:
 953       return do_mpc_arg1 (result_real, result_imag, mpc_cos,
 954                           arg_real, arg_imag, format);
 955
 956     CASE_CFN_CCOSH:
 957       return do_mpc_arg1 (result_real, result_imag, mpc_cosh,
 958                           arg_real, arg_imag, format);
 959
 960     CASE_CFN_CPROJ:
 961       if (real_isinf (arg_real) || real_isinf (arg_imag))
 962         {
 963           real_inf (result_real);
 964           *result_imag = dconst0;
 965           result_imag->sign = arg_imag->sign;
 966         }
 967       else
 968         {
 969           *result_real = *arg_real;
 970           *result_imag = *arg_imag;
 971         }
 972       return true;
 973
 974     CASE_CFN_CSIN:
 975       return do_mpc_arg1 (result_real, result_imag, mpc_sin,
 976                           arg_real, arg_imag, format);
 977
 978     CASE_CFN_CSINH:
 979       return do_mpc_arg1 (result_real, result_imag, mpc_sinh,
 980                           arg_real, arg_imag, format);
 981
 982     CASE_CFN_CTAN:
 983       return do_mpc_arg1 (result_real, result_imag, mpc_tan,
 984                           arg_real, arg_imag, format);
 985
 986     CASE_CFN_CTANH:
 987       return do_mpc_arg1 (result_real, result_imag, mpc_tanh,
 988                           arg_real, arg_imag, format);
 989
 990     CASE_CFN_CLOG:
 991       return do_mpc_arg1 (result_real, result_imag, mpc_log,
 992                           arg_real, arg_imag, format);
 993
 994     CASE_CFN_CSQRT:
 995       return do_mpc_arg1 (result_real, result_imag, mpc_sqrt,
 996                           arg_real, arg_imag, format);
 997
 998     CASE_CFN_CASIN:
 999       return do_mpc_arg1 (result_real, result_imag, mpc_asin,
1000                           arg_real, arg_imag, format);
1001
1002     CASE_CFN_CACOS:
1003       return do_mpc_arg1 (result_real, result_imag, mpc_acos,
1004                           arg_real, arg_imag, format);
1005
1006     CASE_CFN_CATAN:
1007       return do_mpc_arg1 (result_real, result_imag, mpc_atan,
1008                           arg_real, arg_imag, format);
1009
1010     CASE_CFN_CASINH:
1011       return do_mpc_arg1 (result_real, result_imag, mpc_asinh,
1012                           arg_real, arg_imag, format);
1013
1014     CASE_CFN_CACOSH:
1015       return do_mpc_arg1 (result_real, result_imag, mpc_acosh,
1016                           arg_real, arg_imag, format);
1017
1018     CASE_CFN_CATANH:
1019       return do_mpc_arg1 (result_real, result_imag, mpc_atanh,
1020                           arg_real, arg_imag, format);
1021
1022     CASE_CFN_CEXP:
1023       return do_mpc_arg1 (result_real, result_imag, mpc_exp,
1024                           arg_real, arg_imag, format);
1025
1026     default:
1027       return false;
1028     }
1029 }
1030
1031 /* Subroutine of fold_const_call, with the same interface.  Handle cases
1032    where the arguments and result are numerical.  */
1033
1034 static tree
1035 fold_const_call_1 (combined_fn fn, tree type, tree arg)
1036 {
1037   machine_mode mode = TYPE_MODE (type);
1038   machine_mode arg_mode = TYPE_MODE (TREE_TYPE (arg));
1039
1040   if (integer_cst_p (arg))
1041     {
1042       if (SCALAR_INT_MODE_P (mode))
1043         {
1044           wide_int result;
1045           if (fold_const_call_ss (&result, fn, wi::to_wide (arg),
1046                                   TYPE_PRECISION (type), TREE_TYPE (arg)))
1047             return wide_int_to_tree (type, result);
1048         }
1049       return NULL_TREE;
1050     }
1051
1052   if (real_cst_p (arg))
1053     {
1054       gcc_checking_assert (SCALAR_FLOAT_MODE_P (arg_mode));
1055       if (mode == arg_mode)
1056         {
1057           /* real -> real.  */
1058           REAL_VALUE_TYPE result;
1059           if (fold_const_call_ss (&result, fn, TREE_REAL_CST_PTR (arg),
1060                                   REAL_MODE_FORMAT (mode)))
1061             return build_real (type, result);
1062         }
1063       else if (COMPLEX_MODE_P (mode)
1064                && GET_MODE_INNER (mode) == arg_mode)
1065         {
1066           /* real -> complex real.  */
1067           REAL_VALUE_TYPE result_real, result_imag;
1068           if (fold_const_call_cs (&result_real, &result_imag, fn,
1069                                   TREE_REAL_CST_PTR (arg),
1070                                   REAL_MODE_FORMAT (arg_mode)))
1071             return build_complex (type,
1072                                   build_real (TREE_TYPE (type), result_real),
1073                                   build_real (TREE_TYPE (type), result_imag));
1074         }
1075       else if (INTEGRAL_TYPE_P (type))
1076         {
1077           /* real -> int.  */
1078           wide_int result;
1079           if (fold_const_call_ss (&result, fn,
1080                                   TREE_REAL_CST_PTR (arg),
1081                                   TYPE_PRECISION (type),
1082                                   REAL_MODE_FORMAT (arg_mode)))
1083             return wide_int_to_tree (type, result);
1084         }
1085       return NULL_TREE;
1086     }
1087
1088   if (complex_cst_p (arg))
1089     {
1090       gcc_checking_assert (COMPLEX_MODE_P (arg_mode));
1091       machine_mode inner_mode = GET_MODE_INNER (arg_mode);
1092       tree argr = TREE_REALPART (arg);
1093       tree argi = TREE_IMAGPART (arg);
1094       if (mode == arg_mode
1095           && real_cst_p (argr)
1096           && real_cst_p (argi))
1097         {
1098           /* complex real -> complex real.  */
1099           REAL_VALUE_TYPE result_real, result_imag;
1100           if (fold_const_call_cc (&result_real, &result_imag, fn,
1101                                   TREE_REAL_CST_PTR (argr),
1102                                   TREE_REAL_CST_PTR (argi),
1103                                   REAL_MODE_FORMAT (inner_mode)))
1104             return build_complex (type,
1105                                   build_real (TREE_TYPE (type), result_real),
1106                                   build_real (TREE_TYPE (type), result_imag));
1107         }
1108       if (mode == inner_mode
1109           && real_cst_p (argr)
1110           && real_cst_p (argi))
1111         {
1112           /* complex real -> real.  */
1113           REAL_VALUE_TYPE result;
1114           if (fold_const_call_sc (&result, fn,
1115                                   TREE_REAL_CST_PTR (argr),
1116                                   TREE_REAL_CST_PTR (argi),
1117                                   REAL_MODE_FORMAT (inner_mode)))
1118             return build_real (type, result);
1119         }
1120       return NULL_TREE;
1121     }
1122
1123   return NULL_TREE;
1124 }
1125
1126 /* Try to fold FN (ARG) to a constant.  Return the constant on success,
1127    otherwise return null.  TYPE is the type of the return value.  */
1128
1129 tree
1130 fold_const_call (combined_fn fn, tree type, tree arg)
1131 {
1132   switch (fn)
1133     {
1134     case CFN_BUILT_IN_STRLEN:
1135       if (const char *str = c_getstr (arg))
1136         return build_int_cst (type, strlen (str));
1137       return NULL_TREE;
1138
1139     CASE_CFN_NAN:
1140     CASE_FLT_FN_FLOATN_NX (CFN_BUILT_IN_NAN):
1141     case CFN_BUILT_IN_NAND32:
1142     case CFN_BUILT_IN_NAND64:
1143     case CFN_BUILT_IN_NAND128:
1144       return fold_const_builtin_nan (type, arg, true);
1145
1146     CASE_CFN_NANS:
1147     CASE_FLT_FN_FLOATN_NX (CFN_BUILT_IN_NANS):
1148       return fold_const_builtin_nan (type, arg, false);
1149
1150     default:
1151       return fold_const_call_1 (fn, type, arg);
1152     }
1153 }
1154
1155 /* Try to evaluate:
1156
1157       *RESULT = FN (*ARG0, *ARG1)
1158
1159    in format FORMAT.  Return true on success.  */
1160
1161 static bool
1162 fold_const_call_sss (real_value *result, combined_fn fn,
1163                      const real_value *arg0, const real_value *arg1,
1164                      const real_format *format)
1165 {
1166   switch (fn)
1167     {
1168     CASE_CFN_DREM:
1169     CASE_CFN_REMAINDER:
1170       return do_mpfr_arg2 (result, mpfr_remainder, arg0, arg1, format);
1171
1172     CASE_CFN_ATAN2:
1173       return do_mpfr_arg2 (result, mpfr_atan2, arg0, arg1, format);
1174
1175     CASE_CFN_FDIM:
1176       return do_mpfr_arg2 (result, mpfr_dim, arg0, arg1, format);
1177
1178     CASE_CFN_HYPOT:
1179       return do_mpfr_arg2 (result, mpfr_hypot, arg0, arg1, format);
1180
1181     CASE_CFN_COPYSIGN:
1182       *result = *arg0;
1183       real_copysign (result, arg1);
1184       return true;
1185
1186     CASE_CFN_FMIN:
1187       return do_mpfr_arg2 (result, mpfr_min, arg0, arg1, format);
1188
1189     CASE_CFN_FMAX:
1190       return do_mpfr_arg2 (result, mpfr_max, arg0, arg1, format);
1191
1192     CASE_CFN_POW:
1193       return fold_const_pow (result, arg0, arg1, format);
1194
1195     default:
1196       return false;
1197     }
1198 }
1199
1200 /* Try to evaluate:
1201
1202       *RESULT = FN (*ARG0, ARG1)
1203
1204    where FORMAT is the format of *RESULT and *ARG0.  Return true on
1205    success.  */
1206
1207 static bool
1208 fold_const_call_sss (real_value *result, combined_fn fn,
1209                      const real_value *arg0, const wide_int_ref &arg1,
1210                      const real_format *format)
1211 {
1212   switch (fn)
1213     {
1214     CASE_CFN_LDEXP:
1215       return fold_const_builtin_load_exponent (result, arg0, arg1, format);
1216
1217     CASE_CFN_SCALBN:
1218     CASE_CFN_SCALBLN:
1219       return (format->b == 2
1220               && fold_const_builtin_load_exponent (result, arg0, arg1,
1221                                                    format));
1222
1223     CASE_CFN_POWI:
1224       /* Avoid the folding if flag_signaling_nans is on and
1225          operand is a signaling NaN.  */
1226       if (!flag_unsafe_math_optimizations
1227           && flag_signaling_nans
1228           && REAL_VALUE_ISSIGNALING_NAN (*arg0))
1229         return false;
1230
1231       real_powi (result, format, arg0, arg1.to_shwi ());
1232       return true;
1233
1234     default:
1235       return false;
1236     }
1237 }
1238
1239 /* Try to evaluate:
1240
1241       *RESULT = FN (ARG0, *ARG1)
1242
1243    where FORMAT is the format of *RESULT and *ARG1.  Return true on
1244    success.  */
1245
1246 static bool
1247 fold_const_call_sss (real_value *result, combined_fn fn,
1248                      const wide_int_ref &arg0, const real_value *arg1,
1249                      const real_format *format)
1250 {
1251   switch (fn)
1252     {
1253     CASE_CFN_JN:
1254       return do_mpfr_arg2 (result, mpfr_jn, arg0, arg1, format);
1255
1256     CASE_CFN_YN:
1257       return (real_compare (GT_EXPR, arg1, &dconst0)
1258               && do_mpfr_arg2 (result, mpfr_yn, arg0, arg1, format));
1259
1260     default:
1261       return false;
1262     }
1263 }
1264
1265 /* Try to evaluate:
1266
1267       RESULT = fn (ARG0, ARG1)
1268
1269    where FORMAT is the format of the real and imaginary parts of RESULT
1270    (RESULT_REAL and RESULT_IMAG), of ARG0 (ARG0_REAL and ARG0_IMAG)
1271    and of ARG1 (ARG1_REAL and ARG1_IMAG).  Return true on success.  */
1272
1273 static bool
1274 fold_const_call_ccc (real_value *result_real, real_value *result_imag,
1275                      combined_fn fn, const real_value *arg0_real,
1276                      const real_value *arg0_imag, const real_value *arg1_real,
1277                      const real_value *arg1_imag, const real_format *format)
1278 {
1279   switch (fn)
1280     {
1281     CASE_CFN_CPOW:
1282       return do_mpc_arg2 (result_real, result_imag, mpc_pow,
1283                           arg0_real, arg0_imag, arg1_real, arg1_imag, format);
1284
1285     default:
1286       return false;
1287     }
1288 }
1289
1290 /* Subroutine of fold_const_call, with the same interface.  Handle cases
1291    where the arguments and result are numerical.  */
1292
1293 static tree
1294 fold_const_call_1 (combined_fn fn, tree type, tree arg0, tree arg1)
1295 {
1296   machine_mode mode = TYPE_MODE (type);
1297   machine_mode arg0_mode = TYPE_MODE (TREE_TYPE (arg0));
1298   machine_mode arg1_mode = TYPE_MODE (TREE_TYPE (arg1));
1299
1300   if (arg0_mode == arg1_mode
1301       && real_cst_p (arg0)
1302       && real_cst_p (arg1))
1303     {
1304       gcc_checking_assert (SCALAR_FLOAT_MODE_P (arg0_mode));
1305       if (mode == arg0_mode)
1306         {
1307           /* real, real -> real.  */
1308           REAL_VALUE_TYPE result;
1309           if (fold_const_call_sss (&result, fn, TREE_REAL_CST_PTR (arg0),
1310                                    TREE_REAL_CST_PTR (arg1),
1311                                    REAL_MODE_FORMAT (mode)))
1312             return build_real (type, result);
1313         }
1314       return NULL_TREE;
1315     }
1316
1317   if (real_cst_p (arg0)
1318       && integer_cst_p (arg1))
1319     {
1320       gcc_checking_assert (SCALAR_FLOAT_MODE_P (arg0_mode));
1321       if (mode == arg0_mode)
1322         {
1323           /* real, int -> real.  */
1324           REAL_VALUE_TYPE result;
1325           if (fold_const_call_sss (&result, fn, TREE_REAL_CST_PTR (arg0),
1326                                    wi::to_wide (arg1),
1327                                    REAL_MODE_FORMAT (mode)))
1328             return build_real (type, result);
1329         }
1330       return NULL_TREE;
1331     }
1332
1333   if (integer_cst_p (arg0)
1334       && real_cst_p (arg1))
1335     {
1336       gcc_checking_assert (SCALAR_FLOAT_MODE_P (arg1_mode));
1337       if (mode == arg1_mode)
1338         {
1339           /* int, real -> real.  */
1340           REAL_VALUE_TYPE result;
1341           if (fold_const_call_sss (&result, fn, wi::to_wide (arg0),
1342                                    TREE_REAL_CST_PTR (arg1),
1343                                    REAL_MODE_FORMAT (mode)))
1344             return build_real (type, result);
1345         }
1346       return NULL_TREE;
1347     }
1348
1349   if (arg0_mode == arg1_mode
1350       && complex_cst_p (arg0)
1351       && complex_cst_p (arg1))
1352     {
1353       gcc_checking_assert (COMPLEX_MODE_P (arg0_mode));
1354       machine_mode inner_mode = GET_MODE_INNER (arg0_mode);
1355       tree arg0r = TREE_REALPART (arg0);
1356       tree arg0i = TREE_IMAGPART (arg0);
1357       tree arg1r = TREE_REALPART (arg1);
1358       tree arg1i = TREE_IMAGPART (arg1);
1359       if (mode == arg0_mode
1360           && real_cst_p (arg0r)
1361           && real_cst_p (arg0i)
1362           && real_cst_p (arg1r)
1363           && real_cst_p (arg1i))
1364         {
1365           /* complex real, complex real -> complex real.  */
1366           REAL_VALUE_TYPE result_real, result_imag;
1367           if (fold_const_call_ccc (&result_real, &result_imag, fn,
1368                                    TREE_REAL_CST_PTR (arg0r),
1369                                    TREE_REAL_CST_PTR (arg0i),
1370                                    TREE_REAL_CST_PTR (arg1r),
1371                                    TREE_REAL_CST_PTR (arg1i),
1372                                    REAL_MODE_FORMAT (inner_mode)))
1373             return build_complex (type,
1374                                   build_real (TREE_TYPE (type), result_real),
1375                                   build_real (TREE_TYPE (type), result_imag));
1376         }
1377       return NULL_TREE;
1378     }
1379
1380   return NULL_TREE;
1381 }
1382
1383 /* Try to fold FN (ARG0, ARG1) to a constant.  Return the constant on success,
1384    otherwise return null.  TYPE is the type of the return value.  */
1385
1386 tree
1387 fold_const_call (combined_fn fn, tree type, tree arg0, tree arg1)
1388 {
1389   const char *p0, *p1;
1390   char c;
1391   switch (fn)
1392     {
1393     case CFN_BUILT_IN_STRSPN:
1394       if ((p0 = c_getstr (arg0)) && (p1 = c_getstr (arg1)))
1395         return build_int_cst (type, strspn (p0, p1));
1396       return NULL_TREE;
1397
1398     case CFN_BUILT_IN_STRCSPN:
1399       if ((p0 = c_getstr (arg0)) && (p1 = c_getstr (arg1)))
1400         return build_int_cst (type, strcspn (p0, p1));
1401       return NULL_TREE;
1402
1403     case CFN_BUILT_IN_STRCMP:
1404       if ((p0 = c_getstr (arg0)) && (p1 = c_getstr (arg1)))
1405         return build_cmp_result (type, strcmp (p0, p1));
1406       return NULL_TREE;
1407
1408     case CFN_BUILT_IN_STRCASECMP:
1409       if ((p0 = c_getstr (arg0)) && (p1 = c_getstr (arg1)))
1410         {
1411           int r = strcmp (p0, p1);
1412           if (r == 0)
1413             return build_cmp_result (type, r);
1414         }
1415       return NULL_TREE;
1416
1417     case CFN_BUILT_IN_INDEX:
1418     case CFN_BUILT_IN_STRCHR:
1419       if ((p0 = c_getstr (arg0)) && target_char_cst_p (arg1, &c))
1420         {
1421           const char *r = strchr (p0, c);
1422           if (r == NULL)
1423             return build_int_cst (type, 0);
1424           return fold_convert (type,
1425                                fold_build_pointer_plus_hwi (arg0, r - p0));
1426         }
1427       return NULL_TREE;
1428
1429     case CFN_BUILT_IN_RINDEX:
1430     case CFN_BUILT_IN_STRRCHR:
1431       if ((p0 = c_getstr (arg0)) && target_char_cst_p (arg1, &c))
1432         {
1433           const char *r = strrchr (p0, c);
1434           if (r == NULL)
1435             return build_int_cst (type, 0);
1436           return fold_convert (type,
1437                                fold_build_pointer_plus_hwi (arg0, r - p0));
1438         }
1439       return NULL_TREE;
1440
1441     case CFN_BUILT_IN_STRSTR:
1442       if ((p1 = c_getstr (arg1)))
1443         {
1444           if ((p0 = c_getstr (arg0)))
1445             {
1446               const char *r = strstr (p0, p1);
1447               if (r == NULL)
1448                 return build_int_cst (type, 0);
1449               return fold_convert (type,
1450                                    fold_build_pointer_plus_hwi (arg0, r - p0));
1451             }
1452           if (*p1 == '\0')
1453             return fold_convert (type, arg0);
1454         }
1455       return NULL_TREE;
1456
1457     default:
1458       return fold_const_call_1 (fn, type, arg0, arg1);
1459     }
1460 }
1461
1462 /* Try to evaluate:
1463
1464       *RESULT = FN (*ARG0, *ARG1, *ARG2)
1465
1466    in format FORMAT.  Return true on success.  */
1467
1468 static bool
1469 fold_const_call_ssss (real_value *result, combined_fn fn,
1470                       const real_value *arg0, const real_value *arg1,
1471                       const real_value *arg2, const real_format *format)
1472 {
1473   switch (fn)
1474     {
1475     CASE_CFN_FMA:
1476       return do_mpfr_arg3 (result, mpfr_fma, arg0, arg1, arg2, format);
1477
1478     default:
1479       return false;
1480     }
1481 }
1482
1483 /* Subroutine of fold_const_call, with the same interface.  Handle cases
1484    where the arguments and result are numerical.  */
1485
1486 static tree
1487 fold_const_call_1 (combined_fn fn, tree type, tree arg0, tree arg1, tree arg2)
1488 {
1489   machine_mode mode = TYPE_MODE (type);
1490   machine_mode arg0_mode = TYPE_MODE (TREE_TYPE (arg0));
1491   machine_mode arg1_mode = TYPE_MODE (TREE_TYPE (arg1));
1492   machine_mode arg2_mode = TYPE_MODE (TREE_TYPE (arg2));
1493
1494   if (arg0_mode == arg1_mode
1495       && arg0_mode == arg2_mode
1496       && real_cst_p (arg0)
1497       && real_cst_p (arg1)
1498       && real_cst_p (arg2))
1499     {
1500       gcc_checking_assert (SCALAR_FLOAT_MODE_P (arg0_mode));
1501       if (mode == arg0_mode)
1502         {
1503           /* real, real, real -> real.  */
1504           REAL_VALUE_TYPE result;
1505           if (fold_const_call_ssss (&result, fn, TREE_REAL_CST_PTR (arg0),
1506                                     TREE_REAL_CST_PTR (arg1),
1507                                     TREE_REAL_CST_PTR (arg2),
1508                                     REAL_MODE_FORMAT (mode)))
1509             return build_real (type, result);
1510         }
1511       return NULL_TREE;
1512     }
1513
1514   return NULL_TREE;
1515 }
1516
1517 /* Try to fold FN (ARG0, ARG1, ARG2) to a constant.  Return the constant on
1518    success, otherwise return null.  TYPE is the type of the return value.  */
1519
1520 tree
1521 fold_const_call (combined_fn fn, tree type, tree arg0, tree arg1, tree arg2)
1522 {
1523   const char *p0, *p1;
1524   char c;
1525   unsigned HOST_WIDE_INT s0, s1;
1526   size_t s2 = 0;
1527   switch (fn)
1528     {
1529     case CFN_BUILT_IN_STRNCMP:
1530       if (!host_size_t_cst_p (arg2, &s2))
1531         return NULL_TREE;
1532       if (s2 == 0
1533           && !TREE_SIDE_EFFECTS (arg0)
1534           && !TREE_SIDE_EFFECTS (arg1))
1535         return build_int_cst (type, 0);
1536       else if ((p0 = c_getstr (arg0)) && (p1 = c_getstr (arg1)))
1537         return build_int_cst (type, strncmp (p0, p1, s2));
1538       return NULL_TREE;
1539
1540     case CFN_BUILT_IN_STRNCASECMP:
1541       if (!host_size_t_cst_p (arg2, &s2))
1542         return NULL_TREE;
1543       if (s2 == 0
1544           && !TREE_SIDE_EFFECTS (arg0)
1545           && !TREE_SIDE_EFFECTS (arg1))
1546         return build_int_cst (type, 0);
1547       else if ((p0 = c_getstr (arg0))
1548                && (p1 = c_getstr (arg1))
1549                && strncmp (p0, p1, s2) == 0)
1550         return build_int_cst (type, 0);
1551       return NULL_TREE;
1552
1553     case CFN_BUILT_IN_BCMP:
1554     case CFN_BUILT_IN_MEMCMP:
1555       if (!host_size_t_cst_p (arg2, &s2))
1556         return NULL_TREE;
1557       if (s2 == 0
1558           && !TREE_SIDE_EFFECTS (arg0)
1559           && !TREE_SIDE_EFFECTS (arg1))
1560         return build_int_cst (type, 0);
1561       if ((p0 = c_getstr (arg0, &s0))
1562           && (p1 = c_getstr (arg1, &s1))
1563           && s2 <= s0
1564           && s2 <= s1)
1565         return build_cmp_result (type, memcmp (p0, p1, s2));
1566       return NULL_TREE;
1567
1568     case CFN_BUILT_IN_MEMCHR:
1569       if (!host_size_t_cst_p (arg2, &s2))
1570         return NULL_TREE;
1571       if (s2 == 0
1572           && !TREE_SIDE_EFFECTS (arg0)
1573           && !TREE_SIDE_EFFECTS (arg1))
1574         return build_int_cst (type, 0);
1575       if ((p0 = c_getstr (arg0, &s0))
1576           && s2 <= s0
1577           && target_char_cst_p (arg1, &c))
1578         {
1579           const char *r = (const char *) memchr (p0, c, s2);
1580           if (r == NULL)
1581             return build_int_cst (type, 0);
1582           return fold_convert (type,
1583                                fold_build_pointer_plus_hwi (arg0, r - p0));
1584         }
1585       return NULL_TREE;
1586
1587     default:
1588       return fold_const_call_1 (fn, type, arg0, arg1, arg2);
1589     }
1590 }
1591
1592 /* Fold a fma operation with arguments ARG[012].  */
1593
1594 tree
1595 fold_fma (location_t, tree type, tree arg0, tree arg1, tree arg2)
1596 {
1597   REAL_VALUE_TYPE result;
1598   if (real_cst_p (arg0)
1599       && real_cst_p (arg1)
1600       && real_cst_p (arg2)
1601       && do_mpfr_arg3 (&result, mpfr_fma, TREE_REAL_CST_PTR (arg0),
1602                        TREE_REAL_CST_PTR (arg1), TREE_REAL_CST_PTR (arg2),
1603                        REAL_MODE_FORMAT (TYPE_MODE (type))))
1604     return build_real (type, result);
1605
1606   return NULL_TREE;
1607 }