gcc/fold-const-call.c

   1 /* Constant folding for calls to built-in and internal functions.
   2    Copyright (C) 1988-2018 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 = nextafter (*ARG0, *ARG1)
 533
 534    or
 535
 536       *RESULT = nexttoward (*ARG0, *ARG1)
 537
 538    in format FORMAT.  Return true on success.  */
 539
 540 static bool
 541 fold_const_nextafter (real_value *result, const real_value *arg0,
 542                       const real_value *arg1, const real_format *format)
 543 {
 544   if (REAL_VALUE_ISSIGNALING_NAN (*arg0)
 545       || REAL_VALUE_ISSIGNALING_NAN (*arg1))
 546     return false;
 547
 548   /* Don't handle composite modes, nor decimal, nor modes without
 549      inf or denorm at least for now.  */
 550   if (format->pnan < format->p
 551       || format->b == 10
 552       || !format->has_inf
 553       || !format->has_denorm)
 554     return false;
 555
 556   if (real_nextafter (result, format, arg0, arg1)
 557       /* If raising underflow or overflow and setting errno to ERANGE,
 558          fail if we care about those side-effects.  */
 559       && (flag_trapping_math || flag_errno_math))
 560     return false;
 561   /* Similarly for nextafter (0, 1) raising underflow.  */
 562   else if (flag_trapping_math
 563            && arg0->cl == rvc_zero
 564            && result->cl != rvc_zero)
 565     return false;
 566
 567   real_convert (result, format, result);
 568
 569   return true;
 570 }
 571
 572 /* Try to evaluate:
 573
 574       *RESULT = ldexp (*ARG0, ARG1)
 575
 576    in format FORMAT.  Return true on success.  */
 577
 578 static bool
 579 fold_const_builtin_load_exponent (real_value *result, const real_value *arg0,
 580                                   const wide_int_ref &arg1,
 581                                   const real_format *format)
 582 {
 583   /* Bound the maximum adjustment to twice the range of the
 584      mode's valid exponents.  Use abs to ensure the range is
 585      positive as a sanity check.  */
 586   int max_exp_adj = 2 * labs (format->emax - format->emin);
 587
 588   /* The requested adjustment must be inside this range.  This
 589      is a preliminary cap to avoid things like overflow, we
 590      may still fail to compute the result for other reasons.  */
 591   if (wi::les_p (arg1, -max_exp_adj) || wi::ges_p (arg1, max_exp_adj))
 592     return false;
 593
 594   /* Don't perform operation if we honor signaling NaNs and
 595      operand is a signaling NaN.  */
 596   if (!flag_unsafe_math_optimizations
 597       && flag_signaling_nans
 598       && REAL_VALUE_ISSIGNALING_NAN (*arg0))
 599     return false;
 600
 601   REAL_VALUE_TYPE initial_result;
 602   real_ldexp (&initial_result, arg0, arg1.to_shwi ());
 603
 604   /* Ensure we didn't overflow.  */
 605   if (real_isinf (&initial_result))
 606     return false;
 607
 608   /* Only proceed if the target mode can hold the
 609      resulting value.  */
 610   *result = real_value_truncate (format, initial_result);
 611   return real_equal (&initial_result, result);
 612 }
 613
 614 /* Fold a call to __builtin_nan or __builtin_nans with argument ARG and
 615    return type TYPE.  QUIET is true if a quiet rather than signalling
 616    NaN is required.  */
 617
 618 static tree
 619 fold_const_builtin_nan (tree type, tree arg, bool quiet)
 620 {
 621   REAL_VALUE_TYPE real;
 622   const char *str = c_getstr (arg);
 623   if (str && real_nan (&real, str, quiet, TYPE_MODE (type)))
 624     return build_real (type, real);
 625   return NULL_TREE;
 626 }
 627
 628 /* Fold a call to IFN_REDUC_<CODE> (ARG), returning a value of type TYPE.  */
 629
 630 static tree
 631 fold_const_reduction (tree type, tree arg, tree_code code)
 632 {
 633   unsigned HOST_WIDE_INT nelts;
 634   if (TREE_CODE (arg) != VECTOR_CST
 635       || !VECTOR_CST_NELTS (arg).is_constant (&nelts))
 636     return NULL_TREE;
 637
 638   tree res = VECTOR_CST_ELT (arg, 0);
 639   for (unsigned HOST_WIDE_INT i = 1; i < nelts; i++)
 640     {
 641       res = const_binop (code, type, res, VECTOR_CST_ELT (arg, i));
 642       if (res == NULL_TREE || !CONSTANT_CLASS_P (res))
 643         return NULL_TREE;
 644     }
 645   return res;
 646 }
 647
 648 /* Try to evaluate:
 649
 650       *RESULT = FN (*ARG)
 651
 652    in format FORMAT.  Return true on success.  */
 653
 654 static bool
 655 fold_const_call_ss (real_value *result, combined_fn fn,
 656                     const real_value *arg, const real_format *format)
 657 {
 658   switch (fn)
 659     {
 660     CASE_CFN_SQRT:
 661     CASE_CFN_SQRT_FN:
 662       return (real_compare (GE_EXPR, arg, &dconst0)
 663               && do_mpfr_arg1 (result, mpfr_sqrt, arg, format));
 664
 665     CASE_CFN_CBRT:
 666       return do_mpfr_arg1 (result, mpfr_cbrt, arg, format);
 667
 668     CASE_CFN_ASIN:
 669       return (real_compare (GE_EXPR, arg, &dconstm1)
 670               && real_compare (LE_EXPR, arg, &dconst1)
 671               && do_mpfr_arg1 (result, mpfr_asin, arg, format));
 672
 673     CASE_CFN_ACOS:
 674       return (real_compare (GE_EXPR, arg, &dconstm1)
 675               && real_compare (LE_EXPR, arg, &dconst1)
 676               && do_mpfr_arg1 (result, mpfr_acos, arg, format));
 677
 678     CASE_CFN_ATAN:
 679       return do_mpfr_arg1 (result, mpfr_atan, arg, format);
 680
 681     CASE_CFN_ASINH:
 682       return do_mpfr_arg1 (result, mpfr_asinh, arg, format);
 683
 684     CASE_CFN_ACOSH:
 685       return (real_compare (GE_EXPR, arg, &dconst1)
 686               && do_mpfr_arg1 (result, mpfr_acosh, arg, format));
 687
 688     CASE_CFN_ATANH:
 689       return (real_compare (GE_EXPR, arg, &dconstm1)
 690               && real_compare (LE_EXPR, arg, &dconst1)
 691               && do_mpfr_arg1 (result, mpfr_atanh, arg, format));
 692
 693     CASE_CFN_SIN:
 694       return do_mpfr_arg1 (result, mpfr_sin, arg, format);
 695
 696     CASE_CFN_COS:
 697       return do_mpfr_arg1 (result, mpfr_cos, arg, format);
 698
 699     CASE_CFN_TAN:
 700       return do_mpfr_arg1 (result, mpfr_tan, arg, format);
 701
 702     CASE_CFN_SINH:
 703       return do_mpfr_arg1 (result, mpfr_sinh, arg, format);
 704
 705     CASE_CFN_COSH:
 706       return do_mpfr_arg1 (result, mpfr_cosh, arg, format);
 707
 708     CASE_CFN_TANH:
 709       return do_mpfr_arg1 (result, mpfr_tanh, arg, format);
 710
 711     CASE_CFN_ERF:
 712       return do_mpfr_arg1 (result, mpfr_erf, arg, format);
 713
 714     CASE_CFN_ERFC:
 715       return do_mpfr_arg1 (result, mpfr_erfc, arg, format);
 716
 717     CASE_CFN_TGAMMA:
 718       return do_mpfr_arg1 (result, mpfr_gamma, arg, format);
 719
 720     CASE_CFN_EXP:
 721       return do_mpfr_arg1 (result, mpfr_exp, arg, format);
 722
 723     CASE_CFN_EXP2:
 724       return do_mpfr_arg1 (result, mpfr_exp2, arg, format);
 725
 726     CASE_CFN_EXP10:
 727     CASE_CFN_POW10:
 728       return do_mpfr_arg1 (result, mpfr_exp10, arg, format);
 729
 730     CASE_CFN_EXPM1:
 731       return do_mpfr_arg1 (result, mpfr_expm1, arg, format);
 732
 733     CASE_CFN_LOG:
 734       return (real_compare (GT_EXPR, arg, &dconst0)
 735               && do_mpfr_arg1 (result, mpfr_log, arg, format));
 736
 737     CASE_CFN_LOG2:
 738       return (real_compare (GT_EXPR, arg, &dconst0)
 739               && do_mpfr_arg1 (result, mpfr_log2, arg, format));
 740
 741     CASE_CFN_LOG10:
 742       return (real_compare (GT_EXPR, arg, &dconst0)
 743               && do_mpfr_arg1 (result, mpfr_log10, arg, format));
 744
 745     CASE_CFN_LOG1P:
 746       return (real_compare (GT_EXPR, arg, &dconstm1)
 747               && do_mpfr_arg1 (result, mpfr_log1p, arg, format));
 748
 749     CASE_CFN_J0:
 750       return do_mpfr_arg1 (result, mpfr_j0, arg, format);
 751
 752     CASE_CFN_J1:
 753       return do_mpfr_arg1 (result, mpfr_j1, arg, format);
 754
 755     CASE_CFN_Y0:
 756       return (real_compare (GT_EXPR, arg, &dconst0)
 757               && do_mpfr_arg1 (result, mpfr_y0, arg, format));
 758
 759     CASE_CFN_Y1:
 760       return (real_compare (GT_EXPR, arg, &dconst0)
 761               && do_mpfr_arg1 (result, mpfr_y1, arg, format));
 762
 763     CASE_CFN_FLOOR:
 764     CASE_CFN_FLOOR_FN:
 765       if (!REAL_VALUE_ISNAN (*arg) || !flag_errno_math)
 766         {
 767           real_floor (result, format, arg);
 768           return true;
 769         }
 770       return false;
 771
 772     CASE_CFN_CEIL:
 773     CASE_CFN_CEIL_FN:
 774       if (!REAL_VALUE_ISNAN (*arg) || !flag_errno_math)
 775         {
 776           real_ceil (result, format, arg);
 777           return true;
 778         }
 779       return false;
 780
 781     CASE_CFN_TRUNC:
 782     CASE_CFN_TRUNC_FN:
 783       real_trunc (result, format, arg);
 784       return true;
 785
 786     CASE_CFN_ROUND:
 787     CASE_CFN_ROUND_FN:
 788       if (!REAL_VALUE_ISNAN (*arg) || !flag_errno_math)
 789         {
 790           real_round (result, format, arg);
 791           return true;
 792         }
 793       return false;
 794
 795     CASE_CFN_LOGB:
 796       return fold_const_logb (result, arg, format);
 797
 798     CASE_CFN_SIGNIFICAND:
 799       return fold_const_significand (result, arg, format);
 800
 801     default:
 802       return false;
 803     }
 804 }
 805
 806 /* Try to evaluate:
 807
 808       *RESULT = FN (*ARG)
 809
 810    where FORMAT is the format of ARG and PRECISION is the number of
 811    significant bits in the result.  Return true on success.  */
 812
 813 static bool
 814 fold_const_call_ss (wide_int *result, combined_fn fn,
 815                     const real_value *arg, unsigned int precision,
 816                     const real_format *format)
 817 {
 818   switch (fn)
 819     {
 820     CASE_CFN_SIGNBIT:
 821       if (real_isneg (arg))
 822         *result = wi::one (precision);
 823       else
 824         *result = wi::zero (precision);
 825       return true;
 826
 827     CASE_CFN_ILOGB:
 828       /* For ilogb we don't know FP_ILOGB0, so only handle normal values.
 829          Proceed iff radix == 2.  In GCC, normalized significands are in
 830          the range [0.5, 1.0).  We want the exponent as if they were
 831          [1.0, 2.0) so get the exponent and subtract 1.  */
 832       if (arg->cl == rvc_normal && format->b == 2)
 833         {
 834           *result = wi::shwi (REAL_EXP (arg) - 1, precision);
 835           return true;
 836         }
 837       return false;
 838
 839     CASE_CFN_ICEIL:
 840     CASE_CFN_LCEIL:
 841     CASE_CFN_LLCEIL:
 842       return fold_const_conversion (result, real_ceil, arg,
 843                                     precision, format);
 844
 845     CASE_CFN_LFLOOR:
 846     CASE_CFN_IFLOOR:
 847     CASE_CFN_LLFLOOR:
 848       return fold_const_conversion (result, real_floor, arg,
 849                                     precision, format);
 850
 851     CASE_CFN_IROUND:
 852     CASE_CFN_LROUND:
 853     CASE_CFN_LLROUND:
 854       return fold_const_conversion (result, real_round, arg,
 855                                     precision, format);
 856
 857     CASE_CFN_IRINT:
 858     CASE_CFN_LRINT:
 859     CASE_CFN_LLRINT:
 860       /* Not yet folded to a constant.  */
 861       return false;
 862
 863     CASE_CFN_FINITE:
 864     case CFN_BUILT_IN_FINITED32:
 865     case CFN_BUILT_IN_FINITED64:
 866     case CFN_BUILT_IN_FINITED128:
 867     case CFN_BUILT_IN_ISFINITE:
 868       *result = wi::shwi (real_isfinite (arg) ? 1 : 0, precision);
 869       return true;
 870
 871     CASE_CFN_ISINF:
 872     case CFN_BUILT_IN_ISINFD32:
 873     case CFN_BUILT_IN_ISINFD64:
 874     case CFN_BUILT_IN_ISINFD128:
 875       if (real_isinf (arg))
 876         *result = wi::shwi (arg->sign ? -1 : 1, precision);
 877       else
 878         *result = wi::shwi (0, precision);
 879       return true;
 880
 881     CASE_CFN_ISNAN:
 882     case CFN_BUILT_IN_ISNAND32:
 883     case CFN_BUILT_IN_ISNAND64:
 884     case CFN_BUILT_IN_ISNAND128:
 885       *result = wi::shwi (real_isnan (arg) ? 1 : 0, precision);
 886       return true;
 887
 888     default:
 889       return false;
 890     }
 891 }
 892
 893 /* Try to evaluate:
 894
 895       *RESULT = FN (ARG)
 896
 897    where ARG_TYPE is the type of ARG and PRECISION is the number of bits
 898    in the result.  Return true on success.  */
 899
 900 static bool
 901 fold_const_call_ss (wide_int *result, combined_fn fn, const wide_int_ref &arg,
 902                     unsigned int precision, tree arg_type)
 903 {
 904   switch (fn)
 905     {
 906     CASE_CFN_FFS:
 907       *result = wi::shwi (wi::ffs (arg), precision);
 908       return true;
 909
 910     CASE_CFN_CLZ:
 911       {
 912         int tmp;
 913         if (wi::ne_p (arg, 0))
 914           tmp = wi::clz (arg);
 915         else if (!CLZ_DEFINED_VALUE_AT_ZERO (SCALAR_INT_TYPE_MODE (arg_type),
 916                                              tmp))
 917           tmp = TYPE_PRECISION (arg_type);
 918         *result = wi::shwi (tmp, precision);
 919         return true;
 920       }
 921
 922     CASE_CFN_CTZ:
 923       {
 924         int tmp;
 925         if (wi::ne_p (arg, 0))
 926           tmp = wi::ctz (arg);
 927         else if (!CTZ_DEFINED_VALUE_AT_ZERO (SCALAR_INT_TYPE_MODE (arg_type),
 928                                              tmp))
 929           tmp = TYPE_PRECISION (arg_type);
 930         *result = wi::shwi (tmp, precision);
 931         return true;
 932       }
 933
 934     CASE_CFN_CLRSB:
 935       *result = wi::shwi (wi::clrsb (arg), precision);
 936       return true;
 937
 938     CASE_CFN_POPCOUNT:
 939       *result = wi::shwi (wi::popcount (arg), precision);
 940       return true;
 941
 942     CASE_CFN_PARITY:
 943       *result = wi::shwi (wi::parity (arg), precision);
 944       return true;
 945
 946     case CFN_BUILT_IN_BSWAP16:
 947     case CFN_BUILT_IN_BSWAP32:
 948     case CFN_BUILT_IN_BSWAP64:
 949       *result = wide_int::from (arg, precision, TYPE_SIGN (arg_type)).bswap ();
 950       return true;
 951
 952     default:
 953       return false;
 954     }
 955 }
 956
 957 /* Try to evaluate:
 958
 959       RESULT = FN (*ARG)
 960
 961    where FORMAT is the format of ARG and of the real and imaginary parts
 962    of RESULT, passed as RESULT_REAL and RESULT_IMAG respectively.  Return
 963    true on success.  */
 964
 965 static bool
 966 fold_const_call_cs (real_value *result_real, real_value *result_imag,
 967                     combined_fn fn, const real_value *arg,
 968                     const real_format *format)
 969 {
 970   switch (fn)
 971     {
 972     CASE_CFN_CEXPI:
 973       /* cexpi(x+yi) = cos(x)+sin(y)*i.  */
 974       return do_mpfr_sincos (result_imag, result_real, arg, format);
 975
 976     default:
 977       return false;
 978     }
 979 }
 980
 981 /* Try to evaluate:
 982
 983       *RESULT = fn (ARG)
 984
 985    where FORMAT is the format of RESULT and of the real and imaginary parts
 986    of ARG, passed as ARG_REAL and ARG_IMAG respectively.  Return true on
 987    success.  */
 988
 989 static bool
 990 fold_const_call_sc (real_value *result, combined_fn fn,
 991                     const real_value *arg_real, const real_value *arg_imag,
 992                     const real_format *format)
 993 {
 994   switch (fn)
 995     {
 996     CASE_CFN_CABS:
 997       return do_mpfr_arg2 (result, mpfr_hypot, arg_real, arg_imag, format);
 998
 999     default:
1000       return false;
1001     }
1002 }
1003
1004 /* Try to evaluate:
1005
1006       RESULT = fn (ARG)
1007
1008    where FORMAT is the format of the real and imaginary parts of RESULT
1009    (RESULT_REAL and RESULT_IMAG) and of ARG (ARG_REAL and ARG_IMAG).
1010    Return true on success.  */
1011
1012 static bool
1013 fold_const_call_cc (real_value *result_real, real_value *result_imag,
1014                     combined_fn fn, const real_value *arg_real,
1015                     const real_value *arg_imag, const real_format *format)
1016 {
1017   switch (fn)
1018     {
1019     CASE_CFN_CCOS:
1020       return do_mpc_arg1 (result_real, result_imag, mpc_cos,
1021                           arg_real, arg_imag, format);
1022
1023     CASE_CFN_CCOSH:
1024       return do_mpc_arg1 (result_real, result_imag, mpc_cosh,
1025                           arg_real, arg_imag, format);
1026
1027     CASE_CFN_CPROJ:
1028       if (real_isinf (arg_real) || real_isinf (arg_imag))
1029         {
1030           real_inf (result_real);
1031           *result_imag = dconst0;
1032           result_imag->sign = arg_imag->sign;
1033         }
1034       else
1035         {
1036           *result_real = *arg_real;
1037           *result_imag = *arg_imag;
1038         }
1039       return true;
1040
1041     CASE_CFN_CSIN:
1042       return do_mpc_arg1 (result_real, result_imag, mpc_sin,
1043                           arg_real, arg_imag, format);
1044
1045     CASE_CFN_CSINH:
1046       return do_mpc_arg1 (result_real, result_imag, mpc_sinh,
1047                           arg_real, arg_imag, format);
1048
1049     CASE_CFN_CTAN:
1050       return do_mpc_arg1 (result_real, result_imag, mpc_tan,
1051                           arg_real, arg_imag, format);
1052
1053     CASE_CFN_CTANH:
1054       return do_mpc_arg1 (result_real, result_imag, mpc_tanh,
1055                           arg_real, arg_imag, format);
1056
1057     CASE_CFN_CLOG:
1058       return do_mpc_arg1 (result_real, result_imag, mpc_log,
1059                           arg_real, arg_imag, format);
1060
1061     CASE_CFN_CSQRT:
1062       return do_mpc_arg1 (result_real, result_imag, mpc_sqrt,
1063                           arg_real, arg_imag, format);
1064
1065     CASE_CFN_CASIN:
1066       return do_mpc_arg1 (result_real, result_imag, mpc_asin,
1067                           arg_real, arg_imag, format);
1068
1069     CASE_CFN_CACOS:
1070       return do_mpc_arg1 (result_real, result_imag, mpc_acos,
1071                           arg_real, arg_imag, format);
1072
1073     CASE_CFN_CATAN:
1074       return do_mpc_arg1 (result_real, result_imag, mpc_atan,
1075                           arg_real, arg_imag, format);
1076
1077     CASE_CFN_CASINH:
1078       return do_mpc_arg1 (result_real, result_imag, mpc_asinh,
1079                           arg_real, arg_imag, format);
1080
1081     CASE_CFN_CACOSH:
1082       return do_mpc_arg1 (result_real, result_imag, mpc_acosh,
1083                           arg_real, arg_imag, format);
1084
1085     CASE_CFN_CATANH:
1086       return do_mpc_arg1 (result_real, result_imag, mpc_atanh,
1087                           arg_real, arg_imag, format);
1088
1089     CASE_CFN_CEXP:
1090       return do_mpc_arg1 (result_real, result_imag, mpc_exp,
1091                           arg_real, arg_imag, format);
1092
1093     default:
1094       return false;
1095     }
1096 }
1097
1098 /* Subroutine of fold_const_call, with the same interface.  Handle cases
1099    where the arguments and result are numerical.  */
1100
1101 static tree
1102 fold_const_call_1 (combined_fn fn, tree type, tree arg)
1103 {
1104   machine_mode mode = TYPE_MODE (type);
1105   machine_mode arg_mode = TYPE_MODE (TREE_TYPE (arg));
1106
1107   if (integer_cst_p (arg))
1108     {
1109       if (SCALAR_INT_MODE_P (mode))
1110         {
1111           wide_int result;
1112           if (fold_const_call_ss (&result, fn, wi::to_wide (arg),
1113                                   TYPE_PRECISION (type), TREE_TYPE (arg)))
1114             return wide_int_to_tree (type, result);
1115         }
1116       return NULL_TREE;
1117     }
1118
1119   if (real_cst_p (arg))
1120     {
1121       gcc_checking_assert (SCALAR_FLOAT_MODE_P (arg_mode));
1122       if (mode == arg_mode)
1123         {
1124           /* real -> real.  */
1125           REAL_VALUE_TYPE result;
1126           if (fold_const_call_ss (&result, fn, TREE_REAL_CST_PTR (arg),
1127                                   REAL_MODE_FORMAT (mode)))
1128             return build_real (type, result);
1129         }
1130       else if (COMPLEX_MODE_P (mode)
1131                && GET_MODE_INNER (mode) == arg_mode)
1132         {
1133           /* real -> complex real.  */
1134           REAL_VALUE_TYPE result_real, result_imag;
1135           if (fold_const_call_cs (&result_real, &result_imag, fn,
1136                                   TREE_REAL_CST_PTR (arg),
1137                                   REAL_MODE_FORMAT (arg_mode)))
1138             return build_complex (type,
1139                                   build_real (TREE_TYPE (type), result_real),
1140                                   build_real (TREE_TYPE (type), result_imag));
1141         }
1142       else if (INTEGRAL_TYPE_P (type))
1143         {
1144           /* real -> int.  */
1145           wide_int result;
1146           if (fold_const_call_ss (&result, fn,
1147                                   TREE_REAL_CST_PTR (arg),
1148                                   TYPE_PRECISION (type),
1149                                   REAL_MODE_FORMAT (arg_mode)))
1150             return wide_int_to_tree (type, result);
1151         }
1152       return NULL_TREE;
1153     }
1154
1155   if (complex_cst_p (arg))
1156     {
1157       gcc_checking_assert (COMPLEX_MODE_P (arg_mode));
1158       machine_mode inner_mode = GET_MODE_INNER (arg_mode);
1159       tree argr = TREE_REALPART (arg);
1160       tree argi = TREE_IMAGPART (arg);
1161       if (mode == arg_mode
1162           && real_cst_p (argr)
1163           && real_cst_p (argi))
1164         {
1165           /* complex real -> complex real.  */
1166           REAL_VALUE_TYPE result_real, result_imag;
1167           if (fold_const_call_cc (&result_real, &result_imag, fn,
1168                                   TREE_REAL_CST_PTR (argr),
1169                                   TREE_REAL_CST_PTR (argi),
1170                                   REAL_MODE_FORMAT (inner_mode)))
1171             return build_complex (type,
1172                                   build_real (TREE_TYPE (type), result_real),
1173                                   build_real (TREE_TYPE (type), result_imag));
1174         }
1175       if (mode == inner_mode
1176           && real_cst_p (argr)
1177           && real_cst_p (argi))
1178         {
1179           /* complex real -> real.  */
1180           REAL_VALUE_TYPE result;
1181           if (fold_const_call_sc (&result, fn,
1182                                   TREE_REAL_CST_PTR (argr),
1183                                   TREE_REAL_CST_PTR (argi),
1184                                   REAL_MODE_FORMAT (inner_mode)))
1185             return build_real (type, result);
1186         }
1187       return NULL_TREE;
1188     }
1189
1190   return NULL_TREE;
1191 }
1192
1193 /* Try to fold FN (ARG) to a constant.  Return the constant on success,
1194    otherwise return null.  TYPE is the type of the return value.  */
1195
1196 tree
1197 fold_const_call (combined_fn fn, tree type, tree arg)
1198 {
1199   switch (fn)
1200     {
1201     case CFN_BUILT_IN_STRLEN:
1202       if (const char *str = c_getstr (arg))
1203         return build_int_cst (type, strlen (str));
1204       return NULL_TREE;
1205
1206     CASE_CFN_NAN:
1207     CASE_FLT_FN_FLOATN_NX (CFN_BUILT_IN_NAN):
1208     case CFN_BUILT_IN_NAND32:
1209     case CFN_BUILT_IN_NAND64:
1210     case CFN_BUILT_IN_NAND128:
1211       return fold_const_builtin_nan (type, arg, true);
1212
1213     CASE_CFN_NANS:
1214     CASE_FLT_FN_FLOATN_NX (CFN_BUILT_IN_NANS):
1215       return fold_const_builtin_nan (type, arg, false);
1216
1217     case CFN_REDUC_PLUS:
1218       return fold_const_reduction (type, arg, PLUS_EXPR);
1219
1220     case CFN_REDUC_MAX:
1221       return fold_const_reduction (type, arg, MAX_EXPR);
1222
1223     case CFN_REDUC_MIN:
1224       return fold_const_reduction (type, arg, MIN_EXPR);
1225
1226     case CFN_REDUC_AND:
1227       return fold_const_reduction (type, arg, BIT_AND_EXPR);
1228
1229     case CFN_REDUC_IOR:
1230       return fold_const_reduction (type, arg, BIT_IOR_EXPR);
1231
1232     case CFN_REDUC_XOR:
1233       return fold_const_reduction (type, arg, BIT_XOR_EXPR);
1234
1235     default:
1236       return fold_const_call_1 (fn, type, arg);
1237     }
1238 }
1239
1240 /* Fold a call to IFN_FOLD_LEFT_<CODE> (ARG0, ARG1), returning a value
1241    of type TYPE.  */
1242
1243 static tree
1244 fold_const_fold_left (tree type, tree arg0, tree arg1, tree_code code)
1245 {
1246   if (TREE_CODE (arg1) != VECTOR_CST)
1247     return NULL_TREE;
1248
1249   unsigned HOST_WIDE_INT nelts;
1250   if (!VECTOR_CST_NELTS (arg1).is_constant (&nelts))
1251     return NULL_TREE;
1252
1253   for (unsigned HOST_WIDE_INT i = 0; i < nelts; i++)
1254     {
1255       arg0 = const_binop (code, type, arg0, VECTOR_CST_ELT (arg1, i));
1256       if (arg0 == NULL_TREE || !CONSTANT_CLASS_P (arg0))
1257         return NULL_TREE;
1258     }
1259   return arg0;
1260 }
1261
1262 /* Try to evaluate:
1263
1264       *RESULT = FN (*ARG0, *ARG1)
1265
1266    in format FORMAT.  Return true on success.  */
1267
1268 static bool
1269 fold_const_call_sss (real_value *result, combined_fn fn,
1270                      const real_value *arg0, const real_value *arg1,
1271                      const real_format *format)
1272 {
1273   switch (fn)
1274     {
1275     CASE_CFN_DREM:
1276     CASE_CFN_REMAINDER:
1277       return do_mpfr_arg2 (result, mpfr_remainder, arg0, arg1, format);
1278
1279     CASE_CFN_ATAN2:
1280       return do_mpfr_arg2 (result, mpfr_atan2, arg0, arg1, format);
1281
1282     CASE_CFN_FDIM:
1283       return do_mpfr_arg2 (result, mpfr_dim, arg0, arg1, format);
1284
1285     CASE_CFN_HYPOT:
1286       return do_mpfr_arg2 (result, mpfr_hypot, arg0, arg1, format);
1287
1288     CASE_CFN_COPYSIGN:
1289     CASE_CFN_COPYSIGN_FN:
1290       *result = *arg0;
1291       real_copysign (result, arg1);
1292       return true;
1293
1294     CASE_CFN_FMIN:
1295     CASE_CFN_FMIN_FN:
1296       return do_mpfr_arg2 (result, mpfr_min, arg0, arg1, format);
1297
1298     CASE_CFN_FMAX:
1299     CASE_CFN_FMAX_FN:
1300       return do_mpfr_arg2 (result, mpfr_max, arg0, arg1, format);
1301
1302     CASE_CFN_POW:
1303       return fold_const_pow (result, arg0, arg1, format);
1304
1305     CASE_CFN_NEXTAFTER:
1306     CASE_CFN_NEXTTOWARD:
1307       return fold_const_nextafter (result, arg0, arg1, format);
1308
1309     default:
1310       return false;
1311     }
1312 }
1313
1314 /* Try to evaluate:
1315
1316       *RESULT = FN (*ARG0, ARG1)
1317
1318    where FORMAT is the format of *RESULT and *ARG0.  Return true on
1319    success.  */
1320
1321 static bool
1322 fold_const_call_sss (real_value *result, combined_fn fn,
1323                      const real_value *arg0, const wide_int_ref &arg1,
1324                      const real_format *format)
1325 {
1326   switch (fn)
1327     {
1328     CASE_CFN_LDEXP:
1329       return fold_const_builtin_load_exponent (result, arg0, arg1, format);
1330
1331     CASE_CFN_SCALBN:
1332     CASE_CFN_SCALBLN:
1333       return (format->b == 2
1334               && fold_const_builtin_load_exponent (result, arg0, arg1,
1335                                                    format));
1336
1337     CASE_CFN_POWI:
1338       /* Avoid the folding if flag_signaling_nans is on and
1339          operand is a signaling NaN.  */
1340       if (!flag_unsafe_math_optimizations
1341           && flag_signaling_nans
1342           && REAL_VALUE_ISSIGNALING_NAN (*arg0))
1343         return false;
1344
1345       real_powi (result, format, arg0, arg1.to_shwi ());
1346       return true;
1347
1348     default:
1349       return false;
1350     }
1351 }
1352
1353 /* Try to evaluate:
1354
1355       *RESULT = FN (ARG0, *ARG1)
1356
1357    where FORMAT is the format of *RESULT and *ARG1.  Return true on
1358    success.  */
1359
1360 static bool
1361 fold_const_call_sss (real_value *result, combined_fn fn,
1362                      const wide_int_ref &arg0, const real_value *arg1,
1363                      const real_format *format)
1364 {
1365   switch (fn)
1366     {
1367     CASE_CFN_JN:
1368       return do_mpfr_arg2 (result, mpfr_jn, arg0, arg1, format);
1369
1370     CASE_CFN_YN:
1371       return (real_compare (GT_EXPR, arg1, &dconst0)
1372               && do_mpfr_arg2 (result, mpfr_yn, arg0, arg1, format));
1373
1374     default:
1375       return false;
1376     }
1377 }
1378
1379 /* Try to evaluate:
1380
1381       RESULT = fn (ARG0, ARG1)
1382
1383    where FORMAT is the format of the real and imaginary parts of RESULT
1384    (RESULT_REAL and RESULT_IMAG), of ARG0 (ARG0_REAL and ARG0_IMAG)
1385    and of ARG1 (ARG1_REAL and ARG1_IMAG).  Return true on success.  */
1386
1387 static bool
1388 fold_const_call_ccc (real_value *result_real, real_value *result_imag,
1389                      combined_fn fn, const real_value *arg0_real,
1390                      const real_value *arg0_imag, const real_value *arg1_real,
1391                      const real_value *arg1_imag, const real_format *format)
1392 {
1393   switch (fn)
1394     {
1395     CASE_CFN_CPOW:
1396       return do_mpc_arg2 (result_real, result_imag, mpc_pow,
1397                           arg0_real, arg0_imag, arg1_real, arg1_imag, format);
1398
1399     default:
1400       return false;
1401     }
1402 }
1403
1404 /* Subroutine of fold_const_call, with the same interface.  Handle cases
1405    where the arguments and result are numerical.  */
1406
1407 static tree
1408 fold_const_call_1 (combined_fn fn, tree type, tree arg0, tree arg1)
1409 {
1410   machine_mode mode = TYPE_MODE (type);
1411   machine_mode arg0_mode = TYPE_MODE (TREE_TYPE (arg0));
1412   machine_mode arg1_mode = TYPE_MODE (TREE_TYPE (arg1));
1413
1414   if (mode == arg0_mode
1415       && real_cst_p (arg0)
1416       && real_cst_p (arg1))
1417     {
1418       gcc_checking_assert (SCALAR_FLOAT_MODE_P (arg0_mode));
1419       REAL_VALUE_TYPE result;
1420       if (arg0_mode == arg1_mode)
1421         {
1422           /* real, real -> real.  */
1423           if (fold_const_call_sss (&result, fn, TREE_REAL_CST_PTR (arg0),
1424                                    TREE_REAL_CST_PTR (arg1),
1425                                    REAL_MODE_FORMAT (mode)))
1426             return build_real (type, result);
1427         }
1428       else if (arg1_mode == TYPE_MODE (long_double_type_node))
1429         switch (fn)
1430           {
1431           CASE_CFN_NEXTTOWARD:
1432             /* real, long double -> real.  */
1433             if (fold_const_call_sss (&result, fn, TREE_REAL_CST_PTR (arg0),
1434                                      TREE_REAL_CST_PTR (arg1),
1435                                      REAL_MODE_FORMAT (mode)))
1436               return build_real (type, result);
1437             break;
1438           default:
1439             break;
1440           }
1441       return NULL_TREE;
1442     }
1443
1444   if (real_cst_p (arg0)
1445       && integer_cst_p (arg1))
1446     {
1447       gcc_checking_assert (SCALAR_FLOAT_MODE_P (arg0_mode));
1448       if (mode == arg0_mode)
1449         {
1450           /* real, int -> real.  */
1451           REAL_VALUE_TYPE result;
1452           if (fold_const_call_sss (&result, fn, TREE_REAL_CST_PTR (arg0),
1453                                    wi::to_wide (arg1),
1454                                    REAL_MODE_FORMAT (mode)))
1455             return build_real (type, result);
1456         }
1457       return NULL_TREE;
1458     }
1459
1460   if (integer_cst_p (arg0)
1461       && real_cst_p (arg1))
1462     {
1463       gcc_checking_assert (SCALAR_FLOAT_MODE_P (arg1_mode));
1464       if (mode == arg1_mode)
1465         {
1466           /* int, real -> real.  */
1467           REAL_VALUE_TYPE result;
1468           if (fold_const_call_sss (&result, fn, wi::to_wide (arg0),
1469                                    TREE_REAL_CST_PTR (arg1),
1470                                    REAL_MODE_FORMAT (mode)))
1471             return build_real (type, result);
1472         }
1473       return NULL_TREE;
1474     }
1475
1476   if (arg0_mode == arg1_mode
1477       && complex_cst_p (arg0)
1478       && complex_cst_p (arg1))
1479     {
1480       gcc_checking_assert (COMPLEX_MODE_P (arg0_mode));
1481       machine_mode inner_mode = GET_MODE_INNER (arg0_mode);
1482       tree arg0r = TREE_REALPART (arg0);
1483       tree arg0i = TREE_IMAGPART (arg0);
1484       tree arg1r = TREE_REALPART (arg1);
1485       tree arg1i = TREE_IMAGPART (arg1);
1486       if (mode == arg0_mode
1487           && real_cst_p (arg0r)
1488           && real_cst_p (arg0i)
1489           && real_cst_p (arg1r)
1490           && real_cst_p (arg1i))
1491         {
1492           /* complex real, complex real -> complex real.  */
1493           REAL_VALUE_TYPE result_real, result_imag;
1494           if (fold_const_call_ccc (&result_real, &result_imag, fn,
1495                                    TREE_REAL_CST_PTR (arg0r),
1496                                    TREE_REAL_CST_PTR (arg0i),
1497                                    TREE_REAL_CST_PTR (arg1r),
1498                                    TREE_REAL_CST_PTR (arg1i),
1499                                    REAL_MODE_FORMAT (inner_mode)))
1500             return build_complex (type,
1501                                   build_real (TREE_TYPE (type), result_real),
1502                                   build_real (TREE_TYPE (type), result_imag));
1503         }
1504       return NULL_TREE;
1505     }
1506
1507   return NULL_TREE;
1508 }
1509
1510 /* Try to fold FN (ARG0, ARG1) to a constant.  Return the constant on success,
1511    otherwise return null.  TYPE is the type of the return value.  */
1512
1513 tree
1514 fold_const_call (combined_fn fn, tree type, tree arg0, tree arg1)
1515 {
1516   const char *p0, *p1;
1517   char c;
1518   switch (fn)
1519     {
1520     case CFN_BUILT_IN_STRSPN:
1521       if ((p0 = c_getstr (arg0)) && (p1 = c_getstr (arg1)))
1522         return build_int_cst (type, strspn (p0, p1));
1523       return NULL_TREE;
1524
1525     case CFN_BUILT_IN_STRCSPN:
1526       if ((p0 = c_getstr (arg0)) && (p1 = c_getstr (arg1)))
1527         return build_int_cst (type, strcspn (p0, p1));
1528       return NULL_TREE;
1529
1530     case CFN_BUILT_IN_STRCMP:
1531       if ((p0 = c_getstr (arg0)) && (p1 = c_getstr (arg1)))
1532         return build_cmp_result (type, strcmp (p0, p1));
1533       return NULL_TREE;
1534
1535     case CFN_BUILT_IN_STRCASECMP:
1536       if ((p0 = c_getstr (arg0)) && (p1 = c_getstr (arg1)))
1537         {
1538           int r = strcmp (p0, p1);
1539           if (r == 0)
1540             return build_cmp_result (type, r);
1541         }
1542       return NULL_TREE;
1543
1544     case CFN_BUILT_IN_INDEX:
1545     case CFN_BUILT_IN_STRCHR:
1546       if ((p0 = c_getstr (arg0)) && target_char_cst_p (arg1, &c))
1547         {
1548           const char *r = strchr (p0, c);
1549           if (r == NULL)
1550             return build_int_cst (type, 0);
1551           return fold_convert (type,
1552                                fold_build_pointer_plus_hwi (arg0, r - p0));
1553         }
1554       return NULL_TREE;
1555
1556     case CFN_BUILT_IN_RINDEX:
1557     case CFN_BUILT_IN_STRRCHR:
1558       if ((p0 = c_getstr (arg0)) && target_char_cst_p (arg1, &c))
1559         {
1560           const char *r = strrchr (p0, c);
1561           if (r == NULL)
1562             return build_int_cst (type, 0);
1563           return fold_convert (type,
1564                                fold_build_pointer_plus_hwi (arg0, r - p0));
1565         }
1566       return NULL_TREE;
1567
1568     case CFN_BUILT_IN_STRSTR:
1569       if ((p1 = c_getstr (arg1)))
1570         {
1571           if ((p0 = c_getstr (arg0)))
1572             {
1573               const char *r = strstr (p0, p1);
1574               if (r == NULL)
1575                 return build_int_cst (type, 0);
1576               return fold_convert (type,
1577                                    fold_build_pointer_plus_hwi (arg0, r - p0));
1578             }
1579           if (*p1 == '\0')
1580             return fold_convert (type, arg0);
1581         }
1582       return NULL_TREE;
1583
1584     case CFN_FOLD_LEFT_PLUS:
1585       return fold_const_fold_left (type, arg0, arg1, PLUS_EXPR);
1586
1587     default:
1588       return fold_const_call_1 (fn, type, arg0, arg1);
1589     }
1590 }
1591
1592 /* Try to evaluate:
1593
1594       *RESULT = FN (*ARG0, *ARG1, *ARG2)
1595
1596    in format FORMAT.  Return true on success.  */
1597
1598 static bool
1599 fold_const_call_ssss (real_value *result, combined_fn fn,
1600                       const real_value *arg0, const real_value *arg1,
1601                       const real_value *arg2, const real_format *format)
1602 {
1603   switch (fn)
1604     {
1605     CASE_CFN_FMA:
1606     CASE_CFN_FMA_FN:
1607       return do_mpfr_arg3 (result, mpfr_fma, arg0, arg1, arg2, format);
1608
1609     case CFN_FMS:
1610       {
1611         real_value new_arg2 = real_value_negate (arg2);
1612         return do_mpfr_arg3 (result, mpfr_fma, arg0, arg1, &new_arg2, format);
1613       }
1614
1615     case CFN_FNMA:
1616       {
1617         real_value new_arg0 = real_value_negate (arg0);
1618         return do_mpfr_arg3 (result, mpfr_fma, &new_arg0, arg1, arg2, format);
1619       }
1620
1621     case CFN_FNMS:
1622       {
1623         real_value new_arg0 = real_value_negate (arg0);
1624         real_value new_arg2 = real_value_negate (arg2);
1625         return do_mpfr_arg3 (result, mpfr_fma, &new_arg0, arg1,
1626                              &new_arg2, format);
1627       }
1628
1629     default:
1630       return false;
1631     }
1632 }
1633
1634 /* Subroutine of fold_const_call, with the same interface.  Handle cases
1635    where the arguments and result are numerical.  */
1636
1637 static tree
1638 fold_const_call_1 (combined_fn fn, tree type, tree arg0, tree arg1, tree arg2)
1639 {
1640   machine_mode mode = TYPE_MODE (type);
1641   machine_mode arg0_mode = TYPE_MODE (TREE_TYPE (arg0));
1642   machine_mode arg1_mode = TYPE_MODE (TREE_TYPE (arg1));
1643   machine_mode arg2_mode = TYPE_MODE (TREE_TYPE (arg2));
1644
1645   if (arg0_mode == arg1_mode
1646       && arg0_mode == arg2_mode
1647       && real_cst_p (arg0)
1648       && real_cst_p (arg1)
1649       && real_cst_p (arg2))
1650     {
1651       gcc_checking_assert (SCALAR_FLOAT_MODE_P (arg0_mode));
1652       if (mode == arg0_mode)
1653         {
1654           /* real, real, real -> real.  */
1655           REAL_VALUE_TYPE result;
1656           if (fold_const_call_ssss (&result, fn, TREE_REAL_CST_PTR (arg0),
1657                                     TREE_REAL_CST_PTR (arg1),
1658                                     TREE_REAL_CST_PTR (arg2),
1659                                     REAL_MODE_FORMAT (mode)))
1660             return build_real (type, result);
1661         }
1662       return NULL_TREE;
1663     }
1664
1665   return NULL_TREE;
1666 }
1667
1668 /* Try to fold FN (ARG0, ARG1, ARG2) to a constant.  Return the constant on
1669    success, otherwise return null.  TYPE is the type of the return value.  */
1670
1671 tree
1672 fold_const_call (combined_fn fn, tree type, tree arg0, tree arg1, tree arg2)
1673 {
1674   const char *p0, *p1;
1675   char c;
1676   unsigned HOST_WIDE_INT s0, s1;
1677   size_t s2 = 0;
1678   switch (fn)
1679     {
1680     case CFN_BUILT_IN_STRNCMP:
1681       if (!host_size_t_cst_p (arg2, &s2))
1682         return NULL_TREE;
1683       if (s2 == 0
1684           && !TREE_SIDE_EFFECTS (arg0)
1685           && !TREE_SIDE_EFFECTS (arg1))
1686         return build_int_cst (type, 0);
1687       else if ((p0 = c_getstr (arg0)) && (p1 = c_getstr (arg1)))
1688         return build_int_cst (type, strncmp (p0, p1, s2));
1689       return NULL_TREE;
1690
1691     case CFN_BUILT_IN_STRNCASECMP:
1692       if (!host_size_t_cst_p (arg2, &s2))
1693         return NULL_TREE;
1694       if (s2 == 0
1695           && !TREE_SIDE_EFFECTS (arg0)
1696           && !TREE_SIDE_EFFECTS (arg1))
1697         return build_int_cst (type, 0);
1698       else if ((p0 = c_getstr (arg0))
1699                && (p1 = c_getstr (arg1))
1700                && strncmp (p0, p1, s2) == 0)
1701         return build_int_cst (type, 0);
1702       return NULL_TREE;
1703
1704     case CFN_BUILT_IN_BCMP:
1705     case CFN_BUILT_IN_MEMCMP:
1706       if (!host_size_t_cst_p (arg2, &s2))
1707         return NULL_TREE;
1708       if (s2 == 0
1709           && !TREE_SIDE_EFFECTS (arg0)
1710           && !TREE_SIDE_EFFECTS (arg1))
1711         return build_int_cst (type, 0);
1712       if ((p0 = c_getstr (arg0, &s0))
1713           && (p1 = c_getstr (arg1, &s1))
1714           && s2 <= s0
1715           && s2 <= s1)
1716         return build_cmp_result (type, memcmp (p0, p1, s2));
1717       return NULL_TREE;
1718
1719     case CFN_BUILT_IN_MEMCHR:
1720       if (!host_size_t_cst_p (arg2, &s2))
1721         return NULL_TREE;
1722       if (s2 == 0
1723           && !TREE_SIDE_EFFECTS (arg0)
1724           && !TREE_SIDE_EFFECTS (arg1))
1725         return build_int_cst (type, 0);
1726       if ((p0 = c_getstr (arg0, &s0))
1727           && s2 <= s0
1728           && target_char_cst_p (arg1, &c))
1729         {
1730           const char *r = (const char *) memchr (p0, c, s2);
1731           if (r == NULL)
1732             return build_int_cst (type, 0);
1733           return fold_convert (type,
1734                                fold_build_pointer_plus_hwi (arg0, r - p0));
1735         }
1736       return NULL_TREE;
1737
1738     default:
1739       return fold_const_call_1 (fn, type, arg0, arg1, arg2);
1740     }
1741 }