gcc/fold-const.c

   1 /* Fold a constant sub-tree into a single node for C-compiler
   2    Copyright (C) 1987-2015 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 /*@@ This file should be rewritten to use an arbitrary precision
  21   @@ representation for "struct tree_int_cst" and "struct tree_real_cst".
  22   @@ Perhaps the routines could also be used for bc/dc, and made a lib.
  23   @@ The routines that translate from the ap rep should
  24   @@ warn if precision et. al. is lost.
  25   @@ This would also make life easier when this technology is used
  26   @@ for cross-compilers.  */
  27
  28 /* The entry points in this file are fold, size_int_wide and size_binop.
  29
  30    fold takes a tree as argument and returns a simplified tree.
  31
  32    size_binop takes a tree code for an arithmetic operation
  33    and two operands that are trees, and produces a tree for the
  34    result, assuming the type comes from `sizetype'.
  35
  36    size_int takes an integer value, and creates a tree constant
  37    with type from `sizetype'.
  38
  39    Note: Since the folders get called on non-gimple code as well as
  40    gimple code, we need to handle GIMPLE tuples as well as their
  41    corresponding tree equivalents.  */
  42
  43 #include "config.h"
  44 #include "system.h"
  45 #include "coretypes.h"
  46 #include "backend.h"
  47 #include "predict.h"
  48 #include "tree.h"
  49 #include "gimple.h"
  50 #include "rtl.h"
  51 #include "flags.h"
  52 #include "alias.h"
  53 #include "fold-const.h"
  54 #include "stor-layout.h"
  55 #include "calls.h"
  56 #include "tree-iterator.h"
  57 #include "realmpfr.h"
  58 #include "insn-config.h"
  59 #include "expmed.h"
  60 #include "dojump.h"
  61 #include "explow.h"
  62 #include "emit-rtl.h"
  63 #include "varasm.h"
  64 #include "stmt.h"
  65 #include "expr.h"
  66 #include "tm_p.h"
  67 #include "target.h"
  68 #include "diagnostic-core.h"
  69 #include "intl.h"
  70 #include "langhooks.h"
  71 #include "md5.h"
  72 #include "internal-fn.h"
  73 #include "tree-eh.h"
  74 #include "gimplify.h"
  75 #include "tree-dfa.h"
  76 #include "builtins.h"
  77 #include "cgraph.h"
  78 #include "generic-match.h"
  79 #include "optabs.h"
  80
  81 #ifndef LOAD_EXTEND_OP
  82 #define LOAD_EXTEND_OP(M) UNKNOWN
  83 #endif
  84
  85 /* Nonzero if we are folding constants inside an initializer; zero
  86    otherwise.  */
  87 int folding_initializer = 0;
  88
  89 /* The following constants represent a bit based encoding of GCC's
  90    comparison operators.  This encoding simplifies transformations
  91    on relational comparison operators, such as AND and OR.  */
  92 enum comparison_code {
  93   COMPCODE_FALSE = 0,
  94   COMPCODE_LT = 1,
  95   COMPCODE_EQ = 2,
  96   COMPCODE_LE = 3,
  97   COMPCODE_GT = 4,
  98   COMPCODE_LTGT = 5,
  99   COMPCODE_GE = 6,
 100   COMPCODE_ORD = 7,
 101   COMPCODE_UNORD = 8,
 102   COMPCODE_UNLT = 9,
 103   COMPCODE_UNEQ = 10,
 104   COMPCODE_UNLE = 11,
 105   COMPCODE_UNGT = 12,
 106   COMPCODE_NE = 13,
 107   COMPCODE_UNGE = 14,
 108   COMPCODE_TRUE = 15
 109 };
 110
 111 static bool negate_mathfn_p (enum built_in_function);
 112 static bool negate_expr_p (tree);
 113 static tree negate_expr (tree);
 114 static tree split_tree (tree, enum tree_code, tree *, tree *, tree *, int);
 115 static tree associate_trees (location_t, tree, tree, enum tree_code, tree);
 116 static enum comparison_code comparison_to_compcode (enum tree_code);
 117 static enum tree_code compcode_to_comparison (enum comparison_code);
 118 static int operand_equal_for_comparison_p (tree, tree, tree);
 119 static int twoval_comparison_p (tree, tree *, tree *, int *);
 120 static tree eval_subst (location_t, tree, tree, tree, tree, tree);
 121 static tree make_bit_field_ref (location_t, tree, tree,
 122                                 HOST_WIDE_INT, HOST_WIDE_INT, int);
 123 static tree optimize_bit_field_compare (location_t, enum tree_code,
 124                                         tree, tree, tree);
 125 static tree decode_field_reference (location_t, tree, HOST_WIDE_INT *,
 126                                     HOST_WIDE_INT *,
 127                                     machine_mode *, int *, int *,
 128                                     tree *, tree *);
 129 static int simple_operand_p (const_tree);
 130 static bool simple_operand_p_2 (tree);
 131 static tree range_binop (enum tree_code, tree, tree, int, tree, int);
 132 static tree range_predecessor (tree);
 133 static tree range_successor (tree);
 134 static tree fold_range_test (location_t, enum tree_code, tree, tree, tree);
 135 static tree fold_cond_expr_with_comparison (location_t, tree, tree, tree, tree);
 136 static tree unextend (tree, int, int, tree);
 137 static tree optimize_minmax_comparison (location_t, enum tree_code,
 138                                         tree, tree, tree);
 139 static tree extract_muldiv (tree, tree, enum tree_code, tree, bool *);
 140 static tree extract_muldiv_1 (tree, tree, enum tree_code, tree, bool *);
 141 static tree fold_binary_op_with_conditional_arg (location_t,
 142                                                  enum tree_code, tree,
 143                                                  tree, tree,
 144                                                  tree, tree, int);
 145 static tree fold_div_compare (location_t, enum tree_code, tree, tree, tree);
 146 static bool reorder_operands_p (const_tree, const_tree);
 147 static tree fold_negate_const (tree, tree);
 148 static tree fold_not_const (const_tree, tree);
 149 static tree fold_relational_const (enum tree_code, tree, tree, tree);
 150 static tree fold_convert_const (enum tree_code, tree, tree);
 151 static tree fold_view_convert_expr (tree, tree);
 152 static bool vec_cst_ctor_to_array (tree, tree *);
 153
 154
 155 /* Return EXPR_LOCATION of T if it is not UNKNOWN_LOCATION.
 156    Otherwise, return LOC.  */
 157
 158 static location_t
 159 expr_location_or (tree t, location_t loc)
 160 {
 161   location_t tloc = EXPR_LOCATION (t);
 162   return tloc == UNKNOWN_LOCATION ? loc : tloc;
 163 }
 164
 165 /* Similar to protected_set_expr_location, but never modify x in place,
 166    if location can and needs to be set, unshare it.  */
 167
 168 static inline tree
 169 protected_set_expr_location_unshare (tree x, location_t loc)
 170 {
 171   if (CAN_HAVE_LOCATION_P (x)
 172       && EXPR_LOCATION (x) != loc
 173       && !(TREE_CODE (x) == SAVE_EXPR
 174            || TREE_CODE (x) == TARGET_EXPR
 175            || TREE_CODE (x) == BIND_EXPR))
 176     {
 177       x = copy_node (x);
 178       SET_EXPR_LOCATION (x, loc);
 179     }
 180   return x;
 181 }
 182 \f
 183 /* If ARG2 divides ARG1 with zero remainder, carries out the exact
 184    division and returns the quotient.  Otherwise returns
 185    NULL_TREE.  */
 186
 187 tree
 188 div_if_zero_remainder (const_tree arg1, const_tree arg2)
 189 {
 190   widest_int quo;
 191
 192   if (wi::multiple_of_p (wi::to_widest (arg1), wi::to_widest (arg2),
 193                          SIGNED, &quo))
 194     return wide_int_to_tree (TREE_TYPE (arg1), quo);
 195
 196   return NULL_TREE;
 197 }
 198 \f
 199 /* This is nonzero if we should defer warnings about undefined
 200    overflow.  This facility exists because these warnings are a
 201    special case.  The code to estimate loop iterations does not want
 202    to issue any warnings, since it works with expressions which do not
 203    occur in user code.  Various bits of cleanup code call fold(), but
 204    only use the result if it has certain characteristics (e.g., is a
 205    constant); that code only wants to issue a warning if the result is
 206    used.  */
 207
 208 static int fold_deferring_overflow_warnings;
 209
 210 /* If a warning about undefined overflow is deferred, this is the
 211    warning.  Note that this may cause us to turn two warnings into
 212    one, but that is fine since it is sufficient to only give one
 213    warning per expression.  */
 214
 215 static const char* fold_deferred_overflow_warning;
 216
 217 /* If a warning about undefined overflow is deferred, this is the
 218    level at which the warning should be emitted.  */
 219
 220 static enum warn_strict_overflow_code fold_deferred_overflow_code;
 221
 222 /* Start deferring overflow warnings.  We could use a stack here to
 223    permit nested calls, but at present it is not necessary.  */
 224
 225 void
 226 fold_defer_overflow_warnings (void)
 227 {
 228   ++fold_deferring_overflow_warnings;
 229 }
 230
 231 /* Stop deferring overflow warnings.  If there is a pending warning,
 232    and ISSUE is true, then issue the warning if appropriate.  STMT is
 233    the statement with which the warning should be associated (used for
 234    location information); STMT may be NULL.  CODE is the level of the
 235    warning--a warn_strict_overflow_code value.  This function will use
 236    the smaller of CODE and the deferred code when deciding whether to
 237    issue the warning.  CODE may be zero to mean to always use the
 238    deferred code.  */
 239
 240 void
 241 fold_undefer_overflow_warnings (bool issue, const_gimple stmt, int code)
 242 {
 243   const char *warnmsg;
 244   location_t locus;
 245
 246   gcc_assert (fold_deferring_overflow_warnings > 0);
 247   --fold_deferring_overflow_warnings;
 248   if (fold_deferring_overflow_warnings > 0)
 249     {
 250       if (fold_deferred_overflow_warning != NULL
 251           && code != 0
 252           && code < (int) fold_deferred_overflow_code)
 253         fold_deferred_overflow_code = (enum warn_strict_overflow_code) code;
 254       return;
 255     }
 256
 257   warnmsg = fold_deferred_overflow_warning;
 258   fold_deferred_overflow_warning = NULL;
 259
 260   if (!issue || warnmsg == NULL)
 261     return;
 262
 263   if (gimple_no_warning_p (stmt))
 264     return;
 265
 266   /* Use the smallest code level when deciding to issue the
 267      warning.  */
 268   if (code == 0 || code > (int) fold_deferred_overflow_code)
 269     code = fold_deferred_overflow_code;
 270
 271   if (!issue_strict_overflow_warning (code))
 272     return;
 273
 274   if (stmt == NULL)
 275     locus = input_location;
 276   else
 277     locus = gimple_location (stmt);
 278   warning_at (locus, OPT_Wstrict_overflow, "%s", warnmsg);
 279 }
 280
 281 /* Stop deferring overflow warnings, ignoring any deferred
 282    warnings.  */
 283
 284 void
 285 fold_undefer_and_ignore_overflow_warnings (void)
 286 {
 287   fold_undefer_overflow_warnings (false, NULL, 0);
 288 }
 289
 290 /* Whether we are deferring overflow warnings.  */
 291
 292 bool
 293 fold_deferring_overflow_warnings_p (void)
 294 {
 295   return fold_deferring_overflow_warnings > 0;
 296 }
 297
 298 /* This is called when we fold something based on the fact that signed
 299    overflow is undefined.  */
 300
 301 static void
 302 fold_overflow_warning (const char* gmsgid, enum warn_strict_overflow_code wc)
 303 {
 304   if (fold_deferring_overflow_warnings > 0)
 305     {
 306       if (fold_deferred_overflow_warning == NULL
 307           || wc < fold_deferred_overflow_code)
 308         {
 309           fold_deferred_overflow_warning = gmsgid;
 310           fold_deferred_overflow_code = wc;
 311         }
 312     }
 313   else if (issue_strict_overflow_warning (wc))
 314     warning (OPT_Wstrict_overflow, gmsgid);
 315 }
 316 \f
 317 /* Return true if the built-in mathematical function specified by CODE
 318    is odd, i.e. -f(x) == f(-x).  */
 319
 320 static bool
 321 negate_mathfn_p (enum built_in_function code)
 322 {
 323   switch (code)
 324     {
 325     CASE_FLT_FN (BUILT_IN_ASIN):
 326     CASE_FLT_FN (BUILT_IN_ASINH):
 327     CASE_FLT_FN (BUILT_IN_ATAN):
 328     CASE_FLT_FN (BUILT_IN_ATANH):
 329     CASE_FLT_FN (BUILT_IN_CASIN):
 330     CASE_FLT_FN (BUILT_IN_CASINH):
 331     CASE_FLT_FN (BUILT_IN_CATAN):
 332     CASE_FLT_FN (BUILT_IN_CATANH):
 333     CASE_FLT_FN (BUILT_IN_CBRT):
 334     CASE_FLT_FN (BUILT_IN_CPROJ):
 335     CASE_FLT_FN (BUILT_IN_CSIN):
 336     CASE_FLT_FN (BUILT_IN_CSINH):
 337     CASE_FLT_FN (BUILT_IN_CTAN):
 338     CASE_FLT_FN (BUILT_IN_CTANH):
 339     CASE_FLT_FN (BUILT_IN_ERF):
 340     CASE_FLT_FN (BUILT_IN_LLROUND):
 341     CASE_FLT_FN (BUILT_IN_LROUND):
 342     CASE_FLT_FN (BUILT_IN_ROUND):
 343     CASE_FLT_FN (BUILT_IN_SIN):
 344     CASE_FLT_FN (BUILT_IN_SINH):
 345     CASE_FLT_FN (BUILT_IN_TAN):
 346     CASE_FLT_FN (BUILT_IN_TANH):
 347     CASE_FLT_FN (BUILT_IN_TRUNC):
 348       return true;
 349
 350     CASE_FLT_FN (BUILT_IN_LLRINT):
 351     CASE_FLT_FN (BUILT_IN_LRINT):
 352     CASE_FLT_FN (BUILT_IN_NEARBYINT):
 353     CASE_FLT_FN (BUILT_IN_RINT):
 354       return !flag_rounding_math;
 355
 356     default:
 357       break;
 358     }
 359   return false;
 360 }
 361
 362 /* Check whether we may negate an integer constant T without causing
 363    overflow.  */
 364
 365 bool
 366 may_negate_without_overflow_p (const_tree t)
 367 {
 368   tree type;
 369
 370   gcc_assert (TREE_CODE (t) == INTEGER_CST);
 371
 372   type = TREE_TYPE (t);
 373   if (TYPE_UNSIGNED (type))
 374     return false;
 375
 376   return !wi::only_sign_bit_p (t);
 377 }
 378
 379 /* Determine whether an expression T can be cheaply negated using
 380    the function negate_expr without introducing undefined overflow.  */
 381
 382 static bool
 383 negate_expr_p (tree t)
 384 {
 385   tree type;
 386
 387   if (t == 0)
 388     return false;
 389
 390   type = TREE_TYPE (t);
 391
 392   STRIP_SIGN_NOPS (t);
 393   switch (TREE_CODE (t))
 394     {
 395     case INTEGER_CST:
 396       if (INTEGRAL_TYPE_P (type) && TYPE_OVERFLOW_WRAPS (type))
 397         return true;
 398
 399       /* Check that -CST will not overflow type.  */
 400       return may_negate_without_overflow_p (t);
 401     case BIT_NOT_EXPR:
 402       return (INTEGRAL_TYPE_P (type)
 403               && TYPE_OVERFLOW_WRAPS (type));
 404
 405     case FIXED_CST:
 406       return true;
 407
 408     case NEGATE_EXPR:
 409       return !TYPE_OVERFLOW_SANITIZED (type);
 410
 411     case REAL_CST:
 412       /* We want to canonicalize to positive real constants.  Pretend
 413          that only negative ones can be easily negated.  */
 414       return REAL_VALUE_NEGATIVE (TREE_REAL_CST (t));
 415
 416     case COMPLEX_CST:
 417       return negate_expr_p (TREE_REALPART (t))
 418              && negate_expr_p (TREE_IMAGPART (t));
 419
 420     case VECTOR_CST:
 421       {
 422         if (FLOAT_TYPE_P (TREE_TYPE (type)) || TYPE_OVERFLOW_WRAPS (type))
 423           return true;
 424
 425         int count = TYPE_VECTOR_SUBPARTS (type), i;
 426
 427         for (i = 0; i < count; i++)
 428           if (!negate_expr_p (VECTOR_CST_ELT (t, i)))
 429             return false;
 430
 431         return true;
 432       }
 433
 434     case COMPLEX_EXPR:
 435       return negate_expr_p (TREE_OPERAND (t, 0))
 436              && negate_expr_p (TREE_OPERAND (t, 1));
 437
 438     case CONJ_EXPR:
 439       return negate_expr_p (TREE_OPERAND (t, 0));
 440
 441     case PLUS_EXPR:
 442       if (HONOR_SIGN_DEPENDENT_ROUNDING (element_mode (type))
 443           || HONOR_SIGNED_ZEROS (element_mode (type)))
 444         return false;
 445       /* -(A + B) -> (-B) - A.  */
 446       if (negate_expr_p (TREE_OPERAND (t, 1))
 447           && reorder_operands_p (TREE_OPERAND (t, 0),
 448                                  TREE_OPERAND (t, 1)))
 449         return true;
 450       /* -(A + B) -> (-A) - B.  */
 451       return negate_expr_p (TREE_OPERAND (t, 0));
 452
 453     case MINUS_EXPR:
 454       /* We can't turn -(A-B) into B-A when we honor signed zeros.  */
 455       return !HONOR_SIGN_DEPENDENT_ROUNDING (element_mode (type))
 456              && !HONOR_SIGNED_ZEROS (element_mode (type))
 457              && reorder_operands_p (TREE_OPERAND (t, 0),
 458                                     TREE_OPERAND (t, 1));
 459
 460     case MULT_EXPR:
 461       if (TYPE_UNSIGNED (TREE_TYPE (t)))
 462         break;
 463
 464       /* Fall through.  */
 465
 466     case RDIV_EXPR:
 467       if (! HONOR_SIGN_DEPENDENT_ROUNDING (element_mode (TREE_TYPE (t))))
 468         return negate_expr_p (TREE_OPERAND (t, 1))
 469                || negate_expr_p (TREE_OPERAND (t, 0));
 470       break;
 471
 472     case TRUNC_DIV_EXPR:
 473     case ROUND_DIV_EXPR:
 474     case EXACT_DIV_EXPR:
 475       /* In general we can't negate A / B, because if A is INT_MIN and
 476          B is 1, we may turn this into INT_MIN / -1 which is undefined
 477          and actually traps on some architectures.  But if overflow is
 478          undefined, we can negate, because - (INT_MIN / 1) is an
 479          overflow.  */
 480       if (INTEGRAL_TYPE_P (TREE_TYPE (t)))
 481         {
 482           if (!TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (t)))
 483             break;
 484           /* If overflow is undefined then we have to be careful because
 485              we ask whether it's ok to associate the negate with the
 486              division which is not ok for example for
 487              -((a - b) / c) where (-(a - b)) / c may invoke undefined
 488              overflow because of negating INT_MIN.  So do not use
 489              negate_expr_p here but open-code the two important cases.  */
 490           if (TREE_CODE (TREE_OPERAND (t, 0)) == NEGATE_EXPR
 491               || (TREE_CODE (TREE_OPERAND (t, 0)) == INTEGER_CST
 492                   && may_negate_without_overflow_p (TREE_OPERAND (t, 0))))
 493             return true;
 494         }
 495       else if (negate_expr_p (TREE_OPERAND (t, 0)))
 496         return true;
 497       return negate_expr_p (TREE_OPERAND (t, 1));
 498
 499     case NOP_EXPR:
 500       /* Negate -((double)float) as (double)(-float).  */
 501       if (TREE_CODE (type) == REAL_TYPE)
 502         {
 503           tree tem = strip_float_extensions (t);
 504           if (tem != t)
 505             return negate_expr_p (tem);
 506         }
 507       break;
 508
 509     case CALL_EXPR:
 510       /* Negate -f(x) as f(-x).  */
 511       if (negate_mathfn_p (builtin_mathfn_code (t)))
 512         return negate_expr_p (CALL_EXPR_ARG (t, 0));
 513       break;
 514
 515     case RSHIFT_EXPR:
 516       /* Optimize -((int)x >> 31) into (unsigned)x >> 31 for int.  */
 517       if (TREE_CODE (TREE_OPERAND (t, 1)) == INTEGER_CST)
 518         {
 519           tree op1 = TREE_OPERAND (t, 1);
 520           if (wi::eq_p (op1, TYPE_PRECISION (type) - 1))
 521             return true;
 522         }
 523       break;
 524
 525     default:
 526       break;
 527     }
 528   return false;
 529 }
 530
 531 /* Given T, an expression, return a folded tree for -T or NULL_TREE, if no
 532    simplification is possible.
 533    If negate_expr_p would return true for T, NULL_TREE will never be
 534    returned.  */
 535
 536 static tree
 537 fold_negate_expr (location_t loc, tree t)
 538 {
 539   tree type = TREE_TYPE (t);
 540   tree tem;
 541
 542   switch (TREE_CODE (t))
 543     {
 544     /* Convert - (~A) to A + 1.  */
 545     case BIT_NOT_EXPR:
 546       if (INTEGRAL_TYPE_P (type))
 547         return fold_build2_loc (loc, PLUS_EXPR, type, TREE_OPERAND (t, 0),
 548                             build_one_cst (type));
 549       break;
 550
 551     case INTEGER_CST:
 552       tem = fold_negate_const (t, type);
 553       if (TREE_OVERFLOW (tem) == TREE_OVERFLOW (t)
 554           || (ANY_INTEGRAL_TYPE_P (type)
 555               && !TYPE_OVERFLOW_TRAPS (type)
 556               && TYPE_OVERFLOW_WRAPS (type))
 557           || (flag_sanitize & SANITIZE_SI_OVERFLOW) == 0)
 558         return tem;
 559       break;
 560
 561     case REAL_CST:
 562       tem = fold_negate_const (t, type);
 563       return tem;
 564
 565     case FIXED_CST:
 566       tem = fold_negate_const (t, type);
 567       return tem;
 568
 569     case COMPLEX_CST:
 570       {
 571         tree rpart = fold_negate_expr (loc, TREE_REALPART (t));
 572         tree ipart = fold_negate_expr (loc, TREE_IMAGPART (t));
 573         if (rpart && ipart)
 574           return build_complex (type, rpart, ipart);
 575       }
 576       break;
 577
 578     case VECTOR_CST:
 579       {
 580         int count = TYPE_VECTOR_SUBPARTS (type), i;
 581         tree *elts = XALLOCAVEC (tree, count);
 582
 583         for (i = 0; i < count; i++)
 584           {
 585             elts[i] = fold_negate_expr (loc, VECTOR_CST_ELT (t, i));
 586             if (elts[i] == NULL_TREE)
 587               return NULL_TREE;
 588           }
 589
 590         return build_vector (type, elts);
 591       }
 592
 593     case COMPLEX_EXPR:
 594       if (negate_expr_p (t))
 595         return fold_build2_loc (loc, COMPLEX_EXPR, type,
 596                             fold_negate_expr (loc, TREE_OPERAND (t, 0)),
 597                             fold_negate_expr (loc, TREE_OPERAND (t, 1)));
 598       break;
 599
 600     case CONJ_EXPR:
 601       if (negate_expr_p (t))
 602         return fold_build1_loc (loc, CONJ_EXPR, type,
 603                             fold_negate_expr (loc, TREE_OPERAND (t, 0)));
 604       break;
 605
 606     case NEGATE_EXPR:
 607       if (!TYPE_OVERFLOW_SANITIZED (type))
 608         return TREE_OPERAND (t, 0);
 609       break;
 610
 611     case PLUS_EXPR:
 612       if (!HONOR_SIGN_DEPENDENT_ROUNDING (element_mode (type))
 613           && !HONOR_SIGNED_ZEROS (element_mode (type)))
 614         {
 615           /* -(A + B) -> (-B) - A.  */
 616           if (negate_expr_p (TREE_OPERAND (t, 1))
 617               && reorder_operands_p (TREE_OPERAND (t, 0),
 618                                      TREE_OPERAND (t, 1)))
 619             {
 620               tem = negate_expr (TREE_OPERAND (t, 1));
 621               return fold_build2_loc (loc, MINUS_EXPR, type,
 622                                   tem, TREE_OPERAND (t, 0));
 623             }
 624
 625           /* -(A + B) -> (-A) - B.  */
 626           if (negate_expr_p (TREE_OPERAND (t, 0)))
 627             {
 628               tem = negate_expr (TREE_OPERAND (t, 0));
 629               return fold_build2_loc (loc, MINUS_EXPR, type,
 630                                   tem, TREE_OPERAND (t, 1));
 631             }
 632         }
 633       break;
 634
 635     case MINUS_EXPR:
 636       /* - (A - B) -> B - A  */
 637       if (!HONOR_SIGN_DEPENDENT_ROUNDING (element_mode (type))
 638           && !HONOR_SIGNED_ZEROS (element_mode (type))
 639           && reorder_operands_p (TREE_OPERAND (t, 0), TREE_OPERAND (t, 1)))
 640         return fold_build2_loc (loc, MINUS_EXPR, type,
 641                             TREE_OPERAND (t, 1), TREE_OPERAND (t, 0));
 642       break;
 643
 644     case MULT_EXPR:
 645       if (TYPE_UNSIGNED (type))
 646         break;
 647
 648       /* Fall through.  */
 649
 650     case RDIV_EXPR:
 651       if (! HONOR_SIGN_DEPENDENT_ROUNDING (element_mode (type)))
 652         {
 653           tem = TREE_OPERAND (t, 1);
 654           if (negate_expr_p (tem))
 655             return fold_build2_loc (loc, TREE_CODE (t), type,
 656                                 TREE_OPERAND (t, 0), negate_expr (tem));
 657           tem = TREE_OPERAND (t, 0);
 658           if (negate_expr_p (tem))
 659             return fold_build2_loc (loc, TREE_CODE (t), type,
 660                                 negate_expr (tem), TREE_OPERAND (t, 1));
 661         }
 662       break;
 663
 664     case TRUNC_DIV_EXPR:
 665     case ROUND_DIV_EXPR:
 666     case EXACT_DIV_EXPR:
 667       /* In general we can't negate A / B, because if A is INT_MIN and
 668          B is 1, we may turn this into INT_MIN / -1 which is undefined
 669          and actually traps on some architectures.  But if overflow is
 670          undefined, we can negate, because - (INT_MIN / 1) is an
 671          overflow.  */
 672       if (!INTEGRAL_TYPE_P (type) || TYPE_OVERFLOW_UNDEFINED (type))
 673         {
 674           const char * const warnmsg = G_("assuming signed overflow does not "
 675                                           "occur when negating a division");
 676           tem = TREE_OPERAND (t, 1);
 677           if (negate_expr_p (tem))
 678             {
 679               if (INTEGRAL_TYPE_P (type)
 680                   && (TREE_CODE (tem) != INTEGER_CST
 681                       || integer_onep (tem)))
 682                 fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_MISC);
 683               return fold_build2_loc (loc, TREE_CODE (t), type,
 684                                   TREE_OPERAND (t, 0), negate_expr (tem));
 685             }
 686           /* If overflow is undefined then we have to be careful because
 687              we ask whether it's ok to associate the negate with the
 688              division which is not ok for example for
 689              -((a - b) / c) where (-(a - b)) / c may invoke undefined
 690              overflow because of negating INT_MIN.  So do not use
 691              negate_expr_p here but open-code the two important cases.  */
 692           tem = TREE_OPERAND (t, 0);
 693           if ((INTEGRAL_TYPE_P (type)
 694                && (TREE_CODE (tem) == NEGATE_EXPR
 695                    || (TREE_CODE (tem) == INTEGER_CST
 696                        && may_negate_without_overflow_p (tem))))
 697               || !INTEGRAL_TYPE_P (type))
 698             return fold_build2_loc (loc, TREE_CODE (t), type,
 699                                     negate_expr (tem), TREE_OPERAND (t, 1));
 700         }
 701       break;
 702
 703     case NOP_EXPR:
 704       /* Convert -((double)float) into (double)(-float).  */
 705       if (TREE_CODE (type) == REAL_TYPE)
 706         {
 707           tem = strip_float_extensions (t);
 708           if (tem != t && negate_expr_p (tem))
 709             return fold_convert_loc (loc, type, negate_expr (tem));
 710         }
 711       break;
 712
 713     case CALL_EXPR:
 714       /* Negate -f(x) as f(-x).  */
 715       if (negate_mathfn_p (builtin_mathfn_code (t))
 716           && negate_expr_p (CALL_EXPR_ARG (t, 0)))
 717         {
 718           tree fndecl, arg;
 719
 720           fndecl = get_callee_fndecl (t);
 721           arg = negate_expr (CALL_EXPR_ARG (t, 0));
 722           return build_call_expr_loc (loc, fndecl, 1, arg);
 723         }
 724       break;
 725
 726     case RSHIFT_EXPR:
 727       /* Optimize -((int)x >> 31) into (unsigned)x >> 31 for int.  */
 728       if (TREE_CODE (TREE_OPERAND (t, 1)) == INTEGER_CST)
 729         {
 730           tree op1 = TREE_OPERAND (t, 1);
 731           if (wi::eq_p (op1, TYPE_PRECISION (type) - 1))
 732             {
 733               tree ntype = TYPE_UNSIGNED (type)
 734                            ? signed_type_for (type)
 735                            : unsigned_type_for (type);
 736               tree temp = fold_convert_loc (loc, ntype, TREE_OPERAND (t, 0));
 737               temp = fold_build2_loc (loc, RSHIFT_EXPR, ntype, temp, op1);
 738               return fold_convert_loc (loc, type, temp);
 739             }
 740         }
 741       break;
 742
 743     default:
 744       break;
 745     }
 746
 747   return NULL_TREE;
 748 }
 749
 750 /* Like fold_negate_expr, but return a NEGATE_EXPR tree, if T can not be
 751    negated in a simpler way.  Also allow for T to be NULL_TREE, in which case
 752    return NULL_TREE. */
 753
 754 static tree
 755 negate_expr (tree t)
 756 {
 757   tree type, tem;
 758   location_t loc;
 759
 760   if (t == NULL_TREE)
 761     return NULL_TREE;
 762
 763   loc = EXPR_LOCATION (t);
 764   type = TREE_TYPE (t);
 765   STRIP_SIGN_NOPS (t);
 766
 767   tem = fold_negate_expr (loc, t);
 768   if (!tem)
 769     tem = build1_loc (loc, NEGATE_EXPR, TREE_TYPE (t), t);
 770   return fold_convert_loc (loc, type, tem);
 771 }
 772 \f
 773 /* Split a tree IN into a constant, literal and variable parts that could be
 774    combined with CODE to make IN.  "constant" means an expression with
 775    TREE_CONSTANT but that isn't an actual constant.  CODE must be a
 776    commutative arithmetic operation.  Store the constant part into *CONP,
 777    the literal in *LITP and return the variable part.  If a part isn't
 778    present, set it to null.  If the tree does not decompose in this way,
 779    return the entire tree as the variable part and the other parts as null.
 780
 781    If CODE is PLUS_EXPR we also split trees that use MINUS_EXPR.  In that
 782    case, we negate an operand that was subtracted.  Except if it is a
 783    literal for which we use *MINUS_LITP instead.
 784
 785    If NEGATE_P is true, we are negating all of IN, again except a literal
 786    for which we use *MINUS_LITP instead.
 787
 788    If IN is itself a literal or constant, return it as appropriate.
 789
 790    Note that we do not guarantee that any of the three values will be the
 791    same type as IN, but they will have the same signedness and mode.  */
 792
 793 static tree
 794 split_tree (tree in, enum tree_code code, tree *conp, tree *litp,
 795             tree *minus_litp, int negate_p)
 796 {
 797   tree var = 0;
 798
 799   *conp = 0;
 800   *litp = 0;
 801   *minus_litp = 0;
 802
 803   /* Strip any conversions that don't change the machine mode or signedness.  */
 804   STRIP_SIGN_NOPS (in);
 805
 806   if (TREE_CODE (in) == INTEGER_CST || TREE_CODE (in) == REAL_CST
 807       || TREE_CODE (in) == FIXED_CST)
 808     *litp = in;
 809   else if (TREE_CODE (in) == code
 810            || ((! FLOAT_TYPE_P (TREE_TYPE (in)) || flag_associative_math)
 811                && ! SAT_FIXED_POINT_TYPE_P (TREE_TYPE (in))
 812                /* We can associate addition and subtraction together (even
 813                   though the C standard doesn't say so) for integers because
 814                   the value is not affected.  For reals, the value might be
 815                   affected, so we can't.  */
 816                && ((code == PLUS_EXPR && TREE_CODE (in) == MINUS_EXPR)
 817                    || (code == MINUS_EXPR && TREE_CODE (in) == PLUS_EXPR))))
 818     {
 819       tree op0 = TREE_OPERAND (in, 0);
 820       tree op1 = TREE_OPERAND (in, 1);
 821       int neg1_p = TREE_CODE (in) == MINUS_EXPR;
 822       int neg_litp_p = 0, neg_conp_p = 0, neg_var_p = 0;
 823
 824       /* First see if either of the operands is a literal, then a constant.  */
 825       if (TREE_CODE (op0) == INTEGER_CST || TREE_CODE (op0) == REAL_CST
 826           || TREE_CODE (op0) == FIXED_CST)
 827         *litp = op0, op0 = 0;
 828       else if (TREE_CODE (op1) == INTEGER_CST || TREE_CODE (op1) == REAL_CST
 829                || TREE_CODE (op1) == FIXED_CST)
 830         *litp = op1, neg_litp_p = neg1_p, op1 = 0;
 831
 832       if (op0 != 0 && TREE_CONSTANT (op0))
 833         *conp = op0, op0 = 0;
 834       else if (op1 != 0 && TREE_CONSTANT (op1))
 835         *conp = op1, neg_conp_p = neg1_p, op1 = 0;
 836
 837       /* If we haven't dealt with either operand, this is not a case we can
 838          decompose.  Otherwise, VAR is either of the ones remaining, if any.  */
 839       if (op0 != 0 && op1 != 0)
 840         var = in;
 841       else if (op0 != 0)
 842         var = op0;
 843       else
 844         var = op1, neg_var_p = neg1_p;
 845
 846       /* Now do any needed negations.  */
 847       if (neg_litp_p)
 848         *minus_litp = *litp, *litp = 0;
 849       if (neg_conp_p)
 850         *conp = negate_expr (*conp);
 851       if (neg_var_p)
 852         var = negate_expr (var);
 853     }
 854   else if (TREE_CODE (in) == BIT_NOT_EXPR
 855            && code == PLUS_EXPR)
 856     {
 857       /* -X - 1 is folded to ~X, undo that here.  */
 858       *minus_litp = build_one_cst (TREE_TYPE (in));
 859       var = negate_expr (TREE_OPERAND (in, 0));
 860     }
 861   else if (TREE_CONSTANT (in))
 862     *conp = in;
 863   else
 864     var = in;
 865
 866   if (negate_p)
 867     {
 868       if (*litp)
 869         *minus_litp = *litp, *litp = 0;
 870       else if (*minus_litp)
 871         *litp = *minus_litp, *minus_litp = 0;
 872       *conp = negate_expr (*conp);
 873       var = negate_expr (var);
 874     }
 875
 876   return var;
 877 }
 878
 879 /* Re-associate trees split by the above function.  T1 and T2 are
 880    either expressions to associate or null.  Return the new
 881    expression, if any.  LOC is the location of the new expression.  If
 882    we build an operation, do it in TYPE and with CODE.  */
 883
 884 static tree
 885 associate_trees (location_t loc, tree t1, tree t2, enum tree_code code, tree type)
 886 {
 887   if (t1 == 0)
 888     return t2;
 889   else if (t2 == 0)
 890     return t1;
 891
 892   /* If either input is CODE, a PLUS_EXPR, or a MINUS_EXPR, don't
 893      try to fold this since we will have infinite recursion.  But do
 894      deal with any NEGATE_EXPRs.  */
 895   if (TREE_CODE (t1) == code || TREE_CODE (t2) == code
 896       || TREE_CODE (t1) == MINUS_EXPR || TREE_CODE (t2) == MINUS_EXPR)
 897     {
 898       if (code == PLUS_EXPR)
 899         {
 900           if (TREE_CODE (t1) == NEGATE_EXPR)
 901             return build2_loc (loc, MINUS_EXPR, type,
 902                                fold_convert_loc (loc, type, t2),
 903                                fold_convert_loc (loc, type,
 904                                                  TREE_OPERAND (t1, 0)));
 905           else if (TREE_CODE (t2) == NEGATE_EXPR)
 906             return build2_loc (loc, MINUS_EXPR, type,
 907                                fold_convert_loc (loc, type, t1),
 908                                fold_convert_loc (loc, type,
 909                                                  TREE_OPERAND (t2, 0)));
 910           else if (integer_zerop (t2))
 911             return fold_convert_loc (loc, type, t1);
 912         }
 913       else if (code == MINUS_EXPR)
 914         {
 915           if (integer_zerop (t2))
 916             return fold_convert_loc (loc, type, t1);
 917         }
 918
 919       return build2_loc (loc, code, type, fold_convert_loc (loc, type, t1),
 920                          fold_convert_loc (loc, type, t2));
 921     }
 922
 923   return fold_build2_loc (loc, code, type, fold_convert_loc (loc, type, t1),
 924                           fold_convert_loc (loc, type, t2));
 925 }
 926 \f
 927 /* Check whether TYPE1 and TYPE2 are equivalent integer types, suitable
 928    for use in int_const_binop, size_binop and size_diffop.  */
 929
 930 static bool
 931 int_binop_types_match_p (enum tree_code code, const_tree type1, const_tree type2)
 932 {
 933   if (!INTEGRAL_TYPE_P (type1) && !POINTER_TYPE_P (type1))
 934     return false;
 935   if (!INTEGRAL_TYPE_P (type2) && !POINTER_TYPE_P (type2))
 936     return false;
 937
 938   switch (code)
 939     {
 940     case LSHIFT_EXPR:
 941     case RSHIFT_EXPR:
 942     case LROTATE_EXPR:
 943     case RROTATE_EXPR:
 944       return true;
 945
 946     default:
 947       break;
 948     }
 949
 950   return TYPE_UNSIGNED (type1) == TYPE_UNSIGNED (type2)
 951          && TYPE_PRECISION (type1) == TYPE_PRECISION (type2)
 952          && TYPE_MODE (type1) == TYPE_MODE (type2);
 953 }
 954
 955
 956 /* Combine two integer constants ARG1 and ARG2 under operation CODE
 957    to produce a new constant.  Return NULL_TREE if we don't know how
 958    to evaluate CODE at compile-time.  */
 959
 960 static tree
 961 int_const_binop_1 (enum tree_code code, const_tree arg1, const_tree parg2,
 962                    int overflowable)
 963 {
 964   wide_int res;
 965   tree t;
 966   tree type = TREE_TYPE (arg1);
 967   signop sign = TYPE_SIGN (type);
 968   bool overflow = false;
 969
 970   wide_int arg2 = wide_int::from (parg2, TYPE_PRECISION (type),
 971                                   TYPE_SIGN (TREE_TYPE (parg2)));
 972
 973   switch (code)
 974     {
 975     case BIT_IOR_EXPR:
 976       res = wi::bit_or (arg1, arg2);
 977       break;
 978
 979     case BIT_XOR_EXPR:
 980       res = wi::bit_xor (arg1, arg2);
 981       break;
 982
 983     case BIT_AND_EXPR:
 984       res = wi::bit_and (arg1, arg2);
 985       break;
 986
 987     case RSHIFT_EXPR:
 988     case LSHIFT_EXPR:
 989       if (wi::neg_p (arg2))
 990         {
 991           arg2 = -arg2;
 992           if (code == RSHIFT_EXPR)
 993             code = LSHIFT_EXPR;
 994           else
 995             code = RSHIFT_EXPR;
 996         }
 997
 998       if (code == RSHIFT_EXPR)
 999         /* It's unclear from the C standard whether shifts can overflow.
1000            The following code ignores overflow; perhaps a C standard
1001            interpretation ruling is needed.  */
1002         res = wi::rshift (arg1, arg2, sign);
1003       else
1004         res = wi::lshift (arg1, arg2);
1005       break;
1006
1007     case RROTATE_EXPR:
1008     case LROTATE_EXPR:
1009       if (wi::neg_p (arg2))
1010         {
1011           arg2 = -arg2;
1012           if (code == RROTATE_EXPR)
1013             code = LROTATE_EXPR;
1014           else
1015             code = RROTATE_EXPR;
1016         }
1017
1018       if (code == RROTATE_EXPR)
1019         res = wi::rrotate (arg1, arg2);
1020       else
1021         res = wi::lrotate (arg1, arg2);
1022       break;
1023
1024     case PLUS_EXPR:
1025       res = wi::add (arg1, arg2, sign, &overflow);
1026       break;
1027
1028     case MINUS_EXPR:
1029       res = wi::sub (arg1, arg2, sign, &overflow);
1030       break;
1031
1032     case MULT_EXPR:
1033       res = wi::mul (arg1, arg2, sign, &overflow);
1034       break;
1035
1036     case MULT_HIGHPART_EXPR:
1037       res = wi::mul_high (arg1, arg2, sign);
1038       break;
1039
1040     case TRUNC_DIV_EXPR:
1041     case EXACT_DIV_EXPR:
1042       if (arg2 == 0)
1043         return NULL_TREE;
1044       res = wi::div_trunc (arg1, arg2, sign, &overflow);
1045       break;
1046
1047     case FLOOR_DIV_EXPR:
1048       if (arg2 == 0)
1049         return NULL_TREE;
1050       res = wi::div_floor (arg1, arg2, sign, &overflow);
1051       break;
1052
1053     case CEIL_DIV_EXPR:
1054       if (arg2 == 0)
1055         return NULL_TREE;
1056       res = wi::div_ceil (arg1, arg2, sign, &overflow);
1057       break;
1058
1059     case ROUND_DIV_EXPR:
1060       if (arg2 == 0)
1061         return NULL_TREE;
1062       res = wi::div_round (arg1, arg2, sign, &overflow);
1063       break;
1064
1065     case TRUNC_MOD_EXPR:
1066       if (arg2 == 0)
1067         return NULL_TREE;
1068       res = wi::mod_trunc (arg1, arg2, sign, &overflow);
1069       break;
1070
1071     case FLOOR_MOD_EXPR:
1072       if (arg2 == 0)
1073         return NULL_TREE;
1074       res = wi::mod_floor (arg1, arg2, sign, &overflow);
1075       break;
1076
1077     case CEIL_MOD_EXPR:
1078       if (arg2 == 0)
1079         return NULL_TREE;
1080       res = wi::mod_ceil (arg1, arg2, sign, &overflow);
1081       break;
1082
1083     case ROUND_MOD_EXPR:
1084       if (arg2 == 0)
1085         return NULL_TREE;
1086       res = wi::mod_round (arg1, arg2, sign, &overflow);
1087       break;
1088
1089     case MIN_EXPR:
1090       res = wi::min (arg1, arg2, sign);
1091       break;
1092
1093     case MAX_EXPR:
1094       res = wi::max (arg1, arg2, sign);
1095       break;
1096
1097     default:
1098       return NULL_TREE;
1099     }
1100
1101   t = force_fit_type (type, res, overflowable,
1102                       (((sign == SIGNED || overflowable == -1)
1103                         && overflow)
1104                        | TREE_OVERFLOW (arg1) | TREE_OVERFLOW (parg2)));
1105
1106   return t;
1107 }
1108
1109 tree
1110 int_const_binop (enum tree_code code, const_tree arg1, const_tree arg2)
1111 {
1112   return int_const_binop_1 (code, arg1, arg2, 1);
1113 }
1114
1115 /* Combine two constants ARG1 and ARG2 under operation CODE to produce a new
1116    constant.  We assume ARG1 and ARG2 have the same data type, or at least
1117    are the same kind of constant and the same machine mode.  Return zero if
1118    combining the constants is not allowed in the current operating mode.  */
1119
1120 static tree
1121 const_binop (enum tree_code code, tree arg1, tree arg2)
1122 {
1123   /* Sanity check for the recursive cases.  */
1124   if (!arg1 || !arg2)
1125     return NULL_TREE;
1126
1127   STRIP_NOPS (arg1);
1128   STRIP_NOPS (arg2);
1129
1130   if (TREE_CODE (arg1) == INTEGER_CST && TREE_CODE (arg2) == INTEGER_CST)
1131     {
1132       if (code == POINTER_PLUS_EXPR)
1133         return int_const_binop (PLUS_EXPR,
1134                                 arg1, fold_convert (TREE_TYPE (arg1), arg2));
1135
1136       return int_const_binop (code, arg1, arg2);
1137     }
1138
1139   if (TREE_CODE (arg1) == REAL_CST && TREE_CODE (arg2) == REAL_CST)
1140     {
1141       machine_mode mode;
1142       REAL_VALUE_TYPE d1;
1143       REAL_VALUE_TYPE d2;
1144       REAL_VALUE_TYPE value;
1145       REAL_VALUE_TYPE result;
1146       bool inexact;
1147       tree t, type;
1148
1149       /* The following codes are handled by real_arithmetic.  */
1150       switch (code)
1151         {
1152         case PLUS_EXPR:
1153         case MINUS_EXPR:
1154         case MULT_EXPR:
1155         case RDIV_EXPR:
1156         case MIN_EXPR:
1157         case MAX_EXPR:
1158           break;
1159
1160         default:
1161           return NULL_TREE;
1162         }
1163
1164       d1 = TREE_REAL_CST (arg1);
1165       d2 = TREE_REAL_CST (arg2);
1166
1167       type = TREE_TYPE (arg1);
1168       mode = TYPE_MODE (type);
1169
1170       /* Don't perform operation if we honor signaling NaNs and
1171          either operand is a NaN.  */
1172       if (HONOR_SNANS (mode)
1173           && (REAL_VALUE_ISNAN (d1) || REAL_VALUE_ISNAN (d2)))
1174         return NULL_TREE;
1175
1176       /* Don't perform operation if it would raise a division
1177          by zero exception.  */
1178       if (code == RDIV_EXPR
1179           && REAL_VALUES_EQUAL (d2, dconst0)
1180           && (flag_trapping_math || ! MODE_HAS_INFINITIES (mode)))
1181         return NULL_TREE;
1182
1183       /* If either operand is a NaN, just return it.  Otherwise, set up
1184          for floating-point trap; we return an overflow.  */
1185       if (REAL_VALUE_ISNAN (d1))
1186         return arg1;
1187       else if (REAL_VALUE_ISNAN (d2))
1188         return arg2;
1189
1190       inexact = real_arithmetic (&value, code, &d1, &d2);
1191       real_convert (&result, mode, &value);
1192
1193       /* Don't constant fold this floating point operation if
1194          the result has overflowed and flag_trapping_math.  */
1195       if (flag_trapping_math
1196           && MODE_HAS_INFINITIES (mode)
1197           && REAL_VALUE_ISINF (result)
1198           && !REAL_VALUE_ISINF (d1)
1199           && !REAL_VALUE_ISINF (d2))
1200         return NULL_TREE;
1201
1202       /* Don't constant fold this floating point operation if the
1203          result may dependent upon the run-time rounding mode and
1204          flag_rounding_math is set, or if GCC's software emulation
1205          is unable to accurately represent the result.  */
1206       if ((flag_rounding_math
1207            || (MODE_COMPOSITE_P (mode) && !flag_unsafe_math_optimizations))
1208           && (inexact || !real_identical (&result, &value)))
1209         return NULL_TREE;
1210
1211       t = build_real (type, result);
1212
1213       TREE_OVERFLOW (t) = TREE_OVERFLOW (arg1) | TREE_OVERFLOW (arg2);
1214       return t;
1215     }
1216
1217   if (TREE_CODE (arg1) == FIXED_CST)
1218     {
1219       FIXED_VALUE_TYPE f1;
1220       FIXED_VALUE_TYPE f2;
1221       FIXED_VALUE_TYPE result;
1222       tree t, type;
1223       int sat_p;
1224       bool overflow_p;
1225
1226       /* The following codes are handled by fixed_arithmetic.  */
1227       switch (code)
1228         {
1229         case PLUS_EXPR:
1230         case MINUS_EXPR:
1231         case MULT_EXPR:
1232         case TRUNC_DIV_EXPR:
1233           if (TREE_CODE (arg2) != FIXED_CST)
1234             return NULL_TREE;
1235           f2 = TREE_FIXED_CST (arg2);
1236           break;
1237
1238         case LSHIFT_EXPR:
1239         case RSHIFT_EXPR:
1240           {
1241             if (TREE_CODE (arg2) != INTEGER_CST)
1242               return NULL_TREE;
1243             wide_int w2 = arg2;
1244             f2.data.high = w2.elt (1);
1245             f2.data.low = w2.elt (0);
1246             f2.mode = SImode;
1247           }
1248           break;
1249
1250         default:
1251           return NULL_TREE;
1252         }
1253
1254       f1 = TREE_FIXED_CST (arg1);
1255       type = TREE_TYPE (arg1);
1256       sat_p = TYPE_SATURATING (type);
1257       overflow_p = fixed_arithmetic (&result, code, &f1, &f2, sat_p);
1258       t = build_fixed (type, result);
1259       /* Propagate overflow flags.  */
1260       if (overflow_p | TREE_OVERFLOW (arg1) | TREE_OVERFLOW (arg2))
1261         TREE_OVERFLOW (t) = 1;
1262       return t;
1263     }
1264
1265   if (TREE_CODE (arg1) == COMPLEX_CST && TREE_CODE (arg2) == COMPLEX_CST)
1266     {
1267       tree type = TREE_TYPE (arg1);
1268       tree r1 = TREE_REALPART (arg1);
1269       tree i1 = TREE_IMAGPART (arg1);
1270       tree r2 = TREE_REALPART (arg2);
1271       tree i2 = TREE_IMAGPART (arg2);
1272       tree real, imag;
1273
1274       switch (code)
1275         {
1276         case PLUS_EXPR:
1277         case MINUS_EXPR:
1278           real = const_binop (code, r1, r2);
1279           imag = const_binop (code, i1, i2);
1280           break;
1281
1282         case MULT_EXPR:
1283           if (COMPLEX_FLOAT_TYPE_P (type))
1284             return do_mpc_arg2 (arg1, arg2, type,
1285                                 /* do_nonfinite= */ folding_initializer,
1286                                 mpc_mul);
1287
1288           real = const_binop (MINUS_EXPR,
1289                               const_binop (MULT_EXPR, r1, r2),
1290                               const_binop (MULT_EXPR, i1, i2));
1291           imag = const_binop (PLUS_EXPR,
1292                               const_binop (MULT_EXPR, r1, i2),
1293                               const_binop (MULT_EXPR, i1, r2));
1294           break;
1295
1296         case RDIV_EXPR:
1297           if (COMPLEX_FLOAT_TYPE_P (type))
1298             return do_mpc_arg2 (arg1, arg2, type,
1299                                 /* do_nonfinite= */ folding_initializer,
1300                                 mpc_div);
1301           /* Fallthru ... */
1302         case TRUNC_DIV_EXPR:
1303         case CEIL_DIV_EXPR:
1304         case FLOOR_DIV_EXPR:
1305         case ROUND_DIV_EXPR:
1306           if (flag_complex_method == 0)
1307           {
1308             /* Keep this algorithm in sync with
1309                tree-complex.c:expand_complex_div_straight().
1310
1311                Expand complex division to scalars, straightforward algorithm.
1312                a / b = ((ar*br + ai*bi)/t) + i((ai*br - ar*bi)/t)
1313                t = br*br + bi*bi
1314             */
1315             tree magsquared
1316               = const_binop (PLUS_EXPR,
1317                              const_binop (MULT_EXPR, r2, r2),
1318                              const_binop (MULT_EXPR, i2, i2));
1319             tree t1
1320               = const_binop (PLUS_EXPR,
1321                              const_binop (MULT_EXPR, r1, r2),
1322                              const_binop (MULT_EXPR, i1, i2));
1323             tree t2
1324               = const_binop (MINUS_EXPR,
1325                              const_binop (MULT_EXPR, i1, r2),
1326                              const_binop (MULT_EXPR, r1, i2));
1327
1328             real = const_binop (code, t1, magsquared);
1329             imag = const_binop (code, t2, magsquared);
1330           }
1331           else
1332           {
1333             /* Keep this algorithm in sync with
1334                tree-complex.c:expand_complex_div_wide().
1335
1336                Expand complex division to scalars, modified algorithm to minimize
1337                overflow with wide input ranges.  */
1338             tree compare = fold_build2 (LT_EXPR, boolean_type_node,
1339                                         fold_abs_const (r2, TREE_TYPE (type)),
1340                                         fold_abs_const (i2, TREE_TYPE (type)));
1341
1342             if (integer_nonzerop (compare))
1343               {
1344                 /* In the TRUE branch, we compute
1345                    ratio = br/bi;
1346                    div = (br * ratio) + bi;
1347                    tr = (ar * ratio) + ai;
1348                    ti = (ai * ratio) - ar;
1349                    tr = tr / div;
1350                    ti = ti / div;  */
1351                 tree ratio = const_binop (code, r2, i2);
1352                 tree div = const_binop (PLUS_EXPR, i2,
1353                                         const_binop (MULT_EXPR, r2, ratio));
1354                 real = const_binop (MULT_EXPR, r1, ratio);
1355                 real = const_binop (PLUS_EXPR, real, i1);
1356                 real = const_binop (code, real, div);
1357
1358                 imag = const_binop (MULT_EXPR, i1, ratio);
1359                 imag = const_binop (MINUS_EXPR, imag, r1);
1360                 imag = const_binop (code, imag, div);
1361               }
1362             else
1363               {
1364                 /* In the FALSE branch, we compute
1365                    ratio = d/c;
1366                    divisor = (d * ratio) + c;
1367                    tr = (b * ratio) + a;
1368                    ti = b - (a * ratio);
1369                    tr = tr / div;
1370                    ti = ti / div;  */
1371                 tree ratio = const_binop (code, i2, r2);
1372                 tree div = const_binop (PLUS_EXPR, r2,
1373                                         const_binop (MULT_EXPR, i2, ratio));
1374
1375                 real = const_binop (MULT_EXPR, i1, ratio);
1376                 real = const_binop (PLUS_EXPR, real, r1);
1377                 real = const_binop (code, real, div);
1378
1379                 imag = const_binop (MULT_EXPR, r1, ratio);
1380                 imag = const_binop (MINUS_EXPR, i1, imag);
1381                 imag = const_binop (code, imag, div);
1382               }
1383           }
1384           break;
1385
1386         default:
1387           return NULL_TREE;
1388         }
1389
1390       if (real && imag)
1391         return build_complex (type, real, imag);
1392     }
1393
1394   if (TREE_CODE (arg1) == VECTOR_CST
1395       && TREE_CODE (arg2) == VECTOR_CST)
1396     {
1397       tree type = TREE_TYPE (arg1);
1398       int count = TYPE_VECTOR_SUBPARTS (type), i;
1399       tree *elts = XALLOCAVEC (tree, count);
1400
1401       for (i = 0; i < count; i++)
1402         {
1403           tree elem1 = VECTOR_CST_ELT (arg1, i);
1404           tree elem2 = VECTOR_CST_ELT (arg2, i);
1405
1406           elts[i] = const_binop (code, elem1, elem2);
1407
1408           /* It is possible that const_binop cannot handle the given
1409              code and return NULL_TREE */
1410           if (elts[i] == NULL_TREE)
1411             return NULL_TREE;
1412         }
1413
1414       return build_vector (type, elts);
1415     }
1416
1417   /* Shifts allow a scalar offset for a vector.  */
1418   if (TREE_CODE (arg1) == VECTOR_CST
1419       && TREE_CODE (arg2) == INTEGER_CST)
1420     {
1421       tree type = TREE_TYPE (arg1);
1422       int count = TYPE_VECTOR_SUBPARTS (type), i;
1423       tree *elts = XALLOCAVEC (tree, count);
1424
1425       for (i = 0; i < count; i++)
1426         {
1427           tree elem1 = VECTOR_CST_ELT (arg1, i);
1428
1429           elts[i] = const_binop (code, elem1, arg2);
1430
1431           /* It is possible that const_binop cannot handle the given
1432              code and return NULL_TREE.  */
1433           if (elts[i] == NULL_TREE)
1434             return NULL_TREE;
1435         }
1436
1437       return build_vector (type, elts);
1438     }
1439   return NULL_TREE;
1440 }
1441
1442 /* Overload that adds a TYPE parameter to be able to dispatch
1443    to fold_relational_const.  */
1444
1445 tree
1446 const_binop (enum tree_code code, tree type, tree arg1, tree arg2)
1447 {
1448   if (TREE_CODE_CLASS (code) == tcc_comparison)
1449     return fold_relational_const (code, type, arg1, arg2);
1450
1451   /* ???  Until we make the const_binop worker take the type of the
1452      result as argument put those cases that need it here.  */
1453   switch (code)
1454     {
1455     case COMPLEX_EXPR:
1456       if ((TREE_CODE (arg1) == REAL_CST
1457            && TREE_CODE (arg2) == REAL_CST)
1458           || (TREE_CODE (arg1) == INTEGER_CST
1459               && TREE_CODE (arg2) == INTEGER_CST))
1460         return build_complex (type, arg1, arg2);
1461       return NULL_TREE;
1462
1463     case VEC_PACK_TRUNC_EXPR:
1464     case VEC_PACK_FIX_TRUNC_EXPR:
1465       {
1466         unsigned int nelts = TYPE_VECTOR_SUBPARTS (type), i;
1467         tree *elts;
1468
1469         gcc_assert (TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg1)) == nelts / 2
1470                     && TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg2)) == nelts / 2);
1471         if (TREE_CODE (arg1) != VECTOR_CST
1472             || TREE_CODE (arg2) != VECTOR_CST)
1473           return NULL_TREE;
1474
1475         elts = XALLOCAVEC (tree, nelts);
1476         if (!vec_cst_ctor_to_array (arg1, elts)
1477             || !vec_cst_ctor_to_array (arg2, elts + nelts / 2))
1478           return NULL_TREE;
1479
1480         for (i = 0; i < nelts; i++)
1481           {
1482             elts[i] = fold_convert_const (code == VEC_PACK_TRUNC_EXPR
1483                                           ? NOP_EXPR : FIX_TRUNC_EXPR,
1484                                           TREE_TYPE (type), elts[i]);
1485             if (elts[i] == NULL_TREE || !CONSTANT_CLASS_P (elts[i]))
1486               return NULL_TREE;
1487           }
1488
1489         return build_vector (type, elts);
1490       }
1491
1492     case VEC_WIDEN_MULT_LO_EXPR:
1493     case VEC_WIDEN_MULT_HI_EXPR:
1494     case VEC_WIDEN_MULT_EVEN_EXPR:
1495     case VEC_WIDEN_MULT_ODD_EXPR:
1496       {
1497         unsigned int nelts = TYPE_VECTOR_SUBPARTS (type);
1498         unsigned int out, ofs, scale;
1499         tree *elts;
1500
1501         gcc_assert (TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg1)) == nelts * 2
1502                     && TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg2)) == nelts * 2);
1503         if (TREE_CODE (arg1) != VECTOR_CST || TREE_CODE (arg2) != VECTOR_CST)
1504           return NULL_TREE;
1505
1506         elts = XALLOCAVEC (tree, nelts * 4);
1507         if (!vec_cst_ctor_to_array (arg1, elts)
1508             || !vec_cst_ctor_to_array (arg2, elts + nelts * 2))
1509           return NULL_TREE;
1510
1511         if (code == VEC_WIDEN_MULT_LO_EXPR)
1512           scale = 0, ofs = BYTES_BIG_ENDIAN ? nelts : 0;
1513         else if (code == VEC_WIDEN_MULT_HI_EXPR)
1514           scale = 0, ofs = BYTES_BIG_ENDIAN ? 0 : nelts;
1515         else if (code == VEC_WIDEN_MULT_EVEN_EXPR)
1516           scale = 1, ofs = 0;
1517         else /* if (code == VEC_WIDEN_MULT_ODD_EXPR) */
1518           scale = 1, ofs = 1;
1519
1520         for (out = 0; out < nelts; out++)
1521           {
1522             unsigned int in1 = (out << scale) + ofs;
1523             unsigned int in2 = in1 + nelts * 2;
1524             tree t1, t2;
1525
1526             t1 = fold_convert_const (NOP_EXPR, TREE_TYPE (type), elts[in1]);
1527             t2 = fold_convert_const (NOP_EXPR, TREE_TYPE (type), elts[in2]);
1528
1529             if (t1 == NULL_TREE || t2 == NULL_TREE)
1530               return NULL_TREE;
1531             elts[out] = const_binop (MULT_EXPR, t1, t2);
1532             if (elts[out] == NULL_TREE || !CONSTANT_CLASS_P (elts[out]))
1533               return NULL_TREE;
1534           }
1535
1536         return build_vector (type, elts);
1537       }
1538
1539     default:;
1540     }
1541
1542   if (TREE_CODE_CLASS (code) != tcc_binary)
1543     return NULL_TREE;
1544
1545   /* Make sure type and arg0 have the same saturating flag.  */
1546   gcc_checking_assert (TYPE_SATURATING (type)
1547                        == TYPE_SATURATING (TREE_TYPE (arg1)));
1548
1549   return const_binop (code, arg1, arg2);
1550 }
1551
1552 /* Compute CODE ARG1 with resulting type TYPE with ARG1 being constant.
1553    Return zero if computing the constants is not possible.  */
1554
1555 tree
1556 const_unop (enum tree_code code, tree type, tree arg0)
1557 {
1558   switch (code)
1559     {
1560     CASE_CONVERT:
1561     case FLOAT_EXPR:
1562     case FIX_TRUNC_EXPR:
1563     case FIXED_CONVERT_EXPR:
1564       return fold_convert_const (code, type, arg0);
1565
1566     case ADDR_SPACE_CONVERT_EXPR:
1567       if (integer_zerop (arg0))
1568         return fold_convert_const (code, type, arg0);
1569       break;
1570
1571     case VIEW_CONVERT_EXPR:
1572       return fold_view_convert_expr (type, arg0);
1573
1574     case NEGATE_EXPR:
1575       {
1576         /* Can't call fold_negate_const directly here as that doesn't
1577            handle all cases and we might not be able to negate some
1578            constants.  */
1579         tree tem = fold_negate_expr (UNKNOWN_LOCATION, arg0);
1580         if (tem && CONSTANT_CLASS_P (tem))
1581           return tem;
1582         break;
1583       }
1584
1585     case ABS_EXPR:
1586       if (TREE_CODE (arg0) == INTEGER_CST || TREE_CODE (arg0) == REAL_CST)
1587         return fold_abs_const (arg0, type);
1588       break;
1589
1590     case CONJ_EXPR:
1591       if (TREE_CODE (arg0) == COMPLEX_CST)
1592         {
1593           tree ipart = fold_negate_const (TREE_IMAGPART (arg0),
1594                                           TREE_TYPE (type));
1595           return build_complex (type, TREE_REALPART (arg0), ipart);
1596         }
1597       break;
1598
1599     case BIT_NOT_EXPR:
1600       if (TREE_CODE (arg0) == INTEGER_CST)
1601         return fold_not_const (arg0, type);
1602       /* Perform BIT_NOT_EXPR on each element individually.  */
1603       else if (TREE_CODE (arg0) == VECTOR_CST)
1604         {
1605           tree *elements;
1606           tree elem;
1607           unsigned count = VECTOR_CST_NELTS (arg0), i;
1608
1609           elements = XALLOCAVEC (tree, count);
1610           for (i = 0; i < count; i++)
1611             {
1612               elem = VECTOR_CST_ELT (arg0, i);
1613               elem = const_unop (BIT_NOT_EXPR, TREE_TYPE (type), elem);
1614               if (elem == NULL_TREE)
1615                 break;
1616               elements[i] = elem;
1617             }
1618           if (i == count)
1619             return build_vector (type, elements);
1620         }
1621       break;
1622
1623     case TRUTH_NOT_EXPR:
1624       if (TREE_CODE (arg0) == INTEGER_CST)
1625         return constant_boolean_node (integer_zerop (arg0), type);
1626       break;
1627
1628     case REALPART_EXPR:
1629       if (TREE_CODE (arg0) == COMPLEX_CST)
1630         return fold_convert (type, TREE_REALPART (arg0));
1631       break;
1632
1633     case IMAGPART_EXPR:
1634       if (TREE_CODE (arg0) == COMPLEX_CST)
1635         return fold_convert (type, TREE_IMAGPART (arg0));
1636       break;
1637
1638     case VEC_UNPACK_LO_EXPR:
1639     case VEC_UNPACK_HI_EXPR:
1640     case VEC_UNPACK_FLOAT_LO_EXPR:
1641     case VEC_UNPACK_FLOAT_HI_EXPR:
1642       {
1643         unsigned int nelts = TYPE_VECTOR_SUBPARTS (type), i;
1644         tree *elts;
1645         enum tree_code subcode;
1646
1647         gcc_assert (TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0)) == nelts * 2);
1648         if (TREE_CODE (arg0) != VECTOR_CST)
1649           return NULL_TREE;
1650
1651         elts = XALLOCAVEC (tree, nelts * 2);
1652         if (!vec_cst_ctor_to_array (arg0, elts))
1653           return NULL_TREE;
1654
1655         if ((!BYTES_BIG_ENDIAN) ^ (code == VEC_UNPACK_LO_EXPR
1656                                    || code == VEC_UNPACK_FLOAT_LO_EXPR))
1657           elts += nelts;
1658
1659         if (code == VEC_UNPACK_LO_EXPR || code == VEC_UNPACK_HI_EXPR)
1660           subcode = NOP_EXPR;
1661         else
1662           subcode = FLOAT_EXPR;
1663
1664         for (i = 0; i < nelts; i++)
1665           {
1666             elts[i] = fold_convert_const (subcode, TREE_TYPE (type), elts[i]);
1667             if (elts[i] == NULL_TREE || !CONSTANT_CLASS_P (elts[i]))
1668               return NULL_TREE;
1669           }
1670
1671         return build_vector (type, elts);
1672       }
1673
1674     case REDUC_MIN_EXPR:
1675     case REDUC_MAX_EXPR:
1676     case REDUC_PLUS_EXPR:
1677       {
1678         unsigned int nelts, i;
1679         tree *elts;
1680         enum tree_code subcode;
1681
1682         if (TREE_CODE (arg0) != VECTOR_CST)
1683           return NULL_TREE;
1684         nelts = TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0));
1685
1686         elts = XALLOCAVEC (tree, nelts);
1687         if (!vec_cst_ctor_to_array (arg0, elts))
1688           return NULL_TREE;
1689
1690         switch (code)
1691           {
1692           case REDUC_MIN_EXPR: subcode = MIN_EXPR; break;
1693           case REDUC_MAX_EXPR: subcode = MAX_EXPR; break;
1694           case REDUC_PLUS_EXPR: subcode = PLUS_EXPR; break;
1695           default: gcc_unreachable ();
1696           }
1697
1698         for (i = 1; i < nelts; i++)
1699           {
1700             elts[0] = const_binop (subcode, elts[0], elts[i]);
1701             if (elts[0] == NULL_TREE || !CONSTANT_CLASS_P (elts[0]))
1702               return NULL_TREE;
1703           }
1704
1705         return elts[0];
1706       }
1707
1708     default:
1709       break;
1710     }
1711
1712   return NULL_TREE;
1713 }
1714
1715 /* Create a sizetype INT_CST node with NUMBER sign extended.  KIND
1716    indicates which particular sizetype to create.  */
1717
1718 tree
1719 size_int_kind (HOST_WIDE_INT number, enum size_type_kind kind)
1720 {
1721   return build_int_cst (sizetype_tab[(int) kind], number);
1722 }
1723 \f
1724 /* Combine operands OP1 and OP2 with arithmetic operation CODE.  CODE
1725    is a tree code.  The type of the result is taken from the operands.
1726    Both must be equivalent integer types, ala int_binop_types_match_p.
1727    If the operands are constant, so is the result.  */
1728
1729 tree
1730 size_binop_loc (location_t loc, enum tree_code code, tree arg0, tree arg1)
1731 {
1732   tree type = TREE_TYPE (arg0);
1733
1734   if (arg0 == error_mark_node || arg1 == error_mark_node)
1735     return error_mark_node;
1736
1737   gcc_assert (int_binop_types_match_p (code, TREE_TYPE (arg0),
1738                                        TREE_TYPE (arg1)));
1739
1740   /* Handle the special case of two integer constants faster.  */
1741   if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
1742     {
1743       /* And some specific cases even faster than that.  */
1744       if (code == PLUS_EXPR)
1745         {
1746           if (integer_zerop (arg0) && !TREE_OVERFLOW (arg0))
1747             return arg1;
1748           if (integer_zerop (arg1) && !TREE_OVERFLOW (arg1))
1749             return arg0;
1750         }
1751       else if (code == MINUS_EXPR)
1752         {
1753           if (integer_zerop (arg1) && !TREE_OVERFLOW (arg1))
1754             return arg0;
1755         }
1756       else if (code == MULT_EXPR)
1757         {
1758           if (integer_onep (arg0) && !TREE_OVERFLOW (arg0))
1759             return arg1;
1760         }
1761
1762       /* Handle general case of two integer constants.  For sizetype
1763          constant calculations we always want to know about overflow,
1764          even in the unsigned case.  */
1765       return int_const_binop_1 (code, arg0, arg1, -1);
1766     }
1767
1768   return fold_build2_loc (loc, code, type, arg0, arg1);
1769 }
1770
1771 /* Given two values, either both of sizetype or both of bitsizetype,
1772    compute the difference between the two values.  Return the value
1773    in signed type corresponding to the type of the operands.  */
1774
1775 tree
1776 size_diffop_loc (location_t loc, tree arg0, tree arg1)
1777 {
1778   tree type = TREE_TYPE (arg0);
1779   tree ctype;
1780
1781   gcc_assert (int_binop_types_match_p (MINUS_EXPR, TREE_TYPE (arg0),
1782                                        TREE_TYPE (arg1)));
1783
1784   /* If the type is already signed, just do the simple thing.  */
1785   if (!TYPE_UNSIGNED (type))
1786     return size_binop_loc (loc, MINUS_EXPR, arg0, arg1);
1787
1788   if (type == sizetype)
1789     ctype = ssizetype;
1790   else if (type == bitsizetype)
1791     ctype = sbitsizetype;
1792   else
1793     ctype = signed_type_for (type);
1794
1795   /* If either operand is not a constant, do the conversions to the signed
1796      type and subtract.  The hardware will do the right thing with any
1797      overflow in the subtraction.  */
1798   if (TREE_CODE (arg0) != INTEGER_CST || TREE_CODE (arg1) != INTEGER_CST)
1799     return size_binop_loc (loc, MINUS_EXPR,
1800                            fold_convert_loc (loc, ctype, arg0),
1801                            fold_convert_loc (loc, ctype, arg1));
1802
1803   /* If ARG0 is larger than ARG1, subtract and return the result in CTYPE.
1804      Otherwise, subtract the other way, convert to CTYPE (we know that can't
1805      overflow) and negate (which can't either).  Special-case a result
1806      of zero while we're here.  */
1807   if (tree_int_cst_equal (arg0, arg1))
1808     return build_int_cst (ctype, 0);
1809   else if (tree_int_cst_lt (arg1, arg0))
1810     return fold_convert_loc (loc, ctype,
1811                              size_binop_loc (loc, MINUS_EXPR, arg0, arg1));
1812   else
1813     return size_binop_loc (loc, MINUS_EXPR, build_int_cst (ctype, 0),
1814                            fold_convert_loc (loc, ctype,
1815                                              size_binop_loc (loc,
1816                                                              MINUS_EXPR,
1817                                                              arg1, arg0)));
1818 }
1819 \f
1820 /* A subroutine of fold_convert_const handling conversions of an
1821    INTEGER_CST to another integer type.  */
1822
1823 static tree
1824 fold_convert_const_int_from_int (tree type, const_tree arg1)
1825 {
1826   /* Given an integer constant, make new constant with new type,
1827      appropriately sign-extended or truncated.  Use widest_int
1828      so that any extension is done according ARG1's type.  */
1829   return force_fit_type (type, wi::to_widest (arg1),
1830                          !POINTER_TYPE_P (TREE_TYPE (arg1)),
1831                          TREE_OVERFLOW (arg1));
1832 }
1833
1834 /* A subroutine of fold_convert_const handling conversions a REAL_CST
1835    to an integer type.  */
1836
1837 static tree
1838 fold_convert_const_int_from_real (enum tree_code code, tree type, const_tree arg1)
1839 {
1840   bool overflow = false;
1841   tree t;
1842
1843   /* The following code implements the floating point to integer
1844      conversion rules required by the Java Language Specification,
1845      that IEEE NaNs are mapped to zero and values that overflow
1846      the target precision saturate, i.e. values greater than
1847      INT_MAX are mapped to INT_MAX, and values less than INT_MIN
1848      are mapped to INT_MIN.  These semantics are allowed by the
1849      C and C++ standards that simply state that the behavior of
1850      FP-to-integer conversion is unspecified upon overflow.  */
1851
1852   wide_int val;
1853   REAL_VALUE_TYPE r;
1854   REAL_VALUE_TYPE x = TREE_REAL_CST (arg1);
1855
1856   switch (code)
1857     {
1858     case FIX_TRUNC_EXPR:
1859       real_trunc (&r, VOIDmode, &x);
1860       break;
1861
1862     default:
1863       gcc_unreachable ();
1864     }
1865
1866   /* If R is NaN, return zero and show we have an overflow.  */
1867   if (REAL_VALUE_ISNAN (r))
1868     {
1869       overflow = true;
1870       val = wi::zero (TYPE_PRECISION (type));
1871     }
1872
1873   /* See if R is less than the lower bound or greater than the
1874      upper bound.  */
1875
1876   if (! overflow)
1877     {
1878       tree lt = TYPE_MIN_VALUE (type);
1879       REAL_VALUE_TYPE l = real_value_from_int_cst (NULL_TREE, lt);
1880       if (REAL_VALUES_LESS (r, l))
1881         {
1882           overflow = true;
1883           val = lt;
1884         }
1885     }
1886
1887   if (! overflow)
1888     {
1889       tree ut = TYPE_MAX_VALUE (type);
1890       if (ut)
1891         {
1892           REAL_VALUE_TYPE u = real_value_from_int_cst (NULL_TREE, ut);
1893           if (REAL_VALUES_LESS (u, r))
1894             {
1895               overflow = true;
1896               val = ut;
1897             }
1898         }
1899     }
1900
1901   if (! overflow)
1902     val = real_to_integer (&r, &overflow, TYPE_PRECISION (type));
1903
1904   t = force_fit_type (type, val, -1, overflow | TREE_OVERFLOW (arg1));
1905   return t;
1906 }
1907
1908 /* A subroutine of fold_convert_const handling conversions of a
1909    FIXED_CST to an integer type.  */
1910
1911 static tree
1912 fold_convert_const_int_from_fixed (tree type, const_tree arg1)
1913 {
1914   tree t;
1915   double_int temp, temp_trunc;
1916   unsigned int mode;
1917
1918   /* Right shift FIXED_CST to temp by fbit.  */
1919   temp = TREE_FIXED_CST (arg1).data;
1920   mode = TREE_FIXED_CST (arg1).mode;
1921   if (GET_MODE_FBIT (mode) < HOST_BITS_PER_DOUBLE_INT)
1922     {
1923       temp = temp.rshift (GET_MODE_FBIT (mode),
1924                           HOST_BITS_PER_DOUBLE_INT,
1925                           SIGNED_FIXED_POINT_MODE_P (mode));
1926
1927       /* Left shift temp to temp_trunc by fbit.  */
1928       temp_trunc = temp.lshift (GET_MODE_FBIT (mode),
1929                                 HOST_BITS_PER_DOUBLE_INT,
1930                                 SIGNED_FIXED_POINT_MODE_P (mode));
1931     }
1932   else
1933     {
1934       temp = double_int_zero;
1935       temp_trunc = double_int_zero;
1936     }
1937
1938   /* If FIXED_CST is negative, we need to round the value toward 0.
1939      By checking if the fractional bits are not zero to add 1 to temp.  */
1940   if (SIGNED_FIXED_POINT_MODE_P (mode)
1941       && temp_trunc.is_negative ()
1942       && TREE_FIXED_CST (arg1).data != temp_trunc)
1943     temp += double_int_one;
1944
1945   /* Given a fixed-point constant, make new constant with new type,
1946      appropriately sign-extended or truncated.  */
1947   t = force_fit_type (type, temp, -1,
1948                       (temp.is_negative ()
1949                        && (TYPE_UNSIGNED (type)
1950                            < TYPE_UNSIGNED (TREE_TYPE (arg1))))
1951                       | TREE_OVERFLOW (arg1));
1952
1953   return t;
1954 }
1955
1956 /* A subroutine of fold_convert_const handling conversions a REAL_CST
1957    to another floating point type.  */
1958
1959 static tree
1960 fold_convert_const_real_from_real (tree type, const_tree arg1)
1961 {
1962   REAL_VALUE_TYPE value;
1963   tree t;
1964
1965   real_convert (&value, TYPE_MODE (type), &TREE_REAL_CST (arg1));
1966   t = build_real (type, value);
1967
1968   /* If converting an infinity or NAN to a representation that doesn't
1969      have one, set the overflow bit so that we can produce some kind of
1970      error message at the appropriate point if necessary.  It's not the
1971      most user-friendly message, but it's better than nothing.  */
1972   if (REAL_VALUE_ISINF (TREE_REAL_CST (arg1))
1973       && !MODE_HAS_INFINITIES (TYPE_MODE (type)))
1974     TREE_OVERFLOW (t) = 1;
1975   else if (REAL_VALUE_ISNAN (TREE_REAL_CST (arg1))
1976            && !MODE_HAS_NANS (TYPE_MODE (type)))
1977     TREE_OVERFLOW (t) = 1;
1978   /* Regular overflow, conversion produced an infinity in a mode that
1979      can't represent them.  */
1980   else if (!MODE_HAS_INFINITIES (TYPE_MODE (type))
1981            && REAL_VALUE_ISINF (value)
1982            && !REAL_VALUE_ISINF (TREE_REAL_CST (arg1)))
1983     TREE_OVERFLOW (t) = 1;
1984   else
1985     TREE_OVERFLOW (t) = TREE_OVERFLOW (arg1);
1986   return t;
1987 }
1988
1989 /* A subroutine of fold_convert_const handling conversions a FIXED_CST
1990    to a floating point type.  */
1991
1992 static tree
1993 fold_convert_const_real_from_fixed (tree type, const_tree arg1)
1994 {
1995   REAL_VALUE_TYPE value;
1996   tree t;
1997
1998   real_convert_from_fixed (&value, TYPE_MODE (type), &TREE_FIXED_CST (arg1));
1999   t = build_real (type, value);
2000
2001   TREE_OVERFLOW (t) = TREE_OVERFLOW (arg1);
2002   return t;
2003 }
2004
2005 /* A subroutine of fold_convert_const handling conversions a FIXED_CST
2006    to another fixed-point type.  */
2007
2008 static tree
2009 fold_convert_const_fixed_from_fixed (tree type, const_tree arg1)
2010 {
2011   FIXED_VALUE_TYPE value;
2012   tree t;
2013   bool overflow_p;
2014
2015   overflow_p = fixed_convert (&value, TYPE_MODE (type), &TREE_FIXED_CST (arg1),
2016                               TYPE_SATURATING (type));
2017   t = build_fixed (type, value);
2018
2019   /* Propagate overflow flags.  */
2020   if (overflow_p | TREE_OVERFLOW (arg1))
2021     TREE_OVERFLOW (t) = 1;
2022   return t;
2023 }
2024
2025 /* A subroutine of fold_convert_const handling conversions an INTEGER_CST
2026    to a fixed-point type.  */
2027
2028 static tree
2029 fold_convert_const_fixed_from_int (tree type, const_tree arg1)
2030 {
2031   FIXED_VALUE_TYPE value;
2032   tree t;
2033   bool overflow_p;
2034   double_int di;
2035
2036   gcc_assert (TREE_INT_CST_NUNITS (arg1) <= 2);
2037
2038   di.low = TREE_INT_CST_ELT (arg1, 0);
2039   if (TREE_INT_CST_NUNITS (arg1) == 1)
2040     di.high = (HOST_WIDE_INT) di.low < 0 ? (HOST_WIDE_INT) -1 : 0;
2041   else
2042     di.high = TREE_INT_CST_ELT (arg1, 1);
2043
2044   overflow_p = fixed_convert_from_int (&value, TYPE_MODE (type), di,
2045                                        TYPE_UNSIGNED (TREE_TYPE (arg1)),
2046                                        TYPE_SATURATING (type));
2047   t = build_fixed (type, value);
2048
2049   /* Propagate overflow flags.  */
2050   if (overflow_p | TREE_OVERFLOW (arg1))
2051     TREE_OVERFLOW (t) = 1;
2052   return t;
2053 }
2054
2055 /* A subroutine of fold_convert_const handling conversions a REAL_CST
2056    to a fixed-point type.  */
2057
2058 static tree
2059 fold_convert_const_fixed_from_real (tree type, const_tree arg1)
2060 {
2061   FIXED_VALUE_TYPE value;
2062   tree t;
2063   bool overflow_p;
2064
2065   overflow_p = fixed_convert_from_real (&value, TYPE_MODE (type),
2066                                         &TREE_REAL_CST (arg1),
2067                                         TYPE_SATURATING (type));
2068   t = build_fixed (type, value);
2069
2070   /* Propagate overflow flags.  */
2071   if (overflow_p | TREE_OVERFLOW (arg1))
2072     TREE_OVERFLOW (t) = 1;
2073   return t;
2074 }
2075
2076 /* Attempt to fold type conversion operation CODE of expression ARG1 to
2077    type TYPE.  If no simplification can be done return NULL_TREE.  */
2078
2079 static tree
2080 fold_convert_const (enum tree_code code, tree type, tree arg1)
2081 {
2082   if (TREE_TYPE (arg1) == type)
2083     return arg1;
2084
2085   if (POINTER_TYPE_P (type) || INTEGRAL_TYPE_P (type)
2086       || TREE_CODE (type) == OFFSET_TYPE)
2087     {
2088       if (TREE_CODE (arg1) == INTEGER_CST)
2089         return fold_convert_const_int_from_int (type, arg1);
2090       else if (TREE_CODE (arg1) == REAL_CST)
2091         return fold_convert_const_int_from_real (code, type, arg1);
2092       else if (TREE_CODE (arg1) == FIXED_CST)
2093         return fold_convert_const_int_from_fixed (type, arg1);
2094     }
2095   else if (TREE_CODE (type) == REAL_TYPE)
2096     {
2097       if (TREE_CODE (arg1) == INTEGER_CST)
2098         return build_real_from_int_cst (type, arg1);
2099       else if (TREE_CODE (arg1) == REAL_CST)
2100         return fold_convert_const_real_from_real (type, arg1);
2101       else if (TREE_CODE (arg1) == FIXED_CST)
2102         return fold_convert_const_real_from_fixed (type, arg1);
2103     }
2104   else if (TREE_CODE (type) == FIXED_POINT_TYPE)
2105     {
2106       if (TREE_CODE (arg1) == FIXED_CST)
2107         return fold_convert_const_fixed_from_fixed (type, arg1);
2108       else if (TREE_CODE (arg1) == INTEGER_CST)
2109         return fold_convert_const_fixed_from_int (type, arg1);
2110       else if (TREE_CODE (arg1) == REAL_CST)
2111         return fold_convert_const_fixed_from_real (type, arg1);
2112     }
2113   return NULL_TREE;
2114 }
2115
2116 /* Construct a vector of zero elements of vector type TYPE.  */
2117
2118 static tree
2119 build_zero_vector (tree type)
2120 {
2121   tree t;
2122
2123   t = fold_convert_const (NOP_EXPR, TREE_TYPE (type), integer_zero_node);
2124   return build_vector_from_val (type, t);
2125 }
2126
2127 /* Returns true, if ARG is convertible to TYPE using a NOP_EXPR.  */
2128
2129 bool
2130 fold_convertible_p (const_tree type, const_tree arg)
2131 {
2132   tree orig = TREE_TYPE (arg);
2133
2134   if (type == orig)
2135     return true;
2136
2137   if (TREE_CODE (arg) == ERROR_MARK
2138       || TREE_CODE (type) == ERROR_MARK
2139       || TREE_CODE (orig) == ERROR_MARK)
2140     return false;
2141
2142   if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (orig))
2143     return true;
2144
2145   switch (TREE_CODE (type))
2146     {
2147     case INTEGER_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE:
2148     case POINTER_TYPE: case REFERENCE_TYPE:
2149     case OFFSET_TYPE:
2150       if (INTEGRAL_TYPE_P (orig) || POINTER_TYPE_P (orig)
2151           || TREE_CODE (orig) == OFFSET_TYPE)
2152         return true;
2153       return (TREE_CODE (orig) == VECTOR_TYPE
2154               && tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (orig)));
2155
2156     case REAL_TYPE:
2157     case FIXED_POINT_TYPE:
2158     case COMPLEX_TYPE:
2159     case VECTOR_TYPE:
2160     case VOID_TYPE:
2161       return TREE_CODE (type) == TREE_CODE (orig);
2162
2163     default:
2164       return false;
2165     }
2166 }
2167
2168 /* Convert expression ARG to type TYPE.  Used by the middle-end for
2169    simple conversions in preference to calling the front-end's convert.  */
2170
2171 tree
2172 fold_convert_loc (location_t loc, tree type, tree arg)
2173 {
2174   tree orig = TREE_TYPE (arg);
2175   tree tem;
2176
2177   if (type == orig)
2178     return arg;
2179
2180   if (TREE_CODE (arg) == ERROR_MARK
2181       || TREE_CODE (type) == ERROR_MARK
2182       || TREE_CODE (orig) == ERROR_MARK)
2183     return error_mark_node;
2184
2185   switch (TREE_CODE (type))
2186     {
2187     case POINTER_TYPE:
2188     case REFERENCE_TYPE:
2189       /* Handle conversions between pointers to different address spaces.  */
2190       if (POINTER_TYPE_P (orig)
2191           && (TYPE_ADDR_SPACE (TREE_TYPE (type))
2192               != TYPE_ADDR_SPACE (TREE_TYPE (orig))))
2193         return fold_build1_loc (loc, ADDR_SPACE_CONVERT_EXPR, type, arg);
2194       /* fall through */
2195
2196     case INTEGER_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE:
2197     case OFFSET_TYPE:
2198       if (TREE_CODE (arg) == INTEGER_CST)
2199         {
2200           tem = fold_convert_const (NOP_EXPR, type, arg);
2201           if (tem != NULL_TREE)
2202             return tem;
2203         }
2204       if (INTEGRAL_TYPE_P (orig) || POINTER_TYPE_P (orig)
2205           || TREE_CODE (orig) == OFFSET_TYPE)
2206         return fold_build1_loc (loc, NOP_EXPR, type, arg);
2207       if (TREE_CODE (orig) == COMPLEX_TYPE)
2208         return fold_convert_loc (loc, type,
2209                              fold_build1_loc (loc, REALPART_EXPR,
2210                                           TREE_TYPE (orig), arg));
2211       gcc_assert (TREE_CODE (orig) == VECTOR_TYPE
2212                   && tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (orig)));
2213       return fold_build1_loc (loc, NOP_EXPR, type, arg);
2214
2215     case REAL_TYPE:
2216       if (TREE_CODE (arg) == INTEGER_CST)
2217         {
2218           tem = fold_convert_const (FLOAT_EXPR, type, arg);
2219           if (tem != NULL_TREE)
2220             return tem;
2221         }
2222       else if (TREE_CODE (arg) == REAL_CST)
2223         {
2224           tem = fold_convert_const (NOP_EXPR, type, arg);
2225           if (tem != NULL_TREE)
2226             return tem;
2227         }
2228       else if (TREE_CODE (arg) == FIXED_CST)
2229         {
2230           tem = fold_convert_const (FIXED_CONVERT_EXPR, type, arg);
2231           if (tem != NULL_TREE)
2232             return tem;
2233         }
2234
2235       switch (TREE_CODE (orig))
2236         {
2237         case INTEGER_TYPE:
2238         case BOOLEAN_TYPE: case ENUMERAL_TYPE:
2239         case POINTER_TYPE: case REFERENCE_TYPE:
2240           return fold_build1_loc (loc, FLOAT_EXPR, type, arg);
2241
2242         case REAL_TYPE:
2243           return fold_build1_loc (loc, NOP_EXPR, type, arg);
2244
2245         case FIXED_POINT_TYPE:
2246           return fold_build1_loc (loc, FIXED_CONVERT_EXPR, type, arg);
2247
2248         case COMPLEX_TYPE:
2249           tem = fold_build1_loc (loc, REALPART_EXPR, TREE_TYPE (orig), arg);
2250           return fold_convert_loc (loc, type, tem);
2251
2252         default:
2253           gcc_unreachable ();
2254         }
2255
2256     case FIXED_POINT_TYPE:
2257       if (TREE_CODE (arg) == FIXED_CST || TREE_CODE (arg) == INTEGER_CST
2258           || TREE_CODE (arg) == REAL_CST)
2259         {
2260           tem = fold_convert_const (FIXED_CONVERT_EXPR, type, arg);
2261           if (tem != NULL_TREE)
2262             goto fold_convert_exit;
2263         }
2264
2265       switch (TREE_CODE (orig))
2266         {
2267         case FIXED_POINT_TYPE:
2268         case INTEGER_TYPE:
2269         case ENUMERAL_TYPE:
2270         case BOOLEAN_TYPE:
2271         case REAL_TYPE:
2272           return fold_build1_loc (loc, FIXED_CONVERT_EXPR, type, arg);
2273
2274         case COMPLEX_TYPE:
2275           tem = fold_build1_loc (loc, REALPART_EXPR, TREE_TYPE (orig), arg);
2276           return fold_convert_loc (loc, type, tem);
2277
2278         default:
2279           gcc_unreachable ();
2280         }
2281
2282     case COMPLEX_TYPE:
2283       switch (TREE_CODE (orig))
2284         {
2285         case INTEGER_TYPE:
2286         case BOOLEAN_TYPE: case ENUMERAL_TYPE:
2287         case POINTER_TYPE: case REFERENCE_TYPE:
2288         case REAL_TYPE:
2289         case FIXED_POINT_TYPE:
2290           return fold_build2_loc (loc, COMPLEX_EXPR, type,
2291                               fold_convert_loc (loc, TREE_TYPE (type), arg),
2292                               fold_convert_loc (loc, TREE_TYPE (type),
2293                                             integer_zero_node));
2294         case COMPLEX_TYPE:
2295           {
2296             tree rpart, ipart;
2297
2298             if (TREE_CODE (arg) == COMPLEX_EXPR)
2299               {
2300                 rpart = fold_convert_loc (loc, TREE_TYPE (type),
2301                                       TREE_OPERAND (arg, 0));
2302                 ipart = fold_convert_loc (loc, TREE_TYPE (type),
2303                                       TREE_OPERAND (arg, 1));
2304                 return fold_build2_loc (loc, COMPLEX_EXPR, type, rpart, ipart);
2305               }
2306
2307             arg = save_expr (arg);
2308             rpart = fold_build1_loc (loc, REALPART_EXPR, TREE_TYPE (orig), arg);
2309             ipart = fold_build1_loc (loc, IMAGPART_EXPR, TREE_TYPE (orig), arg);
2310             rpart = fold_convert_loc (loc, TREE_TYPE (type), rpart);
2311             ipart = fold_convert_loc (loc, TREE_TYPE (type), ipart);
2312             return fold_build2_loc (loc, COMPLEX_EXPR, type, rpart, ipart);
2313           }
2314
2315         default:
2316           gcc_unreachable ();
2317         }
2318
2319     case VECTOR_TYPE:
2320       if (integer_zerop (arg))
2321         return build_zero_vector (type);
2322       gcc_assert (tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (orig)));
2323       gcc_assert (INTEGRAL_TYPE_P (orig) || POINTER_TYPE_P (orig)
2324                   || TREE_CODE (orig) == VECTOR_TYPE);
2325       return fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, arg);
2326
2327     case VOID_TYPE:
2328       tem = fold_ignored_result (arg);
2329       return fold_build1_loc (loc, NOP_EXPR, type, tem);
2330
2331     default:
2332       if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (orig))
2333         return fold_build1_loc (loc, NOP_EXPR, type, arg);
2334       gcc_unreachable ();
2335     }
2336  fold_convert_exit:
2337   protected_set_expr_location_unshare (tem, loc);
2338   return tem;
2339 }
2340 \f
2341 /* Return false if expr can be assumed not to be an lvalue, true
2342    otherwise.  */
2343
2344 static bool
2345 maybe_lvalue_p (const_tree x)
2346 {
2347   /* We only need to wrap lvalue tree codes.  */
2348   switch (TREE_CODE (x))
2349   {
2350   case VAR_DECL:
2351   case PARM_DECL:
2352   case RESULT_DECL:
2353   case LABEL_DECL:
2354   case FUNCTION_DECL:
2355   case SSA_NAME:
2356
2357   case COMPONENT_REF:
2358   case MEM_REF:
2359   case INDIRECT_REF:
2360   case ARRAY_REF:
2361   case ARRAY_RANGE_REF:
2362   case BIT_FIELD_REF:
2363   case OBJ_TYPE_REF:
2364
2365   case REALPART_EXPR:
2366   case IMAGPART_EXPR:
2367   case PREINCREMENT_EXPR:
2368   case PREDECREMENT_EXPR:
2369   case SAVE_EXPR:
2370   case TRY_CATCH_EXPR:
2371   case WITH_CLEANUP_EXPR:
2372   case COMPOUND_EXPR:
2373   case MODIFY_EXPR:
2374   case TARGET_EXPR:
2375   case COND_EXPR:
2376   case BIND_EXPR:
2377     break;
2378
2379   default:
2380     /* Assume the worst for front-end tree codes.  */
2381     if ((int)TREE_CODE (x) >= NUM_TREE_CODES)
2382       break;
2383     return false;
2384   }
2385
2386   return true;
2387 }
2388
2389 /* Return an expr equal to X but certainly not valid as an lvalue.  */
2390
2391 tree
2392 non_lvalue_loc (location_t loc, tree x)
2393 {
2394   /* While we are in GIMPLE, NON_LVALUE_EXPR doesn't mean anything to
2395      us.  */
2396   if (in_gimple_form)
2397     return x;
2398
2399   if (! maybe_lvalue_p (x))
2400     return x;
2401   return build1_loc (loc, NON_LVALUE_EXPR, TREE_TYPE (x), x);
2402 }
2403
2404 /* When pedantic, return an expr equal to X but certainly not valid as a
2405    pedantic lvalue.  Otherwise, return X.  */
2406
2407 static tree
2408 pedantic_non_lvalue_loc (location_t loc, tree x)
2409 {
2410   return protected_set_expr_location_unshare (x, loc);
2411 }
2412 \f
2413 /* Given a tree comparison code, return the code that is the logical inverse.
2414    It is generally not safe to do this for floating-point comparisons, except
2415    for EQ_EXPR, NE_EXPR, ORDERED_EXPR and UNORDERED_EXPR, so we return
2416    ERROR_MARK in this case.  */
2417
2418 enum tree_code
2419 invert_tree_comparison (enum tree_code code, bool honor_nans)
2420 {
2421   if (honor_nans && flag_trapping_math && code != EQ_EXPR && code != NE_EXPR
2422       && code != ORDERED_EXPR && code != UNORDERED_EXPR)
2423     return ERROR_MARK;
2424
2425   switch (code)
2426     {
2427     case EQ_EXPR:
2428       return NE_EXPR;
2429     case NE_EXPR:
2430       return EQ_EXPR;
2431     case GT_EXPR:
2432       return honor_nans ? UNLE_EXPR : LE_EXPR;
2433     case GE_EXPR:
2434       return honor_nans ? UNLT_EXPR : LT_EXPR;
2435     case LT_EXPR:
2436       return honor_nans ? UNGE_EXPR : GE_EXPR;
2437     case LE_EXPR:
2438       return honor_nans ? UNGT_EXPR : GT_EXPR;
2439     case LTGT_EXPR:
2440       return UNEQ_EXPR;
2441     case UNEQ_EXPR:
2442       return LTGT_EXPR;
2443     case UNGT_EXPR:
2444       return LE_EXPR;
2445     case UNGE_EXPR:
2446       return LT_EXPR;
2447     case UNLT_EXPR:
2448       return GE_EXPR;
2449     case UNLE_EXPR:
2450       return GT_EXPR;
2451     case ORDERED_EXPR:
2452       return UNORDERED_EXPR;
2453     case UNORDERED_EXPR:
2454       return ORDERED_EXPR;
2455     default:
2456       gcc_unreachable ();
2457     }
2458 }
2459
2460 /* Similar, but return the comparison that results if the operands are
2461    swapped.  This is safe for floating-point.  */
2462
2463 enum tree_code
2464 swap_tree_comparison (enum tree_code code)
2465 {
2466   switch (code)
2467     {
2468     case EQ_EXPR:
2469     case NE_EXPR:
2470     case ORDERED_EXPR:
2471     case UNORDERED_EXPR:
2472     case LTGT_EXPR:
2473     case UNEQ_EXPR:
2474       return code;
2475     case GT_EXPR:
2476       return LT_EXPR;
2477     case GE_EXPR:
2478       return LE_EXPR;
2479     case LT_EXPR:
2480       return GT_EXPR;
2481     case LE_EXPR:
2482       return GE_EXPR;
2483     case UNGT_EXPR:
2484       return UNLT_EXPR;
2485     case UNGE_EXPR:
2486       return UNLE_EXPR;
2487     case UNLT_EXPR:
2488       return UNGT_EXPR;
2489     case UNLE_EXPR:
2490       return UNGE_EXPR;
2491     default:
2492       gcc_unreachable ();
2493     }
2494 }
2495
2496
2497 /* Convert a comparison tree code from an enum tree_code representation
2498    into a compcode bit-based encoding.  This function is the inverse of
2499    compcode_to_comparison.  */
2500
2501 static enum comparison_code
2502 comparison_to_compcode (enum tree_code code)
2503 {
2504   switch (code)
2505     {
2506     case LT_EXPR:
2507       return COMPCODE_LT;
2508     case EQ_EXPR:
2509       return COMPCODE_EQ;
2510     case LE_EXPR:
2511       return COMPCODE_LE;
2512     case GT_EXPR:
2513       return COMPCODE_GT;
2514     case NE_EXPR:
2515       return COMPCODE_NE;
2516     case GE_EXPR:
2517       return COMPCODE_GE;
2518     case ORDERED_EXPR:
2519       return COMPCODE_ORD;
2520     case UNORDERED_EXPR:
2521       return COMPCODE_UNORD;
2522     case UNLT_EXPR:
2523       return COMPCODE_UNLT;
2524     case UNEQ_EXPR:
2525       return COMPCODE_UNEQ;
2526     case UNLE_EXPR:
2527       return COMPCODE_UNLE;
2528     case UNGT_EXPR:
2529       return COMPCODE_UNGT;
2530     case LTGT_EXPR:
2531       return COMPCODE_LTGT;
2532     case UNGE_EXPR:
2533       return COMPCODE_UNGE;
2534     default:
2535       gcc_unreachable ();
2536     }
2537 }
2538
2539 /* Convert a compcode bit-based encoding of a comparison operator back
2540    to GCC's enum tree_code representation.  This function is the
2541    inverse of comparison_to_compcode.  */
2542
2543 static enum tree_code
2544 compcode_to_comparison (enum comparison_code code)
2545 {
2546   switch (code)
2547     {
2548     case COMPCODE_LT:
2549       return LT_EXPR;
2550     case COMPCODE_EQ:
2551       return EQ_EXPR;
2552     case COMPCODE_LE:
2553       return LE_EXPR;
2554     case COMPCODE_GT:
2555       return GT_EXPR;
2556     case COMPCODE_NE:
2557       return NE_EXPR;
2558     case COMPCODE_GE:
2559       return GE_EXPR;
2560     case COMPCODE_ORD:
2561       return ORDERED_EXPR;
2562     case COMPCODE_UNORD:
2563       return UNORDERED_EXPR;
2564     case COMPCODE_UNLT:
2565       return UNLT_EXPR;
2566     case COMPCODE_UNEQ:
2567       return UNEQ_EXPR;
2568     case COMPCODE_UNLE:
2569       return UNLE_EXPR;
2570     case COMPCODE_UNGT:
2571       return UNGT_EXPR;
2572     case COMPCODE_LTGT:
2573       return LTGT_EXPR;
2574     case COMPCODE_UNGE:
2575       return UNGE_EXPR;
2576     default:
2577       gcc_unreachable ();
2578     }
2579 }
2580
2581 /* Return a tree for the comparison which is the combination of
2582    doing the AND or OR (depending on CODE) of the two operations LCODE
2583    and RCODE on the identical operands LL_ARG and LR_ARG.  Take into account
2584    the possibility of trapping if the mode has NaNs, and return NULL_TREE
2585    if this makes the transformation invalid.  */
2586
2587 tree
2588 combine_comparisons (location_t loc,
2589                      enum tree_code code, enum tree_code lcode,
2590                      enum tree_code rcode, tree truth_type,
2591                      tree ll_arg, tree lr_arg)
2592 {
2593   bool honor_nans = HONOR_NANS (ll_arg);
2594   enum comparison_code lcompcode = comparison_to_compcode (lcode);
2595   enum comparison_code rcompcode = comparison_to_compcode (rcode);
2596   int compcode;
2597
2598   switch (code)
2599     {
2600     case TRUTH_AND_EXPR: case TRUTH_ANDIF_EXPR:
2601       compcode = lcompcode & rcompcode;
2602       break;
2603
2604     case TRUTH_OR_EXPR: case TRUTH_ORIF_EXPR:
2605       compcode = lcompcode | rcompcode;
2606       break;
2607
2608     default:
2609       return NULL_TREE;
2610     }
2611
2612   if (!honor_nans)
2613     {
2614       /* Eliminate unordered comparisons, as well as LTGT and ORD
2615          which are not used unless the mode has NaNs.  */
2616       compcode &= ~COMPCODE_UNORD;
2617       if (compcode == COMPCODE_LTGT)
2618         compcode = COMPCODE_NE;
2619       else if (compcode == COMPCODE_ORD)
2620         compcode = COMPCODE_TRUE;
2621     }
2622    else if (flag_trapping_math)
2623      {
2624         /* Check that the original operation and the optimized ones will trap
2625            under the same condition.  */
2626         bool ltrap = (lcompcode & COMPCODE_UNORD) == 0
2627                      && (lcompcode != COMPCODE_EQ)
2628                      && (lcompcode != COMPCODE_ORD);
2629         bool rtrap = (rcompcode & COMPCODE_UNORD) == 0
2630                      && (rcompcode != COMPCODE_EQ)
2631                      && (rcompcode != COMPCODE_ORD);
2632         bool trap = (compcode & COMPCODE_UNORD) == 0
2633                     && (compcode != COMPCODE_EQ)
2634                     && (compcode != COMPCODE_ORD);
2635
2636         /* In a short-circuited boolean expression the LHS might be
2637            such that the RHS, if evaluated, will never trap.  For
2638            example, in ORD (x, y) && (x < y), we evaluate the RHS only
2639            if neither x nor y is NaN.  (This is a mixed blessing: for
2640            example, the expression above will never trap, hence
2641            optimizing it to x < y would be invalid).  */
2642         if ((code == TRUTH_ORIF_EXPR && (lcompcode & COMPCODE_UNORD))
2643             || (code == TRUTH_ANDIF_EXPR && !(lcompcode & COMPCODE_UNORD)))
2644           rtrap = false;
2645
2646         /* If the comparison was short-circuited, and only the RHS
2647            trapped, we may now generate a spurious trap.  */
2648         if (rtrap && !ltrap
2649             && (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR))
2650           return NULL_TREE;
2651
2652         /* If we changed the conditions that cause a trap, we lose.  */
2653         if ((ltrap || rtrap) != trap)
2654           return NULL_TREE;
2655       }
2656
2657   if (compcode == COMPCODE_TRUE)
2658     return constant_boolean_node (true, truth_type);
2659   else if (compcode == COMPCODE_FALSE)
2660     return constant_boolean_node (false, truth_type);
2661   else
2662     {
2663       enum tree_code tcode;
2664
2665       tcode = compcode_to_comparison ((enum comparison_code) compcode);
2666       return fold_build2_loc (loc, tcode, truth_type, ll_arg, lr_arg);
2667     }
2668 }
2669 \f
2670 /* Return nonzero if two operands (typically of the same tree node)
2671    are necessarily equal.  If either argument has side-effects this
2672    function returns zero.  FLAGS modifies behavior as follows:
2673
2674    If OEP_ONLY_CONST is set, only return nonzero for constants.
2675    This function tests whether the operands are indistinguishable;
2676    it does not test whether they are equal using C's == operation.
2677    The distinction is important for IEEE floating point, because
2678    (1) -0.0 and 0.0 are distinguishable, but -0.0==0.0, and
2679    (2) two NaNs may be indistinguishable, but NaN!=NaN.
2680
2681    If OEP_ONLY_CONST is unset, a VAR_DECL is considered equal to itself
2682    even though it may hold multiple values during a function.
2683    This is because a GCC tree node guarantees that nothing else is
2684    executed between the evaluation of its "operands" (which may often
2685    be evaluated in arbitrary order).  Hence if the operands themselves
2686    don't side-effect, the VAR_DECLs, PARM_DECLs etc... must hold the
2687    same value in each operand/subexpression.  Hence leaving OEP_ONLY_CONST
2688    unset means assuming isochronic (or instantaneous) tree equivalence.
2689    Unless comparing arbitrary expression trees, such as from different
2690    statements, this flag can usually be left unset.
2691
2692    If OEP_PURE_SAME is set, then pure functions with identical arguments
2693    are considered the same.  It is used when the caller has other ways
2694    to ensure that global memory is unchanged in between.  */
2695
2696 int
2697 operand_equal_p (const_tree arg0, const_tree arg1, unsigned int flags)
2698 {
2699   /* If either is ERROR_MARK, they aren't equal.  */
2700   if (TREE_CODE (arg0) == ERROR_MARK || TREE_CODE (arg1) == ERROR_MARK
2701       || TREE_TYPE (arg0) == error_mark_node
2702       || TREE_TYPE (arg1) == error_mark_node)
2703     return 0;
2704
2705   /* Similar, if either does not have a type (like a released SSA name),
2706      they aren't equal.  */
2707   if (!TREE_TYPE (arg0) || !TREE_TYPE (arg1))
2708     return 0;
2709
2710   /* Check equality of integer constants before bailing out due to
2711      precision differences.  */
2712   if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
2713     return tree_int_cst_equal (arg0, arg1);
2714
2715   /* If both types don't have the same signedness, then we can't consider
2716      them equal.  We must check this before the STRIP_NOPS calls
2717      because they may change the signedness of the arguments.  As pointers
2718      strictly don't have a signedness, require either two pointers or
2719      two non-pointers as well.  */
2720   if (TYPE_UNSIGNED (TREE_TYPE (arg0)) != TYPE_UNSIGNED (TREE_TYPE (arg1))
2721       || POINTER_TYPE_P (TREE_TYPE (arg0)) != POINTER_TYPE_P (TREE_TYPE (arg1)))
2722     return 0;
2723
2724   /* We cannot consider pointers to different address space equal.  */
2725   if (POINTER_TYPE_P (TREE_TYPE (arg0)) && POINTER_TYPE_P (TREE_TYPE (arg1))
2726       && (TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (arg0)))
2727           != TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (arg1)))))
2728     return 0;
2729
2730   /* If both types don't have the same precision, then it is not safe
2731      to strip NOPs.  */
2732   if (element_precision (TREE_TYPE (arg0))
2733       != element_precision (TREE_TYPE (arg1)))
2734     return 0;
2735
2736   STRIP_NOPS (arg0);
2737   STRIP_NOPS (arg1);
2738
2739   /* In case both args are comparisons but with different comparison
2740      code, try to swap the comparison operands of one arg to produce
2741      a match and compare that variant.  */
2742   if (TREE_CODE (arg0) != TREE_CODE (arg1)
2743       && COMPARISON_CLASS_P (arg0)
2744       && COMPARISON_CLASS_P (arg1))
2745     {
2746       enum tree_code swap_code = swap_tree_comparison (TREE_CODE (arg1));
2747
2748       if (TREE_CODE (arg0) == swap_code)
2749         return operand_equal_p (TREE_OPERAND (arg0, 0),
2750                                 TREE_OPERAND (arg1, 1), flags)
2751                && operand_equal_p (TREE_OPERAND (arg0, 1),
2752                                    TREE_OPERAND (arg1, 0), flags);
2753     }
2754
2755   if (TREE_CODE (arg0) != TREE_CODE (arg1)
2756       /* NOP_EXPR and CONVERT_EXPR are considered equal.  */
2757       && !(CONVERT_EXPR_P (arg0) && CONVERT_EXPR_P (arg1)))
2758     return 0;
2759
2760   /* This is needed for conversions and for COMPONENT_REF.
2761      Might as well play it safe and always test this.  */
2762   if (TREE_CODE (TREE_TYPE (arg0)) == ERROR_MARK
2763       || TREE_CODE (TREE_TYPE (arg1)) == ERROR_MARK
2764       || TYPE_MODE (TREE_TYPE (arg0)) != TYPE_MODE (TREE_TYPE (arg1)))
2765     return 0;
2766
2767   /* If ARG0 and ARG1 are the same SAVE_EXPR, they are necessarily equal.
2768      We don't care about side effects in that case because the SAVE_EXPR
2769      takes care of that for us. In all other cases, two expressions are
2770      equal if they have no side effects.  If we have two identical
2771      expressions with side effects that should be treated the same due
2772      to the only side effects being identical SAVE_EXPR's, that will
2773      be detected in the recursive calls below.
2774      If we are taking an invariant address of two identical objects
2775      they are necessarily equal as well.  */
2776   if (arg0 == arg1 && ! (flags & OEP_ONLY_CONST)
2777       && (TREE_CODE (arg0) == SAVE_EXPR
2778           || (flags & OEP_CONSTANT_ADDRESS_OF)
2779           || (! TREE_SIDE_EFFECTS (arg0) && ! TREE_SIDE_EFFECTS (arg1))))
2780     return 1;
2781
2782   /* Next handle constant cases, those for which we can return 1 even
2783      if ONLY_CONST is set.  */
2784   if (TREE_CONSTANT (arg0) && TREE_CONSTANT (arg1))
2785     switch (TREE_CODE (arg0))
2786       {
2787       case INTEGER_CST:
2788         return tree_int_cst_equal (arg0, arg1);
2789
2790       case FIXED_CST:
2791         return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (arg0),
2792                                        TREE_FIXED_CST (arg1));
2793
2794       case REAL_CST:
2795         if (REAL_VALUES_IDENTICAL (TREE_REAL_CST (arg0),
2796                                    TREE_REAL_CST (arg1)))
2797           return 1;
2798
2799
2800         if (!HONOR_SIGNED_ZEROS (arg0))
2801           {
2802             /* If we do not distinguish between signed and unsigned zero,
2803                consider them equal.  */
2804             if (real_zerop (arg0) && real_zerop (arg1))
2805               return 1;
2806           }
2807         return 0;
2808
2809       case VECTOR_CST:
2810         {
2811           unsigned i;
2812
2813           if (VECTOR_CST_NELTS (arg0) != VECTOR_CST_NELTS (arg1))
2814             return 0;
2815
2816           for (i = 0; i < VECTOR_CST_NELTS (arg0); ++i)
2817             {
2818               if (!operand_equal_p (VECTOR_CST_ELT (arg0, i),
2819                                     VECTOR_CST_ELT (arg1, i), flags))
2820                 return 0;
2821             }
2822           return 1;
2823         }
2824
2825       case COMPLEX_CST:
2826         return (operand_equal_p (TREE_REALPART (arg0), TREE_REALPART (arg1),
2827                                  flags)
2828                 && operand_equal_p (TREE_IMAGPART (arg0), TREE_IMAGPART (arg1),
2829                                     flags));
2830
2831       case STRING_CST:
2832         return (TREE_STRING_LENGTH (arg0) == TREE_STRING_LENGTH (arg1)
2833                 && ! memcmp (TREE_STRING_POINTER (arg0),
2834                               TREE_STRING_POINTER (arg1),
2835                               TREE_STRING_LENGTH (arg0)));
2836
2837       case ADDR_EXPR:
2838         return operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1, 0),
2839                                 TREE_CONSTANT (arg0) && TREE_CONSTANT (arg1)
2840                                 ? OEP_CONSTANT_ADDRESS_OF | OEP_ADDRESS_OF : 0);
2841       default:
2842         break;
2843       }
2844
2845   if (flags & OEP_ONLY_CONST)
2846     return 0;
2847
2848 /* Define macros to test an operand from arg0 and arg1 for equality and a
2849    variant that allows null and views null as being different from any
2850    non-null value.  In the latter case, if either is null, the both
2851    must be; otherwise, do the normal comparison.  */
2852 #define OP_SAME(N) operand_equal_p (TREE_OPERAND (arg0, N),     \
2853                                     TREE_OPERAND (arg1, N), flags)
2854
2855 #define OP_SAME_WITH_NULL(N)                            \
2856   ((!TREE_OPERAND (arg0, N) || !TREE_OPERAND (arg1, N)) \
2857    ? TREE_OPERAND (arg0, N) == TREE_OPERAND (arg1, N) : OP_SAME (N))
2858
2859   switch (TREE_CODE_CLASS (TREE_CODE (arg0)))
2860     {
2861     case tcc_unary:
2862       /* Two conversions are equal only if signedness and modes match.  */
2863       switch (TREE_CODE (arg0))
2864         {
2865         CASE_CONVERT:
2866         case FIX_TRUNC_EXPR:
2867           if (TYPE_UNSIGNED (TREE_TYPE (arg0))
2868               != TYPE_UNSIGNED (TREE_TYPE (arg1)))
2869             return 0;
2870           break;
2871         default:
2872           break;
2873         }
2874
2875       return OP_SAME (0);
2876
2877
2878     case tcc_comparison:
2879     case tcc_binary:
2880       if (OP_SAME (0) && OP_SAME (1))
2881         return 1;
2882
2883       /* For commutative ops, allow the other order.  */
2884       return (commutative_tree_code (TREE_CODE (arg0))
2885               && operand_equal_p (TREE_OPERAND (arg0, 0),
2886                                   TREE_OPERAND (arg1, 1), flags)
2887               && operand_equal_p (TREE_OPERAND (arg0, 1),
2888                                   TREE_OPERAND (arg1, 0), flags));
2889
2890     case tcc_reference:
2891       /* If either of the pointer (or reference) expressions we are
2892          dereferencing contain a side effect, these cannot be equal,
2893          but their addresses can be.  */
2894       if ((flags & OEP_CONSTANT_ADDRESS_OF) == 0
2895           && (TREE_SIDE_EFFECTS (arg0)
2896               || TREE_SIDE_EFFECTS (arg1)))
2897         return 0;
2898
2899       switch (TREE_CODE (arg0))
2900         {
2901         case INDIRECT_REF:
2902           if (!(flags & OEP_ADDRESS_OF)
2903               && (TYPE_ALIGN (TREE_TYPE (arg0))
2904                   != TYPE_ALIGN (TREE_TYPE (arg1))))
2905             return 0;
2906           flags &= ~(OEP_CONSTANT_ADDRESS_OF|OEP_ADDRESS_OF);
2907           return OP_SAME (0);
2908
2909         case REALPART_EXPR:
2910         case IMAGPART_EXPR:
2911           return OP_SAME (0);
2912
2913         case TARGET_MEM_REF:
2914         case MEM_REF:
2915           /* Require equal access sizes, and similar pointer types.
2916              We can have incomplete types for array references of
2917              variable-sized arrays from the Fortran frontend
2918              though.  Also verify the types are compatible.  */
2919           if (!((TYPE_SIZE (TREE_TYPE (arg0)) == TYPE_SIZE (TREE_TYPE (arg1))
2920                    || (TYPE_SIZE (TREE_TYPE (arg0))
2921                        && TYPE_SIZE (TREE_TYPE (arg1))
2922                        && operand_equal_p (TYPE_SIZE (TREE_TYPE (arg0)),
2923                                            TYPE_SIZE (TREE_TYPE (arg1)), flags)))
2924                   && types_compatible_p (TREE_TYPE (arg0), TREE_TYPE (arg1))
2925                   && ((flags & OEP_ADDRESS_OF)
2926                       || (alias_ptr_types_compatible_p
2927                             (TREE_TYPE (TREE_OPERAND (arg0, 1)),
2928                              TREE_TYPE (TREE_OPERAND (arg1, 1)))
2929                           && (MR_DEPENDENCE_CLIQUE (arg0)
2930                               == MR_DEPENDENCE_CLIQUE (arg1))
2931                           && (MR_DEPENDENCE_BASE (arg0)
2932                               == MR_DEPENDENCE_BASE (arg1))
2933                           && (TYPE_ALIGN (TREE_TYPE (arg0))
2934                             == TYPE_ALIGN (TREE_TYPE (arg1)))))))
2935             return 0;
2936           flags &= ~(OEP_CONSTANT_ADDRESS_OF|OEP_ADDRESS_OF);
2937           return (OP_SAME (0) && OP_SAME (1)
2938                   /* TARGET_MEM_REF require equal extra operands.  */
2939                   && (TREE_CODE (arg0) != TARGET_MEM_REF
2940                       || (OP_SAME_WITH_NULL (2)
2941                           && OP_SAME_WITH_NULL (3)
2942                           && OP_SAME_WITH_NULL (4))));
2943
2944         case ARRAY_REF:
2945         case ARRAY_RANGE_REF:
2946           /* Operands 2 and 3 may be null.
2947              Compare the array index by value if it is constant first as we
2948              may have different types but same value here.  */
2949           if (!OP_SAME (0))
2950             return 0;
2951           flags &= ~(OEP_CONSTANT_ADDRESS_OF|OEP_ADDRESS_OF);
2952           return ((tree_int_cst_equal (TREE_OPERAND (arg0, 1),
2953                                        TREE_OPERAND (arg1, 1))
2954                    || OP_SAME (1))
2955                   && OP_SAME_WITH_NULL (2)
2956                   && OP_SAME_WITH_NULL (3));
2957
2958         case COMPONENT_REF:
2959           /* Handle operand 2 the same as for ARRAY_REF.  Operand 0
2960              may be NULL when we're called to compare MEM_EXPRs.  */
2961           if (!OP_SAME_WITH_NULL (0)
2962               || !OP_SAME (1))
2963             return 0;
2964           flags &= ~(OEP_CONSTANT_ADDRESS_OF|OEP_ADDRESS_OF);
2965           return OP_SAME_WITH_NULL (2);
2966
2967         case BIT_FIELD_REF:
2968           if (!OP_SAME (0))
2969             return 0;
2970           flags &= ~(OEP_CONSTANT_ADDRESS_OF|OEP_ADDRESS_OF);
2971           return OP_SAME (1) && OP_SAME (2);
2972
2973         default:
2974           return 0;
2975         }
2976
2977     case tcc_expression:
2978       switch (TREE_CODE (arg0))
2979         {
2980         case ADDR_EXPR:
2981           return operand_equal_p (TREE_OPERAND (arg0, 0),
2982                                   TREE_OPERAND (arg1, 0),
2983                                   flags | OEP_ADDRESS_OF);
2984
2985         case TRUTH_NOT_EXPR:
2986           return OP_SAME (0);
2987
2988         case TRUTH_ANDIF_EXPR:
2989         case TRUTH_ORIF_EXPR:
2990           return OP_SAME (0) && OP_SAME (1);
2991
2992         case FMA_EXPR:
2993         case WIDEN_MULT_PLUS_EXPR:
2994         case WIDEN_MULT_MINUS_EXPR:
2995           if (!OP_SAME (2))
2996             return 0;
2997           /* The multiplcation operands are commutative.  */
2998           /* FALLTHRU */
2999
3000         case TRUTH_AND_EXPR:
3001         case TRUTH_OR_EXPR:
3002         case TRUTH_XOR_EXPR:
3003           if (OP_SAME (0) && OP_SAME (1))
3004             return 1;
3005
3006           /* Otherwise take into account this is a commutative operation.  */
3007           return (operand_equal_p (TREE_OPERAND (arg0, 0),
3008                                    TREE_OPERAND (arg1, 1), flags)
3009                   && operand_equal_p (TREE_OPERAND (arg0, 1),
3010                                       TREE_OPERAND (arg1, 0), flags));
3011
3012         case COND_EXPR:
3013         case VEC_COND_EXPR:
3014         case DOT_PROD_EXPR:
3015           return OP_SAME (0) && OP_SAME (1) && OP_SAME (2);
3016
3017         default:
3018           return 0;
3019         }
3020
3021     case tcc_vl_exp:
3022       switch (TREE_CODE (arg0))
3023         {
3024         case CALL_EXPR:
3025           if ((CALL_EXPR_FN (arg0) == NULL_TREE)
3026               != (CALL_EXPR_FN (arg1) == NULL_TREE))
3027             /* If not both CALL_EXPRs are either internal or normal function
3028                functions, then they are not equal.  */
3029             return 0;
3030           else if (CALL_EXPR_FN (arg0) == NULL_TREE)
3031             {
3032               /* If the CALL_EXPRs call different internal functions, then they
3033                  are not equal.  */
3034               if (CALL_EXPR_IFN (arg0) != CALL_EXPR_IFN (arg1))
3035                 return 0;
3036             }
3037           else
3038             {
3039               /* If the CALL_EXPRs call different functions, then they are not
3040                  equal.  */
3041               if (! operand_equal_p (CALL_EXPR_FN (arg0), CALL_EXPR_FN (arg1),
3042                                      flags))
3043                 return 0;
3044             }
3045
3046           {
3047             unsigned int cef = call_expr_flags (arg0);
3048             if (flags & OEP_PURE_SAME)
3049               cef &= ECF_CONST | ECF_PURE;
3050             else
3051               cef &= ECF_CONST;
3052             if (!cef)
3053               return 0;
3054           }
3055
3056           /* Now see if all the arguments are the same.  */
3057           {
3058             const_call_expr_arg_iterator iter0, iter1;
3059             const_tree a0, a1;
3060             for (a0 = first_const_call_expr_arg (arg0, &iter0),
3061                    a1 = first_const_call_expr_arg (arg1, &iter1);
3062                  a0 && a1;
3063                  a0 = next_const_call_expr_arg (&iter0),
3064                    a1 = next_const_call_expr_arg (&iter1))
3065               if (! operand_equal_p (a0, a1, flags))
3066                 return 0;
3067
3068             /* If we get here and both argument lists are exhausted
3069                then the CALL_EXPRs are equal.  */
3070             return ! (a0 || a1);
3071           }
3072         default:
3073           return 0;
3074         }
3075
3076     case tcc_declaration:
3077       /* Consider __builtin_sqrt equal to sqrt.  */
3078       return (TREE_CODE (arg0) == FUNCTION_DECL
3079               && DECL_BUILT_IN (arg0) && DECL_BUILT_IN (arg1)
3080               && DECL_BUILT_IN_CLASS (arg0) == DECL_BUILT_IN_CLASS (arg1)
3081               && DECL_FUNCTION_CODE (arg0) == DECL_FUNCTION_CODE (arg1));
3082
3083     default:
3084       return 0;
3085     }
3086
3087 #undef OP_SAME
3088 #undef OP_SAME_WITH_NULL
3089 }
3090 \f
3091 /* Similar to operand_equal_p, but see if ARG0 might have been made by
3092    shorten_compare from ARG1 when ARG1 was being compared with OTHER.
3093
3094    When in doubt, return 0.  */
3095
3096 static int
3097 operand_equal_for_comparison_p (tree arg0, tree arg1, tree other)
3098 {
3099   int unsignedp1, unsignedpo;
3100   tree primarg0, primarg1, primother;
3101   unsigned int correct_width;
3102
3103   if (operand_equal_p (arg0, arg1, 0))
3104     return 1;
3105
3106   if (! INTEGRAL_TYPE_P (TREE_TYPE (arg0))
3107       || ! INTEGRAL_TYPE_P (TREE_TYPE (arg1)))
3108     return 0;
3109
3110   /* Discard any conversions that don't change the modes of ARG0 and ARG1
3111      and see if the inner values are the same.  This removes any
3112      signedness comparison, which doesn't matter here.  */
3113   primarg0 = arg0, primarg1 = arg1;
3114   STRIP_NOPS (primarg0);
3115   STRIP_NOPS (primarg1);
3116   if (operand_equal_p (primarg0, primarg1, 0))
3117     return 1;
3118
3119   /* Duplicate what shorten_compare does to ARG1 and see if that gives the
3120      actual comparison operand, ARG0.
3121
3122      First throw away any conversions to wider types
3123      already present in the operands.  */
3124
3125   primarg1 = get_narrower (arg1, &unsignedp1);
3126   primother = get_narrower (other, &unsignedpo);
3127
3128   correct_width = TYPE_PRECISION (TREE_TYPE (arg1));
3129   if (unsignedp1 == unsignedpo
3130       && TYPE_PRECISION (TREE_TYPE (primarg1)) < correct_width
3131       && TYPE_PRECISION (TREE_TYPE (primother)) < correct_width)
3132     {
3133       tree type = TREE_TYPE (arg0);
3134
3135       /* Make sure shorter operand is extended the right way
3136          to match the longer operand.  */
3137       primarg1 = fold_convert (signed_or_unsigned_type_for
3138                                (unsignedp1, TREE_TYPE (primarg1)), primarg1);
3139
3140       if (operand_equal_p (arg0, fold_convert (type, primarg1), 0))
3141         return 1;
3142     }
3143
3144   return 0;
3145 }
3146 \f
3147 /* See if ARG is an expression that is either a comparison or is performing
3148    arithmetic on comparisons.  The comparisons must only be comparing
3149    two different values, which will be stored in *CVAL1 and *CVAL2; if
3150    they are nonzero it means that some operands have already been found.
3151    No variables may be used anywhere else in the expression except in the
3152    comparisons.  If SAVE_P is true it means we removed a SAVE_EXPR around
3153    the expression and save_expr needs to be called with CVAL1 and CVAL2.
3154
3155    If this is true, return 1.  Otherwise, return zero.  */
3156
3157 static int
3158 twoval_comparison_p (tree arg, tree *cval1, tree *cval2, int *save_p)
3159 {
3160   enum tree_code code = TREE_CODE (arg);
3161   enum tree_code_class tclass = TREE_CODE_CLASS (code);
3162
3163   /* We can handle some of the tcc_expression cases here.  */
3164   if (tclass == tcc_expression && code == TRUTH_NOT_EXPR)
3165     tclass = tcc_unary;
3166   else if (tclass == tcc_expression
3167            && (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR
3168                || code == COMPOUND_EXPR))
3169     tclass = tcc_binary;
3170
3171   else if (tclass == tcc_expression && code == SAVE_EXPR
3172            && ! TREE_SIDE_EFFECTS (TREE_OPERAND (arg, 0)))
3173     {
3174       /* If we've already found a CVAL1 or CVAL2, this expression is
3175          two complex to handle.  */
3176       if (*cval1 || *cval2)
3177         return 0;
3178
3179       tclass = tcc_unary;
3180       *save_p = 1;
3181     }
3182
3183   switch (tclass)
3184     {
3185     case tcc_unary:
3186       return twoval_comparison_p (TREE_OPERAND (arg, 0), cval1, cval2, save_p);
3187
3188     case tcc_binary:
3189       return (twoval_comparison_p (TREE_OPERAND (arg, 0), cval1, cval2, save_p)
3190               && twoval_comparison_p (TREE_OPERAND (arg, 1),
3191                                       cval1, cval2, save_p));
3192
3193     case tcc_constant:
3194       return 1;
3195
3196     case tcc_expression:
3197       if (code == COND_EXPR)
3198         return (twoval_comparison_p (TREE_OPERAND (arg, 0),
3199                                      cval1, cval2, save_p)
3200                 && twoval_comparison_p (TREE_OPERAND (arg, 1),
3201                                         cval1, cval2, save_p)
3202                 && twoval_comparison_p (TREE_OPERAND (arg, 2),
3203                                         cval1, cval2, save_p));
3204       return 0;
3205
3206     case tcc_comparison:
3207       /* First see if we can handle the first operand, then the second.  For
3208          the second operand, we know *CVAL1 can't be zero.  It must be that
3209          one side of the comparison is each of the values; test for the
3210          case where this isn't true by failing if the two operands
3211          are the same.  */
3212
3213       if (operand_equal_p (TREE_OPERAND (arg, 0),
3214                            TREE_OPERAND (arg, 1), 0))
3215         return 0;
3216
3217       if (*cval1 == 0)
3218         *cval1 = TREE_OPERAND (arg, 0);
3219       else if (operand_equal_p (*cval1, TREE_OPERAND (arg, 0), 0))
3220         ;
3221       else if (*cval2 == 0)
3222         *cval2 = TREE_OPERAND (arg, 0);
3223       else if (operand_equal_p (*cval2, TREE_OPERAND (arg, 0), 0))
3224         ;
3225       else
3226         return 0;
3227
3228       if (operand_equal_p (*cval1, TREE_OPERAND (arg, 1), 0))
3229         ;
3230       else if (*cval2 == 0)
3231         *cval2 = TREE_OPERAND (arg, 1);
3232       else if (operand_equal_p (*cval2, TREE_OPERAND (arg, 1), 0))
3233         ;
3234       else
3235         return 0;
3236
3237       return 1;
3238
3239     default:
3240       return 0;
3241     }
3242 }
3243 \f
3244 /* ARG is a tree that is known to contain just arithmetic operations and
3245    comparisons.  Evaluate the operations in the tree substituting NEW0 for
3246    any occurrence of OLD0 as an operand of a comparison and likewise for
3247    NEW1 and OLD1.  */
3248
3249 static tree
3250 eval_subst (location_t loc, tree arg, tree old0, tree new0,
3251             tree old1, tree new1)
3252 {
3253   tree type = TREE_TYPE (arg);
3254   enum tree_code code = TREE_CODE (arg);
3255   enum tree_code_class tclass = TREE_CODE_CLASS (code);
3256
3257   /* We can handle some of the tcc_expression cases here.  */
3258   if (tclass == tcc_expression && code == TRUTH_NOT_EXPR)
3259     tclass = tcc_unary;
3260   else if (tclass == tcc_expression
3261            && (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR))
3262     tclass = tcc_binary;
3263
3264   switch (tclass)
3265     {
3266     case tcc_unary:
3267       return fold_build1_loc (loc, code, type,
3268                           eval_subst (loc, TREE_OPERAND (arg, 0),
3269                                       old0, new0, old1, new1));
3270
3271     case tcc_binary:
3272       return fold_build2_loc (loc, code, type,
3273                           eval_subst (loc, TREE_OPERAND (arg, 0),
3274                                       old0, new0, old1, new1),
3275                           eval_subst (loc, TREE_OPERAND (arg, 1),
3276                                       old0, new0, old1, new1));
3277
3278     case tcc_expression:
3279       switch (code)
3280         {
3281         case SAVE_EXPR:
3282           return eval_subst (loc, TREE_OPERAND (arg, 0), old0, new0,
3283                              old1, new1);
3284
3285         case COMPOUND_EXPR:
3286           return eval_subst (loc, TREE_OPERAND (arg, 1), old0, new0,
3287                              old1, new1);
3288
3289         case COND_EXPR:
3290           return fold_build3_loc (loc, code, type,
3291                               eval_subst (loc, TREE_OPERAND (arg, 0),
3292                                           old0, new0, old1, new1),
3293                               eval_subst (loc, TREE_OPERAND (arg, 1),
3294                                           old0, new0, old1, new1),
3295                               eval_subst (loc, TREE_OPERAND (arg, 2),
3296                                           old0, new0, old1, new1));
3297         default:
3298           break;
3299         }
3300       /* Fall through - ???  */
3301
3302     case tcc_comparison:
3303       {
3304         tree arg0 = TREE_OPERAND (arg, 0);
3305         tree arg1 = TREE_OPERAND (arg, 1);
3306
3307         /* We need to check both for exact equality and tree equality.  The
3308            former will be true if the operand has a side-effect.  In that
3309            case, we know the operand occurred exactly once.  */
3310
3311         if (arg0 == old0 || operand_equal_p (arg0, old0, 0))
3312           arg0 = new0;
3313         else if (arg0 == old1 || operand_equal_p (arg0, old1, 0))
3314           arg0 = new1;
3315
3316         if (arg1 == old0 || operand_equal_p (arg1, old0, 0))
3317           arg1 = new0;
3318         else if (arg1 == old1 || operand_equal_p (arg1, old1, 0))
3319           arg1 = new1;
3320
3321         return fold_build2_loc (loc, code, type, arg0, arg1);
3322       }
3323
3324     default:
3325       return arg;
3326     }
3327 }
3328 \f
3329 /* Return a tree for the case when the result of an expression is RESULT
3330    converted to TYPE and OMITTED was previously an operand of the expression
3331    but is now not needed (e.g., we folded OMITTED * 0).
3332
3333    If OMITTED has side effects, we must evaluate it.  Otherwise, just do
3334    the conversion of RESULT to TYPE.  */
3335
3336 tree
3337 omit_one_operand_loc (location_t loc, tree type, tree result, tree omitted)
3338 {
3339   tree t = fold_convert_loc (loc, type, result);
3340
3341   /* If the resulting operand is an empty statement, just return the omitted
3342      statement casted to void. */
3343   if (IS_EMPTY_STMT (t) && TREE_SIDE_EFFECTS (omitted))
3344     return build1_loc (loc, NOP_EXPR, void_type_node,
3345                        fold_ignored_result (omitted));
3346
3347   if (TREE_SIDE_EFFECTS (omitted))
3348     return build2_loc (loc, COMPOUND_EXPR, type,
3349                        fold_ignored_result (omitted), t);
3350
3351   return non_lvalue_loc (loc, t);
3352 }
3353
3354 /* Return a tree for the case when the result of an expression is RESULT
3355    converted to TYPE and OMITTED1 and OMITTED2 were previously operands
3356    of the expression but are now not needed.
3357
3358    If OMITTED1 or OMITTED2 has side effects, they must be evaluated.
3359    If both OMITTED1 and OMITTED2 have side effects, OMITTED1 is
3360    evaluated before OMITTED2.  Otherwise, if neither has side effects,
3361    just do the conversion of RESULT to TYPE.  */
3362
3363 tree
3364 omit_two_operands_loc (location_t loc, tree type, tree result,
3365                        tree omitted1, tree omitted2)
3366 {
3367   tree t = fold_convert_loc (loc, type, result);
3368
3369   if (TREE_SIDE_EFFECTS (omitted2))
3370     t = build2_loc (loc, COMPOUND_EXPR, type, omitted2, t);
3371   if (TREE_SIDE_EFFECTS (omitted1))
3372     t = build2_loc (loc, COMPOUND_EXPR, type, omitted1, t);
3373
3374   return TREE_CODE (t) != COMPOUND_EXPR ? non_lvalue_loc (loc, t) : t;
3375 }
3376
3377 \f
3378 /* Return a simplified tree node for the truth-negation of ARG.  This
3379    never alters ARG itself.  We assume that ARG is an operation that
3380    returns a truth value (0 or 1).
3381
3382    FIXME: one would think we would fold the result, but it causes
3383    problems with the dominator optimizer.  */
3384
3385 static tree
3386 fold_truth_not_expr (location_t loc, tree arg)
3387 {
3388   tree type = TREE_TYPE (arg);
3389   enum tree_code code = TREE_CODE (arg);
3390   location_t loc1, loc2;
3391
3392   /* If this is a comparison, we can simply invert it, except for
3393      floating-point non-equality comparisons, in which case we just
3394      enclose a TRUTH_NOT_EXPR around what we have.  */
3395
3396   if (TREE_CODE_CLASS (code) == tcc_comparison)
3397     {
3398       tree op_type = TREE_TYPE (TREE_OPERAND (arg, 0));
3399       if (FLOAT_TYPE_P (op_type)
3400           && flag_trapping_math
3401           && code != ORDERED_EXPR && code != UNORDERED_EXPR
3402           && code != NE_EXPR && code != EQ_EXPR)
3403         return NULL_TREE;
3404
3405       code = invert_tree_comparison (code, HONOR_NANS (op_type));
3406       if (code == ERROR_MARK)
3407         return NULL_TREE;
3408
3409       return build2_loc (loc, code, type, TREE_OPERAND (arg, 0),
3410                          TREE_OPERAND (arg, 1));
3411     }
3412
3413   switch (code)
3414     {
3415     case INTEGER_CST:
3416       return constant_boolean_node (integer_zerop (arg), type);
3417
3418     case TRUTH_AND_EXPR:
3419       loc1 = expr_location_or (TREE_OPERAND (arg, 0), loc);
3420       loc2 = expr_location_or (TREE_OPERAND (arg, 1), loc);
3421       return build2_loc (loc, TRUTH_OR_EXPR, type,
3422                          invert_truthvalue_loc (loc1, TREE_OPERAND (arg, 0)),
3423                          invert_truthvalue_loc (loc2, TREE_OPERAND (arg, 1)));
3424
3425     case TRUTH_OR_EXPR:
3426       loc1 = expr_location_or (TREE_OPERAND (arg, 0), loc);
3427       loc2 = expr_location_or (TREE_OPERAND (arg, 1), loc);
3428       return build2_loc (loc, TRUTH_AND_EXPR, type,
3429                          invert_truthvalue_loc (loc1, TREE_OPERAND (arg, 0)),
3430                          invert_truthvalue_loc (loc2, TREE_OPERAND (arg, 1)));
3431
3432     case TRUTH_XOR_EXPR:
3433       /* Here we can invert either operand.  We invert the first operand
3434          unless the second operand is a TRUTH_NOT_EXPR in which case our
3435          result is the XOR of the first operand with the inside of the
3436          negation of the second operand.  */
3437
3438       if (TREE_CODE (TREE_OPERAND (arg, 1)) == TRUTH_NOT_EXPR)
3439         return build2_loc (loc, TRUTH_XOR_EXPR, type, TREE_OPERAND (arg, 0),
3440                            TREE_OPERAND (TREE_OPERAND (arg, 1), 0));
3441       else
3442         return build2_loc (loc, TRUTH_XOR_EXPR, type,
3443                            invert_truthvalue_loc (loc, TREE_OPERAND (arg, 0)),
3444                            TREE_OPERAND (arg, 1));
3445
3446     case TRUTH_ANDIF_EXPR:
3447       loc1 = expr_location_or (TREE_OPERAND (arg, 0), loc);
3448       loc2 = expr_location_or (TREE_OPERAND (arg, 1), loc);
3449       return build2_loc (loc, TRUTH_ORIF_EXPR, type,
3450                          invert_truthvalue_loc (loc1, TREE_OPERAND (arg, 0)),
3451                          invert_truthvalue_loc (loc2, TREE_OPERAND (arg, 1)));
3452
3453     case TRUTH_ORIF_EXPR:
3454       loc1 = expr_location_or (TREE_OPERAND (arg, 0), loc);
3455       loc2 = expr_location_or (TREE_OPERAND (arg, 1), loc);
3456       return build2_loc (loc, TRUTH_ANDIF_EXPR, type,
3457                          invert_truthvalue_loc (loc1, TREE_OPERAND (arg, 0)),
3458                          invert_truthvalue_loc (loc2, TREE_OPERAND (arg, 1)));
3459
3460     case TRUTH_NOT_EXPR:
3461       return TREE_OPERAND (arg, 0);
3462
3463     case COND_EXPR:
3464       {
3465         tree arg1 = TREE_OPERAND (arg, 1);
3466         tree arg2 = TREE_OPERAND (arg, 2);
3467
3468         loc1 = expr_location_or (TREE_OPERAND (arg, 1), loc);
3469         loc2 = expr_location_or (TREE_OPERAND (arg, 2), loc);
3470
3471         /* A COND_EXPR may have a throw as one operand, which
3472            then has void type.  Just leave void operands
3473            as they are.  */
3474         return build3_loc (loc, COND_EXPR, type, TREE_OPERAND (arg, 0),
3475                            VOID_TYPE_P (TREE_TYPE (arg1))
3476                            ? arg1 : invert_truthvalue_loc (loc1, arg1),
3477                            VOID_TYPE_P (TREE_TYPE (arg2))
3478                            ? arg2 : invert_truthvalue_loc (loc2, arg2));
3479       }
3480
3481     case COMPOUND_EXPR:
3482       loc1 = expr_location_or (TREE_OPERAND (arg, 1), loc);
3483       return build2_loc (loc, COMPOUND_EXPR, type,
3484                          TREE_OPERAND (arg, 0),
3485                          invert_truthvalue_loc (loc1, TREE_OPERAND (arg, 1)));
3486
3487     case NON_LVALUE_EXPR:
3488       loc1 = expr_location_or (TREE_OPERAND (arg, 0), loc);
3489       return invert_truthvalue_loc (loc1, TREE_OPERAND (arg, 0));
3490
3491     CASE_CONVERT:
3492       if (TREE_CODE (TREE_TYPE (arg)) == BOOLEAN_TYPE)
3493         return build1_loc (loc, TRUTH_NOT_EXPR, type, arg);
3494
3495       /* ... fall through ...  */
3496
3497     case FLOAT_EXPR:
3498       loc1 = expr_location_or (TREE_OPERAND (arg, 0), loc);
3499       return build1_loc (loc, TREE_CODE (arg), type,
3500                          invert_truthvalue_loc (loc1, TREE_OPERAND (arg, 0)));
3501
3502     case BIT_AND_EXPR:
3503       if (!integer_onep (TREE_OPERAND (arg, 1)))
3504         return NULL_TREE;
3505       return build2_loc (loc, EQ_EXPR, type, arg, build_int_cst (type, 0));
3506
3507     case SAVE_EXPR:
3508       return build1_loc (loc, TRUTH_NOT_EXPR, type, arg);
3509
3510     case CLEANUP_POINT_EXPR:
3511       loc1 = expr_location_or (TREE_OPERAND (arg, 0), loc);
3512       return build1_loc (loc, CLEANUP_POINT_EXPR, type,
3513                          invert_truthvalue_loc (loc1, TREE_OPERAND (arg, 0)));
3514
3515     default:
3516       return NULL_TREE;
3517     }
3518 }
3519
3520 /* Fold the truth-negation of ARG.  This never alters ARG itself.  We
3521    assume that ARG is an operation that returns a truth value (0 or 1
3522    for scalars, 0 or -1 for vectors).  Return the folded expression if
3523    folding is successful.  Otherwise, return NULL_TREE.  */
3524
3525 static tree
3526 fold_invert_truthvalue (location_t loc, tree arg)
3527 {
3528   tree type = TREE_TYPE (arg);
3529   return fold_unary_loc (loc, VECTOR_TYPE_P (type)
3530                               ? BIT_NOT_EXPR
3531                               : TRUTH_NOT_EXPR,
3532                          type, arg);
3533 }
3534
3535 /* Return a simplified tree node for the truth-negation of ARG.  This
3536    never alters ARG itself.  We assume that ARG is an operation that
3537    returns a truth value (0 or 1 for scalars, 0 or -1 for vectors).  */
3538
3539 tree
3540 invert_truthvalue_loc (location_t loc, tree arg)
3541 {
3542   if (TREE_CODE (arg) == ERROR_MARK)
3543     return arg;
3544
3545   tree type = TREE_TYPE (arg);
3546   return fold_build1_loc (loc, VECTOR_TYPE_P (type)
3547                                ? BIT_NOT_EXPR
3548                                : TRUTH_NOT_EXPR,
3549                           type, arg);
3550 }
3551
3552 /* Knowing that ARG0 and ARG1 are both RDIV_EXPRs, simplify a binary operation
3553    with code CODE.  This optimization is unsafe.  */
3554 static tree
3555 distribute_real_division (location_t loc, enum tree_code code, tree type,
3556                           tree arg0, tree arg1)
3557 {
3558   bool mul0 = TREE_CODE (arg0) == MULT_EXPR;
3559   bool mul1 = TREE_CODE (arg1) == MULT_EXPR;
3560
3561   /* (A / C) +- (B / C) -> (A +- B) / C.  */
3562   if (mul0 == mul1
3563       && operand_equal_p (TREE_OPERAND (arg0, 1),
3564                        TREE_OPERAND (arg1, 1), 0))
3565     return fold_build2_loc (loc, mul0 ? MULT_EXPR : RDIV_EXPR, type,
3566                         fold_build2_loc (loc, code, type,
3567                                      TREE_OPERAND (arg0, 0),
3568                                      TREE_OPERAND (arg1, 0)),
3569                         TREE_OPERAND (arg0, 1));
3570
3571   /* (A / C1) +- (A / C2) -> A * (1 / C1 +- 1 / C2).  */
3572   if (operand_equal_p (TREE_OPERAND (arg0, 0),
3573                        TREE_OPERAND (arg1, 0), 0)
3574       && TREE_CODE (TREE_OPERAND (arg0, 1)) == REAL_CST
3575       && TREE_CODE (TREE_OPERAND (arg1, 1)) == REAL_CST)
3576     {
3577       REAL_VALUE_TYPE r0, r1;
3578       r0 = TREE_REAL_CST (TREE_OPERAND (arg0, 1));
3579       r1 = TREE_REAL_CST (TREE_OPERAND (arg1, 1));
3580       if (!mul0)
3581         real_arithmetic (&r0, RDIV_EXPR, &dconst1, &r0);
3582       if (!mul1)
3583         real_arithmetic (&r1, RDIV_EXPR, &dconst1, &r1);
3584       real_arithmetic (&r0, code, &r0, &r1);
3585       return fold_build2_loc (loc, MULT_EXPR, type,
3586                           TREE_OPERAND (arg0, 0),
3587                           build_real (type, r0));
3588     }
3589
3590   return NULL_TREE;
3591 }
3592 \f
3593 /* Return a BIT_FIELD_REF of type TYPE to refer to BITSIZE bits of INNER
3594    starting at BITPOS.  The field is unsigned if UNSIGNEDP is nonzero.  */
3595
3596 static tree
3597 make_bit_field_ref (location_t loc, tree inner, tree type,
3598                     HOST_WIDE_INT bitsize, HOST_WIDE_INT bitpos, int unsignedp)
3599 {
3600   tree result, bftype;
3601
3602   if (bitpos == 0)
3603     {
3604       tree size = TYPE_SIZE (TREE_TYPE (inner));
3605       if ((INTEGRAL_TYPE_P (TREE_TYPE (inner))
3606            || POINTER_TYPE_P (TREE_TYPE (inner)))
3607           && tree_fits_shwi_p (size)
3608           && tree_to_shwi (size) == bitsize)
3609         return fold_convert_loc (loc, type, inner);
3610     }
3611
3612   bftype = type;
3613   if (TYPE_PRECISION (bftype) != bitsize
3614       || TYPE_UNSIGNED (bftype) == !unsignedp)
3615     bftype = build_nonstandard_integer_type (bitsize, 0);
3616
3617   result = build3_loc (loc, BIT_FIELD_REF, bftype, inner,
3618                        size_int (bitsize), bitsize_int (bitpos));
3619
3620   if (bftype != type)
3621     result = fold_convert_loc (loc, type, result);
3622
3623   return result;
3624 }
3625
3626 /* Optimize a bit-field compare.
3627
3628    There are two cases:  First is a compare against a constant and the
3629    second is a comparison of two items where the fields are at the same
3630    bit position relative to the start of a chunk (byte, halfword, word)
3631    large enough to contain it.  In these cases we can avoid the shift
3632    implicit in bitfield extractions.
3633
3634    For constants, we emit a compare of the shifted constant with the
3635    BIT_AND_EXPR of a mask and a byte, halfword, or word of the operand being
3636    compared.  For two fields at the same position, we do the ANDs with the
3637    similar mask and compare the result of the ANDs.
3638
3639    CODE is the comparison code, known to be either NE_EXPR or EQ_EXPR.
3640    COMPARE_TYPE is the type of the comparison, and LHS and RHS
3641    are the left and right operands of the comparison, respectively.
3642
3643    If the optimization described above can be done, we return the resulting
3644    tree.  Otherwise we return zero.  */
3645
3646 static tree
3647 optimize_bit_field_compare (location_t loc, enum tree_code code,
3648                             tree compare_type, tree lhs, tree rhs)
3649 {
3650   HOST_WIDE_INT lbitpos, lbitsize, rbitpos, rbitsize, nbitpos, nbitsize;
3651   tree type = TREE_TYPE (lhs);
3652   tree unsigned_type;
3653   int const_p = TREE_CODE (rhs) == INTEGER_CST;
3654   machine_mode lmode, rmode, nmode;
3655   int lunsignedp, runsignedp;
3656   int lvolatilep = 0, rvolatilep = 0;
3657   tree linner, rinner = NULL_TREE;
3658   tree mask;
3659   tree offset;
3660
3661   /* Get all the information about the extractions being done.  If the bit size
3662      if the same as the size of the underlying object, we aren't doing an
3663      extraction at all and so can do nothing.  We also don't want to
3664      do anything if the inner expression is a PLACEHOLDER_EXPR since we
3665      then will no longer be able to replace it.  */
3666   linner = get_inner_reference (lhs, &lbitsize, &lbitpos, &offset, &lmode,
3667                                 &lunsignedp, &lvolatilep, false);
3668   if (linner == lhs || lbitsize == GET_MODE_BITSIZE (lmode) || lbitsize < 0
3669       || offset != 0 || TREE_CODE (linner) == PLACEHOLDER_EXPR || lvolatilep)
3670     return 0;
3671
3672  if (!const_p)
3673    {
3674      /* If this is not a constant, we can only do something if bit positions,
3675         sizes, and signedness are the same.  */
3676      rinner = get_inner_reference (rhs, &rbitsize, &rbitpos, &offset, &rmode,
3677                                    &runsignedp, &rvolatilep, false);
3678
3679      if (rinner == rhs || lbitpos != rbitpos || lbitsize != rbitsize
3680          || lunsignedp != runsignedp || offset != 0
3681          || TREE_CODE (rinner) == PLACEHOLDER_EXPR || rvolatilep)
3682        return 0;
3683    }
3684
3685   /* See if we can find a mode to refer to this field.  We should be able to,
3686      but fail if we can't.  */
3687   nmode = get_best_mode (lbitsize, lbitpos, 0, 0,
3688                          const_p ? TYPE_ALIGN (TREE_TYPE (linner))
3689                          : MIN (TYPE_ALIGN (TREE_TYPE (linner)),
3690                                 TYPE_ALIGN (TREE_TYPE (rinner))),
3691                          word_mode, false);
3692   if (nmode == VOIDmode)
3693     return 0;
3694
3695   /* Set signed and unsigned types of the precision of this mode for the
3696      shifts below.  */
3697   unsigned_type = lang_hooks.types.type_for_mode (nmode, 1);
3698
3699   /* Compute the bit position and size for the new reference and our offset
3700      within it. If the new reference is the same size as the original, we
3701      won't optimize anything, so return zero.  */
3702   nbitsize = GET_MODE_BITSIZE (nmode);
3703   nbitpos = lbitpos & ~ (nbitsize - 1);
3704   lbitpos -= nbitpos;
3705   if (nbitsize == lbitsize)
3706     return 0;
3707
3708   if (BYTES_BIG_ENDIAN)
3709     lbitpos = nbitsize - lbitsize - lbitpos;
3710
3711   /* Make the mask to be used against the extracted field.  */
3712   mask = build_int_cst_type (unsigned_type, -1);
3713   mask = const_binop (LSHIFT_EXPR, mask, size_int (nbitsize - lbitsize));
3714   mask = const_binop (RSHIFT_EXPR, mask,
3715                       size_int (nbitsize - lbitsize - lbitpos));
3716
3717   if (! const_p)
3718     /* If not comparing with constant, just rework the comparison
3719        and return.  */
3720     return fold_build2_loc (loc, code, compare_type,
3721                         fold_build2_loc (loc, BIT_AND_EXPR, unsigned_type,
3722                                      make_bit_field_ref (loc, linner,
3723                                                          unsigned_type,
3724                                                          nbitsize, nbitpos,
3725                                                          1),
3726                                      mask),
3727                         fold_build2_loc (loc, BIT_AND_EXPR, unsigned_type,
3728                                      make_bit_field_ref (loc, rinner,
3729                                                          unsigned_type,
3730                                                          nbitsize, nbitpos,
3731                                                          1),
3732                                      mask));
3733
3734   /* Otherwise, we are handling the constant case. See if the constant is too
3735      big for the field.  Warn and return a tree of for 0 (false) if so.  We do
3736      this not only for its own sake, but to avoid having to test for this
3737      error case below.  If we didn't, we might generate wrong code.
3738
3739      For unsigned fields, the constant shifted right by the field length should
3740      be all zero.  For signed fields, the high-order bits should agree with
3741      the sign bit.  */
3742
3743   if (lunsignedp)
3744     {
3745       if (wi::lrshift (rhs, lbitsize) != 0)
3746         {
3747           warning (0, "comparison is always %d due to width of bit-field",
3748                    code == NE_EXPR);
3749           return constant_boolean_node (code == NE_EXPR, compare_type);
3750         }
3751     }
3752   else
3753     {
3754       wide_int tem = wi::arshift (rhs, lbitsize - 1);
3755       if (tem != 0 && tem != -1)
3756         {
3757           warning (0, "comparison is always %d due to width of bit-field",
3758                    code == NE_EXPR);
3759           return constant_boolean_node (code == NE_EXPR, compare_type);
3760         }
3761     }
3762
3763   /* Single-bit compares should always be against zero.  */
3764   if (lbitsize == 1 && ! integer_zerop (rhs))
3765     {
3766       code = code == EQ_EXPR ? NE_EXPR : EQ_EXPR;
3767       rhs = build_int_cst (type, 0);
3768     }
3769
3770   /* Make a new bitfield reference, shift the constant over the
3771      appropriate number of bits and mask it with the computed mask
3772      (in case this was a signed field).  If we changed it, make a new one.  */
3773   lhs = make_bit_field_ref (loc, linner, unsigned_type, nbitsize, nbitpos, 1);
3774
3775   rhs = const_binop (BIT_AND_EXPR,
3776                      const_binop (LSHIFT_EXPR,
3777                                   fold_convert_loc (loc, unsigned_type, rhs),
3778                                   size_int (lbitpos)),
3779                      mask);
3780
3781   lhs = build2_loc (loc, code, compare_type,
3782                     build2 (BIT_AND_EXPR, unsigned_type, lhs, mask), rhs);
3783   return lhs;
3784 }
3785 \f
3786 /* Subroutine for fold_truth_andor_1: decode a field reference.
3787
3788    If EXP is a comparison reference, we return the innermost reference.
3789
3790    *PBITSIZE is set to the number of bits in the reference, *PBITPOS is
3791    set to the starting bit number.
3792
3793    If the innermost field can be completely contained in a mode-sized
3794    unit, *PMODE is set to that mode.  Otherwise, it is set to VOIDmode.
3795
3796    *PVOLATILEP is set to 1 if the any expression encountered is volatile;
3797    otherwise it is not changed.
3798
3799    *PUNSIGNEDP is set to the signedness of the field.
3800
3801    *PMASK is set to the mask used.  This is either contained in a
3802    BIT_AND_EXPR or derived from the width of the field.
3803
3804    *PAND_MASK is set to the mask found in a BIT_AND_EXPR, if any.
3805
3806    Return 0 if this is not a component reference or is one that we can't
3807    do anything with.  */
3808
3809 static tree
3810 decode_field_reference (location_t loc, tree exp, HOST_WIDE_INT *pbitsize,
3811                         HOST_WIDE_INT *pbitpos, machine_mode *pmode,
3812                         int *punsignedp, int *pvolatilep,
3813                         tree *pmask, tree *pand_mask)
3814 {
3815   tree outer_type = 0;
3816   tree and_mask = 0;
3817   tree mask, inner, offset;
3818   tree unsigned_type;
3819   unsigned int precision;
3820
3821   /* All the optimizations using this function assume integer fields.
3822      There are problems with FP fields since the type_for_size call
3823      below can fail for, e.g., XFmode.  */
3824   if (! INTEGRAL_TYPE_P (TREE_TYPE (exp)))
3825     return 0;
3826
3827   /* We are interested in the bare arrangement of bits, so strip everything
3828      that doesn't affect the machine mode.  However, record the type of the
3829      outermost expression if it may matter below.  */
3830   if (CONVERT_EXPR_P (exp)
3831       || TREE_CODE (exp) == NON_LVALUE_EXPR)
3832     outer_type = TREE_TYPE (exp);
3833   STRIP_NOPS (exp);
3834
3835   if (TREE_CODE (exp) == BIT_AND_EXPR)
3836     {
3837       and_mask = TREE_OPERAND (exp, 1);
3838       exp = TREE_OPERAND (exp, 0);
3839       STRIP_NOPS (exp); STRIP_NOPS (and_mask);
3840       if (TREE_CODE (and_mask) != INTEGER_CST)
3841         return 0;
3842     }
3843
3844   inner = get_inner_reference (exp, pbitsize, pbitpos, &offset, pmode,
3845                                punsignedp, pvolatilep, false);
3846   if ((inner == exp && and_mask == 0)
3847       || *pbitsize < 0 || offset != 0
3848       || TREE_CODE (inner) == PLACEHOLDER_EXPR)
3849     return 0;
3850
3851   /* If the number of bits in the reference is the same as the bitsize of
3852      the outer type, then the outer type gives the signedness. Otherwise
3853      (in case of a small bitfield) the signedness is unchanged.  */
3854   if (outer_type && *pbitsize == TYPE_PRECISION (outer_type))
3855     *punsignedp = TYPE_UNSIGNED (outer_type);
3856
3857   /* Compute the mask to access the bitfield.  */
3858   unsigned_type = lang_hooks.types.type_for_size (*pbitsize, 1);
3859   precision = TYPE_PRECISION (unsigned_type);
3860
3861   mask = build_int_cst_type (unsigned_type, -1);
3862
3863   mask = const_binop (LSHIFT_EXPR, mask, size_int (precision - *pbitsize));
3864   mask = const_binop (RSHIFT_EXPR, mask, size_int (precision - *pbitsize));
3865
3866   /* Merge it with the mask we found in the BIT_AND_EXPR, if any.  */
3867   if (and_mask != 0)
3868     mask = fold_build2_loc (loc, BIT_AND_EXPR, unsigned_type,
3869                         fold_convert_loc (loc, unsigned_type, and_mask), mask);
3870
3871   *pmask = mask;
3872   *pand_mask = and_mask;
3873   return inner;
3874 }
3875
3876 /* Return nonzero if MASK represents a mask of SIZE ones in the low-order
3877    bit positions and MASK is SIGNED.  */
3878
3879 static int
3880 all_ones_mask_p (const_tree mask, unsigned int size)
3881 {
3882   tree type = TREE_TYPE (mask);
3883   unsigned int precision = TYPE_PRECISION (type);
3884
3885   /* If this function returns true when the type of the mask is
3886      UNSIGNED, then there will be errors.  In particular see
3887      gcc.c-torture/execute/990326-1.c.  There does not appear to be
3888      any documentation paper trail as to why this is so.  But the pre
3889      wide-int worked with that restriction and it has been preserved
3890      here.  */
3891   if (size > precision || TYPE_SIGN (type) == UNSIGNED)
3892     return false;
3893
3894   return wi::mask (size, false, precision) == mask;
3895 }
3896
3897 /* Subroutine for fold: determine if VAL is the INTEGER_CONST that
3898    represents the sign bit of EXP's type.  If EXP represents a sign
3899    or zero extension, also test VAL against the unextended type.
3900    The return value is the (sub)expression whose sign bit is VAL,
3901    or NULL_TREE otherwise.  */
3902
3903 tree
3904 sign_bit_p (tree exp, const_tree val)
3905 {
3906   int width;
3907   tree t;
3908
3909   /* Tree EXP must have an integral type.  */
3910   t = TREE_TYPE (exp);
3911   if (! INTEGRAL_TYPE_P (t))
3912     return NULL_TREE;
3913
3914   /* Tree VAL must be an integer constant.  */
3915   if (TREE_CODE (val) != INTEGER_CST
3916       || TREE_OVERFLOW (val))
3917     return NULL_TREE;
3918
3919   width = TYPE_PRECISION (t);
3920   if (wi::only_sign_bit_p (val, width))
3921     return exp;
3922
3923   /* Handle extension from a narrower type.  */
3924   if (TREE_CODE (exp) == NOP_EXPR
3925       && TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (exp, 0))) < width)
3926     return sign_bit_p (TREE_OPERAND (exp, 0), val);
3927
3928   return NULL_TREE;
3929 }
3930
3931 /* Subroutine for fold_truth_andor_1: determine if an operand is simple enough
3932    to be evaluated unconditionally.  */
3933
3934 static int
3935 simple_operand_p (const_tree exp)
3936 {
3937   /* Strip any conversions that don't change the machine mode.  */
3938   STRIP_NOPS (exp);
3939
3940   return (CONSTANT_CLASS_P (exp)
3941           || TREE_CODE (exp) == SSA_NAME
3942           || (DECL_P (exp)
3943               && ! TREE_ADDRESSABLE (exp)
3944               && ! TREE_THIS_VOLATILE (exp)
3945               && ! DECL_NONLOCAL (exp)
3946               /* Don't regard global variables as simple.  They may be
3947                  allocated in ways unknown to the compiler (shared memory,
3948                  #pragma weak, etc).  */
3949               && ! TREE_PUBLIC (exp)
3950               && ! DECL_EXTERNAL (exp)
3951               /* Weakrefs are not safe to be read, since they can be NULL.
3952                  They are !TREE_PUBLIC && !DECL_EXTERNAL but still
3953                  have DECL_WEAK flag set.  */
3954               && (! VAR_OR_FUNCTION_DECL_P (exp) || ! DECL_WEAK (exp))
3955               /* Loading a static variable is unduly expensive, but global
3956                  registers aren't expensive.  */
3957               && (! TREE_STATIC (exp) || DECL_REGISTER (exp))));
3958 }
3959
3960 /* Subroutine for fold_truth_andor: determine if an operand is simple enough
3961    to be evaluated unconditionally.
3962    I addition to simple_operand_p, we assume that comparisons, conversions,
3963    and logic-not operations are simple, if their operands are simple, too.  */
3964
3965 static bool
3966 simple_operand_p_2 (tree exp)
3967 {
3968   enum tree_code code;
3969
3970   if (TREE_SIDE_EFFECTS (exp)
3971       || tree_could_trap_p (exp))
3972     return false;
3973
3974   while (CONVERT_EXPR_P (exp))
3975     exp = TREE_OPERAND (exp, 0);
3976
3977   code = TREE_CODE (exp);
3978
3979   if (TREE_CODE_CLASS (code) == tcc_comparison)
3980     return (simple_operand_p (TREE_OPERAND (exp, 0))
3981             && simple_operand_p (TREE_OPERAND (exp, 1)));
3982
3983   if (code == TRUTH_NOT_EXPR)
3984       return simple_operand_p_2 (TREE_OPERAND (exp, 0));
3985
3986   return simple_operand_p (exp);
3987 }
3988
3989 \f
3990 /* The following functions are subroutines to fold_range_test and allow it to
3991    try to change a logical combination of comparisons into a range test.
3992
3993    For example, both
3994         X == 2 || X == 3 || X == 4 || X == 5
3995    and
3996         X >= 2 && X <= 5
3997    are converted to
3998         (unsigned) (X - 2) <= 3
3999
4000    We describe each set of comparisons as being either inside or outside
4001    a range, using a variable named like IN_P, and then describe the
4002    range with a lower and upper bound.  If one of the bounds is omitted,
4003    it represents either the highest or lowest value of the type.
4004
4005    In the comments below, we represent a range by two numbers in brackets
4006    preceded by a "+" to designate being inside that range, or a "-" to
4007    designate being outside that range, so the condition can be inverted by
4008    flipping the prefix.  An omitted bound is represented by a "-".  For
4009    example, "- [-, 10]" means being outside the range starting at the lowest
4010    possible value and ending at 10, in other words, being greater than 10.
4011    The range "+ [-, -]" is always true and hence the range "- [-, -]" is
4012    always false.
4013
4014    We set up things so that the missing bounds are handled in a consistent
4015    manner so neither a missing bound nor "true" and "false" need to be
4016    handled using a special case.  */
4017
4018 /* Return the result of applying CODE to ARG0 and ARG1, but handle the case
4019    of ARG0 and/or ARG1 being omitted, meaning an unlimited range. UPPER0_P
4020    and UPPER1_P are nonzero if the respective argument is an upper bound
4021    and zero for a lower.  TYPE, if nonzero, is the type of the result; it
4022    must be specified for a comparison.  ARG1 will be converted to ARG0's
4023    type if both are specified.  */
4024
4025 static tree
4026 range_binop (enum tree_code code, tree type, tree arg0, int upper0_p,
4027              tree arg1, int upper1_p)
4028 {
4029   tree tem;
4030   int result;
4031   int sgn0, sgn1;
4032
4033   /* If neither arg represents infinity, do the normal operation.
4034      Else, if not a comparison, return infinity.  Else handle the special
4035      comparison rules. Note that most of the cases below won't occur, but
4036      are handled for consistency.  */
4037
4038   if (arg0 != 0 && arg1 != 0)
4039     {
4040       tem = fold_build2 (code, type != 0 ? type : TREE_TYPE (arg0),
4041                          arg0, fold_convert (TREE_TYPE (arg0), arg1));
4042       STRIP_NOPS (tem);
4043       return TREE_CODE (tem) == INTEGER_CST ? tem : 0;
4044     }
4045
4046   if (TREE_CODE_CLASS (code) != tcc_comparison)
4047     return 0;
4048
4049   /* Set SGN[01] to -1 if ARG[01] is a lower bound, 1 for upper, and 0
4050      for neither.  In real maths, we cannot assume open ended ranges are
4051      the same. But, this is computer arithmetic, where numbers are finite.
4052      We can therefore make the transformation of any unbounded range with
4053      the value Z, Z being greater than any representable number. This permits
4054      us to treat unbounded ranges as equal.  */
4055   sgn0 = arg0 != 0 ? 0 : (upper0_p ? 1 : -1);
4056   sgn1 = arg1 != 0 ? 0 : (upper1_p ? 1 : -1);
4057   switch (code)
4058     {
4059     case EQ_EXPR:
4060       result = sgn0 == sgn1;
4061       break;
4062     case NE_EXPR:
4063       result = sgn0 != sgn1;
4064       break;
4065     case LT_EXPR:
4066       result = sgn0 < sgn1;
4067       break;
4068     case LE_EXPR:
4069       result = sgn0 <= sgn1;
4070       break;
4071     case GT_EXPR:
4072       result = sgn0 > sgn1;
4073       break;
4074     case GE_EXPR:
4075       result = sgn0 >= sgn1;
4076       break;
4077     default:
4078       gcc_unreachable ();
4079     }
4080
4081   return constant_boolean_node (result, type);
4082 }
4083 \f
4084 /* Helper routine for make_range.  Perform one step for it, return
4085    new expression if the loop should continue or NULL_TREE if it should
4086    stop.  */
4087
4088 tree
4089 make_range_step (location_t loc, enum tree_code code, tree arg0, tree arg1,
4090                  tree exp_type, tree *p_low, tree *p_high, int *p_in_p,
4091                  bool *strict_overflow_p)
4092 {
4093   tree arg0_type = TREE_TYPE (arg0);
4094   tree n_low, n_high, low = *p_low, high = *p_high;
4095   int in_p = *p_in_p, n_in_p;
4096
4097   switch (code)
4098     {
4099     case TRUTH_NOT_EXPR:
4100       /* We can only do something if the range is testing for zero.  */
4101       if (low == NULL_TREE || high == NULL_TREE
4102           || ! integer_zerop (low) || ! integer_zerop (high))
4103         return NULL_TREE;
4104       *p_in_p = ! in_p;
4105       return arg0;
4106
4107     case EQ_EXPR: case NE_EXPR:
4108     case LT_EXPR: case LE_EXPR: case GE_EXPR: case GT_EXPR:
4109       /* We can only do something if the range is testing for zero
4110          and if the second operand is an integer constant.  Note that
4111          saying something is "in" the range we make is done by
4112          complementing IN_P since it will set in the initial case of
4113          being not equal to zero; "out" is leaving it alone.  */
4114       if (low == NULL_TREE || high == NULL_TREE
4115           || ! integer_zerop (low) || ! integer_zerop (high)
4116           || TREE_CODE (arg1) != INTEGER_CST)
4117         return NULL_TREE;
4118
4119       switch (code)
4120         {
4121         case NE_EXPR:  /* - [c, c]  */
4122           low = high = arg1;
4123           break;
4124         case EQ_EXPR:  /* + [c, c]  */
4125           in_p = ! in_p, low = high = arg1;
4126           break;
4127         case GT_EXPR:  /* - [-, c] */
4128           low = 0, high = arg1;
4129           break;
4130         case GE_EXPR:  /* + [c, -] */
4131           in_p = ! in_p, low = arg1, high = 0;
4132           break;
4133         case LT_EXPR:  /* - [c, -] */
4134           low = arg1, high = 0;
4135           break;
4136         case LE_EXPR:  /* + [-, c] */
4137           in_p = ! in_p, low = 0, high = arg1;
4138           break;
4139         default:
4140           gcc_unreachable ();
4141         }
4142
4143       /* If this is an unsigned comparison, we also know that EXP is
4144          greater than or equal to zero.  We base the range tests we make
4145          on that fact, so we record it here so we can parse existing
4146          range tests.  We test arg0_type since often the return type
4147          of, e.g. EQ_EXPR, is boolean.  */
4148       if (TYPE_UNSIGNED (arg0_type) && (low == 0 || high == 0))
4149         {
4150           if (! merge_ranges (&n_in_p, &n_low, &n_high,
4151                               in_p, low, high, 1,
4152                               build_int_cst (arg0_type, 0),
4153                               NULL_TREE))
4154             return NULL_TREE;
4155
4156           in_p = n_in_p, low = n_low, high = n_high;
4157
4158           /* If the high bound is missing, but we have a nonzero low
4159              bound, reverse the range so it goes from zero to the low bound
4160              minus 1.  */
4161           if (high == 0 && low && ! integer_zerop (low))
4162             {
4163               in_p = ! in_p;
4164               high = range_binop (MINUS_EXPR, NULL_TREE, low, 0,
4165                                   build_int_cst (TREE_TYPE (low), 1), 0);
4166               low = build_int_cst (arg0_type, 0);
4167             }
4168         }
4169
4170       *p_low = low;
4171       *p_high = high;
4172       *p_in_p = in_p;
4173       return arg0;
4174
4175     case NEGATE_EXPR:
4176       /* If flag_wrapv and ARG0_TYPE is signed, make sure
4177          low and high are non-NULL, then normalize will DTRT.  */
4178       if (!TYPE_UNSIGNED (arg0_type)
4179           && !TYPE_OVERFLOW_UNDEFINED (arg0_type))
4180         {
4181           if (low == NULL_TREE)
4182             low = TYPE_MIN_VALUE (arg0_type);
4183           if (high == NULL_TREE)
4184             high = TYPE_MAX_VALUE (arg0_type);
4185         }
4186
4187       /* (-x) IN [a,b] -> x in [-b, -a]  */
4188       n_low = range_binop (MINUS_EXPR, exp_type,
4189                            build_int_cst (exp_type, 0),
4190                            0, high, 1);
4191       n_high = range_binop (MINUS_EXPR, exp_type,
4192                             build_int_cst (exp_type, 0),
4193                             0, low, 0);
4194       if (n_high != 0 && TREE_OVERFLOW (n_high))
4195         return NULL_TREE;
4196       goto normalize;
4197
4198     case BIT_NOT_EXPR:
4199       /* ~ X -> -X - 1  */
4200       return build2_loc (loc, MINUS_EXPR, exp_type, negate_expr (arg0),
4201                          build_int_cst (exp_type, 1));
4202
4203     case PLUS_EXPR:
4204     case MINUS_EXPR:
4205       if (TREE_CODE (arg1) != INTEGER_CST)
4206         return NULL_TREE;
4207
4208       /* If flag_wrapv and ARG0_TYPE is signed, then we cannot
4209          move a constant to the other side.  */
4210       if (!TYPE_UNSIGNED (arg0_type)
4211           && !TYPE_OVERFLOW_UNDEFINED (arg0_type))
4212         return NULL_TREE;
4213
4214       /* If EXP is signed, any overflow in the computation is undefined,
4215          so we don't worry about it so long as our computations on
4216          the bounds don't overflow.  For unsigned, overflow is defined
4217          and this is exactly the right thing.  */
4218       n_low = range_binop (code == MINUS_EXPR ? PLUS_EXPR : MINUS_EXPR,
4219                            arg0_type, low, 0, arg1, 0);
4220       n_high = range_binop (code == MINUS_EXPR ? PLUS_EXPR : MINUS_EXPR,
4221                             arg0_type, high, 1, arg1, 0);
4222       if ((n_low != 0 && TREE_OVERFLOW (n_low))
4223           || (n_high != 0 && TREE_OVERFLOW (n_high)))
4224         return NULL_TREE;
4225
4226       if (TYPE_OVERFLOW_UNDEFINED (arg0_type))
4227         *strict_overflow_p = true;
4228
4229       normalize:
4230         /* Check for an unsigned range which has wrapped around the maximum
4231            value thus making n_high < n_low, and normalize it.  */
4232         if (n_low && n_high && tree_int_cst_lt (n_high, n_low))
4233           {
4234             low = range_binop (PLUS_EXPR, arg0_type, n_high, 0,
4235                                build_int_cst (TREE_TYPE (n_high), 1), 0);
4236             high = range_binop (MINUS_EXPR, arg0_type, n_low, 0,
4237                                 build_int_cst (TREE_TYPE (n_low), 1), 0);
4238
4239             /* If the range is of the form +/- [ x+1, x ], we won't
4240                be able to normalize it.  But then, it represents the
4241                whole range or the empty set, so make it
4242                +/- [ -, - ].  */
4243             if (tree_int_cst_equal (n_low, low)
4244                 && tree_int_cst_equal (n_high, high))
4245               low = high = 0;
4246             else
4247               in_p = ! in_p;
4248           }
4249         else
4250           low = n_low, high = n_high;
4251
4252         *p_low = low;
4253         *p_high = high;
4254         *p_in_p = in_p;
4255         return arg0;
4256
4257     CASE_CONVERT:
4258     case NON_LVALUE_EXPR:
4259       if (TYPE_PRECISION (arg0_type) > TYPE_PRECISION (exp_type))
4260         return NULL_TREE;
4261
4262       if (! INTEGRAL_TYPE_P (arg0_type)
4263           || (low != 0 && ! int_fits_type_p (low, arg0_type))
4264           || (high != 0 && ! int_fits_type_p (high, arg0_type)))
4265         return NULL_TREE;
4266
4267       n_low = low, n_high = high;
4268
4269       if (n_low != 0)
4270         n_low = fold_convert_loc (loc, arg0_type, n_low);
4271
4272       if (n_high != 0)
4273         n_high = fold_convert_loc (loc, arg0_type, n_high);
4274
4275       /* If we're converting arg0 from an unsigned type, to exp,
4276          a signed type,  we will be doing the comparison as unsigned.
4277          The tests above have already verified that LOW and HIGH
4278          are both positive.
4279
4280          So we have to ensure that we will handle large unsigned
4281          values the same way that the current signed bounds treat
4282          negative values.  */
4283
4284       if (!TYPE_UNSIGNED (exp_type) && TYPE_UNSIGNED (arg0_type))
4285         {
4286           tree high_positive;
4287           tree equiv_type;
4288           /* For fixed-point modes, we need to pass the saturating flag
4289              as the 2nd parameter.  */
4290           if (ALL_FIXED_POINT_MODE_P (TYPE_MODE (arg0_type)))
4291             equiv_type
4292               = lang_hooks.types.type_for_mode (TYPE_MODE (arg0_type),
4293                                                 TYPE_SATURATING (arg0_type));
4294           else
4295             equiv_type
4296               = lang_hooks.types.type_for_mode (TYPE_MODE (arg0_type), 1);
4297
4298           /* A range without an upper bound is, naturally, unbounded.
4299              Since convert would have cropped a very large value, use
4300              the max value for the destination type.  */
4301           high_positive
4302             = TYPE_MAX_VALUE (equiv_type) ? TYPE_MAX_VALUE (equiv_type)
4303               : TYPE_MAX_VALUE (arg0_type);
4304
4305           if (TYPE_PRECISION (exp_type) == TYPE_PRECISION (arg0_type))
4306             high_positive = fold_build2_loc (loc, RSHIFT_EXPR, arg0_type,
4307                                              fold_convert_loc (loc, arg0_type,
4308                                                                high_positive),
4309                                              build_int_cst (arg0_type, 1));
4310
4311           /* If the low bound is specified, "and" the range with the
4312              range for which the original unsigned value will be
4313              positive.  */
4314           if (low != 0)
4315             {
4316               if (! merge_ranges (&n_in_p, &n_low, &n_high, 1, n_low, n_high,
4317                                   1, fold_convert_loc (loc, arg0_type,
4318                                                        integer_zero_node),
4319                                   high_positive))
4320                 return NULL_TREE;
4321
4322               in_p = (n_in_p == in_p);
4323             }
4324           else
4325             {
4326               /* Otherwise, "or" the range with the range of the input
4327                  that will be interpreted as negative.  */
4328               if (! merge_ranges (&n_in_p, &n_low, &n_high, 0, n_low, n_high,
4329                                   1, fold_convert_loc (loc, arg0_type,
4330                                                        integer_zero_node),
4331                                   high_positive))
4332                 return NULL_TREE;
4333
4334               in_p = (in_p != n_in_p);
4335             }
4336         }
4337
4338       *p_low = n_low;
4339       *p_high = n_high;
4340       *p_in_p = in_p;
4341       return arg0;
4342
4343     default:
4344       return NULL_TREE;
4345     }
4346 }
4347
4348 /* Given EXP, a logical expression, set the range it is testing into
4349    variables denoted by PIN_P, PLOW, and PHIGH.  Return the expression
4350    actually being tested.  *PLOW and *PHIGH will be made of the same
4351    type as the returned expression.  If EXP is not a comparison, we
4352    will most likely not be returning a useful value and range.  Set
4353    *STRICT_OVERFLOW_P to true if the return value is only valid
4354    because signed overflow is undefined; otherwise, do not change
4355    *STRICT_OVERFLOW_P.  */
4356
4357 tree
4358 make_range (tree exp, int *pin_p, tree *plow, tree *phigh,
4359             bool *strict_overflow_p)
4360 {
4361   enum tree_code code;
4362   tree arg0, arg1 = NULL_TREE;
4363   tree exp_type, nexp;
4364   int in_p;
4365   tree low, high;
4366   location_t loc = EXPR_LOCATION (exp);
4367
4368   /* Start with simply saying "EXP != 0" and then look at the code of EXP
4369      and see if we can refine the range.  Some of the cases below may not
4370      happen, but it doesn't seem worth worrying about this.  We "continue"
4371      the outer loop when we've changed something; otherwise we "break"
4372      the switch, which will "break" the while.  */
4373
4374   in_p = 0;
4375   low = high = build_int_cst (TREE_TYPE (exp), 0);
4376
4377   while (1)
4378     {
4379       code = TREE_CODE (exp);
4380       exp_type = TREE_TYPE (exp);
4381       arg0 = NULL_TREE;
4382
4383       if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code)))
4384         {
4385           if (TREE_OPERAND_LENGTH (exp) > 0)
4386             arg0 = TREE_OPERAND (exp, 0);
4387           if (TREE_CODE_CLASS (code) == tcc_binary
4388               || TREE_CODE_CLASS (code) == tcc_comparison
4389               || (TREE_CODE_CLASS (code) == tcc_expression
4390                   && TREE_OPERAND_LENGTH (exp) > 1))
4391             arg1 = TREE_OPERAND (exp, 1);
4392         }
4393       if (arg0 == NULL_TREE)
4394         break;
4395
4396       nexp = make_range_step (loc, code, arg0, arg1, exp_type, &low,
4397                               &high, &in_p, strict_overflow_p);
4398       if (nexp == NULL_TREE)
4399         break;
4400       exp = nexp;
4401     }
4402
4403   /* If EXP is a constant, we can evaluate whether this is true or false.  */
4404   if (TREE_CODE (exp) == INTEGER_CST)
4405     {
4406       in_p = in_p == (integer_onep (range_binop (GE_EXPR, integer_type_node,
4407                                                  exp, 0, low, 0))
4408                       && integer_onep (range_binop (LE_EXPR, integer_type_node,
4409                                                     exp, 1, high, 1)));
4410       low = high = 0;
4411       exp = 0;
4412     }
4413
4414   *pin_p = in_p, *plow = low, *phigh = high;
4415   return exp;
4416 }
4417 \f
4418 /* Given a range, LOW, HIGH, and IN_P, an expression, EXP, and a result
4419    type, TYPE, return an expression to test if EXP is in (or out of, depending
4420    on IN_P) the range.  Return 0 if the test couldn't be created.  */
4421
4422 tree
4423 build_range_check (location_t loc, tree type, tree exp, int in_p,
4424                    tree low, tree high)
4425 {
4426   tree etype = TREE_TYPE (exp), value;
4427
4428   /* Disable this optimization for function pointer expressions
4429      on targets that require function pointer canonicalization.  */
4430   if (targetm.have_canonicalize_funcptr_for_compare ()
4431       && TREE_CODE (etype) == POINTER_TYPE
4432       && TREE_CODE (TREE_TYPE (etype)) == FUNCTION_TYPE)
4433     return NULL_TREE;
4434
4435   if (! in_p)
4436     {
4437       value = build_range_check (loc, type, exp, 1, low, high);
4438       if (value != 0)
4439         return invert_truthvalue_loc (loc, value);
4440
4441       return 0;
4442     }
4443
4444   if (low == 0 && high == 0)
4445     return omit_one_operand_loc (loc, type, build_int_cst (type, 1), exp);
4446
4447   if (low == 0)
4448     return fold_build2_loc (loc, LE_EXPR, type, exp,
4449                         fold_convert_loc (loc, etype, high));
4450
4451   if (high == 0)
4452     return fold_build2_loc (loc, GE_EXPR, type, exp,
4453                         fold_convert_loc (loc, etype, low));
4454
4455   if (operand_equal_p (low, high, 0))
4456     return fold_build2_loc (loc, EQ_EXPR, type, exp,
4457                         fold_convert_loc (loc, etype, low));
4458
4459   if (integer_zerop (low))
4460     {
4461       if (! TYPE_UNSIGNED (etype))
4462         {
4463           etype = unsigned_type_for (etype);
4464           high = fold_convert_loc (loc, etype, high);
4465           exp = fold_convert_loc (loc, etype, exp);
4466         }
4467       return build_range_check (loc, type, exp, 1, 0, high);
4468     }
4469
4470   /* Optimize (c>=1) && (c<=127) into (signed char)c > 0.  */
4471   if (integer_onep (low) && TREE_CODE (high) == INTEGER_CST)
4472     {
4473       int prec = TYPE_PRECISION (etype);
4474
4475       if (wi::mask (prec - 1, false, prec) == high)
4476         {
4477           if (TYPE_UNSIGNED (etype))
4478             {
4479               tree signed_etype = signed_type_for (etype);
4480               if (TYPE_PRECISION (signed_etype) != TYPE_PRECISION (etype))
4481                 etype
4482                   = build_nonstandard_integer_type (TYPE_PRECISION (etype), 0);
4483               else
4484                 etype = signed_etype;
4485               exp = fold_convert_loc (loc, etype, exp);
4486             }
4487           return fold_build2_loc (loc, GT_EXPR, type, exp,
4488                               build_int_cst (etype, 0));
4489         }
4490     }
4491
4492   /* Optimize (c>=low) && (c<=high) into (c-low>=0) && (c-low<=high-low).
4493      This requires wrap-around arithmetics for the type of the expression.
4494      First make sure that arithmetics in this type is valid, then make sure
4495      that it wraps around.  */
4496   if (TREE_CODE (etype) == ENUMERAL_TYPE || TREE_CODE (etype) == BOOLEAN_TYPE)
4497     etype = lang_hooks.types.type_for_size (TYPE_PRECISION (etype),
4498                                             TYPE_UNSIGNED (etype));
4499
4500   if (TREE_CODE (etype) == INTEGER_TYPE && !TYPE_OVERFLOW_WRAPS (etype))
4501     {
4502       tree utype, minv, maxv;
4503
4504       /* Check if (unsigned) INT_MAX + 1 == (unsigned) INT_MIN
4505          for the type in question, as we rely on this here.  */
4506       utype = unsigned_type_for (etype);
4507       maxv = fold_convert_loc (loc, utype, TYPE_MAX_VALUE (etype));
4508       maxv = range_binop (PLUS_EXPR, NULL_TREE, maxv, 1,
4509                           build_int_cst (TREE_TYPE (maxv), 1), 1);
4510       minv = fold_convert_loc (loc, utype, TYPE_MIN_VALUE (etype));
4511
4512       if (integer_zerop (range_binop (NE_EXPR, integer_type_node,
4513                                       minv, 1, maxv, 1)))
4514         etype = utype;
4515       else
4516         return 0;
4517     }
4518
4519   high = fold_convert_loc (loc, etype, high);
4520   low = fold_convert_loc (loc, etype, low);
4521   exp = fold_convert_loc (loc, etype, exp);
4522
4523   value = const_binop (MINUS_EXPR, high, low);
4524
4525
4526   if (POINTER_TYPE_P (etype))
4527     {
4528       if (value != 0 && !TREE_OVERFLOW (value))
4529         {
4530           low = fold_build1_loc (loc, NEGATE_EXPR, TREE_TYPE (low), low);
4531           return build_range_check (loc, type,
4532                                     fold_build_pointer_plus_loc (loc, exp, low),
4533                                     1, build_int_cst (etype, 0), value);
4534         }
4535       return 0;
4536     }
4537
4538   if (value != 0 && !TREE_OVERFLOW (value))
4539     return build_range_check (loc, type,
4540                               fold_build2_loc (loc, MINUS_EXPR, etype, exp, low),
4541                               1, build_int_cst (etype, 0), value);
4542
4543   return 0;
4544 }
4545 \f
4546 /* Return the predecessor of VAL in its type, handling the infinite case.  */
4547
4548 static tree
4549 range_predecessor (tree val)
4550 {
4551   tree type = TREE_TYPE (val);
4552
4553   if (INTEGRAL_TYPE_P (type)
4554       && operand_equal_p (val, TYPE_MIN_VALUE (type), 0))
4555     return 0;
4556   else
4557     return range_binop (MINUS_EXPR, NULL_TREE, val, 0,
4558                         build_int_cst (TREE_TYPE (val), 1), 0);
4559 }
4560
4561 /* Return the successor of VAL in its type, handling the infinite case.  */
4562
4563 static tree
4564 range_successor (tree val)
4565 {
4566   tree type = TREE_TYPE (val);
4567
4568   if (INTEGRAL_TYPE_P (type)
4569       && operand_equal_p (val, TYPE_MAX_VALUE (type), 0))
4570     return 0;
4571   else
4572     return range_binop (PLUS_EXPR, NULL_TREE, val, 0,
4573                         build_int_cst (TREE_TYPE (val), 1), 0);
4574 }
4575
4576 /* Given two ranges, see if we can merge them into one.  Return 1 if we
4577    can, 0 if we can't.  Set the output range into the specified parameters.  */
4578
4579 bool
4580 merge_ranges (int *pin_p, tree *plow, tree *phigh, int in0_p, tree low0,
4581               tree high0, int in1_p, tree low1, tree high1)
4582 {
4583   int no_overlap;
4584   int subset;
4585   int temp;
4586   tree tem;
4587   int in_p;
4588   tree low, high;
4589   int lowequal = ((low0 == 0 && low1 == 0)
4590                   || integer_onep (range_binop (EQ_EXPR, integer_type_node,
4591                                                 low0, 0, low1, 0)));
4592   int highequal = ((high0 == 0 && high1 == 0)
4593                    || integer_onep (range_binop (EQ_EXPR, integer_type_node,
4594                                                  high0, 1, high1, 1)));
4595
4596   /* Make range 0 be the range that starts first, or ends last if they
4597      start at the same value.  Swap them if it isn't.  */
4598   if (integer_onep (range_binop (GT_EXPR, integer_type_node,
4599                                  low0, 0, low1, 0))
4600       || (lowequal
4601           && integer_onep (range_binop (GT_EXPR, integer_type_node,
4602                                         high1, 1, high0, 1))))
4603     {
4604       temp = in0_p, in0_p = in1_p, in1_p = temp;
4605       tem = low0, low0 = low1, low1 = tem;
4606       tem = high0, high0 = high1, high1 = tem;
4607     }
4608
4609   /* Now flag two cases, whether the ranges are disjoint or whether the
4610      second range is totally subsumed in the first.  Note that the tests
4611      below are simplified by the ones above.  */
4612   no_overlap = integer_onep (range_binop (LT_EXPR, integer_type_node,
4613                                           high0, 1, low1, 0));
4614   subset = integer_onep (range_binop (LE_EXPR, integer_type_node,
4615                                       high1, 1, high0, 1));
4616
4617   /* We now have four cases, depending on whether we are including or
4618      excluding the two ranges.  */
4619   if (in0_p && in1_p)
4620     {
4621       /* If they don't overlap, the result is false.  If the second range
4622          is a subset it is the result.  Otherwise, the range is from the start
4623          of the second to the end of the first.  */
4624       if (no_overlap)
4625         in_p = 0, low = high = 0;
4626       else if (subset)
4627         in_p = 1, low = low1, high = high1;
4628       else
4629         in_p = 1, low = low1, high = high0;
4630     }
4631
4632   else if (in0_p && ! in1_p)
4633     {
4634       /* If they don't overlap, the result is the first range.  If they are
4635          equal, the result is false.  If the second range is a subset of the
4636          first, and the ranges begin at the same place, we go from just after
4637          the end of the second range to the end of the first.  If the second
4638          range is not a subset of the first, or if it is a subset and both
4639          ranges end at the same place, the range starts at the start of the
4640          first range and ends just before the second range.
4641          Otherwise, we can't describe this as a single range.  */
4642       if (no_overlap)
4643         in_p = 1, low = low0, high = high0;
4644       else if (lowequal && highequal)
4645         in_p = 0, low = high = 0;
4646       else if (subset && lowequal)
4647         {
4648           low = range_successor (high1);
4649           high = high0;
4650           in_p = 1;
4651           if (low == 0)
4652             {
4653               /* We are in the weird situation where high0 > high1 but
4654                  high1 has no successor.  Punt.  */
4655               return 0;
4656             }
4657         }
4658       else if (! subset || highequal)
4659         {
4660           low = low0;
4661           high = range_predecessor (low1);
4662           in_p = 1;
4663           if (high == 0)
4664             {
4665               /* low0 < low1 but low1 has no predecessor.  Punt.  */
4666               return 0;
4667             }
4668         }
4669       else
4670         return 0;
4671     }
4672
4673   else if (! in0_p && in1_p)
4674     {
4675       /* If they don't overlap, the result is the second range.  If the second
4676          is a subset of the first, the result is false.  Otherwise,
4677          the range starts just after the first range and ends at the
4678          end of the second.  */
4679       if (no_overlap)
4680         in_p = 1, low = low1, high = high1;
4681       else if (subset || highequal)
4682         in_p = 0, low = high = 0;
4683       else
4684         {
4685           low = range_successor (high0);
4686           high = high1;
4687           in_p = 1;
4688           if (low == 0)
4689             {
4690               /* high1 > high0 but high0 has no successor.  Punt.  */
4691               return 0;
4692             }
4693         }
4694     }
4695
4696   else
4697     {
4698       /* The case where we are excluding both ranges.  Here the complex case
4699          is if they don't overlap.  In that case, the only time we have a
4700          range is if they are adjacent.  If the second is a subset of the
4701          first, the result is the first.  Otherwise, the range to exclude
4702          starts at the beginning of the first range and ends at the end of the
4703          second.  */
4704       if (no_overlap)
4705         {
4706           if (integer_onep (range_binop (EQ_EXPR, integer_type_node,
4707                                          range_successor (high0),
4708                                          1, low1, 0)))
4709             in_p = 0, low = low0, high = high1;
4710           else
4711             {
4712               /* Canonicalize - [min, x] into - [-, x].  */
4713               if (low0 && TREE_CODE (low0) == INTEGER_CST)
4714                 switch (TREE_CODE (TREE_TYPE (low0)))
4715                   {
4716                   case ENUMERAL_TYPE:
4717                     if (TYPE_PRECISION (TREE_TYPE (low0))
4718                         != GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (low0))))
4719                       break;
4720                     /* FALLTHROUGH */
4721                   case INTEGER_TYPE:
4722                     if (tree_int_cst_equal (low0,
4723                                             TYPE_MIN_VALUE (TREE_TYPE (low0))))
4724                       low0 = 0;
4725                     break;
4726                   case POINTER_TYPE:
4727                     if (TYPE_UNSIGNED (TREE_TYPE (low0))
4728                         && integer_zerop (low0))
4729                       low0 = 0;
4730                     break;
4731                   default:
4732                     break;
4733                   }
4734
4735               /* Canonicalize - [x, max] into - [x, -].  */
4736               if (high1 && TREE_CODE (high1) == INTEGER_CST)
4737                 switch (TREE_CODE (TREE_TYPE (high1)))
4738                   {
4739                   case ENUMERAL_TYPE:
4740                     if (TYPE_PRECISION (TREE_TYPE (high1))
4741                         != GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (high1))))
4742                       break;
4743                     /* FALLTHROUGH */
4744                   case INTEGER_TYPE:
4745                     if (tree_int_cst_equal (high1,
4746                                             TYPE_MAX_VALUE (TREE_TYPE (high1))))
4747                       high1 = 0;
4748                     break;
4749                   case POINTER_TYPE:
4750                     if (TYPE_UNSIGNED (TREE_TYPE (high1))
4751                         && integer_zerop (range_binop (PLUS_EXPR, NULL_TREE,
4752                                                        high1, 1,
4753                                                        build_int_cst (TREE_TYPE (high1), 1),
4754                                                        1)))
4755                       high1 = 0;
4756                     break;
4757                   default:
4758                     break;
4759                   }
4760
4761               /* The ranges might be also adjacent between the maximum and
4762                  minimum values of the given type.  For
4763                  - [{min,-}, x] and - [y, {max,-}] ranges where x + 1 < y
4764                  return + [x + 1, y - 1].  */
4765               if (low0 == 0 && high1 == 0)
4766                 {
4767                   low = range_successor (high0);
4768                   high = range_predecessor (low1);
4769                   if (low == 0 || high == 0)
4770                     return 0;
4771
4772                   in_p = 1;
4773                 }
4774               else
4775                 return 0;
4776             }
4777         }
4778       else if (subset)
4779         in_p = 0, low = low0, high = high0;
4780       else
4781         in_p = 0, low = low0, high = high1;
4782     }
4783
4784   *pin_p = in_p, *plow = low, *phigh = high;
4785   return 1;
4786 }
4787 \f
4788
4789 /* Subroutine of fold, looking inside expressions of the form
4790    A op B ? A : C, where ARG0, ARG1 and ARG2 are the three operands
4791    of the COND_EXPR.  This function is being used also to optimize
4792    A op B ? C : A, by reversing the comparison first.
4793
4794    Return a folded expression whose code is not a COND_EXPR
4795    anymore, or NULL_TREE if no folding opportunity is found.  */
4796
4797 static tree
4798 fold_cond_expr_with_comparison (location_t loc, tree type,
4799                                 tree arg0, tree arg1, tree arg2)
4800 {
4801   enum tree_code comp_code = TREE_CODE (arg0);
4802   tree arg00 = TREE_OPERAND (arg0, 0);
4803   tree arg01 = TREE_OPERAND (arg0, 1);
4804   tree arg1_type = TREE_TYPE (arg1);
4805   tree tem;
4806
4807   STRIP_NOPS (arg1);
4808   STRIP_NOPS (arg2);
4809
4810   /* If we have A op 0 ? A : -A, consider applying the following
4811      transformations:
4812
4813      A == 0? A : -A    same as -A
4814      A != 0? A : -A    same as A
4815      A >= 0? A : -A    same as abs (A)
4816      A > 0?  A : -A    same as abs (A)
4817      A <= 0? A : -A    same as -abs (A)
4818      A < 0?  A : -A    same as -abs (A)
4819
4820      None of these transformations work for modes with signed
4821      zeros.  If A is +/-0, the first two transformations will
4822      change the sign of the result (from +0 to -0, or vice
4823      versa).  The last four will fix the sign of the result,
4824      even though the original expressions could be positive or
4825      negative, depending on the sign of A.
4826
4827      Note that all these transformations are correct if A is
4828      NaN, since the two alternatives (A and -A) are also NaNs.  */
4829   if (!HONOR_SIGNED_ZEROS (element_mode (type))
4830       && (FLOAT_TYPE_P (TREE_TYPE (arg01))
4831           ? real_zerop (arg01)
4832           : integer_zerop (arg01))
4833       && ((TREE_CODE (arg2) == NEGATE_EXPR
4834            && operand_equal_p (TREE_OPERAND (arg2, 0), arg1, 0))
4835              /* In the case that A is of the form X-Y, '-A' (arg2) may
4836                 have already been folded to Y-X, check for that. */
4837           || (TREE_CODE (arg1) == MINUS_EXPR
4838               && TREE_CODE (arg2) == MINUS_EXPR
4839               && operand_equal_p (TREE_OPERAND (arg1, 0),
4840                                   TREE_OPERAND (arg2, 1), 0)
4841               && operand_equal_p (TREE_OPERAND (arg1, 1),
4842                                   TREE_OPERAND (arg2, 0), 0))))
4843     switch (comp_code)
4844       {
4845       case EQ_EXPR:
4846       case UNEQ_EXPR:
4847         tem = fold_convert_loc (loc, arg1_type, arg1);
4848         return pedantic_non_lvalue_loc (loc,
4849                                     fold_convert_loc (loc, type,
4850                                                   negate_expr (tem)));
4851       case NE_EXPR:
4852       case LTGT_EXPR:
4853         return pedantic_non_lvalue_loc (loc, fold_convert_loc (loc, type, arg1));
4854       case UNGE_EXPR:
4855       case UNGT_EXPR:
4856         if (flag_trapping_math)
4857           break;
4858         /* Fall through.  */
4859       case GE_EXPR:
4860       case GT_EXPR:
4861         if (TYPE_UNSIGNED (TREE_TYPE (arg1)))
4862           arg1 = fold_convert_loc (loc, signed_type_for
4863                                (TREE_TYPE (arg1)), arg1);
4864         tem = fold_build1_loc (loc, ABS_EXPR, TREE_TYPE (arg1), arg1);
4865         return pedantic_non_lvalue_loc (loc, fold_convert_loc (loc, type, tem));
4866       case UNLE_EXPR:
4867       case UNLT_EXPR:
4868         if (flag_trapping_math)
4869           break;
4870       case LE_EXPR:
4871       case LT_EXPR:
4872         if (TYPE_UNSIGNED (TREE_TYPE (arg1)))
4873           arg1 = fold_convert_loc (loc, signed_type_for
4874                                (TREE_TYPE (arg1)), arg1);
4875         tem = fold_build1_loc (loc, ABS_EXPR, TREE_TYPE (arg1), arg1);
4876         return negate_expr (fold_convert_loc (loc, type, tem));
4877       default:
4878         gcc_assert (TREE_CODE_CLASS (comp_code) == tcc_comparison);
4879         break;
4880       }
4881
4882   /* A != 0 ? A : 0 is simply A, unless A is -0.  Likewise
4883      A == 0 ? A : 0 is always 0 unless A is -0.  Note that
4884      both transformations are correct when A is NaN: A != 0
4885      is then true, and A == 0 is false.  */
4886
4887   if (!HONOR_SIGNED_ZEROS (element_mode (type))
4888       && integer_zerop (arg01) && integer_zerop (arg2))
4889     {
4890       if (comp_code == NE_EXPR)
4891         return pedantic_non_lvalue_loc (loc, fold_convert_loc (loc, type, arg1));
4892       else if (comp_code == EQ_EXPR)
4893         return build_zero_cst (type);
4894     }
4895
4896   /* Try some transformations of A op B ? A : B.
4897
4898      A == B? A : B    same as B
4899      A != B? A : B    same as A
4900      A >= B? A : B    same as max (A, B)
4901      A > B?  A : B    same as max (B, A)
4902      A <= B? A : B    same as min (A, B)
4903      A < B?  A : B    same as min (B, A)
4904
4905      As above, these transformations don't work in the presence
4906      of signed zeros.  For example, if A and B are zeros of
4907      opposite sign, the first two transformations will change
4908      the sign of the result.  In the last four, the original
4909      expressions give different results for (A=+0, B=-0) and
4910      (A=-0, B=+0), but the transformed expressions do not.
4911
4912      The first two transformations are correct if either A or B
4913      is a NaN.  In the first transformation, the condition will
4914      be false, and B will indeed be chosen.  In the case of the
4915      second transformation, the condition A != B will be true,
4916      and A will be chosen.
4917
4918      The conversions to max() and min() are not correct if B is
4919      a number and A is not.  The conditions in the original
4920      expressions will be false, so all four give B.  The min()
4921      and max() versions would give a NaN instead.  */
4922   if (!HONOR_SIGNED_ZEROS (element_mode (type))
4923       && operand_equal_for_comparison_p (arg01, arg2, arg00)
4924       /* Avoid these transformations if the COND_EXPR may be used
4925          as an lvalue in the C++ front-end.  PR c++/19199.  */
4926       && (in_gimple_form
4927           || VECTOR_TYPE_P (type)
4928           || (! lang_GNU_CXX ()
4929               && strcmp (lang_hooks.name, "GNU Objective-C++") != 0)
4930           || ! maybe_lvalue_p (arg1)
4931           || ! maybe_lvalue_p (arg2)))
4932     {
4933       tree comp_op0 = arg00;
4934       tree comp_op1 = arg01;
4935       tree comp_type = TREE_TYPE (comp_op0);
4936
4937       /* Avoid adding NOP_EXPRs in case this is an lvalue.  */
4938       if (TYPE_MAIN_VARIANT (comp_type) == TYPE_MAIN_VARIANT (type))
4939         {
4940           comp_type = type;
4941           comp_op0 = arg1;
4942           comp_op1 = arg2;
4943         }
4944
4945       switch (comp_code)
4946         {
4947         case EQ_EXPR:
4948           return pedantic_non_lvalue_loc (loc, fold_convert_loc (loc, type, arg2));
4949         case NE_EXPR:
4950           return pedantic_non_lvalue_loc (loc, fold_convert_loc (loc, type, arg1));
4951         case LE_EXPR:
4952         case LT_EXPR:
4953         case UNLE_EXPR:
4954         case UNLT_EXPR:
4955           /* In C++ a ?: expression can be an lvalue, so put the
4956              operand which will be used if they are equal first
4957              so that we can convert this back to the
4958              corresponding COND_EXPR.  */
4959           if (!HONOR_NANS (arg1))
4960             {
4961               comp_op0 = fold_convert_loc (loc, comp_type, comp_op0);
4962               comp_op1 = fold_convert_loc (loc, comp_type, comp_op1);
4963               tem = (comp_code == LE_EXPR || comp_code == UNLE_EXPR)
4964                     ? fold_build2_loc (loc, MIN_EXPR, comp_type, comp_op0, comp_op1)
4965                     : fold_build2_loc (loc, MIN_EXPR, comp_type,
4966                                    comp_op1, comp_op0);
4967               return pedantic_non_lvalue_loc (loc,
4968                                           fold_convert_loc (loc, type, tem));
4969             }
4970           break;
4971         case GE_EXPR:
4972         case GT_EXPR:
4973         case UNGE_EXPR:
4974         case UNGT_EXPR:
4975           if (!HONOR_NANS (arg1))
4976             {
4977               comp_op0 = fold_convert_loc (loc, comp_type, comp_op0);
4978               comp_op1 = fold_convert_loc (loc, comp_type, comp_op1);
4979               tem = (comp_code == GE_EXPR || comp_code == UNGE_EXPR)
4980                     ? fold_build2_loc (loc, MAX_EXPR, comp_type, comp_op0, comp_op1)
4981                     : fold_build2_loc (loc, MAX_EXPR, comp_type,
4982                                    comp_op1, comp_op0);
4983               return pedantic_non_lvalue_loc (loc,
4984                                           fold_convert_loc (loc, type, tem));
4985             }
4986           break;
4987         case UNEQ_EXPR:
4988           if (!HONOR_NANS (arg1))
4989             return pedantic_non_lvalue_loc (loc,
4990                                         fold_convert_loc (loc, type, arg2));
4991           break;
4992         case LTGT_EXPR:
4993           if (!HONOR_NANS (arg1))
4994             return pedantic_non_lvalue_loc (loc,
4995                                         fold_convert_loc (loc, type, arg1));
4996           break;
4997         default:
4998           gcc_assert (TREE_CODE_CLASS (comp_code) == tcc_comparison);
4999           break;
5000         }
5001     }
5002
5003   /* If this is A op C1 ? A : C2 with C1 and C2 constant integers,
5004      we might still be able to simplify this.  For example,
5005      if C1 is one less or one more than C2, this might have started
5006      out as a MIN or MAX and been transformed by this function.
5007      Only good for INTEGER_TYPEs, because we need TYPE_MAX_VALUE.  */
5008
5009   if (INTEGRAL_TYPE_P (type)
5010       && TREE_CODE (arg01) == INTEGER_CST
5011       && TREE_CODE (arg2) == INTEGER_CST)
5012     switch (comp_code)
5013       {
5014       case EQ_EXPR:
5015         if (TREE_CODE (arg1) == INTEGER_CST)
5016           break;
5017         /* We can replace A with C1 in this case.  */
5018         arg1 = fold_convert_loc (loc, type, arg01);
5019         return fold_build3_loc (loc, COND_EXPR, type, arg0, arg1, arg2);
5020
5021       case LT_EXPR:
5022         /* If C1 is C2 + 1, this is min(A, C2), but use ARG00's type for
5023            MIN_EXPR, to preserve the signedness of the comparison.  */
5024         if (! operand_equal_p (arg2, TYPE_MAX_VALUE (type),
5025                                OEP_ONLY_CONST)
5026             && operand_equal_p (arg01,
5027                                 const_binop (PLUS_EXPR, arg2,
5028                                              build_int_cst (type, 1)),
5029                                 OEP_ONLY_CONST))
5030           {
5031             tem = fold_build2_loc (loc, MIN_EXPR, TREE_TYPE (arg00), arg00,
5032                                    fold_convert_loc (loc, TREE_TYPE (arg00),
5033                                                      arg2));
5034             return pedantic_non_lvalue_loc (loc,
5035                                             fold_convert_loc (loc, type, tem));
5036           }
5037         break;
5038
5039       case LE_EXPR:
5040         /* If C1 is C2 - 1, this is min(A, C2), with the same care
5041            as above.  */
5042         if (! operand_equal_p (arg2, TYPE_MIN_VALUE (type),
5043                                OEP_ONLY_CONST)
5044             && operand_equal_p (arg01,
5045                                 const_binop (MINUS_EXPR, arg2,
5046                                              build_int_cst (type, 1)),
5047                                 OEP_ONLY_CONST))
5048           {
5049             tem = fold_build2_loc (loc, MIN_EXPR, TREE_TYPE (arg00), arg00,
5050                                    fold_convert_loc (loc, TREE_TYPE (arg00),
5051                                                      arg2));
5052             return pedantic_non_lvalue_loc (loc,
5053                                             fold_convert_loc (loc, type, tem));
5054           }
5055         break;
5056
5057       case GT_EXPR:
5058         /* If C1 is C2 - 1, this is max(A, C2), but use ARG00's type for
5059            MAX_EXPR, to preserve the signedness of the comparison.  */
5060         if (! operand_equal_p (arg2, TYPE_MIN_VALUE (type),
5061                                OEP_ONLY_CONST)
5062             && operand_equal_p (arg01,
5063                                 const_binop (MINUS_EXPR, arg2,
5064                                              build_int_cst (type, 1)),
5065                                 OEP_ONLY_CONST))
5066           {
5067             tem = fold_build2_loc (loc, MAX_EXPR, TREE_TYPE (arg00), arg00,
5068                                    fold_convert_loc (loc, TREE_TYPE (arg00),
5069                                                      arg2));
5070             return pedantic_non_lvalue_loc (loc, fold_convert_loc (loc, type, tem));
5071           }
5072         break;
5073
5074       case GE_EXPR:
5075         /* If C1 is C2 + 1, this is max(A, C2), with the same care as above.  */
5076         if (! operand_equal_p (arg2, TYPE_MAX_VALUE (type),
5077                                OEP_ONLY_CONST)
5078             && operand_equal_p (arg01,
5079                                 const_binop (PLUS_EXPR, arg2,
5080                                              build_int_cst (type, 1)),
5081                                 OEP_ONLY_CONST))
5082           {
5083             tem = fold_build2_loc (loc, MAX_EXPR, TREE_TYPE (arg00), arg00,
5084                                    fold_convert_loc (loc, TREE_TYPE (arg00),
5085                                                      arg2));
5086             return pedantic_non_lvalue_loc (loc, fold_convert_loc (loc, type, tem));
5087           }
5088         break;
5089       case NE_EXPR:
5090         break;
5091       default:
5092         gcc_unreachable ();
5093       }
5094
5095   return NULL_TREE;
5096 }
5097
5098
5099 \f
5100 #ifndef LOGICAL_OP_NON_SHORT_CIRCUIT
5101 #define LOGICAL_OP_NON_SHORT_CIRCUIT \
5102   (BRANCH_COST (optimize_function_for_speed_p (cfun), \
5103                 false) >= 2)
5104 #endif
5105
5106 /* EXP is some logical combination of boolean tests.  See if we can
5107    merge it into some range test.  Return the new tree if so.  */
5108
5109 static tree
5110 fold_range_test (location_t loc, enum tree_code code, tree type,
5111                  tree op0, tree op1)
5112 {
5113   int or_op = (code == TRUTH_ORIF_EXPR
5114                || code == TRUTH_OR_EXPR);
5115   int in0_p, in1_p, in_p;
5116   tree low0, low1, low, high0, high1, high;
5117   bool strict_overflow_p = false;
5118   tree tem, lhs, rhs;
5119   const char * const warnmsg = G_("assuming signed overflow does not occur "
5120                                   "when simplifying range test");
5121
5122   if (!INTEGRAL_TYPE_P (type))
5123     return 0;
5124
5125   lhs = make_range (op0, &in0_p, &low0, &high0, &strict_overflow_p);
5126   rhs = make_range (op1, &in1_p, &low1, &high1, &strict_overflow_p);
5127
5128   /* If this is an OR operation, invert both sides; we will invert
5129      again at the end.  */
5130   if (or_op)
5131     in0_p = ! in0_p, in1_p = ! in1_p;
5132
5133   /* If both expressions are the same, if we can merge the ranges, and we
5134      can build the range test, return it or it inverted.  If one of the
5135      ranges is always true or always false, consider it to be the same
5136      expression as the other.  */
5137   if ((lhs == 0 || rhs == 0 || operand_equal_p (lhs, rhs, 0))
5138       && merge_ranges (&in_p, &low, &high, in0_p, low0, high0,
5139                        in1_p, low1, high1)
5140       && 0 != (tem = (build_range_check (loc, type,
5141                                          lhs != 0 ? lhs
5142                                          : rhs != 0 ? rhs : integer_zero_node,
5143                                          in_p, low, high))))
5144     {
5145       if (strict_overflow_p)
5146         fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_COMPARISON);
5147       return or_op ? invert_truthvalue_loc (loc, tem) : tem;
5148     }
5149
5150   /* On machines where the branch cost is expensive, if this is a
5151      short-circuited branch and the underlying object on both sides
5152      is the same, make a non-short-circuit operation.  */
5153   else if (LOGICAL_OP_NON_SHORT_CIRCUIT
5154            && lhs != 0 && rhs != 0
5155            && (code == TRUTH_ANDIF_EXPR
5156                || code == TRUTH_ORIF_EXPR)
5157            && operand_equal_p (lhs, rhs, 0))
5158     {
5159       /* If simple enough, just rewrite.  Otherwise, make a SAVE_EXPR
5160          unless we are at top level or LHS contains a PLACEHOLDER_EXPR, in
5161          which cases we can't do this.  */
5162       if (simple_operand_p (lhs))
5163         return build2_loc (loc, code == TRUTH_ANDIF_EXPR
5164                            ? TRUTH_AND_EXPR : TRUTH_OR_EXPR,
5165                            type, op0, op1);
5166
5167       else if (!lang_hooks.decls.global_bindings_p ()
5168                && !CONTAINS_PLACEHOLDER_P (lhs))
5169         {
5170           tree common = save_expr (lhs);
5171
5172           if (0 != (lhs = build_range_check (loc, type, common,
5173                                              or_op ? ! in0_p : in0_p,
5174                                              low0, high0))
5175               && (0 != (rhs = build_range_check (loc, type, common,
5176                                                  or_op ? ! in1_p : in1_p,
5177                                                  low1, high1))))
5178             {
5179               if (strict_overflow_p)
5180                 fold_overflow_warning (warnmsg,
5181                                        WARN_STRICT_OVERFLOW_COMPARISON);
5182               return build2_loc (loc, code == TRUTH_ANDIF_EXPR
5183                                  ? TRUTH_AND_EXPR : TRUTH_OR_EXPR,
5184                                  type, lhs, rhs);
5185             }
5186         }
5187     }
5188
5189   return 0;
5190 }
5191 \f
5192 /* Subroutine for fold_truth_andor_1: C is an INTEGER_CST interpreted as a P
5193    bit value.  Arrange things so the extra bits will be set to zero if and
5194    only if C is signed-extended to its full width.  If MASK is nonzero,
5195    it is an INTEGER_CST that should be AND'ed with the extra bits.  */
5196
5197 static tree
5198 unextend (tree c, int p, int unsignedp, tree mask)
5199 {
5200   tree type = TREE_TYPE (c);
5201   int modesize = GET_MODE_BITSIZE (TYPE_MODE (type));
5202   tree temp;
5203
5204   if (p == modesize || unsignedp)
5205     return c;
5206
5207   /* We work by getting just the sign bit into the low-order bit, then
5208      into the high-order bit, then sign-extend.  We then XOR that value
5209      with C.  */
5210   temp = build_int_cst (TREE_TYPE (c), wi::extract_uhwi (c, p - 1, 1));
5211
5212   /* We must use a signed type in order to get an arithmetic right shift.
5213      However, we must also avoid introducing accidental overflows, so that
5214      a subsequent call to integer_zerop will work.  Hence we must
5215      do the type conversion here.  At this point, the constant is either
5216      zero or one, and the conversion to a signed type can never overflow.
5217      We could get an overflow if this conversion is done anywhere else.  */
5218   if (TYPE_UNSIGNED (type))
5219     temp = fold_convert (signed_type_for (type), temp);
5220
5221   temp = const_binop (LSHIFT_EXPR, temp, size_int (modesize - 1));
5222   temp = const_binop (RSHIFT_EXPR, temp, size_int (modesize - p - 1));
5223   if (mask != 0)
5224     temp = const_binop (BIT_AND_EXPR, temp,
5225                         fold_convert (TREE_TYPE (c), mask));
5226   /* If necessary, convert the type back to match the type of C.  */
5227   if (TYPE_UNSIGNED (type))
5228     temp = fold_convert (type, temp);
5229
5230   return fold_convert (type, const_binop (BIT_XOR_EXPR, c, temp));
5231 }
5232 \f
5233 /* For an expression that has the form
5234      (A && B) || ~B
5235    or
5236      (A || B) && ~B,
5237    we can drop one of the inner expressions and simplify to
5238      A || ~B
5239    or
5240      A && ~B
5241    LOC is the location of the resulting expression.  OP is the inner
5242    logical operation; the left-hand side in the examples above, while CMPOP
5243    is the right-hand side.  RHS_ONLY is used to prevent us from accidentally
5244    removing a condition that guards another, as in
5245      (A != NULL && A->...) || A == NULL
5246    which we must not transform.  If RHS_ONLY is true, only eliminate the
5247    right-most operand of the inner logical operation.  */
5248
5249 static tree
5250 merge_truthop_with_opposite_arm (location_t loc, tree op, tree cmpop,
5251                                  bool rhs_only)
5252 {
5253   tree type = TREE_TYPE (cmpop);
5254   enum tree_code code = TREE_CODE (cmpop);
5255   enum tree_code truthop_code = TREE_CODE (op);
5256   tree lhs = TREE_OPERAND (op, 0);
5257   tree rhs = TREE_OPERAND (op, 1);
5258   tree orig_lhs = lhs, orig_rhs = rhs;
5259   enum tree_code rhs_code = TREE_CODE (rhs);
5260   enum tree_code lhs_code = TREE_CODE (lhs);
5261   enum tree_code inv_code;
5262
5263   if (TREE_SIDE_EFFECTS (op) || TREE_SIDE_EFFECTS (cmpop))
5264     return NULL_TREE;
5265
5266   if (TREE_CODE_CLASS (code) != tcc_comparison)
5267     return NULL_TREE;
5268
5269   if (rhs_code == truthop_code)
5270     {
5271       tree newrhs = merge_truthop_with_opposite_arm (loc, rhs, cmpop, rhs_only);
5272       if (newrhs != NULL_TREE)
5273         {
5274           rhs = newrhs;
5275           rhs_code = TREE_CODE (rhs);
5276         }
5277     }
5278   if (lhs_code == truthop_code && !rhs_only)
5279     {
5280       tree newlhs = merge_truthop_with_opposite_arm (loc, lhs, cmpop, false);
5281       if (newlhs != NULL_TREE)
5282         {
5283           lhs = newlhs;
5284           lhs_code = TREE_CODE (lhs);
5285         }
5286     }
5287
5288   inv_code = invert_tree_comparison (code, HONOR_NANS (type));
5289   if (inv_code == rhs_code
5290       && operand_equal_p (TREE_OPERAND (rhs, 0), TREE_OPERAND (cmpop, 0), 0)
5291       && operand_equal_p (TREE_OPERAND (rhs, 1), TREE_OPERAND (cmpop, 1), 0))
5292     return lhs;
5293   if (!rhs_only && inv_code == lhs_code
5294       && operand_equal_p (TREE_OPERAND (lhs, 0), TREE_OPERAND (cmpop, 0), 0)
5295       && operand_equal_p (TREE_OPERAND (lhs, 1), TREE_OPERAND (cmpop, 1), 0))
5296     return rhs;
5297   if (rhs != orig_rhs || lhs != orig_lhs)
5298     return fold_build2_loc (loc, truthop_code, TREE_TYPE (cmpop),
5299                             lhs, rhs);
5300   return NULL_TREE;
5301 }
5302
5303 /* Find ways of folding logical expressions of LHS and RHS:
5304    Try to merge two comparisons to the same innermost item.
5305    Look for range tests like "ch >= '0' && ch <= '9'".
5306    Look for combinations of simple terms on machines with expensive branches
5307    and evaluate the RHS unconditionally.
5308
5309    For example, if we have p->a == 2 && p->b == 4 and we can make an
5310    object large enough to span both A and B, we can do this with a comparison
5311    against the object ANDed with the a mask.
5312
5313    If we have p->a == q->a && p->b == q->b, we may be able to use bit masking
5314    operations to do this with one comparison.
5315
5316    We check for both normal comparisons and the BIT_AND_EXPRs made this by
5317    function and the one above.
5318
5319    CODE is the logical operation being done.  It can be TRUTH_ANDIF_EXPR,
5320    TRUTH_AND_EXPR, TRUTH_ORIF_EXPR, or TRUTH_OR_EXPR.
5321
5322    TRUTH_TYPE is the type of the logical operand and LHS and RHS are its
5323    two operands.
5324
5325    We return the simplified tree or 0 if no optimization is possible.  */
5326
5327 static tree
5328 fold_truth_andor_1 (location_t loc, enum tree_code code, tree truth_type,
5329                     tree lhs, tree rhs)
5330 {
5331   /* If this is the "or" of two comparisons, we can do something if
5332      the comparisons are NE_EXPR.  If this is the "and", we can do something
5333      if the comparisons are EQ_EXPR.  I.e.,
5334         (a->b == 2 && a->c == 4) can become (a->new == NEW).
5335
5336      WANTED_CODE is this operation code.  For single bit fields, we can
5337      convert EQ_EXPR to NE_EXPR so we need not reject the "wrong"
5338      comparison for one-bit fields.  */
5339
5340   enum tree_code wanted_code;
5341   enum tree_code lcode, rcode;
5342   tree ll_arg, lr_arg, rl_arg, rr_arg;
5343   tree ll_inner, lr_inner, rl_inner, rr_inner;
5344   HOST_WIDE_INT ll_bitsize, ll_bitpos, lr_bitsize, lr_bitpos;
5345   HOST_WIDE_INT rl_bitsize, rl_bitpos, rr_bitsize, rr_bitpos;
5346   HOST_WIDE_INT xll_bitpos, xlr_bitpos, xrl_bitpos, xrr_bitpos;
5347   HOST_WIDE_INT lnbitsize, lnbitpos, rnbitsize, rnbitpos;
5348   int ll_unsignedp, lr_unsignedp, rl_unsignedp, rr_unsignedp;
5349   machine_mode ll_mode, lr_mode, rl_mode, rr_mode;
5350   machine_mode lnmode, rnmode;
5351   tree ll_mask, lr_mask, rl_mask, rr_mask;
5352   tree ll_and_mask, lr_and_mask, rl_and_mask, rr_and_mask;
5353   tree l_const, r_const;
5354   tree lntype, rntype, result;
5355   HOST_WIDE_INT first_bit, end_bit;
5356   int volatilep;
5357
5358   /* Start by getting the comparison codes.  Fail if anything is volatile.
5359      If one operand is a BIT_AND_EXPR with the constant one, treat it as if
5360      it were surrounded with a NE_EXPR.  */
5361
5362   if (TREE_SIDE_EFFECTS (lhs) || TREE_SIDE_EFFECTS (rhs))
5363     return 0;
5364
5365   lcode = TREE_CODE (lhs);
5366   rcode = TREE_CODE (rhs);
5367
5368   if (lcode == BIT_AND_EXPR && integer_onep (TREE_OPERAND (lhs, 1)))
5369     {
5370       lhs = build2 (NE_EXPR, truth_type, lhs,
5371                     build_int_cst (TREE_TYPE (lhs), 0));
5372       lcode = NE_EXPR;
5373     }
5374
5375   if (rcode == BIT_AND_EXPR && integer_onep (TREE_OPERAND (rhs, 1)))
5376     {
5377       rhs = build2 (NE_EXPR, truth_type, rhs,
5378                     build_int_cst (TREE_TYPE (rhs), 0));
5379       rcode = NE_EXPR;
5380     }
5381
5382   if (TREE_CODE_CLASS (lcode) != tcc_comparison
5383       || TREE_CODE_CLASS (rcode) != tcc_comparison)
5384     return 0;
5385
5386   ll_arg = TREE_OPERAND (lhs, 0);
5387   lr_arg = TREE_OPERAND (lhs, 1);
5388   rl_arg = TREE_OPERAND (rhs, 0);
5389   rr_arg = TREE_OPERAND (rhs, 1);
5390
5391   /* Simplify (x<y) && (x==y) into (x<=y) and related optimizations.  */
5392   if (simple_operand_p (ll_arg)
5393       && simple_operand_p (lr_arg))
5394     {
5395       if (operand_equal_p (ll_arg, rl_arg, 0)
5396           && operand_equal_p (lr_arg, rr_arg, 0))
5397         {
5398           result = combine_comparisons (loc, code, lcode, rcode,
5399                                         truth_type, ll_arg, lr_arg);
5400           if (result)
5401             return result;
5402         }
5403       else if (operand_equal_p (ll_arg, rr_arg, 0)
5404                && operand_equal_p (lr_arg, rl_arg, 0))
5405         {
5406           result = combine_comparisons (loc, code, lcode,
5407                                         swap_tree_comparison (rcode),
5408                                         truth_type, ll_arg, lr_arg);
5409           if (result)
5410             return result;
5411         }
5412     }
5413
5414   code = ((code == TRUTH_AND_EXPR || code == TRUTH_ANDIF_EXPR)
5415           ? TRUTH_AND_EXPR : TRUTH_OR_EXPR);
5416
5417   /* If the RHS can be evaluated unconditionally and its operands are
5418      simple, it wins to evaluate the RHS unconditionally on machines
5419      with expensive branches.  In this case, this isn't a comparison
5420      that can be merged.  */
5421
5422   if (BRANCH_COST (optimize_function_for_speed_p (cfun),
5423                    false) >= 2
5424       && ! FLOAT_TYPE_P (TREE_TYPE (rl_arg))
5425       && simple_operand_p (rl_arg)
5426       && simple_operand_p (rr_arg))
5427     {
5428       /* Convert (a != 0) || (b != 0) into (a | b) != 0.  */
5429       if (code == TRUTH_OR_EXPR
5430           && lcode == NE_EXPR && integer_zerop (lr_arg)
5431           && rcode == NE_EXPR && integer_zerop (rr_arg)
5432           && TREE_TYPE (ll_arg) == TREE_TYPE (rl_arg)
5433           && INTEGRAL_TYPE_P (TREE_TYPE (ll_arg)))
5434         return build2_loc (loc, NE_EXPR, truth_type,
5435                            build2 (BIT_IOR_EXPR, TREE_TYPE (ll_arg),
5436                                    ll_arg, rl_arg),
5437                            build_int_cst (TREE_TYPE (ll_arg), 0));
5438
5439       /* Convert (a == 0) && (b == 0) into (a | b) == 0.  */
5440       if (code == TRUTH_AND_EXPR
5441           && lcode == EQ_EXPR && integer_zerop (lr_arg)
5442           && rcode == EQ_EXPR && integer_zerop (rr_arg)
5443           && TREE_TYPE (ll_arg) == TREE_TYPE (rl_arg)
5444           && INTEGRAL_TYPE_P (TREE_TYPE (ll_arg)))
5445         return build2_loc (loc, EQ_EXPR, truth_type,
5446                            build2 (BIT_IOR_EXPR, TREE_TYPE (ll_arg),
5447                                    ll_arg, rl_arg),
5448                            build_int_cst (TREE_TYPE (ll_arg), 0));
5449     }
5450
5451   /* See if the comparisons can be merged.  Then get all the parameters for
5452      each side.  */
5453
5454   if ((lcode != EQ_EXPR && lcode != NE_EXPR)
5455       || (rcode != EQ_EXPR && rcode != NE_EXPR))
5456     return 0;
5457
5458   volatilep = 0;
5459   ll_inner = decode_field_reference (loc, ll_arg,
5460                                      &ll_bitsize, &ll_bitpos, &ll_mode,
5461                                      &ll_unsignedp, &volatilep, &ll_mask,
5462                                      &ll_and_mask);
5463   lr_inner = decode_field_reference (loc, lr_arg,
5464                                      &lr_bitsize, &lr_bitpos, &lr_mode,
5465                                      &lr_unsignedp, &volatilep, &lr_mask,
5466                                      &lr_and_mask);
5467   rl_inner = decode_field_reference (loc, rl_arg,
5468                                      &rl_bitsize, &rl_bitpos, &rl_mode,
5469                                      &rl_unsignedp, &volatilep, &rl_mask,
5470                                      &rl_and_mask);
5471   rr_inner = decode_field_reference (loc, rr_arg,
5472                                      &rr_bitsize, &rr_bitpos, &rr_mode,
5473                                      &rr_unsignedp, &volatilep, &rr_mask,
5474                                      &rr_and_mask);
5475
5476   /* It must be true that the inner operation on the lhs of each
5477      comparison must be the same if we are to be able to do anything.
5478      Then see if we have constants.  If not, the same must be true for
5479      the rhs's.  */
5480   if (volatilep || ll_inner == 0 || rl_inner == 0
5481       || ! operand_equal_p (ll_inner, rl_inner, 0))
5482     return 0;
5483
5484   if (TREE_CODE (lr_arg) == INTEGER_CST
5485       && TREE_CODE (rr_arg) == INTEGER_CST)
5486     l_const = lr_arg, r_const = rr_arg;
5487   else if (lr_inner == 0 || rr_inner == 0
5488            || ! operand_equal_p (lr_inner, rr_inner, 0))
5489     return 0;
5490   else
5491     l_const = r_const = 0;
5492
5493   /* If either comparison code is not correct for our logical operation,
5494      fail.  However, we can convert a one-bit comparison against zero into
5495      the opposite comparison against that bit being set in the field.  */
5496
5497   wanted_code = (code == TRUTH_AND_EXPR ? EQ_EXPR : NE_EXPR);
5498   if (lcode != wanted_code)
5499     {
5500       if (l_const && integer_zerop (l_const) && integer_pow2p (ll_mask))
5501         {
5502           /* Make the left operand unsigned, since we are only interested
5503              in the value of one bit.  Otherwise we are doing the wrong
5504              thing below.  */
5505           ll_unsignedp = 1;
5506           l_const = ll_mask;
5507         }
5508       else
5509         return 0;
5510     }
5511
5512   /* This is analogous to the code for l_const above.  */
5513   if (rcode != wanted_code)
5514     {
5515       if (r_const && integer_zerop (r_const) && integer_pow2p (rl_mask))
5516         {
5517           rl_unsignedp = 1;
5518           r_const = rl_mask;
5519         }
5520       else
5521         return 0;
5522     }
5523
5524   /* See if we can find a mode that contains both fields being compared on
5525      the left.  If we can't, fail.  Otherwise, update all constants and masks
5526      to be relative to a field of that size.  */
5527   first_bit = MIN (ll_bitpos, rl_bitpos);
5528   end_bit = MAX (ll_bitpos + ll_bitsize, rl_bitpos + rl_bitsize);
5529   lnmode = get_best_mode (end_bit - first_bit, first_bit, 0, 0,
5530                           TYPE_ALIGN (TREE_TYPE (ll_inner)), word_mode,
5531                           volatilep);
5532   if (lnmode == VOIDmode)
5533     return 0;
5534
5535   lnbitsize = GET_MODE_BITSIZE (lnmode);
5536   lnbitpos = first_bit & ~ (lnbitsize - 1);
5537   lntype = lang_hooks.types.type_for_size (lnbitsize, 1);
5538   xll_bitpos = ll_bitpos - lnbitpos, xrl_bitpos = rl_bitpos - lnbitpos;
5539
5540   if (BYTES_BIG_ENDIAN)
5541     {
5542       xll_bitpos = lnbitsize - xll_bitpos - ll_bitsize;
5543       xrl_bitpos = lnbitsize - xrl_bitpos - rl_bitsize;
5544     }
5545
5546   ll_mask = const_binop (LSHIFT_EXPR, fold_convert_loc (loc, lntype, ll_mask),
5547                          size_int (xll_bitpos));
5548   rl_mask = const_binop (LSHIFT_EXPR, fold_convert_loc (loc, lntype, rl_mask),
5549                          size_int (xrl_bitpos));
5550
5551   if (l_const)
5552     {
5553       l_const = fold_convert_loc (loc, lntype, l_const);
5554       l_const = unextend (l_const, ll_bitsize, ll_unsignedp, ll_and_mask);
5555       l_const = const_binop (LSHIFT_EXPR, l_const, size_int (xll_bitpos));
5556       if (! integer_zerop (const_binop (BIT_AND_EXPR, l_const,
5557                                         fold_build1_loc (loc, BIT_NOT_EXPR,
5558                                                      lntype, ll_mask))))
5559         {
5560           warning (0, "comparison is always %d", wanted_code == NE_EXPR);
5561
5562           return constant_boolean_node (wanted_code == NE_EXPR, truth_type);
5563         }
5564     }
5565   if (r_const)
5566     {
5567       r_const = fold_convert_loc (loc, lntype, r_const);
5568       r_const = unextend (r_const, rl_bitsize, rl_unsignedp, rl_and_mask);
5569       r_const = const_binop (LSHIFT_EXPR, r_const, size_int (xrl_bitpos));
5570       if (! integer_zerop (const_binop (BIT_AND_EXPR, r_const,
5571                                         fold_build1_loc (loc, BIT_NOT_EXPR,
5572                                                      lntype, rl_mask))))
5573         {
5574           warning (0, "comparison is always %d", wanted_code == NE_EXPR);
5575
5576           return constant_boolean_node (wanted_code == NE_EXPR, truth_type);
5577         }
5578     }
5579
5580   /* If the right sides are not constant, do the same for it.  Also,
5581      disallow this optimization if a size or signedness mismatch occurs
5582      between the left and right sides.  */
5583   if (l_const == 0)
5584     {
5585       if (ll_bitsize != lr_bitsize || rl_bitsize != rr_bitsize
5586           || ll_unsignedp != lr_unsignedp || rl_unsignedp != rr_unsignedp
5587           /* Make sure the two fields on the right
5588              correspond to the left without being swapped.  */
5589           || ll_bitpos - rl_bitpos != lr_bitpos - rr_bitpos)
5590         return 0;
5591
5592       first_bit = MIN (lr_bitpos, rr_bitpos);
5593       end_bit = MAX (lr_bitpos + lr_bitsize, rr_bitpos + rr_bitsize);
5594       rnmode = get_best_mode (end_bit - first_bit, first_bit, 0, 0,
5595                               TYPE_ALIGN (TREE_TYPE (lr_inner)), word_mode,
5596                               volatilep);
5597       if (rnmode == VOIDmode)
5598         return 0;
5599
5600       rnbitsize = GET_MODE_BITSIZE (rnmode);
5601       rnbitpos = first_bit & ~ (rnbitsize - 1);
5602       rntype = lang_hooks.types.type_for_size (rnbitsize, 1);
5603       xlr_bitpos = lr_bitpos - rnbitpos, xrr_bitpos = rr_bitpos - rnbitpos;
5604
5605       if (BYTES_BIG_ENDIAN)
5606         {
5607           xlr_bitpos = rnbitsize - xlr_bitpos - lr_bitsize;
5608           xrr_bitpos = rnbitsize - xrr_bitpos - rr_bitsize;
5609         }
5610
5611       lr_mask = const_binop (LSHIFT_EXPR, fold_convert_loc (loc,
5612                                                             rntype, lr_mask),
5613                              size_int (xlr_bitpos));
5614       rr_mask = const_binop (LSHIFT_EXPR, fold_convert_loc (loc,
5615                                                             rntype, rr_mask),
5616                              size_int (xrr_bitpos));
5617
5618       /* Make a mask that corresponds to both fields being compared.
5619          Do this for both items being compared.  If the operands are the
5620          same size and the bits being compared are in the same position
5621          then we can do this by masking both and comparing the masked
5622          results.  */
5623       ll_mask = const_binop (BIT_IOR_EXPR, ll_mask, rl_mask);
5624       lr_mask = const_binop (BIT_IOR_EXPR, lr_mask, rr_mask);
5625       if (lnbitsize == rnbitsize && xll_bitpos == xlr_bitpos)
5626         {
5627           lhs = make_bit_field_ref (loc, ll_inner, lntype, lnbitsize, lnbitpos,
5628                                     ll_unsignedp || rl_unsignedp);
5629           if (! all_ones_mask_p (ll_mask, lnbitsize))
5630             lhs = build2 (BIT_AND_EXPR, lntype, lhs, ll_mask);
5631
5632           rhs = make_bit_field_ref (loc, lr_inner, rntype, rnbitsize, rnbitpos,
5633                                     lr_unsignedp || rr_unsignedp);
5634           if (! all_ones_mask_p (lr_mask, rnbitsize))
5635             rhs = build2 (BIT_AND_EXPR, rntype, rhs, lr_mask);
5636
5637           return build2_loc (loc, wanted_code, truth_type, lhs, rhs);
5638         }
5639
5640       /* There is still another way we can do something:  If both pairs of
5641          fields being compared are adjacent, we may be able to make a wider
5642          field containing them both.
5643
5644          Note that we still must mask the lhs/rhs expressions.  Furthermore,
5645          the mask must be shifted to account for the shift done by
5646          make_bit_field_ref.  */
5647       if ((ll_bitsize + ll_bitpos == rl_bitpos
5648            && lr_bitsize + lr_bitpos == rr_bitpos)
5649           || (ll_bitpos == rl_bitpos + rl_bitsize
5650               && lr_bitpos == rr_bitpos + rr_bitsize))
5651         {
5652           tree type;
5653
5654           lhs = make_bit_field_ref (loc, ll_inner, lntype,
5655                                     ll_bitsize + rl_bitsize,
5656                                     MIN (ll_bitpos, rl_bitpos), ll_unsignedp);
5657           rhs = make_bit_field_ref (loc, lr_inner, rntype,
5658                                     lr_bitsize + rr_bitsize,
5659                                     MIN (lr_bitpos, rr_bitpos), lr_unsignedp);
5660
5661           ll_mask = const_binop (RSHIFT_EXPR, ll_mask,
5662                                  size_int (MIN (xll_bitpos, xrl_bitpos)));
5663           lr_mask = const_binop (RSHIFT_EXPR, lr_mask,
5664                                  size_int (MIN (xlr_bitpos, xrr_bitpos)));
5665
5666           /* Convert to the smaller type before masking out unwanted bits.  */
5667           type = lntype;
5668           if (lntype != rntype)
5669             {
5670               if (lnbitsize > rnbitsize)
5671                 {
5672                   lhs = fold_convert_loc (loc, rntype, lhs);
5673                   ll_mask = fold_convert_loc (loc, rntype, ll_mask);
5674                   type = rntype;
5675                 }
5676               else if (lnbitsize < rnbitsize)
5677                 {
5678                   rhs = fold_convert_loc (loc, lntype, rhs);
5679                   lr_mask = fold_convert_loc (loc, lntype, lr_mask);
5680                   type = lntype;
5681                 }
5682             }
5683
5684           if (! all_ones_mask_p (ll_mask, ll_bitsize + rl_bitsize))
5685             lhs = build2 (BIT_AND_EXPR, type, lhs, ll_mask);
5686
5687           if (! all_ones_mask_p (lr_mask, lr_bitsize + rr_bitsize))
5688             rhs = build2 (BIT_AND_EXPR, type, rhs, lr_mask);
5689
5690           return build2_loc (loc, wanted_code, truth_type, lhs, rhs);
5691         }
5692
5693       return 0;
5694     }
5695
5696   /* Handle the case of comparisons with constants.  If there is something in
5697      common between the masks, those bits of the constants must be the same.
5698      If not, the condition is always false.  Test for this to avoid generating
5699      incorrect code below.  */
5700   result = const_binop (BIT_AND_EXPR, ll_mask, rl_mask);
5701   if (! integer_zerop (result)
5702       && simple_cst_equal (const_binop (BIT_AND_EXPR, result, l_const),
5703                            const_binop (BIT_AND_EXPR, result, r_const)) != 1)
5704     {
5705       if (wanted_code == NE_EXPR)
5706         {
5707           warning (0, "%<or%> of unmatched not-equal tests is always 1");
5708           return constant_boolean_node (true, truth_type);
5709         }
5710       else
5711         {
5712           warning (0, "%<and%> of mutually exclusive equal-tests is always 0");
5713           return constant_boolean_node (false, truth_type);
5714         }
5715     }
5716
5717   /* Construct the expression we will return.  First get the component
5718      reference we will make.  Unless the mask is all ones the width of
5719      that field, perform the mask operation.  Then compare with the
5720      merged constant.  */
5721   result = make_bit_field_ref (loc, ll_inner, lntype, lnbitsize, lnbitpos,
5722                                ll_unsignedp || rl_unsignedp);
5723
5724   ll_mask = const_binop (BIT_IOR_EXPR, ll_mask, rl_mask);
5725   if (! all_ones_mask_p (ll_mask, lnbitsize))
5726     result = build2_loc (loc, BIT_AND_EXPR, lntype, result, ll_mask);
5727
5728   return build2_loc (loc, wanted_code, truth_type, result,
5729                      const_binop (BIT_IOR_EXPR, l_const, r_const));
5730 }
5731 \f
5732 /* Optimize T, which is a comparison of a MIN_EXPR or MAX_EXPR with a
5733    constant.  */
5734
5735 static tree
5736 optimize_minmax_comparison (location_t loc, enum tree_code code, tree type,
5737                             tree op0, tree op1)
5738 {
5739   tree arg0 = op0;
5740   enum tree_code op_code;
5741   tree comp_const;
5742   tree minmax_const;
5743   int consts_equal, consts_lt;
5744   tree inner;
5745
5746   STRIP_SIGN_NOPS (arg0);
5747
5748   op_code = TREE_CODE (arg0);
5749   minmax_const = TREE_OPERAND (arg0, 1);
5750   comp_const = fold_convert_loc (loc, TREE_TYPE (arg0), op1);
5751   consts_equal = tree_int_cst_equal (minmax_const, comp_const);
5752   consts_lt = tree_int_cst_lt (minmax_const, comp_const);
5753   inner = TREE_OPERAND (arg0, 0);
5754
5755   /* If something does not permit us to optimize, return the original tree.  */
5756   if ((op_code != MIN_EXPR && op_code != MAX_EXPR)
5757       || TREE_CODE (comp_const) != INTEGER_CST
5758       || TREE_OVERFLOW (comp_const)
5759       || TREE_CODE (minmax_const) != INTEGER_CST
5760       || TREE_OVERFLOW (minmax_const))
5761     return NULL_TREE;
5762
5763   /* Now handle all the various comparison codes.  We only handle EQ_EXPR
5764      and GT_EXPR, doing the rest with recursive calls using logical
5765      simplifications.  */
5766   switch (code)
5767     {
5768     case NE_EXPR:  case LT_EXPR:  case LE_EXPR:
5769       {
5770         tree tem
5771           = optimize_minmax_comparison (loc,
5772                                         invert_tree_comparison (code, false),
5773                                         type, op0, op1);
5774         if (tem)
5775           return invert_truthvalue_loc (loc, tem);
5776         return NULL_TREE;
5777       }
5778
5779     case GE_EXPR:
5780       return
5781         fold_build2_loc (loc, TRUTH_ORIF_EXPR, type,
5782                      optimize_minmax_comparison
5783                      (loc, EQ_EXPR, type, arg0, comp_const),
5784                      optimize_minmax_comparison
5785                      (loc, GT_EXPR, type, arg0, comp_const));
5786
5787     case EQ_EXPR:
5788       if (op_code == MAX_EXPR && consts_equal)
5789         /* MAX (X, 0) == 0  ->  X <= 0  */
5790         return fold_build2_loc (loc, LE_EXPR, type, inner, comp_const);
5791
5792       else if (op_code == MAX_EXPR && consts_lt)
5793         /* MAX (X, 0) == 5  ->  X == 5   */
5794         return fold_build2_loc (loc, EQ_EXPR, type, inner, comp_const);
5795
5796       else if (op_code == MAX_EXPR)
5797         /* MAX (X, 0) == -1  ->  false  */
5798         return omit_one_operand_loc (loc, type, integer_zero_node, inner);
5799
5800       else if (consts_equal)
5801         /* MIN (X, 0) == 0  ->  X >= 0  */
5802         return fold_build2_loc (loc, GE_EXPR, type, inner, comp_const);
5803
5804       else if (consts_lt)
5805         /* MIN (X, 0) == 5  ->  false  */
5806         return omit_one_operand_loc (loc, type, integer_zero_node, inner);
5807
5808       else
5809         /* MIN (X, 0) == -1  ->  X == -1  */
5810         return fold_build2_loc (loc, EQ_EXPR, type, inner, comp_const);
5811
5812     case GT_EXPR:
5813       if (op_code == MAX_EXPR && (consts_equal || consts_lt))
5814         /* MAX (X, 0) > 0  ->  X > 0
5815            MAX (X, 0) > 5  ->  X > 5  */
5816         return fold_build2_loc (loc, GT_EXPR, type, inner, comp_const);
5817
5818       else if (op_code == MAX_EXPR)
5819         /* MAX (X, 0) > -1  ->  true  */
5820         return omit_one_operand_loc (loc, type, integer_one_node, inner);
5821
5822       else if (op_code == MIN_EXPR && (consts_equal || consts_lt))
5823         /* MIN (X, 0) > 0  ->  false
5824            MIN (X, 0) > 5  ->  false  */
5825         return omit_one_operand_loc (loc, type, integer_zero_node, inner);
5826
5827       else
5828         /* MIN (X, 0) > -1  ->  X > -1  */
5829         return fold_build2_loc (loc, GT_EXPR, type, inner, comp_const);
5830
5831     default:
5832       return NULL_TREE;
5833     }
5834 }
5835 \f
5836 /* T is an integer expression that is being multiplied, divided, or taken a
5837    modulus (CODE says which and what kind of divide or modulus) by a
5838    constant C.  See if we can eliminate that operation by folding it with
5839    other operations already in T.  WIDE_TYPE, if non-null, is a type that
5840    should be used for the computation if wider than our type.
5841
5842    For example, if we are dividing (X * 8) + (Y * 16) by 4, we can return
5843    (X * 2) + (Y * 4).  We must, however, be assured that either the original
5844    expression would not overflow or that overflow is undefined for the type
5845    in the language in question.
5846
5847    If we return a non-null expression, it is an equivalent form of the
5848    original computation, but need not be in the original type.
5849
5850    We set *STRICT_OVERFLOW_P to true if the return values depends on
5851    signed overflow being undefined.  Otherwise we do not change
5852    *STRICT_OVERFLOW_P.  */
5853
5854 static tree
5855 extract_muldiv (tree t, tree c, enum tree_code code, tree wide_type,
5856                 bool *strict_overflow_p)
5857 {
5858   /* To avoid exponential search depth, refuse to allow recursion past
5859      three levels.  Beyond that (1) it's highly unlikely that we'll find
5860      something interesting and (2) we've probably processed it before
5861      when we built the inner expression.  */
5862
5863   static int depth;
5864   tree ret;
5865
5866   if (depth > 3)
5867     return NULL;
5868
5869   depth++;
5870   ret = extract_muldiv_1 (t, c, code, wide_type, strict_overflow_p);
5871   depth--;
5872
5873   return ret;
5874 }
5875
5876 static tree
5877 extract_muldiv_1 (tree t, tree c, enum tree_code code, tree wide_type,
5878                   bool *strict_overflow_p)
5879 {
5880   tree type = TREE_TYPE (t);
5881   enum tree_code tcode = TREE_CODE (t);
5882   tree ctype = (wide_type != 0 && (GET_MODE_SIZE (TYPE_MODE (wide_type))
5883                                    > GET_MODE_SIZE (TYPE_MODE (type)))
5884                 ? wide_type : type);
5885   tree t1, t2;
5886   int same_p = tcode == code;
5887   tree op0 = NULL_TREE, op1 = NULL_TREE;
5888   bool sub_strict_overflow_p;
5889
5890   /* Don't deal with constants of zero here; they confuse the code below.  */
5891   if (integer_zerop (c))
5892     return NULL_TREE;
5893
5894   if (TREE_CODE_CLASS (tcode) == tcc_unary)
5895     op0 = TREE_OPERAND (t, 0);
5896
5897   if (TREE_CODE_CLASS (tcode) == tcc_binary)
5898     op0 = TREE_OPERAND (t, 0), op1 = TREE_OPERAND (t, 1);
5899
5900   /* Note that we need not handle conditional operations here since fold
5901      already handles those cases.  So just do arithmetic here.  */
5902   switch (tcode)
5903     {
5904     case INTEGER_CST:
5905       /* For a constant, we can always simplify if we are a multiply
5906          or (for divide and modulus) if it is a multiple of our constant.  */
5907       if (code == MULT_EXPR
5908           || wi::multiple_of_p (t, c, TYPE_SIGN (type)))
5909         return const_binop (code, fold_convert (ctype, t),
5910                             fold_convert (ctype, c));
5911       break;
5912
5913     CASE_CONVERT: case NON_LVALUE_EXPR:
5914       /* If op0 is an expression ...  */
5915       if ((COMPARISON_CLASS_P (op0)
5916            || UNARY_CLASS_P (op0)
5917            || BINARY_CLASS_P (op0)
5918            || VL_EXP_CLASS_P (op0)
5919            || EXPRESSION_CLASS_P (op0))
5920           /* ... and has wrapping overflow, and its type is smaller
5921              than ctype, then we cannot pass through as widening.  */
5922           && (((ANY_INTEGRAL_TYPE_P (TREE_TYPE (op0))
5923                 && TYPE_OVERFLOW_WRAPS (TREE_TYPE (op0)))
5924                && (TYPE_PRECISION (ctype)
5925                    > TYPE_PRECISION (TREE_TYPE (op0))))
5926               /* ... or this is a truncation (t is narrower than op0),
5927                  then we cannot pass through this narrowing.  */
5928               || (TYPE_PRECISION (type)
5929                   < TYPE_PRECISION (TREE_TYPE (op0)))
5930               /* ... or signedness changes for division or modulus,
5931                  then we cannot pass through this conversion.  */
5932               || (code != MULT_EXPR
5933                   && (TYPE_UNSIGNED (ctype)
5934                       != TYPE_UNSIGNED (TREE_TYPE (op0))))
5935               /* ... or has undefined overflow while the converted to
5936                  type has not, we cannot do the operation in the inner type
5937                  as that would introduce undefined overflow.  */
5938               || ((ANY_INTEGRAL_TYPE_P (TREE_TYPE (op0))
5939                    && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (op0)))
5940                   && !TYPE_OVERFLOW_UNDEFINED (type))))
5941         break;
5942
5943       /* Pass the constant down and see if we can make a simplification.  If
5944          we can, replace this expression with the inner simplification for
5945          possible later conversion to our or some other type.  */
5946       if ((t2 = fold_convert (TREE_TYPE (op0), c)) != 0
5947           && TREE_CODE (t2) == INTEGER_CST
5948           && !TREE_OVERFLOW (t2)
5949           && (0 != (t1 = extract_muldiv (op0, t2, code,
5950                                          code == MULT_EXPR
5951                                          ? ctype : NULL_TREE,
5952                                          strict_overflow_p))))
5953         return t1;
5954       break;
5955
5956     case ABS_EXPR:
5957       /* If widening the type changes it from signed to unsigned, then we
5958          must avoid building ABS_EXPR itself as unsigned.  */
5959       if (TYPE_UNSIGNED (ctype) && !TYPE_UNSIGNED (type))
5960         {
5961           tree cstype = (*signed_type_for) (ctype);
5962           if ((t1 = extract_muldiv (op0, c, code, cstype, strict_overflow_p))
5963               != 0)
5964             {
5965               t1 = fold_build1 (tcode, cstype, fold_convert (cstype, t1));
5966               return fold_convert (ctype, t1);
5967             }
5968           break;
5969         }
5970       /* If the constant is negative, we cannot simplify this.  */
5971       if (tree_int_cst_sgn (c) == -1)
5972         break;
5973       /* FALLTHROUGH */
5974     case NEGATE_EXPR:
5975       /* For division and modulus, type can't be unsigned, as e.g.
5976          (-(x / 2U)) / 2U isn't equal to -((x / 2U) / 2U) for x >= 2.
5977          For signed types, even with wrapping overflow, this is fine.  */
5978       if (code != MULT_EXPR && TYPE_UNSIGNED (type))
5979         break;
5980       if ((t1 = extract_muldiv (op0, c, code, wide_type, strict_overflow_p))
5981           != 0)
5982         return fold_build1 (tcode, ctype, fold_convert (ctype, t1));
5983       break;
5984
5985     case MIN_EXPR:  case MAX_EXPR:
5986       /* If widening the type changes the signedness, then we can't perform
5987          this optimization as that changes the result.  */
5988       if (TYPE_UNSIGNED (ctype) != TYPE_UNSIGNED (type))
5989         break;
5990
5991       /* MIN (a, b) / 5 -> MIN (a / 5, b / 5)  */
5992       sub_strict_overflow_p = false;
5993       if ((t1 = extract_muldiv (op0, c, code, wide_type,
5994                                 &sub_strict_overflow_p)) != 0
5995           && (t2 = extract_muldiv (op1, c, code, wide_type,
5996                                    &sub_strict_overflow_p)) != 0)
5997         {
5998           if (tree_int_cst_sgn (c) < 0)
5999             tcode = (tcode == MIN_EXPR ? MAX_EXPR : MIN_EXPR);
6000           if (sub_strict_overflow_p)
6001             *strict_overflow_p = true;
6002           return fold_build2 (tcode, ctype, fold_convert (ctype, t1),
6003                               fold_convert (ctype, t2));
6004         }
6005       break;
6006
6007     case LSHIFT_EXPR:  case RSHIFT_EXPR:
6008       /* If the second operand is constant, this is a multiplication
6009          or floor division, by a power of two, so we can treat it that
6010          way unless the multiplier or divisor overflows.  Signed
6011          left-shift overflow is implementation-defined rather than
6012          undefined in C90, so do not convert signed left shift into
6013          multiplication.  */
6014       if (TREE_CODE (op1) == INTEGER_CST
6015           && (tcode == RSHIFT_EXPR || TYPE_UNSIGNED (TREE_TYPE (op0)))
6016           /* const_binop may not detect overflow correctly,
6017              so check for it explicitly here.  */
6018           && wi::gtu_p (TYPE_PRECISION (TREE_TYPE (size_one_node)), op1)
6019           && 0 != (t1 = fold_convert (ctype,
6020                                       const_binop (LSHIFT_EXPR,
6021                                                    size_one_node,
6022                                                    op1)))
6023           && !TREE_OVERFLOW (t1))
6024         return extract_muldiv (build2 (tcode == LSHIFT_EXPR
6025                                        ? MULT_EXPR : FLOOR_DIV_EXPR,
6026                                        ctype,
6027                                        fold_convert (ctype, op0),
6028                                        t1),
6029                                c, code, wide_type, strict_overflow_p);
6030       break;
6031
6032     case PLUS_EXPR:  case MINUS_EXPR:
6033       /* See if we can eliminate the operation on both sides.  If we can, we
6034          can return a new PLUS or MINUS.  If we can't, the only remaining
6035          cases where we can do anything are if the second operand is a
6036          constant.  */
6037       sub_strict_overflow_p = false;
6038       t1 = extract_muldiv (op0, c, code, wide_type, &sub_strict_overflow_p);
6039       t2 = extract_muldiv (op1, c, code, wide_type, &sub_strict_overflow_p);
6040       if (t1 != 0 && t2 != 0
6041           && (code == MULT_EXPR
6042               /* If not multiplication, we can only do this if both operands
6043                  are divisible by c.  */
6044               || (multiple_of_p (ctype, op0, c)
6045                   && multiple_of_p (ctype, op1, c))))
6046         {
6047           if (sub_strict_overflow_p)
6048             *strict_overflow_p = true;
6049           return fold_build2 (tcode, ctype, fold_convert (ctype, t1),
6050                               fold_convert (ctype, t2));
6051         }
6052
6053       /* If this was a subtraction, negate OP1 and set it to be an addition.
6054          This simplifies the logic below.  */
6055       if (tcode == MINUS_EXPR)
6056         {
6057           tcode = PLUS_EXPR, op1 = negate_expr (op1);
6058           /* If OP1 was not easily negatable, the constant may be OP0.  */
6059           if (TREE_CODE (op0) == INTEGER_CST)
6060             {
6061               std::swap (op0, op1);
6062               std::swap (t1, t2);
6063             }
6064         }
6065
6066       if (TREE_CODE (op1) != INTEGER_CST)
6067         break;
6068
6069       /* If either OP1 or C are negative, this optimization is not safe for
6070          some of the division and remainder types while for others we need
6071          to change the code.  */
6072       if (tree_int_cst_sgn (op1) < 0 || tree_int_cst_sgn (c) < 0)
6073         {
6074           if (code == CEIL_DIV_EXPR)
6075             code = FLOOR_DIV_EXPR;
6076           else if (code == FLOOR_DIV_EXPR)
6077             code = CEIL_DIV_EXPR;
6078           else if (code != MULT_EXPR
6079                    && code != CEIL_MOD_EXPR && code != FLOOR_MOD_EXPR)
6080             break;
6081         }
6082
6083       /* If it's a multiply or a division/modulus operation of a multiple
6084          of our constant, do the operation and verify it doesn't overflow.  */
6085       if (code == MULT_EXPR
6086           || wi::multiple_of_p (op1, c, TYPE_SIGN (type)))
6087         {
6088           op1 = const_binop (code, fold_convert (ctype, op1),
6089                              fold_convert (ctype, c));
6090           /* We allow the constant to overflow with wrapping semantics.  */
6091           if (op1 == 0
6092               || (TREE_OVERFLOW (op1) && !TYPE_OVERFLOW_WRAPS (ctype)))
6093             break;
6094         }
6095       else
6096         break;
6097
6098       /* If we have an unsigned type, we cannot widen the operation since it
6099          will change the result if the original computation overflowed.  */
6100       if (TYPE_UNSIGNED (ctype) && ctype != type)
6101         break;
6102
6103       /* If we were able to eliminate our operation from the first side,
6104          apply our operation to the second side and reform the PLUS.  */
6105       if (t1 != 0 && (TREE_CODE (t1) != code || code == MULT_EXPR))
6106         return fold_build2 (tcode, ctype, fold_convert (ctype, t1), op1);
6107
6108       /* The last case is if we are a multiply.  In that case, we can
6109          apply the distributive law to commute the multiply and addition
6110          if the multiplication of the constants doesn't overflow
6111          and overflow is defined.  With undefined overflow
6112          op0 * c might overflow, while (op0 + orig_op1) * c doesn't.  */
6113       if (code == MULT_EXPR && TYPE_OVERFLOW_WRAPS (ctype))
6114         return fold_build2 (tcode, ctype,
6115                             fold_build2 (code, ctype,
6116                                          fold_convert (ctype, op0),
6117                                          fold_convert (ctype, c)),
6118                             op1);
6119
6120       break;
6121
6122     case MULT_EXPR:
6123       /* We have a special case here if we are doing something like
6124          (C * 8) % 4 since we know that's zero.  */
6125       if ((code == TRUNC_MOD_EXPR || code == CEIL_MOD_EXPR
6126            || code == FLOOR_MOD_EXPR || code == ROUND_MOD_EXPR)
6127           /* If the multiplication can overflow we cannot optimize this.  */
6128           && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (t))
6129           && TREE_CODE (TREE_OPERAND (t, 1)) == INTEGER_CST
6130           && wi::multiple_of_p (op1, c, TYPE_SIGN (type)))
6131         {
6132           *strict_overflow_p = true;
6133           return omit_one_operand (type, integer_zero_node, op0);
6134         }
6135
6136       /* ... fall through ...  */
6137
6138     case TRUNC_DIV_EXPR:  case CEIL_DIV_EXPR:  case FLOOR_DIV_EXPR:
6139     case ROUND_DIV_EXPR:  case EXACT_DIV_EXPR:
6140       /* If we can extract our operation from the LHS, do so and return a
6141          new operation.  Likewise for the RHS from a MULT_EXPR.  Otherwise,
6142          do something only if the second operand is a constant.  */
6143       if (same_p
6144           && (t1 = extract_muldiv (op0, c, code, wide_type,
6145                                    strict_overflow_p)) != 0)
6146         return fold_build2 (tcode, ctype, fold_convert (ctype, t1),
6147                             fold_convert (ctype, op1));
6148       else if (tcode == MULT_EXPR && code == MULT_EXPR
6149                && (t1 = extract_muldiv (op1, c, code, wide_type,
6150                                         strict_overflow_p)) != 0)
6151         return fold_build2 (tcode, ctype, fold_convert (ctype, op0),
6152                             fold_convert (ctype, t1));
6153       else if (TREE_CODE (op1) != INTEGER_CST)
6154         return 0;
6155
6156       /* If these are the same operation types, we can associate them
6157          assuming no overflow.  */
6158       if (tcode == code)
6159         {
6160           bool overflow_p = false;
6161           bool overflow_mul_p;
6162           signop sign = TYPE_SIGN (ctype);
6163           wide_int mul = wi::mul (op1, c, sign, &overflow_mul_p);
6164           overflow_p = TREE_OVERFLOW (c) | TREE_OVERFLOW (op1);
6165           if (overflow_mul_p
6166               && ((sign == UNSIGNED && tcode != MULT_EXPR) || sign == SIGNED))
6167             overflow_p = true;
6168           if (!overflow_p)
6169             {
6170               mul = wide_int::from (mul, TYPE_PRECISION (ctype),
6171                                     TYPE_SIGN (TREE_TYPE (op1)));
6172               return fold_build2 (tcode, ctype, fold_convert (ctype, op0),
6173                                   wide_int_to_tree (ctype, mul));
6174             }
6175         }
6176
6177       /* If these operations "cancel" each other, we have the main
6178          optimizations of this pass, which occur when either constant is a
6179          multiple of the other, in which case we replace this with either an
6180          operation or CODE or TCODE.
6181
6182          If we have an unsigned type, we cannot do this since it will change
6183          the result if the original computation overflowed.  */
6184       if (TYPE_OVERFLOW_UNDEFINED (ctype)
6185           && ((code == MULT_EXPR && tcode == EXACT_DIV_EXPR)
6186               || (tcode == MULT_EXPR
6187                   && code != TRUNC_MOD_EXPR && code != CEIL_MOD_EXPR
6188                   && code != FLOOR_MOD_EXPR && code != ROUND_MOD_EXPR
6189                   && code != MULT_EXPR)))
6190         {
6191           if (wi::multiple_of_p (op1, c, TYPE_SIGN (type)))
6192             {
6193               if (TYPE_OVERFLOW_UNDEFINED (ctype))
6194                 *strict_overflow_p = true;
6195               return fold_build2 (tcode, ctype, fold_convert (ctype, op0),
6196                                   fold_convert (ctype,
6197                                                 const_binop (TRUNC_DIV_EXPR,
6198                                                              op1, c)));
6199             }
6200           else if (wi::multiple_of_p (c, op1, TYPE_SIGN (type)))
6201             {
6202               if (TYPE_OVERFLOW_UNDEFINED (ctype))
6203                 *strict_overflow_p = true;
6204               return fold_build2 (code, ctype, fold_convert (ctype, op0),
6205                                   fold_convert (ctype,
6206                                                 const_binop (TRUNC_DIV_EXPR,
6207                                                              c, op1)));
6208             }
6209         }
6210       break;
6211
6212     default:
6213       break;
6214     }
6215
6216   return 0;
6217 }
6218 \f
6219 /* Return a node which has the indicated constant VALUE (either 0 or
6220    1 for scalars or {-1,-1,..} or {0,0,...} for vectors),
6221    and is of the indicated TYPE.  */
6222
6223 tree
6224 constant_boolean_node (bool value, tree type)
6225 {
6226   if (type == integer_type_node)
6227     return value ? integer_one_node : integer_zero_node;
6228   else if (type == boolean_type_node)
6229     return value ? boolean_true_node : boolean_false_node;
6230   else if (TREE_CODE (type) == VECTOR_TYPE)
6231     return build_vector_from_val (type,
6232                                   build_int_cst (TREE_TYPE (type),
6233                                                  value ? -1 : 0));
6234   else
6235     return fold_convert (type, value ? integer_one_node : integer_zero_node);
6236 }
6237
6238
6239 /* Transform `a + (b ? x : y)' into `b ? (a + x) : (a + y)'.
6240    Transform, `a + (x < y)' into `(x < y) ? (a + 1) : (a + 0)'.  Here
6241    CODE corresponds to the `+', COND to the `(b ? x : y)' or `(x < y)'
6242    expression, and ARG to `a'.  If COND_FIRST_P is nonzero, then the
6243    COND is the first argument to CODE; otherwise (as in the example
6244    given here), it is the second argument.  TYPE is the type of the
6245    original expression.  Return NULL_TREE if no simplification is
6246    possible.  */
6247
6248 static tree
6249 fold_binary_op_with_conditional_arg (location_t loc,
6250                                      enum tree_code code,
6251                                      tree type, tree op0, tree op1,
6252                                      tree cond, tree arg, int cond_first_p)
6253 {
6254   tree cond_type = cond_first_p ? TREE_TYPE (op0) : TREE_TYPE (op1);
6255   tree arg_type = cond_first_p ? TREE_TYPE (op1) : TREE_TYPE (op0);
6256   tree test, true_value, false_value;
6257   tree lhs = NULL_TREE;
6258   tree rhs = NULL_TREE;
6259   enum tree_code cond_code = COND_EXPR;
6260
6261   if (TREE_CODE (cond) == COND_EXPR
6262       || TREE_CODE (cond) == VEC_COND_EXPR)
6263     {
6264       test = TREE_OPERAND (cond, 0);
6265       true_value = TREE_OPERAND (cond, 1);
6266       false_value = TREE_OPERAND (cond, 2);
6267       /* If this operand throws an expression, then it does not make
6268          sense to try to perform a logical or arithmetic operation
6269          involving it.  */
6270       if (VOID_TYPE_P (TREE_TYPE (true_value)))
6271         lhs = true_value;
6272       if (VOID_TYPE_P (TREE_TYPE (false_value)))
6273         rhs = false_value;
6274     }
6275   else
6276     {
6277       tree testtype = TREE_TYPE (cond);
6278       test = cond;
6279       true_value = constant_boolean_node (true, testtype);
6280       false_value = constant_boolean_node (false, testtype);
6281     }
6282
6283   if (TREE_CODE (TREE_TYPE (test)) == VECTOR_TYPE)
6284     cond_code = VEC_COND_EXPR;
6285
6286   /* This transformation is only worthwhile if we don't have to wrap ARG
6287      in a SAVE_EXPR and the operation can be simplified without recursing
6288      on at least one of the branches once its pushed inside the COND_EXPR.  */
6289   if (!TREE_CONSTANT (arg)
6290       && (TREE_SIDE_EFFECTS (arg)
6291           || TREE_CODE (arg) == COND_EXPR || TREE_CODE (arg) == VEC_COND_EXPR
6292           || TREE_CONSTANT (true_value) || TREE_CONSTANT (false_value)))
6293     return NULL_TREE;
6294
6295   arg = fold_convert_loc (loc, arg_type, arg);
6296   if (lhs == 0)
6297     {
6298       true_value = fold_convert_loc (loc, cond_type, true_value);
6299       if (cond_first_p)
6300         lhs = fold_build2_loc (loc, code, type, true_value, arg);
6301       else
6302         lhs = fold_build2_loc (loc, code, type, arg, true_value);
6303     }
6304   if (rhs == 0)
6305     {
6306       false_value = fold_convert_loc (loc, cond_type, false_value);
6307       if (cond_first_p)
6308         rhs = fold_build2_loc (loc, code, type, false_value, arg);
6309       else
6310         rhs = fold_build2_loc (loc, code, type, arg, false_value);
6311     }
6312
6313   /* Check that we have simplified at least one of the branches.  */
6314   if (!TREE_CONSTANT (arg) && !TREE_CONSTANT (lhs) && !TREE_CONSTANT (rhs))
6315     return NULL_TREE;
6316
6317   return fold_build3_loc (loc, cond_code, type, test, lhs, rhs);
6318 }
6319
6320 \f
6321 /* Subroutine of fold() that checks for the addition of +/- 0.0.
6322
6323    If !NEGATE, return true if ADDEND is +/-0.0 and, for all X of type
6324    TYPE, X + ADDEND is the same as X.  If NEGATE, return true if X -
6325    ADDEND is the same as X.
6326
6327    X + 0 and X - 0 both give X when X is NaN, infinite, or nonzero
6328    and finite.  The problematic cases are when X is zero, and its mode
6329    has signed zeros.  In the case of rounding towards -infinity,
6330    X - 0 is not the same as X because 0 - 0 is -0.  In other rounding
6331    modes, X + 0 is not the same as X because -0 + 0 is 0.  */
6332
6333 bool
6334 fold_real_zero_addition_p (const_tree type, const_tree addend, int negate)
6335 {
6336   if (!real_zerop (addend))
6337     return false;
6338
6339   /* Don't allow the fold with -fsignaling-nans.  */
6340   if (HONOR_SNANS (element_mode (type)))
6341     return false;
6342
6343   /* Allow the fold if zeros aren't signed, or their sign isn't important.  */
6344   if (!HONOR_SIGNED_ZEROS (element_mode (type)))
6345     return true;
6346
6347   /* In a vector or complex, we would need to check the sign of all zeros.  */
6348   if (TREE_CODE (addend) != REAL_CST)
6349     return false;
6350
6351   /* Treat x + -0 as x - 0 and x - -0 as x + 0.  */
6352   if (REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (addend)))
6353     negate = !negate;
6354
6355   /* The mode has signed zeros, and we have to honor their sign.
6356      In this situation, there is only one case we can return true for.
6357      X - 0 is the same as X unless rounding towards -infinity is
6358      supported.  */
6359   return negate && !HONOR_SIGN_DEPENDENT_ROUNDING (element_mode (type));
6360 }
6361
6362 /* Subroutine of fold() that optimizes comparisons of a division by
6363    a nonzero integer constant against an integer constant, i.e.
6364    X/C1 op C2.
6365
6366    CODE is the comparison operator: EQ_EXPR, NE_EXPR, GT_EXPR, LT_EXPR,
6367    GE_EXPR or LE_EXPR.  TYPE is the type of the result and ARG0 and ARG1
6368    are the operands of the comparison.  ARG1 must be a TREE_REAL_CST.
6369
6370    The function returns the constant folded tree if a simplification
6371    can be made, and NULL_TREE otherwise.  */
6372
6373 static tree
6374 fold_div_compare (location_t loc,
6375                   enum tree_code code, tree type, tree arg0, tree arg1)
6376 {
6377   tree prod, tmp, hi, lo;
6378   tree arg00 = TREE_OPERAND (arg0, 0);
6379   tree arg01 = TREE_OPERAND (arg0, 1);
6380   signop sign = TYPE_SIGN (TREE_TYPE (arg0));
6381   bool neg_overflow = false;
6382   bool overflow;
6383
6384   /* We have to do this the hard way to detect unsigned overflow.
6385      prod = int_const_binop (MULT_EXPR, arg01, arg1);  */
6386   wide_int val = wi::mul (arg01, arg1, sign, &overflow);
6387   prod = force_fit_type (TREE_TYPE (arg00), val, -1, overflow);
6388   neg_overflow = false;
6389
6390   if (sign == UNSIGNED)
6391     {
6392       tmp = int_const_binop (MINUS_EXPR, arg01,
6393                              build_int_cst (TREE_TYPE (arg01), 1));
6394       lo = prod;
6395
6396       /* Likewise hi = int_const_binop (PLUS_EXPR, prod, tmp).  */
6397       val = wi::add (prod, tmp, sign, &overflow);
6398       hi = force_fit_type (TREE_TYPE (arg00), val,
6399                            -1, overflow | TREE_OVERFLOW (prod));
6400     }
6401   else if (tree_int_cst_sgn (arg01) >= 0)
6402     {
6403       tmp = int_const_binop (MINUS_EXPR, arg01,
6404                              build_int_cst (TREE_TYPE (arg01), 1));
6405       switch (tree_int_cst_sgn (arg1))
6406         {
6407         case -1:
6408           neg_overflow = true;
6409           lo = int_const_binop (MINUS_EXPR, prod, tmp);
6410           hi = prod;
6411           break;
6412
6413         case  0:
6414           lo = fold_negate_const (tmp, TREE_TYPE (arg0));
6415           hi = tmp;
6416           break;
6417
6418         case  1:
6419           hi = int_const_binop (PLUS_EXPR, prod, tmp);
6420           lo = prod;
6421           break;
6422
6423         default:
6424           gcc_unreachable ();
6425         }
6426     }
6427   else
6428     {
6429       /* A negative divisor reverses the relational operators.  */
6430       code = swap_tree_comparison (code);
6431
6432       tmp = int_const_binop (PLUS_EXPR, arg01,
6433                              build_int_cst (TREE_TYPE (arg01), 1));
6434       switch (tree_int_cst_sgn (arg1))
6435         {
6436         case -1:
6437           hi = int_const_binop (MINUS_EXPR, prod, tmp);
6438           lo = prod;
6439           break;
6440
6441         case  0:
6442           hi = fold_negate_const (tmp, TREE_TYPE (arg0));
6443           lo = tmp;
6444           break;
6445
6446         case  1:
6447           neg_overflow = true;
6448           lo = int_const_binop (PLUS_EXPR, prod, tmp);
6449           hi = prod;
6450           break;
6451
6452         default:
6453           gcc_unreachable ();
6454         }
6455     }
6456
6457   switch (code)
6458     {
6459     case EQ_EXPR:
6460       if (TREE_OVERFLOW (lo) && TREE_OVERFLOW (hi))
6461         return omit_one_operand_loc (loc, type, integer_zero_node, arg00);
6462       if (TREE_OVERFLOW (hi))
6463         return fold_build2_loc (loc, GE_EXPR, type, arg00, lo);
6464       if (TREE_OVERFLOW (lo))
6465         return fold_build2_loc (loc, LE_EXPR, type, arg00, hi);
6466       return build_range_check (loc, type, arg00, 1, lo, hi);
6467
6468     case NE_EXPR:
6469       if (TREE_OVERFLOW (lo) && TREE_OVERFLOW (hi))
6470         return omit_one_operand_loc (loc, type, integer_one_node, arg00);
6471       if (TREE_OVERFLOW (hi))
6472         return fold_build2_loc (loc, LT_EXPR, type, arg00, lo);
6473       if (TREE_OVERFLOW (lo))
6474         return fold_build2_loc (loc, GT_EXPR, type, arg00, hi);
6475       return build_range_check (loc, type, arg00, 0, lo, hi);
6476
6477     case LT_EXPR:
6478       if (TREE_OVERFLOW (lo))
6479         {
6480           tmp = neg_overflow ? integer_zero_node : integer_one_node;
6481           return omit_one_operand_loc (loc, type, tmp, arg00);
6482         }
6483       return fold_build2_loc (loc, LT_EXPR, type, arg00, lo);
6484
6485     case LE_EXPR:
6486       if (TREE_OVERFLOW (hi))
6487         {
6488           tmp = neg_overflow ? integer_zero_node : integer_one_node;
6489           return omit_one_operand_loc (loc, type, tmp, arg00);
6490         }
6491       return fold_build2_loc (loc, LE_EXPR, type, arg00, hi);
6492
6493     case GT_EXPR:
6494       if (TREE_OVERFLOW (hi))
6495         {
6496           tmp = neg_overflow ? integer_one_node : integer_zero_node;
6497           return omit_one_operand_loc (loc, type, tmp, arg00);
6498         }
6499       return fold_build2_loc (loc, GT_EXPR, type, arg00, hi);
6500
6501     case GE_EXPR:
6502       if (TREE_OVERFLOW (lo))
6503         {
6504           tmp = neg_overflow ? integer_one_node : integer_zero_node;
6505           return omit_one_operand_loc (loc, type, tmp, arg00);
6506         }
6507       return fold_build2_loc (loc, GE_EXPR, type, arg00, lo);
6508
6509     default:
6510       break;
6511     }
6512
6513   return NULL_TREE;
6514 }
6515
6516
6517 /* If CODE with arguments ARG0 and ARG1 represents a single bit
6518    equality/inequality test, then return a simplified form of the test
6519    using a sign testing.  Otherwise return NULL.  TYPE is the desired
6520    result type.  */
6521
6522 static tree
6523 fold_single_bit_test_into_sign_test (location_t loc,
6524                                      enum tree_code code, tree arg0, tree arg1,
6525                                      tree result_type)
6526 {
6527   /* If this is testing a single bit, we can optimize the test.  */
6528   if ((code == NE_EXPR || code == EQ_EXPR)
6529       && TREE_CODE (arg0) == BIT_AND_EXPR && integer_zerop (arg1)
6530       && integer_pow2p (TREE_OPERAND (arg0, 1)))
6531     {
6532       /* If we have (A & C) != 0 where C is the sign bit of A, convert
6533          this into A < 0.  Similarly for (A & C) == 0 into A >= 0.  */
6534       tree arg00 = sign_bit_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg0, 1));
6535
6536       if (arg00 != NULL_TREE
6537           /* This is only a win if casting to a signed type is cheap,
6538              i.e. when arg00's type is not a partial mode.  */
6539           && TYPE_PRECISION (TREE_TYPE (arg00))
6540              == GET_MODE_PRECISION (TYPE_MODE (TREE_TYPE (arg00))))
6541         {
6542           tree stype = signed_type_for (TREE_TYPE (arg00));
6543           return fold_build2_loc (loc, code == EQ_EXPR ? GE_EXPR : LT_EXPR,
6544                               result_type,
6545                               fold_convert_loc (loc, stype, arg00),
6546                               build_int_cst (stype, 0));
6547         }
6548     }
6549
6550   return NULL_TREE;
6551 }
6552
6553 /* If CODE with arguments ARG0 and ARG1 represents a single bit
6554    equality/inequality test, then return a simplified form of
6555    the test using shifts and logical operations.  Otherwise return
6556    NULL.  TYPE is the desired result type.  */
6557
6558 tree
6559 fold_single_bit_test (location_t loc, enum tree_code code,
6560                       tree arg0, tree arg1, tree result_type)
6561 {
6562   /* If this is testing a single bit, we can optimize the test.  */
6563   if ((code == NE_EXPR || code == EQ_EXPR)
6564       && TREE_CODE (arg0) == BIT_AND_EXPR && integer_zerop (arg1)
6565       && integer_pow2p (TREE_OPERAND (arg0, 1)))
6566     {
6567       tree inner = TREE_OPERAND (arg0, 0);
6568       tree type = TREE_TYPE (arg0);
6569       int bitnum = tree_log2 (TREE_OPERAND (arg0, 1));
6570       machine_mode operand_mode = TYPE_MODE (type);
6571       int ops_unsigned;
6572       tree signed_type, unsigned_type, intermediate_type;
6573       tree tem, one;
6574
6575       /* First, see if we can fold the single bit test into a sign-bit
6576          test.  */
6577       tem = fold_single_bit_test_into_sign_test (loc, code, arg0, arg1,
6578                                                  result_type);
6579       if (tem)
6580         return tem;
6581
6582       /* Otherwise we have (A & C) != 0 where C is a single bit,
6583          convert that into ((A >> C2) & 1).  Where C2 = log2(C).
6584          Similarly for (A & C) == 0.  */
6585
6586       /* If INNER is a right shift of a constant and it plus BITNUM does
6587          not overflow, adjust BITNUM and INNER.  */
6588       if (TREE_CODE (inner) == RSHIFT_EXPR
6589           && TREE_CODE (TREE_OPERAND (inner, 1)) == INTEGER_CST
6590           && bitnum < TYPE_PRECISION (type)
6591           && wi::ltu_p (TREE_OPERAND (inner, 1),
6592                         TYPE_PRECISION (type) - bitnum))
6593         {
6594           bitnum += tree_to_uhwi (TREE_OPERAND (inner, 1));
6595           inner = TREE_OPERAND (inner, 0);
6596         }
6597
6598       /* If we are going to be able to omit the AND below, we must do our
6599          operations as unsigned.  If we must use the AND, we have a choice.
6600          Normally unsigned is faster, but for some machines signed is.  */
6601       ops_unsigned = (LOAD_EXTEND_OP (operand_mode) == SIGN_EXTEND
6602                       && !flag_syntax_only) ? 0 : 1;
6603
6604       signed_type = lang_hooks.types.type_for_mode (operand_mode, 0);
6605       unsigned_type = lang_hooks.types.type_for_mode (operand_mode, 1);
6606       intermediate_type = ops_unsigned ? unsigned_type : signed_type;
6607       inner = fold_convert_loc (loc, intermediate_type, inner);
6608
6609       if (bitnum != 0)
6610         inner = build2 (RSHIFT_EXPR, intermediate_type,
6611                         inner, size_int (bitnum));
6612
6613       one = build_int_cst (intermediate_type, 1);
6614
6615       if (code == EQ_EXPR)
6616         inner = fold_build2_loc (loc, BIT_XOR_EXPR, intermediate_type, inner, one);
6617
6618       /* Put the AND last so it can combine with more things.  */
6619       inner = build2 (BIT_AND_EXPR, intermediate_type, inner, one);
6620
6621       /* Make sure to return the proper type.  */
6622       inner = fold_convert_loc (loc, result_type, inner);
6623
6624       return inner;
6625     }
6626   return NULL_TREE;
6627 }
6628
6629 /* Check whether we are allowed to reorder operands arg0 and arg1,
6630    such that the evaluation of arg1 occurs before arg0.  */
6631
6632 static bool
6633 reorder_operands_p (const_tree arg0, const_tree arg1)
6634 {
6635   if (! flag_evaluation_order)
6636       return true;
6637   if (TREE_CONSTANT (arg0) || TREE_CONSTANT (arg1))
6638     return true;
6639   return ! TREE_SIDE_EFFECTS (arg0)
6640          && ! TREE_SIDE_EFFECTS (arg1);
6641 }
6642
6643 /* Test whether it is preferable two swap two operands, ARG0 and
6644    ARG1, for example because ARG0 is an integer constant and ARG1
6645    isn't.  If REORDER is true, only recommend swapping if we can
6646    evaluate the operands in reverse order.  */
6647
6648 bool
6649 tree_swap_operands_p (const_tree arg0, const_tree arg1, bool reorder)
6650 {
6651   if (CONSTANT_CLASS_P (arg1))
6652     return 0;
6653   if (CONSTANT_CLASS_P (arg0))
6654     return 1;
6655
6656   STRIP_NOPS (arg0);
6657   STRIP_NOPS (arg1);
6658
6659   if (TREE_CONSTANT (arg1))
6660     return 0;
6661   if (TREE_CONSTANT (arg0))
6662     return 1;
6663
6664   if (reorder && flag_evaluation_order
6665       && (TREE_SIDE_EFFECTS (arg0) || TREE_SIDE_EFFECTS (arg1)))
6666     return 0;
6667
6668   /* It is preferable to swap two SSA_NAME to ensure a canonical form
6669      for commutative and comparison operators.  Ensuring a canonical
6670      form allows the optimizers to find additional redundancies without
6671      having to explicitly check for both orderings.  */
6672   if (TREE_CODE (arg0) == SSA_NAME
6673       && TREE_CODE (arg1) == SSA_NAME
6674       && SSA_NAME_VERSION (arg0) > SSA_NAME_VERSION (arg1))
6675     return 1;
6676
6677   /* Put SSA_NAMEs last.  */
6678   if (TREE_CODE (arg1) == SSA_NAME)
6679     return 0;
6680   if (TREE_CODE (arg0) == SSA_NAME)
6681     return 1;
6682
6683   /* Put variables last.  */
6684   if (DECL_P (arg1))
6685     return 0;
6686   if (DECL_P (arg0))
6687     return 1;
6688
6689   return 0;
6690 }
6691
6692
6693 /* Fold A < X && A + 1 > Y to A < X && A >= Y.  Normally A + 1 > Y
6694    means A >= Y && A != MAX, but in this case we know that
6695    A < X <= MAX.  INEQ is A + 1 > Y, BOUND is A < X.  */
6696
6697 static tree
6698 fold_to_nonsharp_ineq_using_bound (location_t loc, tree ineq, tree bound)
6699 {
6700   tree a, typea, type = TREE_TYPE (ineq), a1, diff, y;
6701
6702   if (TREE_CODE (bound) == LT_EXPR)
6703     a = TREE_OPERAND (bound, 0);
6704   else if (TREE_CODE (bound) == GT_EXPR)
6705     a = TREE_OPERAND (bound, 1);
6706   else
6707     return NULL_TREE;
6708
6709   typea = TREE_TYPE (a);
6710   if (!INTEGRAL_TYPE_P (typea)
6711       && !POINTER_TYPE_P (typea))
6712     return NULL_TREE;
6713
6714   if (TREE_CODE (ineq) == LT_EXPR)
6715     {
6716       a1 = TREE_OPERAND (ineq, 1);
6717       y = TREE_OPERAND (ineq, 0);
6718     }
6719   else if (TREE_CODE (ineq) == GT_EXPR)
6720     {
6721       a1 = TREE_OPERAND (ineq, 0);
6722       y = TREE_OPERAND (ineq, 1);
6723     }
6724   else
6725     return NULL_TREE;
6726
6727   if (TREE_TYPE (a1) != typea)
6728     return NULL_TREE;
6729
6730   if (POINTER_TYPE_P (typea))
6731     {
6732       /* Convert the pointer types into integer before taking the difference.  */
6733       tree ta = fold_convert_loc (loc, ssizetype, a);
6734       tree ta1 = fold_convert_loc (loc, ssizetype, a1);
6735       diff = fold_binary_loc (loc, MINUS_EXPR, ssizetype, ta1, ta);
6736     }
6737   else
6738     diff = fold_binary_loc (loc, MINUS_EXPR, typea, a1, a);
6739
6740   if (!diff || !integer_onep (diff))
6741    return NULL_TREE;
6742
6743   return fold_build2_loc (loc, GE_EXPR, type, a, y);
6744 }
6745
6746 /* Fold a sum or difference of at least one multiplication.
6747    Returns the folded tree or NULL if no simplification could be made.  */
6748
6749 static tree
6750 fold_plusminus_mult_expr (location_t loc, enum tree_code code, tree type,
6751                           tree arg0, tree arg1)
6752 {
6753   tree arg00, arg01, arg10, arg11;
6754   tree alt0 = NULL_TREE, alt1 = NULL_TREE, same;
6755
6756   /* (A * C) +- (B * C) -> (A+-B) * C.
6757      (A * C) +- A -> A * (C+-1).
6758      We are most concerned about the case where C is a constant,
6759      but other combinations show up during loop reduction.  Since
6760      it is not difficult, try all four possibilities.  */
6761
6762   if (TREE_CODE (arg0) == MULT_EXPR)
6763     {
6764       arg00 = TREE_OPERAND (arg0, 0);
6765       arg01 = TREE_OPERAND (arg0, 1);
6766     }
6767   else if (TREE_CODE (arg0) == INTEGER_CST)
6768     {
6769       arg00 = build_one_cst (type);
6770       arg01 = arg0;
6771     }
6772   else
6773     {
6774       /* We cannot generate constant 1 for fract.  */
6775       if (ALL_FRACT_MODE_P (TYPE_MODE (type)))
6776         return NULL_TREE;
6777       arg00 = arg0;
6778       arg01 = build_one_cst (type);
6779     }
6780   if (TREE_CODE (arg1) == MULT_EXPR)
6781     {
6782       arg10 = TREE_OPERAND (arg1, 0);
6783       arg11 = TREE_OPERAND (arg1, 1);
6784     }
6785   else if (TREE_CODE (arg1) == INTEGER_CST)
6786     {
6787       arg10 = build_one_cst (type);
6788       /* As we canonicalize A - 2 to A + -2 get rid of that sign for
6789          the purpose of this canonicalization.  */
6790       if (wi::neg_p (arg1, TYPE_SIGN (TREE_TYPE (arg1)))
6791           && negate_expr_p (arg1)
6792           && code == PLUS_EXPR)
6793         {
6794           arg11 = negate_expr (arg1);
6795           code = MINUS_EXPR;
6796         }
6797       else
6798         arg11 = arg1;
6799     }
6800   else
6801     {
6802       /* We cannot generate constant 1 for fract.  */
6803       if (ALL_FRACT_MODE_P (TYPE_MODE (type)))
6804         return NULL_TREE;
6805       arg10 = arg1;
6806       arg11 = build_one_cst (type);
6807     }
6808   same = NULL_TREE;
6809
6810   if (operand_equal_p (arg01, arg11, 0))
6811     same = arg01, alt0 = arg00, alt1 = arg10;
6812   else if (operand_equal_p (arg00, arg10, 0))
6813     same = arg00, alt0 = arg01, alt1 = arg11;
6814   else if (operand_equal_p (arg00, arg11, 0))
6815     same = arg00, alt0 = arg01, alt1 = arg10;
6816   else if (operand_equal_p (arg01, arg10, 0))
6817     same = arg01, alt0 = arg00, alt1 = arg11;
6818
6819   /* No identical multiplicands; see if we can find a common
6820      power-of-two factor in non-power-of-two multiplies.  This
6821      can help in multi-dimensional array access.  */
6822   else if (tree_fits_shwi_p (arg01)
6823            && tree_fits_shwi_p (arg11))
6824     {
6825       HOST_WIDE_INT int01, int11, tmp;
6826       bool swap = false;
6827       tree maybe_same;
6828       int01 = tree_to_shwi (arg01);
6829       int11 = tree_to_shwi (arg11);
6830
6831       /* Move min of absolute values to int11.  */
6832       if (absu_hwi (int01) < absu_hwi (int11))
6833         {
6834           tmp = int01, int01 = int11, int11 = tmp;
6835           alt0 = arg00, arg00 = arg10, arg10 = alt0;
6836           maybe_same = arg01;
6837           swap = true;
6838         }
6839       else
6840         maybe_same = arg11;
6841
6842       if (exact_log2 (absu_hwi (int11)) > 0 && int01 % int11 == 0
6843           /* The remainder should not be a constant, otherwise we
6844              end up folding i * 4 + 2 to (i * 2 + 1) * 2 which has
6845              increased the number of multiplications necessary.  */
6846           && TREE_CODE (arg10) != INTEGER_CST)
6847         {
6848           alt0 = fold_build2_loc (loc, MULT_EXPR, TREE_TYPE (arg00), arg00,
6849                               build_int_cst (TREE_TYPE (arg00),
6850                                              int01 / int11));
6851           alt1 = arg10;
6852           same = maybe_same;
6853           if (swap)
6854             maybe_same = alt0, alt0 = alt1, alt1 = maybe_same;
6855         }
6856     }
6857
6858   if (same)
6859     return fold_build2_loc (loc, MULT_EXPR, type,
6860                         fold_build2_loc (loc, code, type,
6861                                      fold_convert_loc (loc, type, alt0),
6862                                      fold_convert_loc (loc, type, alt1)),
6863                         fold_convert_loc (loc, type, same));
6864
6865   return NULL_TREE;
6866 }
6867
6868 /* Subroutine of native_encode_expr.  Encode the INTEGER_CST
6869    specified by EXPR into the buffer PTR of length LEN bytes.
6870    Return the number of bytes placed in the buffer, or zero
6871    upon failure.  */
6872
6873 static int
6874 native_encode_int (const_tree expr, unsigned char *ptr, int len, int off)
6875 {
6876   tree type = TREE_TYPE (expr);
6877   int total_bytes = GET_MODE_SIZE (TYPE_MODE (type));
6878   int byte, offset, word, words;
6879   unsigned char value;
6880
6881   if ((off == -1 && total_bytes > len)
6882       || off >= total_bytes)
6883     return 0;
6884   if (off == -1)
6885     off = 0;
6886   words = total_bytes / UNITS_PER_WORD;
6887
6888   for (byte = 0; byte < total_bytes; byte++)
6889     {
6890       int bitpos = byte * BITS_PER_UNIT;
6891       /* Extend EXPR according to TYPE_SIGN if the precision isn't a whole
6892          number of bytes.  */
6893       value = wi::extract_uhwi (wi::to_widest (expr), bitpos, BITS_PER_UNIT);
6894
6895       if (total_bytes > UNITS_PER_WORD)
6896         {
6897           word = byte / UNITS_PER_WORD;
6898           if (WORDS_BIG_ENDIAN)
6899             word = (words - 1) - word;
6900           offset = word * UNITS_PER_WORD;
6901           if (BYTES_BIG_ENDIAN)
6902             offset += (UNITS_PER_WORD - 1) - (byte % UNITS_PER_WORD);
6903           else
6904             offset += byte % UNITS_PER_WORD;
6905         }
6906       else
6907         offset = BYTES_BIG_ENDIAN ? (total_bytes - 1) - byte : byte;
6908       if (offset >= off
6909           && offset - off < len)
6910         ptr[offset - off] = value;
6911     }
6912   return MIN (len, total_bytes - off);
6913 }
6914
6915
6916 /* Subroutine of native_encode_expr.  Encode the FIXED_CST
6917    specified by EXPR into the buffer PTR of length LEN bytes.
6918    Return the number of bytes placed in the buffer, or zero
6919    upon failure.  */
6920
6921 static int
6922 native_encode_fixed (const_tree expr, unsigned char *ptr, int len, int off)
6923 {
6924   tree type = TREE_TYPE (expr);
6925   machine_mode mode = TYPE_MODE (type);
6926   int total_bytes = GET_MODE_SIZE (mode);
6927   FIXED_VALUE_TYPE value;
6928   tree i_value, i_type;
6929
6930   if (total_bytes * BITS_PER_UNIT > HOST_BITS_PER_DOUBLE_INT)
6931     return 0;
6932
6933   i_type = lang_hooks.types.type_for_size (GET_MODE_BITSIZE (mode), 1);
6934
6935   if (NULL_TREE == i_type
6936       || TYPE_PRECISION (i_type) != total_bytes)
6937     return 0;
6938
6939   value = TREE_FIXED_CST (expr);
6940   i_value = double_int_to_tree (i_type, value.data);
6941
6942   return native_encode_int (i_value, ptr, len, off);
6943 }
6944
6945
6946 /* Subroutine of native_encode_expr.  Encode the REAL_CST
6947    specified by EXPR into the buffer PTR of length LEN bytes.
6948    Return the number of bytes placed in the buffer, or zero
6949    upon failure.  */
6950
6951 static int
6952 native_encode_real (const_tree expr, unsigned char *ptr, int len, int off)
6953 {
6954   tree type = TREE_TYPE (expr);
6955   int total_bytes = GET_MODE_SIZE (TYPE_MODE (type));
6956   int byte, offset, word, words, bitpos;
6957   unsigned char value;
6958
6959   /* There are always 32 bits in each long, no matter the size of
6960      the hosts long.  We handle floating point representations with
6961      up to 192 bits.  */
6962   long tmp[6];
6963
6964   if ((off == -1 && total_bytes > len)
6965       || off >= total_bytes)
6966     return 0;
6967   if (off == -1)
6968     off = 0;
6969   words = (32 / BITS_PER_UNIT) / UNITS_PER_WORD;
6970
6971   real_to_target (tmp, TREE_REAL_CST_PTR (expr), TYPE_MODE (type));
6972
6973   for (bitpos = 0; bitpos < total_bytes * BITS_PER_UNIT;
6974        bitpos += BITS_PER_UNIT)
6975     {
6976       byte = (bitpos / BITS_PER_UNIT) & 3;
6977       value = (unsigned char) (tmp[bitpos / 32] >> (bitpos & 31));
6978
6979       if (UNITS_PER_WORD < 4)
6980         {
6981           word = byte / UNITS_PER_WORD;
6982           if (WORDS_BIG_ENDIAN)
6983             word = (words - 1) - word;
6984           offset = word * UNITS_PER_WORD;
6985           if (BYTES_BIG_ENDIAN)
6986             offset += (UNITS_PER_WORD - 1) - (byte % UNITS_PER_WORD);
6987           else
6988             offset += byte % UNITS_PER_WORD;
6989         }
6990       else
6991         offset = BYTES_BIG_ENDIAN ? 3 - byte : byte;
6992       offset = offset + ((bitpos / BITS_PER_UNIT) & ~3);
6993       if (offset >= off
6994           && offset - off < len)
6995         ptr[offset - off] = value;
6996     }
6997   return MIN (len, total_bytes - off);
6998 }
6999
7000 /* Subroutine of native_encode_expr.  Encode the COMPLEX_CST
7001    specified by EXPR into the buffer PTR of length LEN bytes.
7002    Return the number of bytes placed in the buffer, or zero
7003    upon failure.  */
7004
7005 static int
7006 native_encode_complex (const_tree expr, unsigned char *ptr, int len, int off)
7007 {
7008   int rsize, isize;
7009   tree part;
7010
7011   part = TREE_REALPART (expr);
7012   rsize = native_encode_expr (part, ptr, len, off);
7013   if (off == -1
7014       && rsize == 0)
7015     return 0;
7016   part = TREE_IMAGPART (expr);
7017   if (off != -1)
7018     off = MAX (0, off - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (part))));
7019   isize = native_encode_expr (part, ptr+rsize, len-rsize, off);
7020   if (off == -1
7021       && isize != rsize)
7022     return 0;
7023   return rsize + isize;
7024 }
7025
7026
7027 /* Subroutine of native_encode_expr.  Encode the VECTOR_CST
7028    specified by EXPR into the buffer PTR of length LEN bytes.
7029    Return the number of bytes placed in the buffer, or zero
7030    upon failure.  */
7031
7032 static int
7033 native_encode_vector (const_tree expr, unsigned char *ptr, int len, int off)
7034 {
7035   unsigned i, count;
7036   int size, offset;
7037   tree itype, elem;
7038
7039   offset = 0;
7040   count = VECTOR_CST_NELTS (expr);
7041   itype = TREE_TYPE (TREE_TYPE (expr));
7042   size = GET_MODE_SIZE (TYPE_MODE (itype));
7043   for (i = 0; i < count; i++)
7044     {
7045       if (off >= size)
7046         {
7047           off -= size;
7048           continue;
7049         }
7050       elem = VECTOR_CST_ELT (expr, i);
7051       int res = native_encode_expr (elem, ptr+offset, len-offset, off);
7052       if ((off == -1 && res != size)
7053           || res == 0)
7054         return 0;
7055       offset += res;
7056       if (offset >= len)
7057         return offset;
7058       if (off != -1)
7059         off = 0;
7060     }
7061   return offset;
7062 }
7063
7064
7065 /* Subroutine of native_encode_expr.  Encode the STRING_CST
7066    specified by EXPR into the buffer PTR of length LEN bytes.
7067    Return the number of bytes placed in the buffer, or zero
7068    upon failure.  */
7069
7070 static int
7071 native_encode_string (const_tree expr, unsigned char *ptr, int len, int off)
7072 {
7073   tree type = TREE_TYPE (expr);
7074   HOST_WIDE_INT total_bytes;
7075
7076   if (TREE_CODE (type) != ARRAY_TYPE
7077       || TREE_CODE (TREE_TYPE (type)) != INTEGER_TYPE
7078       || GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (type))) != BITS_PER_UNIT
7079       || !tree_fits_shwi_p (TYPE_SIZE_UNIT (type)))
7080     return 0;
7081   total_bytes = tree_to_shwi (TYPE_SIZE_UNIT (type));
7082   if ((off == -1 && total_bytes > len)
7083       || off >= total_bytes)
7084     return 0;
7085   if (off == -1)
7086     off = 0;
7087   if (TREE_STRING_LENGTH (expr) - off < MIN (total_bytes, len))
7088     {
7089       int written = 0;
7090       if (off < TREE_STRING_LENGTH (expr))
7091         {
7092           written = MIN (len, TREE_STRING_LENGTH (expr) - off);
7093           memcpy (ptr, TREE_STRING_POINTER (expr) + off, written);
7094         }
7095       memset (ptr + written, 0,
7096               MIN (total_bytes - written, len - written));
7097     }
7098   else
7099     memcpy (ptr, TREE_STRING_POINTER (expr) + off, MIN (total_bytes, len));
7100   return MIN (total_bytes - off, len);
7101 }
7102
7103
7104 /* Subroutine of fold_view_convert_expr.  Encode the INTEGER_CST,
7105    REAL_CST, COMPLEX_CST or VECTOR_CST specified by EXPR into the
7106    buffer PTR of length LEN bytes.  If OFF is not -1 then start
7107    the encoding at byte offset OFF and encode at most LEN bytes.
7108    Return the number of bytes placed in the buffer, or zero upon failure.  */
7109
7110 int
7111 native_encode_expr (const_tree expr, unsigned char *ptr, int len, int off)
7112 {
7113   switch (TREE_CODE (expr))
7114     {
7115     case INTEGER_CST:
7116       return native_encode_int (expr, ptr, len, off);
7117
7118     case REAL_CST:
7119       return native_encode_real (expr, ptr, len, off);
7120
7121     case FIXED_CST:
7122       return native_encode_fixed (expr, ptr, len, off);
7123
7124     case COMPLEX_CST:
7125       return native_encode_complex (expr, ptr, len, off);
7126
7127     case VECTOR_CST:
7128       return native_encode_vector (expr, ptr, len, off);
7129
7130     case STRING_CST:
7131       return native_encode_string (expr, ptr, len, off);
7132
7133     default:
7134       return 0;
7135     }
7136 }
7137
7138
7139 /* Subroutine of native_interpret_expr.  Interpret the contents of
7140    the buffer PTR of length LEN as an INTEGER_CST of type TYPE.
7141    If the buffer cannot be interpreted, return NULL_TREE.  */
7142
7143 static tree
7144 native_interpret_int (tree type, const unsigned char *ptr, int len)
7145 {
7146   int total_bytes = GET_MODE_SIZE (TYPE_MODE (type));
7147
7148   if (total_bytes > len
7149       || total_bytes * BITS_PER_UNIT > HOST_BITS_PER_DOUBLE_INT)
7150     return NULL_TREE;
7151
7152   wide_int result = wi::from_buffer (ptr, total_bytes);
7153
7154   return wide_int_to_tree (type, result);
7155 }
7156
7157
7158 /* Subroutine of native_interpret_expr.  Interpret the contents of
7159    the buffer PTR of length LEN as a FIXED_CST of type TYPE.
7160    If the buffer cannot be interpreted, return NULL_TREE.  */
7161
7162 static tree
7163 native_interpret_fixed (tree type, const unsigned char *ptr, int len)
7164 {
7165   int total_bytes = GET_MODE_SIZE (TYPE_MODE (type));
7166   double_int result;
7167   FIXED_VALUE_TYPE fixed_value;
7168
7169   if (total_bytes > len
7170       || total_bytes * BITS_PER_UNIT > HOST_BITS_PER_DOUBLE_INT)
7171     return NULL_TREE;
7172
7173   result = double_int::from_buffer (ptr, total_bytes);
7174   fixed_value = fixed_from_double_int (result, TYPE_MODE (type));
7175
7176   return build_fixed (type, fixed_value);
7177 }
7178
7179
7180 /* Subroutine of native_interpret_expr.  Interpret the contents of
7181    the buffer PTR of length LEN as a REAL_CST of type TYPE.
7182    If the buffer cannot be interpreted, return NULL_TREE.  */
7183
7184 static tree
7185 native_interpret_real (tree type, const unsigned char *ptr, int len)
7186 {
7187   machine_mode mode = TYPE_MODE (type);
7188   int total_bytes = GET_MODE_SIZE (mode);
7189   unsigned char value;
7190   /* There are always 32 bits in each long, no matter the size of
7191      the hosts long.  We handle floating point representations with
7192      up to 192 bits.  */
7193   REAL_VALUE_TYPE r;
7194   long tmp[6];
7195
7196   total_bytes = GET_MODE_SIZE (TYPE_MODE (type));
7197   if (total_bytes > len || total_bytes > 24)
7198     return NULL_TREE;
7199   int words = (32 / BITS_PER_UNIT) / UNITS_PER_WORD;
7200
7201   memset (tmp, 0, sizeof (tmp));
7202   for (int bitpos = 0; bitpos < total_bytes * BITS_PER_UNIT;
7203        bitpos += BITS_PER_UNIT)
7204     {
7205       /* Both OFFSET and BYTE index within a long;
7206          bitpos indexes the whole float.  */
7207       int offset, byte = (bitpos / BITS_PER_UNIT) & 3;
7208       if (UNITS_PER_WORD < 4)
7209         {
7210           int word = byte / UNITS_PER_WORD;
7211           if (WORDS_BIG_ENDIAN)
7212             word = (words - 1) - word;
7213           offset = word * UNITS_PER_WORD;
7214           if (BYTES_BIG_ENDIAN)
7215             offset += (UNITS_PER_WORD - 1) - (byte % UNITS_PER_WORD);
7216           else
7217             offset += byte % UNITS_PER_WORD;
7218         }
7219       else
7220         {
7221           offset = byte;
7222           if (BYTES_BIG_ENDIAN)
7223             {
7224               /* Reverse bytes within each long, or within the entire float
7225                  if it's smaller than a long (for HFmode).  */
7226               offset = MIN (3, total_bytes - 1) - offset;
7227               gcc_assert (offset >= 0);
7228             }
7229         }
7230       value = ptr[offset + ((bitpos / BITS_PER_UNIT) & ~3)];
7231
7232       tmp[bitpos / 32] |= (unsigned long)value << (bitpos & 31);
7233     }
7234
7235   real_from_target (&r, tmp, mode);
7236   return build_real (type, r);
7237 }
7238
7239
7240 /* Subroutine of native_interpret_expr.  Interpret the contents of
7241    the buffer PTR of length LEN as a COMPLEX_CST of type TYPE.
7242    If the buffer cannot be interpreted, return NULL_TREE.  */
7243
7244 static tree
7245 native_interpret_complex (tree type, const unsigned char *ptr, int len)
7246 {
7247   tree etype, rpart, ipart;
7248   int size;
7249
7250   etype = TREE_TYPE (type);
7251   size = GET_MODE_SIZE (TYPE_MODE (etype));
7252   if (size * 2 > len)
7253     return NULL_TREE;
7254   rpart = native_interpret_expr (etype, ptr, size);
7255   if (!rpart)
7256     return NULL_TREE;
7257   ipart = native_interpret_expr (etype, ptr+size, size);
7258   if (!ipart)
7259     return NULL_TREE;
7260   return build_complex (type, rpart, ipart);
7261 }
7262
7263
7264 /* Subroutine of native_interpret_expr.  Interpret the contents of
7265    the buffer PTR of length LEN as a VECTOR_CST of type TYPE.
7266    If the buffer cannot be interpreted, return NULL_TREE.  */
7267
7268 static tree
7269 native_interpret_vector (tree type, const unsigned char *ptr, int len)
7270 {
7271   tree etype, elem;
7272   int i, size, count;
7273   tree *elements;
7274
7275   etype = TREE_TYPE (type);
7276   size = GET_MODE_SIZE (TYPE_MODE (etype));
7277   count = TYPE_VECTOR_SUBPARTS (type);
7278   if (size * count > len)
7279     return NULL_TREE;
7280
7281   elements = XALLOCAVEC (tree, count);
7282   for (i = count - 1; i >= 0; i--)
7283     {
7284       elem = native_interpret_expr (etype, ptr+(i*size), size);
7285       if (!elem)
7286         return NULL_TREE;
7287       elements[i] = elem;
7288     }
7289   return build_vector (type, elements);
7290 }
7291
7292
7293 /* Subroutine of fold_view_convert_expr.  Interpret the contents of
7294    the buffer PTR of length LEN as a constant of type TYPE.  For
7295    INTEGRAL_TYPE_P we return an INTEGER_CST, for SCALAR_FLOAT_TYPE_P
7296    we return a REAL_CST, etc...  If the buffer cannot be interpreted,
7297    return NULL_TREE.  */
7298
7299 tree
7300 native_interpret_expr (tree type, const unsigned char *ptr, int len)
7301 {
7302   switch (TREE_CODE (type))
7303     {
7304     case INTEGER_TYPE:
7305     case ENUMERAL_TYPE:
7306     case BOOLEAN_TYPE:
7307     case POINTER_TYPE:
7308     case REFERENCE_TYPE:
7309       return native_interpret_int (type, ptr, len);
7310
7311     case REAL_TYPE:
7312       return native_interpret_real (type, ptr, len);
7313
7314     case FIXED_POINT_TYPE:
7315       return native_interpret_fixed (type, ptr, len);
7316
7317     case COMPLEX_TYPE:
7318       return native_interpret_complex (type, ptr, len);
7319
7320     case VECTOR_TYPE:
7321       return native_interpret_vector (type, ptr, len);
7322
7323     default:
7324       return NULL_TREE;
7325     }
7326 }
7327
7328 /* Returns true if we can interpret the contents of a native encoding
7329    as TYPE.  */
7330
7331 static bool
7332 can_native_interpret_type_p (tree type)
7333 {
7334   switch (TREE_CODE (type))
7335     {
7336     case INTEGER_TYPE:
7337     case ENUMERAL_TYPE:
7338     case BOOLEAN_TYPE:
7339     case POINTER_TYPE:
7340     case REFERENCE_TYPE:
7341     case FIXED_POINT_TYPE:
7342     case REAL_TYPE:
7343     case COMPLEX_TYPE:
7344     case VECTOR_TYPE:
7345       return true;
7346     default:
7347       return false;
7348     }
7349 }
7350
7351 /* Fold a VIEW_CONVERT_EXPR of a constant expression EXPR to type
7352    TYPE at compile-time.  If we're unable to perform the conversion
7353    return NULL_TREE.  */
7354
7355 static tree
7356 fold_view_convert_expr (tree type, tree expr)
7357 {
7358   /* We support up to 512-bit values (for V8DFmode).  */
7359   unsigned char buffer[64];
7360   int len;
7361
7362   /* Check that the host and target are sane.  */
7363   if (CHAR_BIT != 8 || BITS_PER_UNIT != 8)
7364     return NULL_TREE;
7365
7366   len = native_encode_expr (expr, buffer, sizeof (buffer));
7367   if (len == 0)
7368     return NULL_TREE;
7369
7370   return native_interpret_expr (type, buffer, len);
7371 }
7372
7373 /* Build an expression for the address of T.  Folds away INDIRECT_REF
7374    to avoid confusing the gimplify process.  */
7375
7376 tree
7377 build_fold_addr_expr_with_type_loc (location_t loc, tree t, tree ptrtype)
7378 {
7379   /* The size of the object is not relevant when talking about its address.  */
7380   if (TREE_CODE (t) == WITH_SIZE_EXPR)
7381     t = TREE_OPERAND (t, 0);
7382
7383   if (TREE_CODE (t) == INDIRECT_REF)
7384     {
7385       t = TREE_OPERAND (t, 0);
7386
7387       if (TREE_TYPE (t) != ptrtype)
7388         t = build1_loc (loc, NOP_EXPR, ptrtype, t);
7389     }
7390   else if (TREE_CODE (t) == MEM_REF
7391            && integer_zerop (TREE_OPERAND (t, 1)))
7392     return TREE_OPERAND (t, 0);
7393   else if (TREE_CODE (t) == MEM_REF
7394            && TREE_CODE (TREE_OPERAND (t, 0)) == INTEGER_CST)
7395     return fold_binary (POINTER_PLUS_EXPR, ptrtype,
7396                         TREE_OPERAND (t, 0),
7397                         convert_to_ptrofftype (TREE_OPERAND (t, 1)));
7398   else if (TREE_CODE (t) == VIEW_CONVERT_EXPR)
7399     {
7400       t = build_fold_addr_expr_loc (loc, TREE_OPERAND (t, 0));
7401
7402       if (TREE_TYPE (t) != ptrtype)
7403         t = fold_convert_loc (loc, ptrtype, t);
7404     }
7405   else
7406     t = build1_loc (loc, ADDR_EXPR, ptrtype, t);
7407
7408   return t;
7409 }
7410
7411 /* Build an expression for the address of T.  */
7412
7413 tree
7414 build_fold_addr_expr_loc (location_t loc, tree t)
7415 {
7416   tree ptrtype = build_pointer_type (TREE_TYPE (t));
7417
7418   return build_fold_addr_expr_with_type_loc (loc, t, ptrtype);
7419 }
7420
7421 /* Fold a unary expression of code CODE and type TYPE with operand
7422    OP0.  Return the folded expression if folding is successful.
7423    Otherwise, return NULL_TREE.  */
7424
7425 tree
7426 fold_unary_loc (location_t loc, enum tree_code code, tree type, tree op0)
7427 {
7428   tree tem;
7429   tree arg0;
7430   enum tree_code_class kind = TREE_CODE_CLASS (code);
7431
7432   gcc_assert (IS_EXPR_CODE_CLASS (kind)
7433               && TREE_CODE_LENGTH (code) == 1);
7434
7435   arg0 = op0;
7436   if (arg0)
7437     {
7438       if (CONVERT_EXPR_CODE_P (code)
7439           || code == FLOAT_EXPR || code == ABS_EXPR || code == NEGATE_EXPR)
7440         {
7441           /* Don't use STRIP_NOPS, because signedness of argument type
7442              matters.  */
7443           STRIP_SIGN_NOPS (arg0);
7444         }
7445       else
7446         {
7447           /* Strip any conversions that don't change the mode.  This
7448              is safe for every expression, except for a comparison
7449              expression because its signedness is derived from its
7450              operands.
7451
7452              Note that this is done as an internal manipulation within
7453              the constant folder, in order to find the simplest
7454              representation of the arguments so that their form can be
7455              studied.  In any cases, the appropriate type conversions
7456              should be put back in the tree that will get out of the
7457              constant folder.  */
7458           STRIP_NOPS (arg0);
7459         }
7460
7461       if (CONSTANT_CLASS_P (arg0))
7462         {
7463           tree tem = const_unop (code, type, arg0);
7464           if (tem)
7465             {
7466               if (TREE_TYPE (tem) != type)
7467                 tem = fold_convert_loc (loc, type, tem);
7468               return tem;
7469             }
7470         }
7471     }
7472
7473   tem = generic_simplify (loc, code, type, op0);
7474   if (tem)
7475     return tem;
7476
7477   if (TREE_CODE_CLASS (code) == tcc_unary)
7478     {
7479       if (TREE_CODE (arg0) == COMPOUND_EXPR)
7480         return build2 (COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
7481                        fold_build1_loc (loc, code, type,
7482                                     fold_convert_loc (loc, TREE_TYPE (op0),
7483                                                       TREE_OPERAND (arg0, 1))));
7484       else if (TREE_CODE (arg0) == COND_EXPR)
7485         {
7486           tree arg01 = TREE_OPERAND (arg0, 1);
7487           tree arg02 = TREE_OPERAND (arg0, 2);
7488           if (! VOID_TYPE_P (TREE_TYPE (arg01)))
7489             arg01 = fold_build1_loc (loc, code, type,
7490                                  fold_convert_loc (loc,
7491                                                    TREE_TYPE (op0), arg01));
7492           if (! VOID_TYPE_P (TREE_TYPE (arg02)))
7493             arg02 = fold_build1_loc (loc, code, type,
7494                                  fold_convert_loc (loc,
7495                                                    TREE_TYPE (op0), arg02));
7496           tem = fold_build3_loc (loc, COND_EXPR, type, TREE_OPERAND (arg0, 0),
7497                              arg01, arg02);
7498
7499           /* If this was a conversion, and all we did was to move into
7500              inside the COND_EXPR, bring it back out.  But leave it if
7501              it is a conversion from integer to integer and the
7502              result precision is no wider than a word since such a
7503              conversion is cheap and may be optimized away by combine,
7504              while it couldn't if it were outside the COND_EXPR.  Then return
7505              so we don't get into an infinite recursion loop taking the
7506              conversion out and then back in.  */
7507
7508           if ((CONVERT_EXPR_CODE_P (code)
7509                || code == NON_LVALUE_EXPR)
7510               && TREE_CODE (tem) == COND_EXPR
7511               && TREE_CODE (TREE_OPERAND (tem, 1)) == code
7512               && TREE_CODE (TREE_OPERAND (tem, 2)) == code
7513               && ! VOID_TYPE_P (TREE_OPERAND (tem, 1))
7514               && ! VOID_TYPE_P (TREE_OPERAND (tem, 2))
7515               && (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (tem, 1), 0))
7516                   == TREE_TYPE (TREE_OPERAND (TREE_OPERAND (tem, 2), 0)))
7517               && (! (INTEGRAL_TYPE_P (TREE_TYPE (tem))
7518                      && (INTEGRAL_TYPE_P
7519                          (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (tem, 1), 0))))
7520                      && TYPE_PRECISION (TREE_TYPE (tem)) <= BITS_PER_WORD)
7521                   || flag_syntax_only))
7522             tem = build1_loc (loc, code, type,
7523                               build3 (COND_EXPR,
7524                                       TREE_TYPE (TREE_OPERAND
7525                                                  (TREE_OPERAND (tem, 1), 0)),
7526                                       TREE_OPERAND (tem, 0),
7527                                       TREE_OPERAND (TREE_OPERAND (tem, 1), 0),
7528                                       TREE_OPERAND (TREE_OPERAND (tem, 2),
7529                                                     0)));
7530           return tem;
7531         }
7532    }
7533
7534   switch (code)
7535     {
7536     case NON_LVALUE_EXPR:
7537       if (!maybe_lvalue_p (op0))
7538         return fold_convert_loc (loc, type, op0);
7539       return NULL_TREE;
7540
7541     CASE_CONVERT:
7542     case FLOAT_EXPR:
7543     case FIX_TRUNC_EXPR:
7544       if (COMPARISON_CLASS_P (op0))
7545         {
7546           /* If we have (type) (a CMP b) and type is an integral type, return
7547              new expression involving the new type.  Canonicalize
7548              (type) (a CMP b) to (a CMP b) ? (type) true : (type) false for
7549              non-integral type.
7550              Do not fold the result as that would not simplify further, also
7551              folding again results in recursions.  */
7552           if (TREE_CODE (type) == BOOLEAN_TYPE)
7553             return build2_loc (loc, TREE_CODE (op0), type,
7554                                TREE_OPERAND (op0, 0),
7555                                TREE_OPERAND (op0, 1));
7556           else if (!INTEGRAL_TYPE_P (type) && !VOID_TYPE_P (type)
7557                    && TREE_CODE (type) != VECTOR_TYPE)
7558             return build3_loc (loc, COND_EXPR, type, op0,
7559                                constant_boolean_node (true, type),
7560                                constant_boolean_node (false, type));
7561         }
7562
7563       /* Handle (T *)&A.B.C for A being of type T and B and C
7564          living at offset zero.  This occurs frequently in
7565          C++ upcasting and then accessing the base.  */
7566       if (TREE_CODE (op0) == ADDR_EXPR
7567           && POINTER_TYPE_P (type)
7568           && handled_component_p (TREE_OPERAND (op0, 0)))
7569         {
7570           HOST_WIDE_INT bitsize, bitpos;
7571           tree offset;
7572           machine_mode mode;
7573           int unsignedp, volatilep;
7574           tree base = TREE_OPERAND (op0, 0);
7575           base = get_inner_reference (base, &bitsize, &bitpos, &offset,
7576                                       &mode, &unsignedp, &volatilep, false);
7577           /* If the reference was to a (constant) zero offset, we can use
7578              the address of the base if it has the same base type
7579              as the result type and the pointer type is unqualified.  */
7580           if (! offset && bitpos == 0
7581               && (TYPE_MAIN_VARIANT (TREE_TYPE (type))
7582                   == TYPE_MAIN_VARIANT (TREE_TYPE (base)))
7583               && TYPE_QUALS (type) == TYPE_UNQUALIFIED)
7584             return fold_convert_loc (loc, type,
7585                                      build_fold_addr_expr_loc (loc, base));
7586         }
7587
7588       if (TREE_CODE (op0) == MODIFY_EXPR
7589           && TREE_CONSTANT (TREE_OPERAND (op0, 1))
7590           /* Detect assigning a bitfield.  */
7591           && !(TREE_CODE (TREE_OPERAND (op0, 0)) == COMPONENT_REF
7592                && DECL_BIT_FIELD
7593                (TREE_OPERAND (TREE_OPERAND (op0, 0), 1))))
7594         {
7595           /* Don't leave an assignment inside a conversion
7596              unless assigning a bitfield.  */
7597           tem = fold_build1_loc (loc, code, type, TREE_OPERAND (op0, 1));
7598           /* First do the assignment, then return converted constant.  */
7599           tem = build2_loc (loc, COMPOUND_EXPR, TREE_TYPE (tem), op0, tem);
7600           TREE_NO_WARNING (tem) = 1;
7601           TREE_USED (tem) = 1;
7602           return tem;
7603         }
7604
7605       /* Convert (T)(x & c) into (T)x & (T)c, if c is an integer
7606          constants (if x has signed type, the sign bit cannot be set
7607          in c).  This folds extension into the BIT_AND_EXPR.
7608          ??? We don't do it for BOOLEAN_TYPE or ENUMERAL_TYPE because they
7609          very likely don't have maximal range for their precision and this
7610          transformation effectively doesn't preserve non-maximal ranges.  */
7611       if (TREE_CODE (type) == INTEGER_TYPE
7612           && TREE_CODE (op0) == BIT_AND_EXPR
7613           && TREE_CODE (TREE_OPERAND (op0, 1)) == INTEGER_CST)
7614         {
7615           tree and_expr = op0;
7616           tree and0 = TREE_OPERAND (and_expr, 0);
7617           tree and1 = TREE_OPERAND (and_expr, 1);
7618           int change = 0;
7619
7620           if (TYPE_UNSIGNED (TREE_TYPE (and_expr))
7621               || (TYPE_PRECISION (type)
7622                   <= TYPE_PRECISION (TREE_TYPE (and_expr))))
7623             change = 1;
7624           else if (TYPE_PRECISION (TREE_TYPE (and1))
7625                    <= HOST_BITS_PER_WIDE_INT
7626                    && tree_fits_uhwi_p (and1))
7627             {
7628               unsigned HOST_WIDE_INT cst;
7629
7630               cst = tree_to_uhwi (and1);
7631               cst &= HOST_WIDE_INT_M1U
7632                      << (TYPE_PRECISION (TREE_TYPE (and1)) - 1);
7633               change = (cst == 0);
7634               if (change
7635                   && !flag_syntax_only
7636                   && (LOAD_EXTEND_OP (TYPE_MODE (TREE_TYPE (and0)))
7637                       == ZERO_EXTEND))
7638                 {
7639                   tree uns = unsigned_type_for (TREE_TYPE (and0));
7640                   and0 = fold_convert_loc (loc, uns, and0);
7641                   and1 = fold_convert_loc (loc, uns, and1);
7642                 }
7643             }
7644           if (change)
7645             {
7646               tem = force_fit_type (type, wi::to_widest (and1), 0,
7647                                     TREE_OVERFLOW (and1));
7648               return fold_build2_loc (loc, BIT_AND_EXPR, type,
7649                                       fold_convert_loc (loc, type, and0), tem);
7650             }
7651         }
7652
7653       /* Convert (T1)(X p+ Y) into ((T1)X p+ Y), for pointer type,
7654          when one of the new casts will fold away. Conservatively we assume
7655          that this happens when X or Y is NOP_EXPR or Y is INTEGER_CST. */
7656       if (POINTER_TYPE_P (type)
7657           && TREE_CODE (arg0) == POINTER_PLUS_EXPR
7658           && (!TYPE_RESTRICT (type) || TYPE_RESTRICT (TREE_TYPE (arg0)))
7659           && (TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
7660               || TREE_CODE (TREE_OPERAND (arg0, 0)) == NOP_EXPR
7661               || TREE_CODE (TREE_OPERAND (arg0, 1)) == NOP_EXPR))
7662         {
7663           tree arg00 = TREE_OPERAND (arg0, 0);
7664           tree arg01 = TREE_OPERAND (arg0, 1);
7665
7666           return fold_build_pointer_plus_loc
7667                    (loc, fold_convert_loc (loc, type, arg00), arg01);
7668         }
7669
7670       /* Convert (T1)(~(T2)X) into ~(T1)X if T1 and T2 are integral types
7671          of the same precision, and X is an integer type not narrower than
7672          types T1 or T2, i.e. the cast (T2)X isn't an extension.  */
7673       if (INTEGRAL_TYPE_P (type)
7674           && TREE_CODE (op0) == BIT_NOT_EXPR
7675           && INTEGRAL_TYPE_P (TREE_TYPE (op0))
7676           && CONVERT_EXPR_P (TREE_OPERAND (op0, 0))
7677           && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (op0)))
7678         {
7679           tem = TREE_OPERAND (TREE_OPERAND (op0, 0), 0);
7680           if (INTEGRAL_TYPE_P (TREE_TYPE (tem))
7681               && TYPE_PRECISION (type) <= TYPE_PRECISION (TREE_TYPE (tem)))
7682             return fold_build1_loc (loc, BIT_NOT_EXPR, type,
7683                                 fold_convert_loc (loc, type, tem));
7684         }
7685
7686       /* Convert (T1)(X * Y) into (T1)X * (T1)Y if T1 is narrower than the
7687          type of X and Y (integer types only).  */
7688       if (INTEGRAL_TYPE_P (type)
7689           && TREE_CODE (op0) == MULT_EXPR
7690           && INTEGRAL_TYPE_P (TREE_TYPE (op0))
7691           && TYPE_PRECISION (type) < TYPE_PRECISION (TREE_TYPE (op0)))
7692         {
7693           /* Be careful not to introduce new overflows.  */
7694           tree mult_type;
7695           if (TYPE_OVERFLOW_WRAPS (type))
7696             mult_type = type;
7697           else
7698             mult_type = unsigned_type_for (type);
7699
7700           if (TYPE_PRECISION (mult_type) < TYPE_PRECISION (TREE_TYPE (op0)))
7701             {
7702               tem = fold_build2_loc (loc, MULT_EXPR, mult_type,
7703                                  fold_convert_loc (loc, mult_type,
7704                                                    TREE_OPERAND (op0, 0)),
7705                                  fold_convert_loc (loc, mult_type,
7706                                                    TREE_OPERAND (op0, 1)));
7707               return fold_convert_loc (loc, type, tem);
7708             }
7709         }
7710
7711       return NULL_TREE;
7712
7713     case VIEW_CONVERT_EXPR:
7714       if (TREE_CODE (op0) == MEM_REF)
7715         return fold_build2_loc (loc, MEM_REF, type,
7716                                 TREE_OPERAND (op0, 0), TREE_OPERAND (op0, 1));
7717
7718       return NULL_TREE;
7719
7720     case NEGATE_EXPR:
7721       tem = fold_negate_expr (loc, arg0);
7722       if (tem)
7723         return fold_convert_loc (loc, type, tem);
7724       return NULL_TREE;
7725
7726     case ABS_EXPR:
7727       /* Convert fabs((double)float) into (double)fabsf(float).  */
7728       if (TREE_CODE (arg0) == NOP_EXPR
7729           && TREE_CODE (type) == REAL_TYPE)
7730         {
7731           tree targ0 = strip_float_extensions (arg0);
7732           if (targ0 != arg0)
7733             return fold_convert_loc (loc, type,
7734                                      fold_build1_loc (loc, ABS_EXPR,
7735                                                   TREE_TYPE (targ0),
7736                                                   targ0));
7737         }
7738
7739       /* Strip sign ops from argument.  */
7740       if (TREE_CODE (type) == REAL_TYPE)
7741         {
7742           tem = fold_strip_sign_ops (arg0);
7743           if (tem)
7744             return fold_build1_loc (loc, ABS_EXPR, type,
7745                                 fold_convert_loc (loc, type, tem));
7746         }
7747       return NULL_TREE;
7748
7749     case BIT_NOT_EXPR:
7750       /* Convert ~(X ^ Y) to ~X ^ Y or X ^ ~Y if ~X or ~Y simplify.  */
7751       if (TREE_CODE (arg0) == BIT_XOR_EXPR
7752           && (tem = fold_unary_loc (loc, BIT_NOT_EXPR, type,
7753                                     fold_convert_loc (loc, type,
7754                                                       TREE_OPERAND (arg0, 0)))))
7755         return fold_build2_loc (loc, BIT_XOR_EXPR, type, tem,
7756                                 fold_convert_loc (loc, type,
7757                                                   TREE_OPERAND (arg0, 1)));
7758       else if (TREE_CODE (arg0) == BIT_XOR_EXPR
7759                && (tem = fold_unary_loc (loc, BIT_NOT_EXPR, type,
7760                                      fold_convert_loc (loc, type,
7761                                                        TREE_OPERAND (arg0, 1)))))
7762         return fold_build2_loc (loc, BIT_XOR_EXPR, type,
7763                             fold_convert_loc (loc, type,
7764                                               TREE_OPERAND (arg0, 0)), tem);
7765
7766       return NULL_TREE;
7767
7768     case TRUTH_NOT_EXPR:
7769       /* Note that the operand of this must be an int
7770          and its values must be 0 or 1.
7771          ("true" is a fixed value perhaps depending on the language,
7772          but we don't handle values other than 1 correctly yet.)  */
7773       tem = fold_truth_not_expr (loc, arg0);
7774       if (!tem)
7775         return NULL_TREE;
7776       return fold_convert_loc (loc, type, tem);
7777
7778     case INDIRECT_REF:
7779       /* Fold *&X to X if X is an lvalue.  */
7780       if (TREE_CODE (op0) == ADDR_EXPR)
7781         {
7782           tree op00 = TREE_OPERAND (op0, 0);
7783           if ((TREE_CODE (op00) == VAR_DECL
7784                || TREE_CODE (op00) == PARM_DECL
7785                || TREE_CODE (op00) == RESULT_DECL)
7786               && !TREE_READONLY (op00))
7787             return op00;
7788         }
7789       return NULL_TREE;
7790
7791     default:
7792       return NULL_TREE;
7793     } /* switch (code) */
7794 }
7795
7796
7797 /* If the operation was a conversion do _not_ mark a resulting constant
7798    with TREE_OVERFLOW if the original constant was not.  These conversions
7799    have implementation defined behavior and retaining the TREE_OVERFLOW
7800    flag here would confuse later passes such as VRP.  */
7801 tree
7802 fold_unary_ignore_overflow_loc (location_t loc, enum tree_code code,
7803                                 tree type, tree op0)
7804 {
7805   tree res = fold_unary_loc (loc, code, type, op0);
7806   if (res
7807       && TREE_CODE (res) == INTEGER_CST
7808       && TREE_CODE (op0) == INTEGER_CST
7809       && CONVERT_EXPR_CODE_P (code))
7810     TREE_OVERFLOW (res) = TREE_OVERFLOW (op0);
7811
7812   return res;
7813 }
7814
7815 /* Fold a binary bitwise/truth expression of code CODE and type TYPE with
7816    operands OP0 and OP1.  LOC is the location of the resulting expression.
7817    ARG0 and ARG1 are the NOP_STRIPed results of OP0 and OP1.
7818    Return the folded expression if folding is successful.  Otherwise,
7819    return NULL_TREE.  */
7820 static tree
7821 fold_truth_andor (location_t loc, enum tree_code code, tree type,
7822                   tree arg0, tree arg1, tree op0, tree op1)
7823 {
7824   tree tem;
7825
7826   /* We only do these simplifications if we are optimizing.  */
7827   if (!optimize)
7828     return NULL_TREE;
7829
7830   /* Check for things like (A || B) && (A || C).  We can convert this
7831      to A || (B && C).  Note that either operator can be any of the four
7832      truth and/or operations and the transformation will still be
7833      valid.   Also note that we only care about order for the
7834      ANDIF and ORIF operators.  If B contains side effects, this
7835      might change the truth-value of A.  */
7836   if (TREE_CODE (arg0) == TREE_CODE (arg1)
7837       && (TREE_CODE (arg0) == TRUTH_ANDIF_EXPR
7838           || TREE_CODE (arg0) == TRUTH_ORIF_EXPR
7839           || TREE_CODE (arg0) == TRUTH_AND_EXPR
7840           || TREE_CODE (arg0) == TRUTH_OR_EXPR)
7841       && ! TREE_SIDE_EFFECTS (TREE_OPERAND (arg0, 1)))
7842     {
7843       tree a00 = TREE_OPERAND (arg0, 0);
7844       tree a01 = TREE_OPERAND (arg0, 1);
7845       tree a10 = TREE_OPERAND (arg1, 0);
7846       tree a11 = TREE_OPERAND (arg1, 1);
7847       int commutative = ((TREE_CODE (arg0) == TRUTH_OR_EXPR
7848                           || TREE_CODE (arg0) == TRUTH_AND_EXPR)
7849                          && (code == TRUTH_AND_EXPR
7850                              || code == TRUTH_OR_EXPR));
7851
7852       if (operand_equal_p (a00, a10, 0))
7853         return fold_build2_loc (loc, TREE_CODE (arg0), type, a00,
7854                             fold_build2_loc (loc, code, type, a01, a11));
7855       else if (commutative && operand_equal_p (a00, a11, 0))
7856         return fold_build2_loc (loc, TREE_CODE (arg0), type, a00,
7857                             fold_build2_loc (loc, code, type, a01, a10));
7858       else if (commutative && operand_equal_p (a01, a10, 0))
7859         return fold_build2_loc (loc, TREE_CODE (arg0), type, a01,
7860                             fold_build2_loc (loc, code, type, a00, a11));
7861
7862       /* This case if tricky because we must either have commutative
7863          operators or else A10 must not have side-effects.  */
7864
7865       else if ((commutative || ! TREE_SIDE_EFFECTS (a10))
7866                && operand_equal_p (a01, a11, 0))
7867         return fold_build2_loc (loc, TREE_CODE (arg0), type,
7868                             fold_build2_loc (loc, code, type, a00, a10),
7869                             a01);
7870     }
7871
7872   /* See if we can build a range comparison.  */
7873   if (0 != (tem = fold_range_test (loc, code, type, op0, op1)))
7874     return tem;
7875
7876   if ((code == TRUTH_ANDIF_EXPR && TREE_CODE (arg0) == TRUTH_ORIF_EXPR)
7877       || (code == TRUTH_ORIF_EXPR && TREE_CODE (arg0) == TRUTH_ANDIF_EXPR))
7878     {
7879       tem = merge_truthop_with_opposite_arm (loc, arg0, arg1, true);
7880       if (tem)
7881         return fold_build2_loc (loc, code, type, tem, arg1);
7882     }
7883
7884   if ((code == TRUTH_ANDIF_EXPR && TREE_CODE (arg1) == TRUTH_ORIF_EXPR)
7885       || (code == TRUTH_ORIF_EXPR && TREE_CODE (arg1) == TRUTH_ANDIF_EXPR))
7886     {
7887       tem = merge_truthop_with_opposite_arm (loc, arg1, arg0, false);
7888       if (tem)
7889         return fold_build2_loc (loc, code, type, arg0, tem);
7890     }
7891
7892   /* Check for the possibility of merging component references.  If our
7893      lhs is another similar operation, try to merge its rhs with our
7894      rhs.  Then try to merge our lhs and rhs.  */
7895   if (TREE_CODE (arg0) == code
7896       && 0 != (tem = fold_truth_andor_1 (loc, code, type,
7897                                          TREE_OPERAND (arg0, 1), arg1)))
7898     return fold_build2_loc (loc, code, type, TREE_OPERAND (arg0, 0), tem);
7899
7900   if ((tem = fold_truth_andor_1 (loc, code, type, arg0, arg1)) != 0)
7901     return tem;
7902
7903   if (LOGICAL_OP_NON_SHORT_CIRCUIT
7904       && (code == TRUTH_AND_EXPR
7905           || code == TRUTH_ANDIF_EXPR
7906           || code == TRUTH_OR_EXPR
7907           || code == TRUTH_ORIF_EXPR))
7908     {
7909       enum tree_code ncode, icode;
7910
7911       ncode = (code == TRUTH_ANDIF_EXPR || code == TRUTH_AND_EXPR)
7912               ? TRUTH_AND_EXPR : TRUTH_OR_EXPR;
7913       icode = ncode == TRUTH_AND_EXPR ? TRUTH_ANDIF_EXPR : TRUTH_ORIF_EXPR;
7914
7915       /* Transform ((A AND-IF B) AND[-IF] C) into (A AND-IF (B AND C)),
7916          or ((A OR-IF B) OR[-IF] C) into (A OR-IF (B OR C))
7917          We don't want to pack more than two leafs to a non-IF AND/OR
7918          expression.
7919          If tree-code of left-hand operand isn't an AND/OR-IF code and not
7920          equal to IF-CODE, then we don't want to add right-hand operand.
7921          If the inner right-hand side of left-hand operand has
7922          side-effects, or isn't simple, then we can't add to it,
7923          as otherwise we might destroy if-sequence.  */
7924       if (TREE_CODE (arg0) == icode
7925           && simple_operand_p_2 (arg1)
7926           /* Needed for sequence points to handle trappings, and
7927              side-effects.  */
7928           && simple_operand_p_2 (TREE_OPERAND (arg0, 1)))
7929         {
7930           tem = fold_build2_loc (loc, ncode, type, TREE_OPERAND (arg0, 1),
7931                                  arg1);
7932           return fold_build2_loc (loc, icode, type, TREE_OPERAND (arg0, 0),
7933                                   tem);
7934         }
7935         /* Same as abouve but for (A AND[-IF] (B AND-IF C)) -> ((A AND B) AND-IF C),
7936            or (A OR[-IF] (B OR-IF C) -> ((A OR B) OR-IF C).  */
7937       else if (TREE_CODE (arg1) == icode
7938           && simple_operand_p_2 (arg0)
7939           /* Needed for sequence points to handle trappings, and
7940              side-effects.  */
7941           && simple_operand_p_2 (TREE_OPERAND (arg1, 0)))
7942         {
7943           tem = fold_build2_loc (loc, ncode, type,
7944                                  arg0, TREE_OPERAND (arg1, 0));
7945           return fold_build2_loc (loc, icode, type, tem,
7946                                   TREE_OPERAND (arg1, 1));
7947         }
7948       /* Transform (A AND-IF B) into (A AND B), or (A OR-IF B)
7949          into (A OR B).
7950          For sequence point consistancy, we need to check for trapping,
7951          and side-effects.  */
7952       else if (code == icode && simple_operand_p_2 (arg0)
7953                && simple_operand_p_2 (arg1))
7954         return fold_build2_loc (loc, ncode, type, arg0, arg1);
7955     }
7956
7957   return NULL_TREE;
7958 }
7959
7960 /* Fold a binary expression of code CODE and type TYPE with operands
7961    OP0 and OP1, containing either a MIN-MAX or a MAX-MIN combination.
7962    Return the folded expression if folding is successful.  Otherwise,
7963    return NULL_TREE.  */
7964
7965 static tree
7966 fold_minmax (location_t loc, enum tree_code code, tree type, tree op0, tree op1)
7967 {
7968   enum tree_code compl_code;
7969
7970   if (code == MIN_EXPR)
7971     compl_code = MAX_EXPR;
7972   else if (code == MAX_EXPR)
7973     compl_code = MIN_EXPR;
7974   else
7975     gcc_unreachable ();
7976
7977   /* MIN (MAX (a, b), b) == b.  */
7978   if (TREE_CODE (op0) == compl_code
7979       && operand_equal_p (TREE_OPERAND (op0, 1), op1, 0))
7980     return omit_one_operand_loc (loc, type, op1, TREE_OPERAND (op0, 0));
7981
7982   /* MIN (MAX (b, a), b) == b.  */
7983   if (TREE_CODE (op0) == compl_code
7984       && operand_equal_p (TREE_OPERAND (op0, 0), op1, 0)
7985       && reorder_operands_p (TREE_OPERAND (op0, 1), op1))
7986     return omit_one_operand_loc (loc, type, op1, TREE_OPERAND (op0, 1));
7987
7988   /* MIN (a, MAX (a, b)) == a.  */
7989   if (TREE_CODE (op1) == compl_code
7990       && operand_equal_p (op0, TREE_OPERAND (op1, 0), 0)
7991       && reorder_operands_p (op0, TREE_OPERAND (op1, 1)))
7992     return omit_one_operand_loc (loc, type, op0, TREE_OPERAND (op1, 1));
7993
7994   /* MIN (a, MAX (b, a)) == a.  */
7995   if (TREE_CODE (op1) == compl_code
7996       && operand_equal_p (op0, TREE_OPERAND (op1, 1), 0)
7997       && reorder_operands_p (op0, TREE_OPERAND (op1, 0)))
7998     return omit_one_operand_loc (loc, type, op0, TREE_OPERAND (op1, 0));
7999
8000   return NULL_TREE;
8001 }
8002
8003 /* Helper that tries to canonicalize the comparison ARG0 CODE ARG1
8004    by changing CODE to reduce the magnitude of constants involved in
8005    ARG0 of the comparison.
8006    Returns a canonicalized comparison tree if a simplification was
8007    possible, otherwise returns NULL_TREE.
8008    Set *STRICT_OVERFLOW_P to true if the canonicalization is only
8009    valid if signed overflow is undefined.  */
8010
8011 static tree
8012 maybe_canonicalize_comparison_1 (location_t loc, enum tree_code code, tree type,
8013                                  tree arg0, tree arg1,
8014                                  bool *strict_overflow_p)
8015 {
8016   enum tree_code code0 = TREE_CODE (arg0);
8017   tree t, cst0 = NULL_TREE;
8018   int sgn0;
8019
8020   /* Match A +- CST code arg1.  We can change this only if overflow
8021      is undefined.  */
8022   if (!((ANY_INTEGRAL_TYPE_P (TREE_TYPE (arg0))
8023          && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg0)))
8024         /* In principle pointers also have undefined overflow behavior,
8025            but that causes problems elsewhere.  */
8026         && !POINTER_TYPE_P (TREE_TYPE (arg0))
8027         && (code0 == MINUS_EXPR
8028             || code0 == PLUS_EXPR)
8029         && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST))
8030     return NULL_TREE;
8031
8032   /* Identify the constant in arg0 and its sign.  */
8033   cst0 = TREE_OPERAND (arg0, 1);
8034   sgn0 = tree_int_cst_sgn (cst0);
8035
8036   /* Overflowed constants and zero will cause problems.  */
8037   if (integer_zerop (cst0)
8038       || TREE_OVERFLOW (cst0))
8039     return NULL_TREE;
8040
8041   /* See if we can reduce the magnitude of the constant in
8042      arg0 by changing the comparison code.  */
8043   /* A - CST < arg1  ->  A - CST-1 <= arg1.  */
8044   if (code == LT_EXPR
8045       && code0 == ((sgn0 == -1) ? PLUS_EXPR : MINUS_EXPR))
8046     code = LE_EXPR;
8047   /* A + CST > arg1  ->  A + CST-1 >= arg1.  */
8048   else if (code == GT_EXPR
8049            && code0 == ((sgn0 == -1) ? MINUS_EXPR : PLUS_EXPR))
8050     code = GE_EXPR;
8051   /* A + CST <= arg1  ->  A + CST-1 < arg1.  */
8052   else if (code == LE_EXPR
8053            && code0 == ((sgn0 == -1) ? MINUS_EXPR : PLUS_EXPR))
8054     code = LT_EXPR;
8055   /* A - CST >= arg1  ->  A - CST-1 > arg1.  */
8056   else if (code == GE_EXPR
8057            && code0 == ((sgn0 == -1) ? PLUS_EXPR : MINUS_EXPR))
8058     code = GT_EXPR;
8059   else
8060     return NULL_TREE;
8061   *strict_overflow_p = true;
8062
8063   /* Now build the constant reduced in magnitude.  But not if that
8064      would produce one outside of its types range.  */
8065   if (INTEGRAL_TYPE_P (TREE_TYPE (cst0))
8066       && ((sgn0 == 1
8067            && TYPE_MIN_VALUE (TREE_TYPE (cst0))
8068            && tree_int_cst_equal (cst0, TYPE_MIN_VALUE (TREE_TYPE (cst0))))
8069           || (sgn0 == -1
8070               && TYPE_MAX_VALUE (TREE_TYPE (cst0))
8071               && tree_int_cst_equal (cst0, TYPE_MAX_VALUE (TREE_TYPE (cst0))))))
8072     return NULL_TREE;
8073
8074   t = int_const_binop (sgn0 == -1 ? PLUS_EXPR : MINUS_EXPR,
8075                        cst0, build_int_cst (TREE_TYPE (cst0), 1));
8076   t = fold_build2_loc (loc, code0, TREE_TYPE (arg0), TREE_OPERAND (arg0, 0), t);
8077   t = fold_convert (TREE_TYPE (arg1), t);
8078
8079   return fold_build2_loc (loc, code, type, t, arg1);
8080 }
8081
8082 /* Canonicalize the comparison ARG0 CODE ARG1 with type TYPE with undefined
8083    overflow further.  Try to decrease the magnitude of constants involved
8084    by changing LE_EXPR and GE_EXPR to LT_EXPR and GT_EXPR or vice versa
8085    and put sole constants at the second argument position.
8086    Returns the canonicalized tree if changed, otherwise NULL_TREE.  */
8087
8088 static tree
8089 maybe_canonicalize_comparison (location_t loc, enum tree_code code, tree type,
8090                                tree arg0, tree arg1)
8091 {
8092   tree t;
8093   bool strict_overflow_p;
8094   const char * const warnmsg = G_("assuming signed overflow does not occur "
8095                                   "when reducing constant in comparison");
8096
8097   /* Try canonicalization by simplifying arg0.  */
8098   strict_overflow_p = false;
8099   t = maybe_canonicalize_comparison_1 (loc, code, type, arg0, arg1,
8100                                        &strict_overflow_p);
8101   if (t)
8102     {
8103       if (strict_overflow_p)
8104         fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_MAGNITUDE);
8105       return t;
8106     }
8107
8108   /* Try canonicalization by simplifying arg1 using the swapped
8109      comparison.  */
8110   code = swap_tree_comparison (code);
8111   strict_overflow_p = false;
8112   t = maybe_canonicalize_comparison_1 (loc, code, type, arg1, arg0,
8113                                        &strict_overflow_p);
8114   if (t && strict_overflow_p)
8115     fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_MAGNITUDE);
8116   return t;
8117 }
8118
8119 /* Return whether BASE + OFFSET + BITPOS may wrap around the address
8120    space.  This is used to avoid issuing overflow warnings for
8121    expressions like &p->x which can not wrap.  */
8122
8123 static bool
8124 pointer_may_wrap_p (tree base, tree offset, HOST_WIDE_INT bitpos)
8125 {
8126   if (!POINTER_TYPE_P (TREE_TYPE (base)))
8127     return true;
8128
8129   if (bitpos < 0)
8130     return true;
8131
8132   wide_int wi_offset;
8133   int precision = TYPE_PRECISION (TREE_TYPE (base));
8134   if (offset == NULL_TREE)
8135     wi_offset = wi::zero (precision);
8136   else if (TREE_CODE (offset) != INTEGER_CST || TREE_OVERFLOW (offset))
8137     return true;
8138   else
8139     wi_offset = offset;
8140
8141   bool overflow;
8142   wide_int units = wi::shwi (bitpos / BITS_PER_UNIT, precision);
8143   wide_int total = wi::add (wi_offset, units, UNSIGNED, &overflow);
8144   if (overflow)
8145     return true;
8146
8147   if (!wi::fits_uhwi_p (total))
8148     return true;
8149
8150   HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (TREE_TYPE (base)));
8151   if (size <= 0)
8152     return true;
8153
8154   /* We can do slightly better for SIZE if we have an ADDR_EXPR of an
8155      array.  */
8156   if (TREE_CODE (base) == ADDR_EXPR)
8157     {
8158       HOST_WIDE_INT base_size;
8159
8160       base_size = int_size_in_bytes (TREE_TYPE (TREE_OPERAND (base, 0)));
8161       if (base_size > 0 && size < base_size)
8162         size = base_size;
8163     }
8164
8165   return total.to_uhwi () > (unsigned HOST_WIDE_INT) size;
8166 }
8167
8168 /* Return the HOST_WIDE_INT least significant bits of T, a sizetype
8169    kind INTEGER_CST.  This makes sure to properly sign-extend the
8170    constant.  */
8171
8172 static HOST_WIDE_INT
8173 size_low_cst (const_tree t)
8174 {
8175   HOST_WIDE_INT w = TREE_INT_CST_ELT (t, 0);
8176   int prec = TYPE_PRECISION (TREE_TYPE (t));
8177   if (prec < HOST_BITS_PER_WIDE_INT)
8178     return sext_hwi (w, prec);
8179   return w;
8180 }
8181
8182 /* Subroutine of fold_binary.  This routine performs all of the
8183    transformations that are common to the equality/inequality
8184    operators (EQ_EXPR and NE_EXPR) and the ordering operators
8185    (LT_EXPR, LE_EXPR, GE_EXPR and GT_EXPR).  Callers other than
8186    fold_binary should call fold_binary.  Fold a comparison with
8187    tree code CODE and type TYPE with operands OP0 and OP1.  Return
8188    the folded comparison or NULL_TREE.  */
8189
8190 static tree
8191 fold_comparison (location_t loc, enum tree_code code, tree type,
8192                  tree op0, tree op1)
8193 {
8194   const bool equality_code = (code == EQ_EXPR || code == NE_EXPR);
8195   tree arg0, arg1, tem;
8196
8197   arg0 = op0;
8198   arg1 = op1;
8199
8200   STRIP_SIGN_NOPS (arg0);
8201   STRIP_SIGN_NOPS (arg1);
8202
8203   /* Transform comparisons of the form X +- C1 CMP C2 to X CMP C2 -+ C1.  */
8204   if ((TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
8205       && (equality_code
8206           || (ANY_INTEGRAL_TYPE_P (TREE_TYPE (arg0))
8207               && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg0))))
8208       && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
8209       && !TREE_OVERFLOW (TREE_OPERAND (arg0, 1))
8210       && TREE_CODE (arg1) == INTEGER_CST
8211       && !TREE_OVERFLOW (arg1))
8212     {
8213       const enum tree_code
8214         reverse_op = TREE_CODE (arg0) == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR;
8215       tree const1 = TREE_OPERAND (arg0, 1);
8216       tree const2 = fold_convert_loc (loc, TREE_TYPE (const1), arg1);
8217       tree variable = TREE_OPERAND (arg0, 0);
8218       tree new_const = int_const_binop (reverse_op, const2, const1);
8219
8220       /* If the constant operation overflowed this can be
8221          simplified as a comparison against INT_MAX/INT_MIN.  */
8222       if (TREE_OVERFLOW (new_const)
8223           && !TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg0)))
8224         {
8225           int const1_sgn = tree_int_cst_sgn (const1);
8226           enum tree_code code2 = code;
8227
8228           /* Get the sign of the constant on the lhs if the
8229              operation were VARIABLE + CONST1.  */
8230           if (TREE_CODE (arg0) == MINUS_EXPR)
8231             const1_sgn = -const1_sgn;
8232
8233           /* The sign of the constant determines if we overflowed
8234              INT_MAX (const1_sgn == -1) or INT_MIN (const1_sgn == 1).
8235              Canonicalize to the INT_MIN overflow by swapping the comparison
8236              if necessary.  */
8237           if (const1_sgn == -1)
8238             code2 = swap_tree_comparison (code);
8239
8240           /* We now can look at the canonicalized case
8241                VARIABLE + 1  CODE2  INT_MIN
8242              and decide on the result.  */
8243           switch (code2)
8244             {
8245             case EQ_EXPR:
8246             case LT_EXPR:
8247             case LE_EXPR:
8248               return
8249                 omit_one_operand_loc (loc, type, boolean_false_node, variable);
8250
8251             case NE_EXPR:
8252             case GE_EXPR:
8253             case GT_EXPR:
8254               return
8255                 omit_one_operand_loc (loc, type, boolean_true_node, variable);
8256
8257             default:
8258               gcc_unreachable ();
8259             }
8260         }
8261       else
8262         {
8263           if (!equality_code)
8264             fold_overflow_warning ("assuming signed overflow does not occur "
8265                                    "when changing X +- C1 cmp C2 to "
8266                                    "X cmp C2 -+ C1",
8267                                    WARN_STRICT_OVERFLOW_COMPARISON);
8268           return fold_build2_loc (loc, code, type, variable, new_const);
8269         }
8270     }
8271
8272   /* For comparisons of pointers we can decompose it to a compile time
8273      comparison of the base objects and the offsets into the object.
8274      This requires at least one operand being an ADDR_EXPR or a
8275      POINTER_PLUS_EXPR to do more than the operand_equal_p test below.  */
8276   if (POINTER_TYPE_P (TREE_TYPE (arg0))
8277       && (TREE_CODE (arg0) == ADDR_EXPR
8278           || TREE_CODE (arg1) == ADDR_EXPR
8279           || TREE_CODE (arg0) == POINTER_PLUS_EXPR
8280           || TREE_CODE (arg1) == POINTER_PLUS_EXPR))
8281     {
8282       tree base0, base1, offset0 = NULL_TREE, offset1 = NULL_TREE;
8283       HOST_WIDE_INT bitsize, bitpos0 = 0, bitpos1 = 0;
8284       machine_mode mode;
8285       int volatilep, unsignedp;
8286       bool indirect_base0 = false, indirect_base1 = false;
8287
8288       /* Get base and offset for the access.  Strip ADDR_EXPR for
8289          get_inner_reference, but put it back by stripping INDIRECT_REF
8290          off the base object if possible.  indirect_baseN will be true
8291          if baseN is not an address but refers to the object itself.  */
8292       base0 = arg0;
8293       if (TREE_CODE (arg0) == ADDR_EXPR)
8294         {
8295           base0 = get_inner_reference (TREE_OPERAND (arg0, 0),
8296                                        &bitsize, &bitpos0, &offset0, &mode,
8297                                        &unsignedp, &volatilep, false);
8298           if (TREE_CODE (base0) == INDIRECT_REF)
8299             base0 = TREE_OPERAND (base0, 0);
8300           else
8301             indirect_base0 = true;
8302         }
8303       else if (TREE_CODE (arg0) == POINTER_PLUS_EXPR)
8304         {
8305           base0 = TREE_OPERAND (arg0, 0);
8306           STRIP_SIGN_NOPS (base0);
8307           if (TREE_CODE (base0) == ADDR_EXPR)
8308             {
8309               base0 = TREE_OPERAND (base0, 0);
8310               indirect_base0 = true;
8311             }
8312           offset0 = TREE_OPERAND (arg0, 1);
8313           if (tree_fits_shwi_p (offset0))
8314             {
8315               HOST_WIDE_INT off = size_low_cst (offset0);
8316               if ((HOST_WIDE_INT) (((unsigned HOST_WIDE_INT) off)
8317                                    * BITS_PER_UNIT)
8318                   / BITS_PER_UNIT == (HOST_WIDE_INT) off)
8319                 {
8320                   bitpos0 = off * BITS_PER_UNIT;
8321                   offset0 = NULL_TREE;
8322                 }
8323             }
8324         }
8325
8326       base1 = arg1;
8327       if (TREE_CODE (arg1) == ADDR_EXPR)
8328         {
8329           base1 = get_inner_reference (TREE_OPERAND (arg1, 0),
8330                                        &bitsize, &bitpos1, &offset1, &mode,
8331                                        &unsignedp, &volatilep, false);
8332           if (TREE_CODE (base1) == INDIRECT_REF)
8333             base1 = TREE_OPERAND (base1, 0);
8334           else
8335             indirect_base1 = true;
8336         }
8337       else if (TREE_CODE (arg1) == POINTER_PLUS_EXPR)
8338         {
8339           base1 = TREE_OPERAND (arg1, 0);
8340           STRIP_SIGN_NOPS (base1);
8341           if (TREE_CODE (base1) == ADDR_EXPR)
8342             {
8343               base1 = TREE_OPERAND (base1, 0);
8344               indirect_base1 = true;
8345             }
8346           offset1 = TREE_OPERAND (arg1, 1);
8347           if (tree_fits_shwi_p (offset1))
8348             {
8349               HOST_WIDE_INT off = size_low_cst (offset1);
8350               if ((HOST_WIDE_INT) (((unsigned HOST_WIDE_INT) off)
8351                                    * BITS_PER_UNIT)
8352                   / BITS_PER_UNIT == (HOST_WIDE_INT) off)
8353                 {
8354                   bitpos1 = off * BITS_PER_UNIT;
8355                   offset1 = NULL_TREE;
8356                 }
8357             }
8358         }
8359
8360       /* If we have equivalent bases we might be able to simplify.  */
8361       if (indirect_base0 == indirect_base1
8362           && operand_equal_p (base0, base1, 0))
8363         {
8364           /* We can fold this expression to a constant if the non-constant
8365              offset parts are equal.  */
8366           if ((offset0 == offset1
8367                || (offset0 && offset1
8368                    && operand_equal_p (offset0, offset1, 0)))
8369               && (code == EQ_EXPR
8370                   || code == NE_EXPR
8371                   || (indirect_base0 && DECL_P (base0))
8372                   || POINTER_TYPE_OVERFLOW_UNDEFINED))
8373
8374             {
8375               if (!equality_code
8376                   && bitpos0 != bitpos1
8377                   && (pointer_may_wrap_p (base0, offset0, bitpos0)
8378                       || pointer_may_wrap_p (base1, offset1, bitpos1)))
8379                 fold_overflow_warning (("assuming pointer wraparound does not "
8380                                         "occur when comparing P +- C1 with "
8381                                         "P +- C2"),
8382                                        WARN_STRICT_OVERFLOW_CONDITIONAL);
8383
8384               switch (code)
8385                 {
8386                 case EQ_EXPR:
8387                   return constant_boolean_node (bitpos0 == bitpos1, type);
8388                 case NE_EXPR:
8389                   return constant_boolean_node (bitpos0 != bitpos1, type);
8390                 case LT_EXPR:
8391                   return constant_boolean_node (bitpos0 < bitpos1, type);
8392                 case LE_EXPR:
8393                   return constant_boolean_node (bitpos0 <= bitpos1, type);
8394                 case GE_EXPR:
8395                   return constant_boolean_node (bitpos0 >= bitpos1, type);
8396                 case GT_EXPR:
8397                   return constant_boolean_node (bitpos0 > bitpos1, type);
8398                 default:;
8399                 }
8400             }
8401           /* We can simplify the comparison to a comparison of the variable
8402              offset parts if the constant offset parts are equal.
8403              Be careful to use signed sizetype here because otherwise we
8404              mess with array offsets in the wrong way.  This is possible
8405              because pointer arithmetic is restricted to retain within an
8406              object and overflow on pointer differences is undefined as of
8407              6.5.6/8 and /9 with respect to the signed ptrdiff_t.  */
8408           else if (bitpos0 == bitpos1
8409                    && (equality_code
8410                        || (indirect_base0 && DECL_P (base0))
8411                        || POINTER_TYPE_OVERFLOW_UNDEFINED))
8412             {
8413               /* By converting to signed sizetype we cover middle-end pointer
8414                  arithmetic which operates on unsigned pointer types of size
8415                  type size and ARRAY_REF offsets which are properly sign or
8416                  zero extended from their type in case it is narrower than
8417                  sizetype.  */
8418               if (offset0 == NULL_TREE)
8419                 offset0 = build_int_cst (ssizetype, 0);
8420               else
8421                 offset0 = fold_convert_loc (loc, ssizetype, offset0);
8422               if (offset1 == NULL_TREE)
8423                 offset1 = build_int_cst (ssizetype, 0);
8424               else
8425                 offset1 = fold_convert_loc (loc, ssizetype, offset1);
8426
8427               if (!equality_code
8428                   && (pointer_may_wrap_p (base0, offset0, bitpos0)
8429                       || pointer_may_wrap_p (base1, offset1, bitpos1)))
8430                 fold_overflow_warning (("assuming pointer wraparound does not "
8431                                         "occur when comparing P +- C1 with "
8432                                         "P +- C2"),
8433                                        WARN_STRICT_OVERFLOW_COMPARISON);
8434
8435               return fold_build2_loc (loc, code, type, offset0, offset1);
8436             }
8437         }
8438       /* For equal offsets we can simplify to a comparison of the
8439          base addresses.  */
8440       else if (bitpos0 == bitpos1
8441                && (indirect_base0
8442                    ? base0 != TREE_OPERAND (arg0, 0) : base0 != arg0)
8443                && (indirect_base1
8444                    ? base1 != TREE_OPERAND (arg1, 0) : base1 != arg1)
8445                && ((offset0 == offset1)
8446                    || (offset0 && offset1
8447                        && operand_equal_p (offset0, offset1, 0))))
8448         {
8449           if (indirect_base0)
8450             base0 = build_fold_addr_expr_loc (loc, base0);
8451           if (indirect_base1)
8452             base1 = build_fold_addr_expr_loc (loc, base1);
8453           return fold_build2_loc (loc, code, type, base0, base1);
8454         }
8455     }
8456
8457   /* Transform comparisons of the form X +- C1 CMP Y +- C2 to
8458      X CMP Y +- C2 +- C1 for signed X, Y.  This is valid if
8459      the resulting offset is smaller in absolute value than the
8460      original one and has the same sign.  */
8461   if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (arg0))
8462       && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg0))
8463       && (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
8464       && (TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
8465           && !TREE_OVERFLOW (TREE_OPERAND (arg0, 1)))
8466       && (TREE_CODE (arg1) == PLUS_EXPR || TREE_CODE (arg1) == MINUS_EXPR)
8467       && (TREE_CODE (TREE_OPERAND (arg1, 1)) == INTEGER_CST
8468           && !TREE_OVERFLOW (TREE_OPERAND (arg1, 1))))
8469     {
8470       tree const1 = TREE_OPERAND (arg0, 1);
8471       tree const2 = TREE_OPERAND (arg1, 1);
8472       tree variable1 = TREE_OPERAND (arg0, 0);
8473       tree variable2 = TREE_OPERAND (arg1, 0);
8474       tree cst;
8475       const char * const warnmsg = G_("assuming signed overflow does not "
8476                                       "occur when combining constants around "
8477                                       "a comparison");
8478
8479       /* Put the constant on the side where it doesn't overflow and is
8480          of lower absolute value and of same sign than before.  */
8481       cst = int_const_binop (TREE_CODE (arg0) == TREE_CODE (arg1)
8482                              ? MINUS_EXPR : PLUS_EXPR,
8483                              const2, const1);
8484       if (!TREE_OVERFLOW (cst)
8485           && tree_int_cst_compare (const2, cst) == tree_int_cst_sgn (const2)
8486           && tree_int_cst_sgn (cst) == tree_int_cst_sgn (const2))
8487         {
8488           fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_COMPARISON);
8489           return fold_build2_loc (loc, code, type,
8490                                   variable1,
8491                                   fold_build2_loc (loc, TREE_CODE (arg1),
8492                                                    TREE_TYPE (arg1),
8493                                                    variable2, cst));
8494         }
8495
8496       cst = int_const_binop (TREE_CODE (arg0) == TREE_CODE (arg1)
8497                              ? MINUS_EXPR : PLUS_EXPR,
8498                              const1, const2);
8499       if (!TREE_OVERFLOW (cst)
8500           && tree_int_cst_compare (const1, cst) == tree_int_cst_sgn (const1)
8501           && tree_int_cst_sgn (cst) == tree_int_cst_sgn (const1))
8502         {
8503           fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_COMPARISON);
8504           return fold_build2_loc (loc, code, type,
8505                                   fold_build2_loc (loc, TREE_CODE (arg0),
8506                                                    TREE_TYPE (arg0),
8507                                                    variable1, cst),
8508                                   variable2);
8509         }
8510     }
8511
8512   tem = maybe_canonicalize_comparison (loc, code, type, arg0, arg1);
8513   if (tem)
8514     return tem;
8515
8516   /* If this is comparing a constant with a MIN_EXPR or a MAX_EXPR of a
8517      constant, we can simplify it.  */
8518   if (TREE_CODE (arg1) == INTEGER_CST
8519       && (TREE_CODE (arg0) == MIN_EXPR
8520           || TREE_CODE (arg0) == MAX_EXPR)
8521       && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
8522     {
8523       tem = optimize_minmax_comparison (loc, code, type, op0, op1);
8524       if (tem)
8525         return tem;
8526     }
8527
8528   /* If we are comparing an expression that just has comparisons
8529      of two integer values, arithmetic expressions of those comparisons,
8530      and constants, we can simplify it.  There are only three cases
8531      to check: the two values can either be equal, the first can be
8532      greater, or the second can be greater.  Fold the expression for
8533      those three values.  Since each value must be 0 or 1, we have
8534      eight possibilities, each of which corresponds to the constant 0
8535      or 1 or one of the six possible comparisons.
8536
8537      This handles common cases like (a > b) == 0 but also handles
8538      expressions like  ((x > y) - (y > x)) > 0, which supposedly
8539      occur in macroized code.  */
8540
8541   if (TREE_CODE (arg1) == INTEGER_CST && TREE_CODE (arg0) != INTEGER_CST)
8542     {
8543       tree cval1 = 0, cval2 = 0;
8544       int save_p = 0;
8545
8546       if (twoval_comparison_p (arg0, &cval1, &cval2, &save_p)
8547           /* Don't handle degenerate cases here; they should already
8548              have been handled anyway.  */
8549           && cval1 != 0 && cval2 != 0
8550           && ! (TREE_CONSTANT (cval1) && TREE_CONSTANT (cval2))
8551           && TREE_TYPE (cval1) == TREE_TYPE (cval2)
8552           && INTEGRAL_TYPE_P (TREE_TYPE (cval1))
8553           && TYPE_MAX_VALUE (TREE_TYPE (cval1))
8554           && TYPE_MAX_VALUE (TREE_TYPE (cval2))
8555           && ! operand_equal_p (TYPE_MIN_VALUE (TREE_TYPE (cval1)),
8556                                 TYPE_MAX_VALUE (TREE_TYPE (cval2)), 0))
8557         {
8558           tree maxval = TYPE_MAX_VALUE (TREE_TYPE (cval1));
8559           tree minval = TYPE_MIN_VALUE (TREE_TYPE (cval1));
8560
8561           /* We can't just pass T to eval_subst in case cval1 or cval2
8562              was the same as ARG1.  */
8563
8564           tree high_result
8565                 = fold_build2_loc (loc, code, type,
8566                                eval_subst (loc, arg0, cval1, maxval,
8567                                            cval2, minval),
8568                                arg1);
8569           tree equal_result
8570                 = fold_build2_loc (loc, code, type,
8571                                eval_subst (loc, arg0, cval1, maxval,
8572                                            cval2, maxval),
8573                                arg1);
8574           tree low_result
8575                 = fold_build2_loc (loc, code, type,
8576                                eval_subst (loc, arg0, cval1, minval,
8577                                            cval2, maxval),
8578                                arg1);
8579
8580           /* All three of these results should be 0 or 1.  Confirm they are.
8581              Then use those values to select the proper code to use.  */
8582
8583           if (TREE_CODE (high_result) == INTEGER_CST
8584               && TREE_CODE (equal_result) == INTEGER_CST
8585               && TREE_CODE (low_result) == INTEGER_CST)
8586             {
8587               /* Make a 3-bit mask with the high-order bit being the
8588                  value for `>', the next for '=', and the low for '<'.  */
8589               switch ((integer_onep (high_result) * 4)
8590                       + (integer_onep (equal_result) * 2)
8591                       + integer_onep (low_result))
8592                 {
8593                 case 0:
8594                   /* Always false.  */
8595                   return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
8596                 case 1:
8597                   code = LT_EXPR;
8598                   break;
8599                 case 2:
8600                   code = EQ_EXPR;
8601                   break;
8602                 case 3:
8603                   code = LE_EXPR;
8604                   break;
8605                 case 4:
8606                   code = GT_EXPR;
8607                   break;
8608                 case 5:
8609                   code = NE_EXPR;
8610                   break;
8611                 case 6:
8612                   code = GE_EXPR;
8613                   break;
8614                 case 7:
8615                   /* Always true.  */
8616                   return omit_one_operand_loc (loc, type, integer_one_node, arg0);
8617                 }
8618
8619               if (save_p)
8620                 {
8621                   tem = save_expr (build2 (code, type, cval1, cval2));
8622                   SET_EXPR_LOCATION (tem, loc);
8623                   return tem;
8624                 }
8625               return fold_build2_loc (loc, code, type, cval1, cval2);
8626             }
8627         }
8628     }
8629
8630   /* We can fold X/C1 op C2 where C1 and C2 are integer constants
8631      into a single range test.  */
8632   if ((TREE_CODE (arg0) == TRUNC_DIV_EXPR
8633        || TREE_CODE (arg0) == EXACT_DIV_EXPR)
8634       && TREE_CODE (arg1) == INTEGER_CST
8635       && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
8636       && !integer_zerop (TREE_OPERAND (arg0, 1))
8637       && !TREE_OVERFLOW (TREE_OPERAND (arg0, 1))
8638       && !TREE_OVERFLOW (arg1))
8639     {
8640       tem = fold_div_compare (loc, code, type, arg0, arg1);
8641       if (tem != NULL_TREE)
8642         return tem;
8643     }
8644
8645   return NULL_TREE;
8646 }
8647
8648
8649 /* Subroutine of fold_binary.  Optimize complex multiplications of the
8650    form z * conj(z), as pow(realpart(z),2) + pow(imagpart(z),2).  The
8651    argument EXPR represents the expression "z" of type TYPE.  */
8652
8653 static tree
8654 fold_mult_zconjz (location_t loc, tree type, tree expr)
8655 {
8656   tree itype = TREE_TYPE (type);
8657   tree rpart, ipart, tem;
8658
8659   if (TREE_CODE (expr) == COMPLEX_EXPR)
8660     {
8661       rpart = TREE_OPERAND (expr, 0);
8662       ipart = TREE_OPERAND (expr, 1);
8663     }
8664   else if (TREE_CODE (expr) == COMPLEX_CST)
8665     {
8666       rpart = TREE_REALPART (expr);
8667       ipart = TREE_IMAGPART (expr);
8668     }
8669   else
8670     {
8671       expr = save_expr (expr);
8672       rpart = fold_build1_loc (loc, REALPART_EXPR, itype, expr);
8673       ipart = fold_build1_loc (loc, IMAGPART_EXPR, itype, expr);
8674     }
8675
8676   rpart = save_expr (rpart);
8677   ipart = save_expr (ipart);
8678   tem = fold_build2_loc (loc, PLUS_EXPR, itype,
8679                      fold_build2_loc (loc, MULT_EXPR, itype, rpart, rpart),
8680                      fold_build2_loc (loc, MULT_EXPR, itype, ipart, ipart));
8681   return fold_build2_loc (loc, COMPLEX_EXPR, type, tem,
8682                           build_zero_cst (itype));
8683 }
8684
8685
8686 /* Helper function for fold_vec_perm.  Store elements of VECTOR_CST or
8687    CONSTRUCTOR ARG into array ELTS and return true if successful.  */
8688
8689 static bool
8690 vec_cst_ctor_to_array (tree arg, tree *elts)
8691 {
8692   unsigned int nelts = TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg)), i;
8693
8694   if (TREE_CODE (arg) == VECTOR_CST)
8695     {
8696       for (i = 0; i < VECTOR_CST_NELTS (arg); ++i)
8697         elts[i] = VECTOR_CST_ELT (arg, i);
8698     }
8699   else if (TREE_CODE (arg) == CONSTRUCTOR)
8700     {
8701       constructor_elt *elt;
8702
8703       FOR_EACH_VEC_SAFE_ELT (CONSTRUCTOR_ELTS (arg), i, elt)
8704         if (i >= nelts || TREE_CODE (TREE_TYPE (elt->value)) == VECTOR_TYPE)
8705           return false;
8706         else
8707           elts[i] = elt->value;
8708     }
8709   else
8710     return false;
8711   for (; i < nelts; i++)
8712     elts[i]
8713       = fold_convert (TREE_TYPE (TREE_TYPE (arg)), integer_zero_node);
8714   return true;
8715 }
8716
8717 /* Attempt to fold vector permutation of ARG0 and ARG1 vectors using SEL
8718    selector.  Return the folded VECTOR_CST or CONSTRUCTOR if successful,
8719    NULL_TREE otherwise.  */
8720
8721 static tree
8722 fold_vec_perm (tree type, tree arg0, tree arg1, const unsigned char *sel)
8723 {
8724   unsigned int nelts = TYPE_VECTOR_SUBPARTS (type), i;
8725   tree *elts;
8726   bool need_ctor = false;
8727
8728   gcc_assert (TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0)) == nelts
8729               && TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg1)) == nelts);
8730   if (TREE_TYPE (TREE_TYPE (arg0)) != TREE_TYPE (type)
8731       || TREE_TYPE (TREE_TYPE (arg1)) != TREE_TYPE (type))
8732     return NULL_TREE;
8733
8734   elts = XALLOCAVEC (tree, nelts * 3);
8735   if (!vec_cst_ctor_to_array (arg0, elts)
8736       || !vec_cst_ctor_to_array (arg1, elts + nelts))
8737     return NULL_TREE;
8738
8739   for (i = 0; i < nelts; i++)
8740     {
8741       if (!CONSTANT_CLASS_P (elts[sel[i]]))
8742         need_ctor = true;
8743       elts[i + 2 * nelts] = unshare_expr (elts[sel[i]]);
8744     }
8745
8746   if (need_ctor)
8747     {
8748       vec<constructor_elt, va_gc> *v;
8749       vec_alloc (v, nelts);
8750       for (i = 0; i < nelts; i++)
8751         CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, elts[2 * nelts + i]);
8752       return build_constructor (type, v);
8753     }
8754   else
8755     return build_vector (type, &elts[2 * nelts]);
8756 }
8757
8758 /* Try to fold a pointer difference of type TYPE two address expressions of
8759    array references AREF0 and AREF1 using location LOC.  Return a
8760    simplified expression for the difference or NULL_TREE.  */
8761
8762 static tree
8763 fold_addr_of_array_ref_difference (location_t loc, tree type,
8764                                    tree aref0, tree aref1)
8765 {
8766   tree base0 = TREE_OPERAND (aref0, 0);
8767   tree base1 = TREE_OPERAND (aref1, 0);
8768   tree base_offset = build_int_cst (type, 0);
8769
8770   /* If the bases are array references as well, recurse.  If the bases
8771      are pointer indirections compute the difference of the pointers.
8772      If the bases are equal, we are set.  */
8773   if ((TREE_CODE (base0) == ARRAY_REF
8774        && TREE_CODE (base1) == ARRAY_REF
8775        && (base_offset
8776            = fold_addr_of_array_ref_difference (loc, type, base0, base1)))
8777       || (INDIRECT_REF_P (base0)
8778           && INDIRECT_REF_P (base1)
8779           && (base_offset = fold_binary_loc (loc, MINUS_EXPR, type,
8780                                              TREE_OPERAND (base0, 0),
8781                                              TREE_OPERAND (base1, 0))))
8782       || operand_equal_p (base0, base1, 0))
8783     {
8784       tree op0 = fold_convert_loc (loc, type, TREE_OPERAND (aref0, 1));
8785       tree op1 = fold_convert_loc (loc, type, TREE_OPERAND (aref1, 1));
8786       tree esz = fold_convert_loc (loc, type, array_ref_element_size (aref0));
8787       tree diff = build2 (MINUS_EXPR, type, op0, op1);
8788       return fold_build2_loc (loc, PLUS_EXPR, type,
8789                               base_offset,
8790                               fold_build2_loc (loc, MULT_EXPR, type,
8791                                                diff, esz));
8792     }
8793   return NULL_TREE;
8794 }
8795
8796 /* If the real or vector real constant CST of type TYPE has an exact
8797    inverse, return it, else return NULL.  */
8798
8799 tree
8800 exact_inverse (tree type, tree cst)
8801 {
8802   REAL_VALUE_TYPE r;
8803   tree unit_type, *elts;
8804   machine_mode mode;
8805   unsigned vec_nelts, i;
8806
8807   switch (TREE_CODE (cst))
8808     {
8809     case REAL_CST:
8810       r = TREE_REAL_CST (cst);
8811
8812       if (exact_real_inverse (TYPE_MODE (type), &r))
8813         return build_real (type, r);
8814
8815       return NULL_TREE;
8816
8817     case VECTOR_CST:
8818       vec_nelts = VECTOR_CST_NELTS (cst);
8819       elts = XALLOCAVEC (tree, vec_nelts);
8820       unit_type = TREE_TYPE (type);
8821       mode = TYPE_MODE (unit_type);
8822
8823       for (i = 0; i < vec_nelts; i++)
8824         {
8825           r = TREE_REAL_CST (VECTOR_CST_ELT (cst, i));
8826           if (!exact_real_inverse (mode, &r))
8827             return NULL_TREE;
8828           elts[i] = build_real (unit_type, r);
8829         }
8830
8831       return build_vector (type, elts);
8832
8833     default:
8834       return NULL_TREE;
8835     }
8836 }
8837
8838 /*  Mask out the tz least significant bits of X of type TYPE where
8839     tz is the number of trailing zeroes in Y.  */
8840 static wide_int
8841 mask_with_tz (tree type, const wide_int &x, const wide_int &y)
8842 {
8843   int tz = wi::ctz (y);
8844   if (tz > 0)
8845     return wi::mask (tz, true, TYPE_PRECISION (type)) & x;
8846   return x;
8847 }
8848
8849 /* Return true when T is an address and is known to be nonzero.
8850    For floating point we further ensure that T is not denormal.
8851    Similar logic is present in nonzero_address in rtlanal.h.
8852
8853    If the return value is based on the assumption that signed overflow
8854    is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
8855    change *STRICT_OVERFLOW_P.  */
8856
8857 static bool
8858 tree_expr_nonzero_warnv_p (tree t, bool *strict_overflow_p)
8859 {
8860   tree type = TREE_TYPE (t);
8861   enum tree_code code;
8862
8863   /* Doing something useful for floating point would need more work.  */
8864   if (!INTEGRAL_TYPE_P (type) && !POINTER_TYPE_P (type))
8865     return false;
8866
8867   code = TREE_CODE (t);
8868   switch (TREE_CODE_CLASS (code))
8869     {
8870     case tcc_unary:
8871       return tree_unary_nonzero_warnv_p (code, type, TREE_OPERAND (t, 0),
8872                                               strict_overflow_p);
8873     case tcc_binary:
8874     case tcc_comparison:
8875       return tree_binary_nonzero_warnv_p (code, type,
8876                                                TREE_OPERAND (t, 0),
8877                                                TREE_OPERAND (t, 1),
8878                                                strict_overflow_p);
8879     case tcc_constant:
8880     case tcc_declaration:
8881     case tcc_reference:
8882       return tree_single_nonzero_warnv_p (t, strict_overflow_p);
8883
8884     default:
8885       break;
8886     }
8887
8888   switch (code)
8889     {
8890     case TRUTH_NOT_EXPR:
8891       return tree_unary_nonzero_warnv_p (code, type, TREE_OPERAND (t, 0),
8892                                               strict_overflow_p);
8893
8894     case TRUTH_AND_EXPR:
8895     case TRUTH_OR_EXPR:
8896     case TRUTH_XOR_EXPR:
8897       return tree_binary_nonzero_warnv_p (code, type,
8898                                                TREE_OPERAND (t, 0),
8899                                                TREE_OPERAND (t, 1),
8900                                                strict_overflow_p);
8901
8902     case COND_EXPR:
8903     case CONSTRUCTOR:
8904     case OBJ_TYPE_REF:
8905     case ASSERT_EXPR:
8906     case ADDR_EXPR:
8907     case WITH_SIZE_EXPR:
8908     case SSA_NAME:
8909       return tree_single_nonzero_warnv_p (t, strict_overflow_p);
8910
8911     case COMPOUND_EXPR:
8912     case MODIFY_EXPR:
8913     case BIND_EXPR:
8914       return tree_expr_nonzero_warnv_p (TREE_OPERAND (t, 1),
8915                                         strict_overflow_p);
8916
8917     case SAVE_EXPR:
8918       return tree_expr_nonzero_warnv_p (TREE_OPERAND (t, 0),
8919                                         strict_overflow_p);
8920
8921     case CALL_EXPR:
8922       {
8923         tree fndecl = get_callee_fndecl (t);
8924         if (!fndecl) return false;
8925         if (flag_delete_null_pointer_checks && !flag_check_new
8926             && DECL_IS_OPERATOR_NEW (fndecl)
8927             && !TREE_NOTHROW (fndecl))
8928           return true;
8929         if (flag_delete_null_pointer_checks
8930             && lookup_attribute ("returns_nonnull",
8931                  TYPE_ATTRIBUTES (TREE_TYPE (fndecl))))
8932           return true;
8933         return alloca_call_p (t);
8934       }
8935
8936     default:
8937       break;
8938     }
8939   return false;
8940 }
8941
8942 /* Return true when T is an address and is known to be nonzero.
8943    Handle warnings about undefined signed overflow.  */
8944
8945 static bool
8946 tree_expr_nonzero_p (tree t)
8947 {
8948   bool ret, strict_overflow_p;
8949
8950   strict_overflow_p = false;
8951   ret = tree_expr_nonzero_warnv_p (t, &strict_overflow_p);
8952   if (strict_overflow_p)
8953     fold_overflow_warning (("assuming signed overflow does not occur when "
8954                             "determining that expression is always "
8955                             "non-zero"),
8956                            WARN_STRICT_OVERFLOW_MISC);
8957   return ret;
8958 }
8959
8960 /* Fold a binary expression of code CODE and type TYPE with operands
8961    OP0 and OP1.  LOC is the location of the resulting expression.
8962    Return the folded expression if folding is successful.  Otherwise,
8963    return NULL_TREE.  */
8964
8965 tree
8966 fold_binary_loc (location_t loc,
8967              enum tree_code code, tree type, tree op0, tree op1)
8968 {
8969   enum tree_code_class kind = TREE_CODE_CLASS (code);
8970   tree arg0, arg1, tem;
8971   tree t1 = NULL_TREE;
8972   bool strict_overflow_p;
8973   unsigned int prec;
8974
8975   gcc_assert (IS_EXPR_CODE_CLASS (kind)
8976               && TREE_CODE_LENGTH (code) == 2
8977               && op0 != NULL_TREE
8978               && op1 != NULL_TREE);
8979
8980   arg0 = op0;
8981   arg1 = op1;
8982
8983   /* Strip any conversions that don't change the mode.  This is
8984      safe for every expression, except for a comparison expression
8985      because its signedness is derived from its operands.  So, in
8986      the latter case, only strip conversions that don't change the
8987      signedness.  MIN_EXPR/MAX_EXPR also need signedness of arguments
8988      preserved.
8989
8990      Note that this is done as an internal manipulation within the
8991      constant folder, in order to find the simplest representation
8992      of the arguments so that their form can be studied.  In any
8993      cases, the appropriate type conversions should be put back in
8994      the tree that will get out of the constant folder.  */
8995
8996   if (kind == tcc_comparison || code == MIN_EXPR || code == MAX_EXPR)
8997     {
8998       STRIP_SIGN_NOPS (arg0);
8999       STRIP_SIGN_NOPS (arg1);
9000     }
9001   else
9002     {
9003       STRIP_NOPS (arg0);
9004       STRIP_NOPS (arg1);
9005     }
9006
9007   /* Note that TREE_CONSTANT isn't enough: static var addresses are
9008      constant but we can't do arithmetic on them.  */
9009   if (CONSTANT_CLASS_P (arg0) && CONSTANT_CLASS_P (arg1))
9010     {
9011       tem = const_binop (code, type, arg0, arg1);
9012       if (tem != NULL_TREE)
9013         {
9014           if (TREE_TYPE (tem) != type)
9015             tem = fold_convert_loc (loc, type, tem);
9016           return tem;
9017         }
9018     }
9019
9020   /* If this is a commutative operation, and ARG0 is a constant, move it
9021      to ARG1 to reduce the number of tests below.  */
9022   if (commutative_tree_code (code)
9023       && tree_swap_operands_p (arg0, arg1, true))
9024     return fold_build2_loc (loc, code, type, op1, op0);
9025
9026   /* Likewise if this is a comparison, and ARG0 is a constant, move it
9027      to ARG1 to reduce the number of tests below.  */
9028   if (kind == tcc_comparison
9029       && tree_swap_operands_p (arg0, arg1, true))
9030     return fold_build2_loc (loc, swap_tree_comparison (code), type, op1, op0);
9031
9032   tem = generic_simplify (loc, code, type, op0, op1);
9033   if (tem)
9034     return tem;
9035
9036   /* ARG0 is the first operand of EXPR, and ARG1 is the second operand.
9037
9038      First check for cases where an arithmetic operation is applied to a
9039      compound, conditional, or comparison operation.  Push the arithmetic
9040      operation inside the compound or conditional to see if any folding
9041      can then be done.  Convert comparison to conditional for this purpose.
9042      The also optimizes non-constant cases that used to be done in
9043      expand_expr.
9044
9045      Before we do that, see if this is a BIT_AND_EXPR or a BIT_IOR_EXPR,
9046      one of the operands is a comparison and the other is a comparison, a
9047      BIT_AND_EXPR with the constant 1, or a truth value.  In that case, the
9048      code below would make the expression more complex.  Change it to a
9049      TRUTH_{AND,OR}_EXPR.  Likewise, convert a similar NE_EXPR to
9050      TRUTH_XOR_EXPR and an EQ_EXPR to the inversion of a TRUTH_XOR_EXPR.  */
9051
9052   if ((code == BIT_AND_EXPR || code == BIT_IOR_EXPR
9053        || code == EQ_EXPR || code == NE_EXPR)
9054       && TREE_CODE (type) != VECTOR_TYPE
9055       && ((truth_value_p (TREE_CODE (arg0))
9056            && (truth_value_p (TREE_CODE (arg1))
9057                || (TREE_CODE (arg1) == BIT_AND_EXPR
9058                    && integer_onep (TREE_OPERAND (arg1, 1)))))
9059           || (truth_value_p (TREE_CODE (arg1))
9060               && (truth_value_p (TREE_CODE (arg0))
9061                   || (TREE_CODE (arg0) == BIT_AND_EXPR
9062                       && integer_onep (TREE_OPERAND (arg0, 1)))))))
9063     {
9064       tem = fold_build2_loc (loc, code == BIT_AND_EXPR ? TRUTH_AND_EXPR
9065                          : code == BIT_IOR_EXPR ? TRUTH_OR_EXPR
9066                          : TRUTH_XOR_EXPR,
9067                          boolean_type_node,
9068                          fold_convert_loc (loc, boolean_type_node, arg0),
9069                          fold_convert_loc (loc, boolean_type_node, arg1));
9070
9071       if (code == EQ_EXPR)
9072         tem = invert_truthvalue_loc (loc, tem);
9073
9074       return fold_convert_loc (loc, type, tem);
9075     }
9076
9077   if (TREE_CODE_CLASS (code) == tcc_binary
9078       || TREE_CODE_CLASS (code) == tcc_comparison)
9079     {
9080       if (TREE_CODE (arg0) == COMPOUND_EXPR)
9081         {
9082           tem = fold_build2_loc (loc, code, type,
9083                              fold_convert_loc (loc, TREE_TYPE (op0),
9084                                                TREE_OPERAND (arg0, 1)), op1);
9085           return build2_loc (loc, COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
9086                              tem);
9087         }
9088       if (TREE_CODE (arg1) == COMPOUND_EXPR
9089           && reorder_operands_p (arg0, TREE_OPERAND (arg1, 0)))
9090         {
9091           tem = fold_build2_loc (loc, code, type, op0,
9092                              fold_convert_loc (loc, TREE_TYPE (op1),
9093                                                TREE_OPERAND (arg1, 1)));
9094           return build2_loc (loc, COMPOUND_EXPR, type, TREE_OPERAND (arg1, 0),
9095                              tem);
9096         }
9097
9098       if (TREE_CODE (arg0) == COND_EXPR
9099           || TREE_CODE (arg0) == VEC_COND_EXPR
9100           || COMPARISON_CLASS_P (arg0))
9101         {
9102           tem = fold_binary_op_with_conditional_arg (loc, code, type, op0, op1,
9103                                                      arg0, arg1,
9104                                                      /*cond_first_p=*/1);
9105           if (tem != NULL_TREE)
9106             return tem;
9107         }
9108
9109       if (TREE_CODE (arg1) == COND_EXPR
9110           || TREE_CODE (arg1) == VEC_COND_EXPR
9111           || COMPARISON_CLASS_P (arg1))
9112         {
9113           tem = fold_binary_op_with_conditional_arg (loc, code, type, op0, op1,
9114                                                      arg1, arg0,
9115                                                      /*cond_first_p=*/0);
9116           if (tem != NULL_TREE)
9117             return tem;
9118         }
9119     }
9120
9121   switch (code)
9122     {
9123     case MEM_REF:
9124       /* MEM[&MEM[p, CST1], CST2] -> MEM[p, CST1 + CST2].  */
9125       if (TREE_CODE (arg0) == ADDR_EXPR
9126           && TREE_CODE (TREE_OPERAND (arg0, 0)) == MEM_REF)
9127         {
9128           tree iref = TREE_OPERAND (arg0, 0);
9129           return fold_build2 (MEM_REF, type,
9130                               TREE_OPERAND (iref, 0),
9131                               int_const_binop (PLUS_EXPR, arg1,
9132                                                TREE_OPERAND (iref, 1)));
9133         }
9134
9135       /* MEM[&a.b, CST2] -> MEM[&a, offsetof (a, b) + CST2].  */
9136       if (TREE_CODE (arg0) == ADDR_EXPR
9137           && handled_component_p (TREE_OPERAND (arg0, 0)))
9138         {
9139           tree base;
9140           HOST_WIDE_INT coffset;
9141           base = get_addr_base_and_unit_offset (TREE_OPERAND (arg0, 0),
9142                                                 &coffset);
9143           if (!base)
9144             return NULL_TREE;
9145           return fold_build2 (MEM_REF, type,
9146                               build_fold_addr_expr (base),
9147                               int_const_binop (PLUS_EXPR, arg1,
9148                                                size_int (coffset)));
9149         }
9150
9151       return NULL_TREE;
9152
9153     case POINTER_PLUS_EXPR:
9154       /* INT +p INT -> (PTR)(INT + INT).  Stripping types allows for this. */
9155       if (INTEGRAL_TYPE_P (TREE_TYPE (arg1))
9156            && INTEGRAL_TYPE_P (TREE_TYPE (arg0)))
9157         return fold_convert_loc (loc, type,
9158                                  fold_build2_loc (loc, PLUS_EXPR, sizetype,
9159                                               fold_convert_loc (loc, sizetype,
9160                                                                 arg1),
9161                                               fold_convert_loc (loc, sizetype,
9162                                                                 arg0)));
9163
9164       return NULL_TREE;
9165
9166     case PLUS_EXPR:
9167       if (INTEGRAL_TYPE_P (type) || VECTOR_INTEGER_TYPE_P (type))
9168         {
9169           /* X + (X / CST) * -CST is X % CST.  */
9170           if (TREE_CODE (arg1) == MULT_EXPR
9171               && TREE_CODE (TREE_OPERAND (arg1, 0)) == TRUNC_DIV_EXPR
9172               && operand_equal_p (arg0,
9173                                   TREE_OPERAND (TREE_OPERAND (arg1, 0), 0), 0))
9174             {
9175               tree cst0 = TREE_OPERAND (TREE_OPERAND (arg1, 0), 1);
9176               tree cst1 = TREE_OPERAND (arg1, 1);
9177               tree sum = fold_binary_loc (loc, PLUS_EXPR, TREE_TYPE (cst1),
9178                                       cst1, cst0);
9179               if (sum && integer_zerop (sum))
9180                 return fold_convert_loc (loc, type,
9181                                          fold_build2_loc (loc, TRUNC_MOD_EXPR,
9182                                                       TREE_TYPE (arg0), arg0,
9183                                                       cst0));
9184             }
9185         }
9186
9187       /* Handle (A1 * C1) + (A2 * C2) with A1, A2 or C1, C2 being the same or
9188          one.  Make sure the type is not saturating and has the signedness of
9189          the stripped operands, as fold_plusminus_mult_expr will re-associate.
9190          ??? The latter condition should use TYPE_OVERFLOW_* flags instead.  */
9191       if ((TREE_CODE (arg0) == MULT_EXPR
9192            || TREE_CODE (arg1) == MULT_EXPR)
9193           && !TYPE_SATURATING (type)
9194           && TYPE_UNSIGNED (type) == TYPE_UNSIGNED (TREE_TYPE (arg0))
9195           && TYPE_UNSIGNED (type) == TYPE_UNSIGNED (TREE_TYPE (arg1))
9196           && (!FLOAT_TYPE_P (type) || flag_associative_math))
9197         {
9198           tree tem = fold_plusminus_mult_expr (loc, code, type, arg0, arg1);
9199           if (tem)
9200             return tem;
9201         }
9202
9203       if (! FLOAT_TYPE_P (type))
9204         {
9205           /* Reassociate (plus (plus (mult) (foo)) (mult)) as
9206              (plus (plus (mult) (mult)) (foo)) so that we can
9207              take advantage of the factoring cases below.  */
9208           if (ANY_INTEGRAL_TYPE_P (type)
9209               && TYPE_OVERFLOW_WRAPS (type)
9210               && (((TREE_CODE (arg0) == PLUS_EXPR
9211                     || TREE_CODE (arg0) == MINUS_EXPR)
9212                    && TREE_CODE (arg1) == MULT_EXPR)
9213                   || ((TREE_CODE (arg1) == PLUS_EXPR
9214                        || TREE_CODE (arg1) == MINUS_EXPR)
9215                       && TREE_CODE (arg0) == MULT_EXPR)))
9216             {
9217               tree parg0, parg1, parg, marg;
9218               enum tree_code pcode;
9219
9220               if (TREE_CODE (arg1) == MULT_EXPR)
9221                 parg = arg0, marg = arg1;
9222               else
9223                 parg = arg1, marg = arg0;
9224               pcode = TREE_CODE (parg);
9225               parg0 = TREE_OPERAND (parg, 0);
9226               parg1 = TREE_OPERAND (parg, 1);
9227               STRIP_NOPS (parg0);
9228               STRIP_NOPS (parg1);
9229
9230               if (TREE_CODE (parg0) == MULT_EXPR
9231                   && TREE_CODE (parg1) != MULT_EXPR)
9232                 return fold_build2_loc (loc, pcode, type,
9233                                     fold_build2_loc (loc, PLUS_EXPR, type,
9234                                                  fold_convert_loc (loc, type,
9235                                                                    parg0),
9236                                                  fold_convert_loc (loc, type,
9237                                                                    marg)),
9238                                     fold_convert_loc (loc, type, parg1));
9239               if (TREE_CODE (parg0) != MULT_EXPR
9240                   && TREE_CODE (parg1) == MULT_EXPR)
9241                 return
9242                   fold_build2_loc (loc, PLUS_EXPR, type,
9243                                fold_convert_loc (loc, type, parg0),
9244                                fold_build2_loc (loc, pcode, type,
9245                                             fold_convert_loc (loc, type, marg),
9246                                             fold_convert_loc (loc, type,
9247                                                               parg1)));
9248             }
9249         }
9250       else
9251         {
9252           /* Fold __complex__ ( x, 0 ) + __complex__ ( 0, y )
9253              to __complex__ ( x, y ).  This is not the same for SNaNs or
9254              if signed zeros are involved.  */
9255           if (!HONOR_SNANS (element_mode (arg0))
9256               && !HONOR_SIGNED_ZEROS (element_mode (arg0))
9257               && COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0)))
9258             {
9259               tree rtype = TREE_TYPE (TREE_TYPE (arg0));
9260               tree arg0r = fold_unary_loc (loc, REALPART_EXPR, rtype, arg0);
9261               tree arg0i = fold_unary_loc (loc, IMAGPART_EXPR, rtype, arg0);
9262               bool arg0rz = false, arg0iz = false;
9263               if ((arg0r && (arg0rz = real_zerop (arg0r)))
9264                   || (arg0i && (arg0iz = real_zerop (arg0i))))
9265                 {
9266                   tree arg1r = fold_unary_loc (loc, REALPART_EXPR, rtype, arg1);
9267                   tree arg1i = fold_unary_loc (loc, IMAGPART_EXPR, rtype, arg1);
9268                   if (arg0rz && arg1i && real_zerop (arg1i))
9269                     {
9270                       tree rp = arg1r ? arg1r
9271                                   : build1 (REALPART_EXPR, rtype, arg1);
9272                       tree ip = arg0i ? arg0i
9273                                   : build1 (IMAGPART_EXPR, rtype, arg0);
9274                       return fold_build2_loc (loc, COMPLEX_EXPR, type, rp, ip);
9275                     }
9276                   else if (arg0iz && arg1r && real_zerop (arg1r))
9277                     {
9278                       tree rp = arg0r ? arg0r
9279                                   : build1 (REALPART_EXPR, rtype, arg0);
9280                       tree ip = arg1i ? arg1i
9281                                   : build1 (IMAGPART_EXPR, rtype, arg1);
9282                       return fold_build2_loc (loc, COMPLEX_EXPR, type, rp, ip);
9283                     }
9284                 }
9285             }
9286
9287           if (flag_unsafe_math_optimizations
9288               && (TREE_CODE (arg0) == RDIV_EXPR || TREE_CODE (arg0) == MULT_EXPR)
9289               && (TREE_CODE (arg1) == RDIV_EXPR || TREE_CODE (arg1) == MULT_EXPR)
9290               && (tem = distribute_real_division (loc, code, type, arg0, arg1)))
9291             return tem;
9292
9293           /* Convert a + (b*c + d*e) into (a + b*c) + d*e.
9294              We associate floats only if the user has specified
9295              -fassociative-math.  */
9296           if (flag_associative_math
9297               && TREE_CODE (arg1) == PLUS_EXPR
9298               && TREE_CODE (arg0) != MULT_EXPR)
9299             {
9300               tree tree10 = TREE_OPERAND (arg1, 0);
9301               tree tree11 = TREE_OPERAND (arg1, 1);
9302               if (TREE_CODE (tree11) == MULT_EXPR
9303                   && TREE_CODE (tree10) == MULT_EXPR)
9304                 {
9305                   tree tree0;
9306                   tree0 = fold_build2_loc (loc, PLUS_EXPR, type, arg0, tree10);
9307                   return fold_build2_loc (loc, PLUS_EXPR, type, tree0, tree11);
9308                 }
9309             }
9310           /* Convert (b*c + d*e) + a into b*c + (d*e +a).
9311              We associate floats only if the user has specified
9312              -fassociative-math.  */
9313           if (flag_associative_math
9314               && TREE_CODE (arg0) == PLUS_EXPR
9315               && TREE_CODE (arg1) != MULT_EXPR)
9316             {
9317               tree tree00 = TREE_OPERAND (arg0, 0);
9318               tree tree01 = TREE_OPERAND (arg0, 1);
9319               if (TREE_CODE (tree01) == MULT_EXPR
9320                   && TREE_CODE (tree00) == MULT_EXPR)
9321                 {
9322                   tree tree0;
9323                   tree0 = fold_build2_loc (loc, PLUS_EXPR, type, tree01, arg1);
9324                   return fold_build2_loc (loc, PLUS_EXPR, type, tree00, tree0);
9325                 }
9326             }
9327         }
9328
9329      bit_rotate:
9330       /* (A << C1) + (A >> C2) if A is unsigned and C1+C2 is the size of A
9331          is a rotate of A by C1 bits.  */
9332       /* (A << B) + (A >> (Z - B)) if A is unsigned and Z is the size of A
9333          is a rotate of A by B bits.  */
9334       {
9335         enum tree_code code0, code1;
9336         tree rtype;
9337         code0 = TREE_CODE (arg0);
9338         code1 = TREE_CODE (arg1);
9339         if (((code0 == RSHIFT_EXPR && code1 == LSHIFT_EXPR)
9340              || (code1 == RSHIFT_EXPR && code0 == LSHIFT_EXPR))
9341             && operand_equal_p (TREE_OPERAND (arg0, 0),
9342                                 TREE_OPERAND (arg1, 0), 0)
9343             && (rtype = TREE_TYPE (TREE_OPERAND (arg0, 0)),
9344                 TYPE_UNSIGNED (rtype))
9345             /* Only create rotates in complete modes.  Other cases are not
9346                expanded properly.  */
9347             && (element_precision (rtype)
9348                 == GET_MODE_UNIT_PRECISION (TYPE_MODE (rtype))))
9349           {
9350             tree tree01, tree11;
9351             enum tree_code code01, code11;
9352
9353             tree01 = TREE_OPERAND (arg0, 1);
9354             tree11 = TREE_OPERAND (arg1, 1);
9355             STRIP_NOPS (tree01);
9356             STRIP_NOPS (tree11);
9357             code01 = TREE_CODE (tree01);
9358             code11 = TREE_CODE (tree11);
9359             if (code01 == INTEGER_CST
9360                 && code11 == INTEGER_CST
9361                 && (wi::to_widest (tree01) + wi::to_widest (tree11)
9362                     == element_precision (TREE_TYPE (TREE_OPERAND (arg0, 0)))))
9363               {
9364                 tem = build2_loc (loc, LROTATE_EXPR,
9365                                   TREE_TYPE (TREE_OPERAND (arg0, 0)),
9366                                   TREE_OPERAND (arg0, 0),
9367                                   code0 == LSHIFT_EXPR
9368                                   ? TREE_OPERAND (arg0, 1)
9369                                   : TREE_OPERAND (arg1, 1));
9370                 return fold_convert_loc (loc, type, tem);
9371               }
9372             else if (code11 == MINUS_EXPR)
9373               {
9374                 tree tree110, tree111;
9375                 tree110 = TREE_OPERAND (tree11, 0);
9376                 tree111 = TREE_OPERAND (tree11, 1);
9377                 STRIP_NOPS (tree110);
9378                 STRIP_NOPS (tree111);
9379                 if (TREE_CODE (tree110) == INTEGER_CST
9380                     && 0 == compare_tree_int (tree110,
9381                                               element_precision
9382                                               (TREE_TYPE (TREE_OPERAND
9383                                                           (arg0, 0))))
9384                     && operand_equal_p (tree01, tree111, 0))
9385                   return
9386                     fold_convert_loc (loc, type,
9387                                       build2 ((code0 == LSHIFT_EXPR
9388                                                ? LROTATE_EXPR
9389                                                : RROTATE_EXPR),
9390                                               TREE_TYPE (TREE_OPERAND (arg0, 0)),
9391                                               TREE_OPERAND (arg0, 0),
9392                                               TREE_OPERAND (arg0, 1)));
9393               }
9394             else if (code01 == MINUS_EXPR)
9395               {
9396                 tree tree010, tree011;
9397                 tree010 = TREE_OPERAND (tree01, 0);
9398                 tree011 = TREE_OPERAND (tree01, 1);
9399                 STRIP_NOPS (tree010);
9400                 STRIP_NOPS (tree011);
9401                 if (TREE_CODE (tree010) == INTEGER_CST
9402                     && 0 == compare_tree_int (tree010,
9403                                               element_precision
9404                                               (TREE_TYPE (TREE_OPERAND
9405                                                           (arg0, 0))))
9406                     && operand_equal_p (tree11, tree011, 0))
9407                     return fold_convert_loc
9408                       (loc, type,
9409                        build2 ((code0 != LSHIFT_EXPR
9410                                 ? LROTATE_EXPR
9411                                 : RROTATE_EXPR),
9412                                TREE_TYPE (TREE_OPERAND (arg0, 0)),
9413                                TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1, 1)));
9414               }
9415           }
9416       }
9417
9418     associate:
9419       /* In most languages, can't associate operations on floats through
9420          parentheses.  Rather than remember where the parentheses were, we
9421          don't associate floats at all, unless the user has specified
9422          -fassociative-math.
9423          And, we need to make sure type is not saturating.  */
9424
9425       if ((! FLOAT_TYPE_P (type) || flag_associative_math)
9426           && !TYPE_SATURATING (type))
9427         {
9428           tree var0, con0, lit0, minus_lit0;
9429           tree var1, con1, lit1, minus_lit1;
9430           tree atype = type;
9431           bool ok = true;
9432
9433           /* Split both trees into variables, constants, and literals.  Then
9434              associate each group together, the constants with literals,
9435              then the result with variables.  This increases the chances of
9436              literals being recombined later and of generating relocatable
9437              expressions for the sum of a constant and literal.  */
9438           var0 = split_tree (arg0, code, &con0, &lit0, &minus_lit0, 0);
9439           var1 = split_tree (arg1, code, &con1, &lit1, &minus_lit1,
9440                              code == MINUS_EXPR);
9441
9442           /* Recombine MINUS_EXPR operands by using PLUS_EXPR.  */
9443           if (code == MINUS_EXPR)
9444             code = PLUS_EXPR;
9445
9446           /* With undefined overflow prefer doing association in a type
9447              which wraps on overflow, if that is one of the operand types.  */
9448           if ((POINTER_TYPE_P (type) && POINTER_TYPE_OVERFLOW_UNDEFINED)
9449               || (INTEGRAL_TYPE_P (type) && !TYPE_OVERFLOW_WRAPS (type)))
9450             {
9451               if (INTEGRAL_TYPE_P (TREE_TYPE (arg0))
9452                   && TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg0)))
9453                 atype = TREE_TYPE (arg0);
9454               else if (INTEGRAL_TYPE_P (TREE_TYPE (arg1))
9455                        && TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg1)))
9456                 atype = TREE_TYPE (arg1);
9457               gcc_assert (TYPE_PRECISION (atype) == TYPE_PRECISION (type));
9458             }
9459
9460           /* With undefined overflow we can only associate constants with one
9461              variable, and constants whose association doesn't overflow.  */
9462           if ((POINTER_TYPE_P (atype) && POINTER_TYPE_OVERFLOW_UNDEFINED)
9463               || (INTEGRAL_TYPE_P (atype) && !TYPE_OVERFLOW_WRAPS (atype)))
9464             {
9465               if (var0 && var1)
9466                 {
9467                   tree tmp0 = var0;
9468                   tree tmp1 = var1;
9469
9470                   if (TREE_CODE (tmp0) == NEGATE_EXPR)
9471                     tmp0 = TREE_OPERAND (tmp0, 0);
9472                   if (CONVERT_EXPR_P (tmp0)
9473                       && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (tmp0, 0)))
9474                       && (TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (tmp0, 0)))
9475                           <= TYPE_PRECISION (atype)))
9476                     tmp0 = TREE_OPERAND (tmp0, 0);
9477                   if (TREE_CODE (tmp1) == NEGATE_EXPR)
9478                     tmp1 = TREE_OPERAND (tmp1, 0);
9479                   if (CONVERT_EXPR_P (tmp1)
9480                       && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (tmp1, 0)))
9481                       && (TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (tmp1, 0)))
9482                           <= TYPE_PRECISION (atype)))
9483                     tmp1 = TREE_OPERAND (tmp1, 0);
9484                   /* The only case we can still associate with two variables
9485                      is if they are the same, modulo negation and bit-pattern
9486                      preserving conversions.  */
9487                   if (!operand_equal_p (tmp0, tmp1, 0))
9488                     ok = false;
9489                 }
9490             }
9491
9492           /* Only do something if we found more than two objects.  Otherwise,
9493              nothing has changed and we risk infinite recursion.  */
9494           if (ok
9495               && (2 < ((var0 != 0) + (var1 != 0)
9496                        + (con0 != 0) + (con1 != 0)
9497                        + (lit0 != 0) + (lit1 != 0)
9498                        + (minus_lit0 != 0) + (minus_lit1 != 0))))
9499             {
9500               bool any_overflows = false;
9501               if (lit0) any_overflows |= TREE_OVERFLOW (lit0);
9502               if (lit1) any_overflows |= TREE_OVERFLOW (lit1);
9503               if (minus_lit0) any_overflows |= TREE_OVERFLOW (minus_lit0);
9504               if (minus_lit1) any_overflows |= TREE_OVERFLOW (minus_lit1);
9505               var0 = associate_trees (loc, var0, var1, code, atype);
9506               con0 = associate_trees (loc, con0, con1, code, atype);
9507               lit0 = associate_trees (loc, lit0, lit1, code, atype);
9508               minus_lit0 = associate_trees (loc, minus_lit0, minus_lit1,
9509                                             code, atype);
9510
9511               /* Preserve the MINUS_EXPR if the negative part of the literal is
9512                  greater than the positive part.  Otherwise, the multiplicative
9513                  folding code (i.e extract_muldiv) may be fooled in case
9514                  unsigned constants are subtracted, like in the following
9515                  example: ((X*2 + 4) - 8U)/2.  */
9516               if (minus_lit0 && lit0)
9517                 {
9518                   if (TREE_CODE (lit0) == INTEGER_CST
9519                       && TREE_CODE (minus_lit0) == INTEGER_CST
9520                       && tree_int_cst_lt (lit0, minus_lit0))
9521                     {
9522                       minus_lit0 = associate_trees (loc, minus_lit0, lit0,
9523                                                     MINUS_EXPR, atype);
9524                       lit0 = 0;
9525                     }
9526                   else
9527                     {
9528                       lit0 = associate_trees (loc, lit0, minus_lit0,
9529                                               MINUS_EXPR, atype);
9530                       minus_lit0 = 0;
9531                     }
9532                 }
9533
9534               /* Don't introduce overflows through reassociation.  */
9535               if (!any_overflows
9536                   && ((lit0 && TREE_OVERFLOW_P (lit0))
9537                       || (minus_lit0 && TREE_OVERFLOW_P (minus_lit0))))
9538                 return NULL_TREE;
9539
9540               if (minus_lit0)
9541                 {
9542                   if (con0 == 0)
9543                     return
9544                       fold_convert_loc (loc, type,
9545                                         associate_trees (loc, var0, minus_lit0,
9546                                                          MINUS_EXPR, atype));
9547                   else
9548                     {
9549                       con0 = associate_trees (loc, con0, minus_lit0,
9550                                               MINUS_EXPR, atype);
9551                       return
9552                         fold_convert_loc (loc, type,
9553                                           associate_trees (loc, var0, con0,
9554                                                            PLUS_EXPR, atype));
9555                     }
9556                 }
9557
9558               con0 = associate_trees (loc, con0, lit0, code, atype);
9559               return
9560                 fold_convert_loc (loc, type, associate_trees (loc, var0, con0,
9561                                                               code, atype));
9562             }
9563         }
9564
9565       return NULL_TREE;
9566
9567     case MINUS_EXPR:
9568       /* Pointer simplifications for subtraction, simple reassociations. */
9569       if (POINTER_TYPE_P (TREE_TYPE (arg1)) && POINTER_TYPE_P (TREE_TYPE (arg0)))
9570         {
9571           /* (PTR0 p+ A) - (PTR1 p+ B) -> (PTR0 - PTR1) + (A - B) */
9572           if (TREE_CODE (arg0) == POINTER_PLUS_EXPR
9573               && TREE_CODE (arg1) == POINTER_PLUS_EXPR)
9574             {
9575               tree arg00 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
9576               tree arg01 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 1));
9577               tree arg10 = fold_convert_loc (loc, type, TREE_OPERAND (arg1, 0));
9578               tree arg11 = fold_convert_loc (loc, type, TREE_OPERAND (arg1, 1));
9579               return fold_build2_loc (loc, PLUS_EXPR, type,
9580                                   fold_build2_loc (loc, MINUS_EXPR, type,
9581                                                arg00, arg10),
9582                                   fold_build2_loc (loc, MINUS_EXPR, type,
9583                                                arg01, arg11));
9584             }
9585           /* (PTR0 p+ A) - PTR1 -> (PTR0 - PTR1) + A, assuming PTR0 - PTR1 simplifies. */
9586           else if (TREE_CODE (arg0) == POINTER_PLUS_EXPR)
9587             {
9588               tree arg00 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
9589               tree arg01 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 1));
9590               tree tmp = fold_binary_loc (loc, MINUS_EXPR, type, arg00,
9591                                       fold_convert_loc (loc, type, arg1));
9592               if (tmp)
9593                 return fold_build2_loc (loc, PLUS_EXPR, type, tmp, arg01);
9594             }
9595           /* PTR0 - (PTR1 p+ A) -> (PTR0 - PTR1) - A, assuming PTR0 - PTR1
9596              simplifies. */
9597           else if (TREE_CODE (arg1) == POINTER_PLUS_EXPR)
9598             {
9599               tree arg10 = fold_convert_loc (loc, type,
9600                                              TREE_OPERAND (arg1, 0));
9601               tree arg11 = fold_convert_loc (loc, type,
9602                                              TREE_OPERAND (arg1, 1));
9603               tree tmp = fold_binary_loc (loc, MINUS_EXPR, type,
9604                                           fold_convert_loc (loc, type, arg0),
9605                                           arg10);
9606               if (tmp)
9607                 return fold_build2_loc (loc, MINUS_EXPR, type, tmp, arg11);
9608             }
9609         }
9610       /* (-A) - B -> (-B) - A  where B is easily negated and we can swap.  */
9611       if (TREE_CODE (arg0) == NEGATE_EXPR
9612           && negate_expr_p (arg1)
9613           && reorder_operands_p (arg0, arg1))
9614         return fold_build2_loc (loc, MINUS_EXPR, type,
9615                             fold_convert_loc (loc, type,
9616                                               negate_expr (arg1)),
9617                             fold_convert_loc (loc, type,
9618                                               TREE_OPERAND (arg0, 0)));
9619
9620       if (! FLOAT_TYPE_P (type))
9621         {
9622           /* Fold (A & ~B) - (A & B) into (A ^ B) - B, where B is
9623              any power of 2 minus 1.  */
9624           if (TREE_CODE (arg0) == BIT_AND_EXPR
9625               && TREE_CODE (arg1) == BIT_AND_EXPR
9626               && operand_equal_p (TREE_OPERAND (arg0, 0),
9627                                   TREE_OPERAND (arg1, 0), 0))
9628             {
9629               tree mask0 = TREE_OPERAND (arg0, 1);
9630               tree mask1 = TREE_OPERAND (arg1, 1);
9631               tree tem = fold_build1_loc (loc, BIT_NOT_EXPR, type, mask0);
9632
9633               if (operand_equal_p (tem, mask1, 0))
9634                 {
9635                   tem = fold_build2_loc (loc, BIT_XOR_EXPR, type,
9636                                      TREE_OPERAND (arg0, 0), mask1);
9637                   return fold_build2_loc (loc, MINUS_EXPR, type, tem, mask1);
9638                 }
9639             }
9640         }
9641
9642       /* Fold __complex__ ( x, 0 ) - __complex__ ( 0, y ) to
9643          __complex__ ( x, -y ).  This is not the same for SNaNs or if
9644          signed zeros are involved.  */
9645       if (!HONOR_SNANS (element_mode (arg0))
9646           && !HONOR_SIGNED_ZEROS (element_mode (arg0))
9647           && COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0)))
9648         {
9649           tree rtype = TREE_TYPE (TREE_TYPE (arg0));
9650           tree arg0r = fold_unary_loc (loc, REALPART_EXPR, rtype, arg0);
9651           tree arg0i = fold_unary_loc (loc, IMAGPART_EXPR, rtype, arg0);
9652           bool arg0rz = false, arg0iz = false;
9653           if ((arg0r && (arg0rz = real_zerop (arg0r)))
9654               || (arg0i && (arg0iz = real_zerop (arg0i))))
9655             {
9656               tree arg1r = fold_unary_loc (loc, REALPART_EXPR, rtype, arg1);
9657               tree arg1i = fold_unary_loc (loc, IMAGPART_EXPR, rtype, arg1);
9658               if (arg0rz && arg1i && real_zerop (arg1i))
9659                 {
9660                   tree rp = fold_build1_loc (loc, NEGATE_EXPR, rtype,
9661                                          arg1r ? arg1r
9662                                          : build1 (REALPART_EXPR, rtype, arg1));
9663                   tree ip = arg0i ? arg0i
9664                     : build1 (IMAGPART_EXPR, rtype, arg0);
9665                   return fold_build2_loc (loc, COMPLEX_EXPR, type, rp, ip);
9666                 }
9667               else if (arg0iz && arg1r && real_zerop (arg1r))
9668                 {
9669                   tree rp = arg0r ? arg0r
9670                     : build1 (REALPART_EXPR, rtype, arg0);
9671                   tree ip = fold_build1_loc (loc, NEGATE_EXPR, rtype,
9672                                          arg1i ? arg1i
9673                                          : build1 (IMAGPART_EXPR, rtype, arg1));
9674                   return fold_build2_loc (loc, COMPLEX_EXPR, type, rp, ip);
9675                 }
9676             }
9677         }
9678
9679       /* A - B -> A + (-B) if B is easily negatable.  */
9680       if (negate_expr_p (arg1)
9681           && !TYPE_OVERFLOW_SANITIZED (type)
9682           && ((FLOAT_TYPE_P (type)
9683                /* Avoid this transformation if B is a positive REAL_CST.  */
9684                && (TREE_CODE (arg1) != REAL_CST
9685                    ||  REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg1))))
9686               || INTEGRAL_TYPE_P (type)))
9687         return fold_build2_loc (loc, PLUS_EXPR, type,
9688                             fold_convert_loc (loc, type, arg0),
9689                             fold_convert_loc (loc, type,
9690                                               negate_expr (arg1)));
9691
9692       /* Fold &a[i] - &a[j] to i-j.  */
9693       if (TREE_CODE (arg0) == ADDR_EXPR
9694           && TREE_CODE (TREE_OPERAND (arg0, 0)) == ARRAY_REF
9695           && TREE_CODE (arg1) == ADDR_EXPR
9696           && TREE_CODE (TREE_OPERAND (arg1, 0)) == ARRAY_REF)
9697         {
9698           tree tem = fold_addr_of_array_ref_difference (loc, type,
9699                                                         TREE_OPERAND (arg0, 0),
9700                                                         TREE_OPERAND (arg1, 0));
9701           if (tem)
9702             return tem;
9703         }
9704
9705       if (FLOAT_TYPE_P (type)
9706           && flag_unsafe_math_optimizations
9707           && (TREE_CODE (arg0) == RDIV_EXPR || TREE_CODE (arg0) == MULT_EXPR)
9708           && (TREE_CODE (arg1) == RDIV_EXPR || TREE_CODE (arg1) == MULT_EXPR)
9709           && (tem = distribute_real_division (loc, code, type, arg0, arg1)))
9710         return tem;
9711
9712       /* Handle (A1 * C1) - (A2 * C2) with A1, A2 or C1, C2 being the same or
9713          one.  Make sure the type is not saturating and has the signedness of
9714          the stripped operands, as fold_plusminus_mult_expr will re-associate.
9715          ??? The latter condition should use TYPE_OVERFLOW_* flags instead.  */
9716       if ((TREE_CODE (arg0) == MULT_EXPR
9717            || TREE_CODE (arg1) == MULT_EXPR)
9718           && !TYPE_SATURATING (type)
9719           && TYPE_UNSIGNED (type) == TYPE_UNSIGNED (TREE_TYPE (arg0))
9720           && TYPE_UNSIGNED (type) == TYPE_UNSIGNED (TREE_TYPE (arg1))
9721           && (!FLOAT_TYPE_P (type) || flag_associative_math))
9722         {
9723           tree tem = fold_plusminus_mult_expr (loc, code, type, arg0, arg1);
9724           if (tem)
9725             return tem;
9726         }
9727
9728       goto associate;
9729
9730     case MULT_EXPR:
9731       /* (-A) * (-B) -> A * B  */
9732       if (TREE_CODE (arg0) == NEGATE_EXPR && negate_expr_p (arg1))
9733         return fold_build2_loc (loc, MULT_EXPR, type,
9734                             fold_convert_loc (loc, type,
9735                                               TREE_OPERAND (arg0, 0)),
9736                             fold_convert_loc (loc, type,
9737                                               negate_expr (arg1)));
9738       if (TREE_CODE (arg1) == NEGATE_EXPR && negate_expr_p (arg0))
9739         return fold_build2_loc (loc, MULT_EXPR, type,
9740                             fold_convert_loc (loc, type,
9741                                               negate_expr (arg0)),
9742                             fold_convert_loc (loc, type,
9743                                               TREE_OPERAND (arg1, 0)));
9744
9745       if (! FLOAT_TYPE_P (type))
9746         {
9747           /* Transform x * -C into -x * C if x is easily negatable.  */
9748           if (TREE_CODE (arg1) == INTEGER_CST
9749               && tree_int_cst_sgn (arg1) == -1
9750               && negate_expr_p (arg0)
9751               && (tem = negate_expr (arg1)) != arg1
9752               && !TREE_OVERFLOW (tem))
9753             return fold_build2_loc (loc, MULT_EXPR, type,
9754                                 fold_convert_loc (loc, type,
9755                                                   negate_expr (arg0)),
9756                                 tem);
9757
9758           /* (a * (1 << b)) is (a << b)  */
9759           if (TREE_CODE (arg1) == LSHIFT_EXPR
9760               && integer_onep (TREE_OPERAND (arg1, 0)))
9761             return fold_build2_loc (loc, LSHIFT_EXPR, type, op0,
9762                                 TREE_OPERAND (arg1, 1));
9763           if (TREE_CODE (arg0) == LSHIFT_EXPR
9764               && integer_onep (TREE_OPERAND (arg0, 0)))
9765             return fold_build2_loc (loc, LSHIFT_EXPR, type, op1,
9766                                 TREE_OPERAND (arg0, 1));
9767
9768           /* (A + A) * C -> A * 2 * C  */
9769           if (TREE_CODE (arg0) == PLUS_EXPR
9770               && TREE_CODE (arg1) == INTEGER_CST
9771               && operand_equal_p (TREE_OPERAND (arg0, 0),
9772                                   TREE_OPERAND (arg0, 1), 0))
9773             return fold_build2_loc (loc, MULT_EXPR, type,
9774                                 omit_one_operand_loc (loc, type,
9775                                                   TREE_OPERAND (arg0, 0),
9776                                                   TREE_OPERAND (arg0, 1)),
9777                                 fold_build2_loc (loc, MULT_EXPR, type,
9778                                              build_int_cst (type, 2) , arg1));
9779
9780           /* ((T) (X /[ex] C)) * C cancels out if the conversion is
9781              sign-changing only.  */
9782           if (TREE_CODE (arg1) == INTEGER_CST
9783               && TREE_CODE (arg0) == EXACT_DIV_EXPR
9784               && operand_equal_p (arg1, TREE_OPERAND (arg0, 1), 0))
9785             return fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
9786
9787           strict_overflow_p = false;
9788           if (TREE_CODE (arg1) == INTEGER_CST
9789               && 0 != (tem = extract_muldiv (op0, arg1, code, NULL_TREE,
9790                                              &strict_overflow_p)))
9791             {
9792               if (strict_overflow_p)
9793                 fold_overflow_warning (("assuming signed overflow does not "
9794                                         "occur when simplifying "
9795                                         "multiplication"),
9796                                        WARN_STRICT_OVERFLOW_MISC);
9797               return fold_convert_loc (loc, type, tem);
9798             }
9799
9800           /* Optimize z * conj(z) for integer complex numbers.  */
9801           if (TREE_CODE (arg0) == CONJ_EXPR
9802               && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
9803             return fold_mult_zconjz (loc, type, arg1);
9804           if (TREE_CODE (arg1) == CONJ_EXPR
9805               && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
9806             return fold_mult_zconjz (loc, type, arg0);
9807         }
9808       else
9809         {
9810           /* Convert (C1/X)*C2 into (C1*C2)/X.  This transformation may change
9811              the result for floating point types due to rounding so it is applied
9812              only if -fassociative-math was specify.  */
9813           if (flag_associative_math
9814               && TREE_CODE (arg0) == RDIV_EXPR
9815               && TREE_CODE (arg1) == REAL_CST
9816               && TREE_CODE (TREE_OPERAND (arg0, 0)) == REAL_CST)
9817             {
9818               tree tem = const_binop (MULT_EXPR, TREE_OPERAND (arg0, 0),
9819                                       arg1);
9820               if (tem)
9821                 return fold_build2_loc (loc, RDIV_EXPR, type, tem,
9822                                     TREE_OPERAND (arg0, 1));
9823             }
9824
9825           /* Strip sign operations from X in X*X, i.e. -Y*-Y -> Y*Y.  */
9826           if (operand_equal_p (arg0, arg1, 0))
9827             {
9828               tree tem = fold_strip_sign_ops (arg0);
9829               if (tem != NULL_TREE)
9830                 {
9831                   tem = fold_convert_loc (loc, type, tem);
9832                   return fold_build2_loc (loc, MULT_EXPR, type, tem, tem);
9833                 }
9834             }
9835
9836           /* Fold z * +-I to __complex__ (-+__imag z, +-__real z).
9837              This is not the same for NaNs or if signed zeros are
9838              involved.  */
9839           if (!HONOR_NANS (arg0)
9840               && !HONOR_SIGNED_ZEROS (element_mode (arg0))
9841               && COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0))
9842               && TREE_CODE (arg1) == COMPLEX_CST
9843               && real_zerop (TREE_REALPART (arg1)))
9844             {
9845               tree rtype = TREE_TYPE (TREE_TYPE (arg0));
9846               if (real_onep (TREE_IMAGPART (arg1)))
9847                 return
9848                   fold_build2_loc (loc, COMPLEX_EXPR, type,
9849                                negate_expr (fold_build1_loc (loc, IMAGPART_EXPR,
9850                                                              rtype, arg0)),
9851                                fold_build1_loc (loc, REALPART_EXPR, rtype, arg0));
9852               else if (real_minus_onep (TREE_IMAGPART (arg1)))
9853                 return
9854                   fold_build2_loc (loc, COMPLEX_EXPR, type,
9855                                fold_build1_loc (loc, IMAGPART_EXPR, rtype, arg0),
9856                                negate_expr (fold_build1_loc (loc, REALPART_EXPR,
9857                                                              rtype, arg0)));
9858             }
9859
9860           /* Optimize z * conj(z) for floating point complex numbers.
9861              Guarded by flag_unsafe_math_optimizations as non-finite
9862              imaginary components don't produce scalar results.  */
9863           if (flag_unsafe_math_optimizations
9864               && TREE_CODE (arg0) == CONJ_EXPR
9865               && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
9866             return fold_mult_zconjz (loc, type, arg1);
9867           if (flag_unsafe_math_optimizations
9868               && TREE_CODE (arg1) == CONJ_EXPR
9869               && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
9870             return fold_mult_zconjz (loc, type, arg0);
9871
9872           if (flag_unsafe_math_optimizations)
9873             {
9874
9875               /* Canonicalize x*x as pow(x,2.0), which is expanded as x*x.  */
9876               if (!in_gimple_form
9877                   && optimize
9878                   && operand_equal_p (arg0, arg1, 0))
9879                 {
9880                   tree powfn = mathfn_built_in (type, BUILT_IN_POW);
9881
9882                   if (powfn)
9883                     {
9884                       tree arg = build_real (type, dconst2);
9885                       return build_call_expr_loc (loc, powfn, 2, arg0, arg);
9886                     }
9887                 }
9888             }
9889         }
9890       goto associate;
9891
9892     case BIT_IOR_EXPR:
9893       /* Canonicalize (X & C1) | C2.  */
9894       if (TREE_CODE (arg0) == BIT_AND_EXPR
9895           && TREE_CODE (arg1) == INTEGER_CST
9896           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
9897         {
9898           int width = TYPE_PRECISION (type), w;
9899           wide_int c1 = TREE_OPERAND (arg0, 1);
9900           wide_int c2 = arg1;
9901
9902           /* If (C1&C2) == C1, then (X&C1)|C2 becomes (X,C2).  */
9903           if ((c1 & c2) == c1)
9904             return omit_one_operand_loc (loc, type, arg1,
9905                                          TREE_OPERAND (arg0, 0));
9906
9907           wide_int msk = wi::mask (width, false,
9908                                    TYPE_PRECISION (TREE_TYPE (arg1)));
9909
9910           /* If (C1|C2) == ~0 then (X&C1)|C2 becomes X|C2.  */
9911           if (msk.and_not (c1 | c2) == 0)
9912             return fold_build2_loc (loc, BIT_IOR_EXPR, type,
9913                                     TREE_OPERAND (arg0, 0), arg1);
9914
9915           /* Minimize the number of bits set in C1, i.e. C1 := C1 & ~C2,
9916              unless (C1 & ~C2) | (C2 & C3) for some C3 is a mask of some
9917              mode which allows further optimizations.  */
9918           c1 &= msk;
9919           c2 &= msk;
9920           wide_int c3 = c1.and_not (c2);
9921           for (w = BITS_PER_UNIT; w <= width; w <<= 1)
9922             {
9923               wide_int mask = wi::mask (w, false,
9924                                         TYPE_PRECISION (type));
9925               if (((c1 | c2) & mask) == mask && c1.and_not (mask) == 0)
9926                 {
9927                   c3 = mask;
9928                   break;
9929                 }
9930             }
9931
9932           if (c3 != c1)
9933             return fold_build2_loc (loc, BIT_IOR_EXPR, type,
9934                                     fold_build2_loc (loc, BIT_AND_EXPR, type,
9935                                                      TREE_OPERAND (arg0, 0),
9936                                                      wide_int_to_tree (type,
9937                                                                        c3)),
9938                                     arg1);
9939         }
9940
9941       /* (X & ~Y) | (~X & Y) is X ^ Y */
9942       if (TREE_CODE (arg0) == BIT_AND_EXPR
9943           && TREE_CODE (arg1) == BIT_AND_EXPR)
9944         {
9945           tree a0, a1, l0, l1, n0, n1;
9946
9947           a0 = fold_convert_loc (loc, type, TREE_OPERAND (arg1, 0));
9948           a1 = fold_convert_loc (loc, type, TREE_OPERAND (arg1, 1));
9949
9950           l0 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
9951           l1 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 1));
9952
9953           n0 = fold_build1_loc (loc, BIT_NOT_EXPR, type, l0);
9954           n1 = fold_build1_loc (loc, BIT_NOT_EXPR, type, l1);
9955
9956           if ((operand_equal_p (n0, a0, 0)
9957                && operand_equal_p (n1, a1, 0))
9958               || (operand_equal_p (n0, a1, 0)
9959                   && operand_equal_p (n1, a0, 0)))
9960             return fold_build2_loc (loc, BIT_XOR_EXPR, type, l0, n1);
9961         }
9962
9963       /* See if this can be simplified into a rotate first.  If that
9964          is unsuccessful continue in the association code.  */
9965       goto bit_rotate;
9966
9967     case BIT_XOR_EXPR:
9968       /* Fold (X & 1) ^ 1 as (X & 1) == 0.  */
9969       if (TREE_CODE (arg0) == BIT_AND_EXPR
9970           && INTEGRAL_TYPE_P (type)
9971           && integer_onep (TREE_OPERAND (arg0, 1))
9972           && integer_onep (arg1))
9973         return fold_build2_loc (loc, EQ_EXPR, type, arg0,
9974                                 build_zero_cst (TREE_TYPE (arg0)));
9975
9976       /* See if this can be simplified into a rotate first.  If that
9977          is unsuccessful continue in the association code.  */
9978       goto bit_rotate;
9979
9980     case BIT_AND_EXPR:
9981       /* ~X & X, (X == 0) & X, and !X & X are always zero.  */
9982       if ((TREE_CODE (arg0) == BIT_NOT_EXPR
9983            || TREE_CODE (arg0) == TRUTH_NOT_EXPR
9984            || (TREE_CODE (arg0) == EQ_EXPR
9985                && integer_zerop (TREE_OPERAND (arg0, 1))))
9986           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
9987         return omit_one_operand_loc (loc, type, integer_zero_node, arg1);
9988
9989       /* X & ~X , X & (X == 0), and X & !X are always zero.  */
9990       if ((TREE_CODE (arg1) == BIT_NOT_EXPR
9991            || TREE_CODE (arg1) == TRUTH_NOT_EXPR
9992            || (TREE_CODE (arg1) == EQ_EXPR
9993                && integer_zerop (TREE_OPERAND (arg1, 1))))
9994           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
9995         return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
9996
9997       /* Fold (X ^ 1) & 1 as (X & 1) == 0.  */
9998       if (TREE_CODE (arg0) == BIT_XOR_EXPR
9999           && INTEGRAL_TYPE_P (type)
10000           && integer_onep (TREE_OPERAND (arg0, 1))
10001           && integer_onep (arg1))
10002         {
10003           tree tem2;
10004           tem = TREE_OPERAND (arg0, 0);
10005           tem2 = fold_convert_loc (loc, TREE_TYPE (tem), arg1);
10006           tem2 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (tem),
10007                                   tem, tem2);
10008           return fold_build2_loc (loc, EQ_EXPR, type, tem2,
10009                                   build_zero_cst (TREE_TYPE (tem)));
10010         }
10011       /* Fold ~X & 1 as (X & 1) == 0.  */
10012       if (TREE_CODE (arg0) == BIT_NOT_EXPR
10013           && INTEGRAL_TYPE_P (type)
10014           && integer_onep (arg1))
10015         {
10016           tree tem2;
10017           tem = TREE_OPERAND (arg0, 0);
10018           tem2 = fold_convert_loc (loc, TREE_TYPE (tem), arg1);
10019           tem2 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (tem),
10020                                   tem, tem2);
10021           return fold_build2_loc (loc, EQ_EXPR, type, tem2,
10022                                   build_zero_cst (TREE_TYPE (tem)));
10023         }
10024       /* Fold !X & 1 as X == 0.  */
10025       if (TREE_CODE (arg0) == TRUTH_NOT_EXPR
10026           && integer_onep (arg1))
10027         {
10028           tem = TREE_OPERAND (arg0, 0);
10029           return fold_build2_loc (loc, EQ_EXPR, type, tem,
10030                                   build_zero_cst (TREE_TYPE (tem)));
10031         }
10032
10033       /* Fold (X ^ Y) & Y as ~X & Y.  */
10034       if (TREE_CODE (arg0) == BIT_XOR_EXPR
10035           && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
10036         {
10037           tem = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
10038           return fold_build2_loc (loc, BIT_AND_EXPR, type,
10039                               fold_build1_loc (loc, BIT_NOT_EXPR, type, tem),
10040                               fold_convert_loc (loc, type, arg1));
10041         }
10042       /* Fold (X ^ Y) & X as ~Y & X.  */
10043       if (TREE_CODE (arg0) == BIT_XOR_EXPR
10044           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
10045           && reorder_operands_p (TREE_OPERAND (arg0, 1), arg1))
10046         {
10047           tem = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 1));
10048           return fold_build2_loc (loc, BIT_AND_EXPR, type,
10049                               fold_build1_loc (loc, BIT_NOT_EXPR, type, tem),
10050                               fold_convert_loc (loc, type, arg1));
10051         }
10052       /* Fold X & (X ^ Y) as X & ~Y.  */
10053       if (TREE_CODE (arg1) == BIT_XOR_EXPR
10054           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
10055         {
10056           tem = fold_convert_loc (loc, type, TREE_OPERAND (arg1, 1));
10057           return fold_build2_loc (loc, BIT_AND_EXPR, type,
10058                               fold_convert_loc (loc, type, arg0),
10059                               fold_build1_loc (loc, BIT_NOT_EXPR, type, tem));
10060         }
10061       /* Fold X & (Y ^ X) as ~Y & X.  */
10062       if (TREE_CODE (arg1) == BIT_XOR_EXPR
10063           && operand_equal_p (arg0, TREE_OPERAND (arg1, 1), 0)
10064           && reorder_operands_p (arg0, TREE_OPERAND (arg1, 0)))
10065         {
10066           tem = fold_convert_loc (loc, type, TREE_OPERAND (arg1, 0));
10067           return fold_build2_loc (loc, BIT_AND_EXPR, type,
10068                               fold_build1_loc (loc, BIT_NOT_EXPR, type, tem),
10069                               fold_convert_loc (loc, type, arg0));
10070         }
10071
10072       /* Fold (X * Y) & -(1 << CST) to X * Y if Y is a constant
10073          multiple of 1 << CST.  */
10074       if (TREE_CODE (arg1) == INTEGER_CST)
10075         {
10076           wide_int cst1 = arg1;
10077           wide_int ncst1 = -cst1;
10078           if ((cst1 & ncst1) == ncst1
10079               && multiple_of_p (type, arg0,
10080                                 wide_int_to_tree (TREE_TYPE (arg1), ncst1)))
10081             return fold_convert_loc (loc, type, arg0);
10082         }
10083
10084       /* Fold (X * CST1) & CST2 to zero if we can, or drop known zero
10085          bits from CST2.  */
10086       if (TREE_CODE (arg1) == INTEGER_CST
10087           && TREE_CODE (arg0) == MULT_EXPR
10088           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
10089         {
10090           wide_int warg1 = arg1;
10091           wide_int masked = mask_with_tz (type, warg1, TREE_OPERAND (arg0, 1));
10092
10093           if (masked == 0)
10094             return omit_two_operands_loc (loc, type, build_zero_cst (type),
10095                                           arg0, arg1);
10096           else if (masked != warg1)
10097             {
10098               /* Avoid the transform if arg1 is a mask of some
10099                  mode which allows further optimizations.  */
10100               int pop = wi::popcount (warg1);
10101               if (!(pop >= BITS_PER_UNIT
10102                     && exact_log2 (pop) != -1
10103                     && wi::mask (pop, false, warg1.get_precision ()) == warg1))
10104                 return fold_build2_loc (loc, code, type, op0,
10105                                         wide_int_to_tree (type, masked));
10106             }
10107         }
10108
10109       /* For constants M and N, if M == (1LL << cst) - 1 && (N & M) == M,
10110          ((A & N) + B) & M -> (A + B) & M
10111          Similarly if (N & M) == 0,
10112          ((A | N) + B) & M -> (A + B) & M
10113          and for - instead of + (or unary - instead of +)
10114          and/or ^ instead of |.
10115          If B is constant and (B & M) == 0, fold into A & M.  */
10116       if (TREE_CODE (arg1) == INTEGER_CST)
10117         {
10118           wide_int cst1 = arg1;
10119           if ((~cst1 != 0) && (cst1 & (cst1 + 1)) == 0
10120               && INTEGRAL_TYPE_P (TREE_TYPE (arg0))
10121               && (TREE_CODE (arg0) == PLUS_EXPR
10122                   || TREE_CODE (arg0) == MINUS_EXPR
10123                   || TREE_CODE (arg0) == NEGATE_EXPR)
10124               && (TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg0))
10125                   || TREE_CODE (TREE_TYPE (arg0)) == INTEGER_TYPE))
10126             {
10127               tree pmop[2];
10128               int which = 0;
10129               wide_int cst0;
10130
10131               /* Now we know that arg0 is (C + D) or (C - D) or
10132                  -C and arg1 (M) is == (1LL << cst) - 1.
10133                  Store C into PMOP[0] and D into PMOP[1].  */
10134               pmop[0] = TREE_OPERAND (arg0, 0);
10135               pmop[1] = NULL;
10136               if (TREE_CODE (arg0) != NEGATE_EXPR)
10137                 {
10138                   pmop[1] = TREE_OPERAND (arg0, 1);
10139                   which = 1;
10140                 }
10141
10142               if ((wi::max_value (TREE_TYPE (arg0)) & cst1) != cst1)
10143                 which = -1;
10144
10145               for (; which >= 0; which--)
10146                 switch (TREE_CODE (pmop[which]))
10147                   {
10148                   case BIT_AND_EXPR:
10149                   case BIT_IOR_EXPR:
10150                   case BIT_XOR_EXPR:
10151                     if (TREE_CODE (TREE_OPERAND (pmop[which], 1))
10152                         != INTEGER_CST)
10153                       break;
10154                     cst0 = TREE_OPERAND (pmop[which], 1);
10155                     cst0 &= cst1;
10156                     if (TREE_CODE (pmop[which]) == BIT_AND_EXPR)
10157                       {
10158                         if (cst0 != cst1)
10159                           break;
10160                       }
10161                     else if (cst0 != 0)
10162                       break;
10163                     /* If C or D is of the form (A & N) where
10164                        (N & M) == M, or of the form (A | N) or
10165                        (A ^ N) where (N & M) == 0, replace it with A.  */
10166                     pmop[which] = TREE_OPERAND (pmop[which], 0);
10167                     break;
10168                   case INTEGER_CST:
10169                     /* If C or D is a N where (N & M) == 0, it can be
10170                        omitted (assumed 0).  */
10171                     if ((TREE_CODE (arg0) == PLUS_EXPR
10172                          || (TREE_CODE (arg0) == MINUS_EXPR && which == 0))
10173                         && (cst1 & pmop[which]) == 0)
10174                       pmop[which] = NULL;
10175                     break;
10176                   default:
10177                     break;
10178                   }
10179
10180               /* Only build anything new if we optimized one or both arguments
10181                  above.  */
10182               if (pmop[0] != TREE_OPERAND (arg0, 0)
10183                   || (TREE_CODE (arg0) != NEGATE_EXPR
10184                       && pmop[1] != TREE_OPERAND (arg0, 1)))
10185                 {
10186                   tree utype = TREE_TYPE (arg0);
10187                   if (! TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg0)))
10188                     {
10189                       /* Perform the operations in a type that has defined
10190                          overflow behavior.  */
10191                       utype = unsigned_type_for (TREE_TYPE (arg0));
10192                       if (pmop[0] != NULL)
10193                         pmop[0] = fold_convert_loc (loc, utype, pmop[0]);
10194                       if (pmop[1] != NULL)
10195                         pmop[1] = fold_convert_loc (loc, utype, pmop[1]);
10196                     }
10197
10198                   if (TREE_CODE (arg0) == NEGATE_EXPR)
10199                     tem = fold_build1_loc (loc, NEGATE_EXPR, utype, pmop[0]);
10200                   else if (TREE_CODE (arg0) == PLUS_EXPR)
10201                     {
10202                       if (pmop[0] != NULL && pmop[1] != NULL)
10203                         tem = fold_build2_loc (loc, PLUS_EXPR, utype,
10204                                                pmop[0], pmop[1]);
10205                       else if (pmop[0] != NULL)
10206                         tem = pmop[0];
10207                       else if (pmop[1] != NULL)
10208                         tem = pmop[1];
10209                       else
10210                         return build_int_cst (type, 0);
10211                     }
10212                   else if (pmop[0] == NULL)
10213                     tem = fold_build1_loc (loc, NEGATE_EXPR, utype, pmop[1]);
10214                   else
10215                     tem = fold_build2_loc (loc, MINUS_EXPR, utype,
10216                                            pmop[0], pmop[1]);
10217                   /* TEM is now the new binary +, - or unary - replacement.  */
10218                   tem = fold_build2_loc (loc, BIT_AND_EXPR, utype, tem,
10219                                          fold_convert_loc (loc, utype, arg1));
10220                   return fold_convert_loc (loc, type, tem);
10221                 }
10222             }
10223         }
10224
10225       /* Simplify ((int)c & 0377) into (int)c, if c is unsigned char.  */
10226       if (TREE_CODE (arg1) == INTEGER_CST && TREE_CODE (arg0) == NOP_EXPR
10227           && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg0, 0))))
10228         {
10229           prec = element_precision (TREE_TYPE (TREE_OPERAND (arg0, 0)));
10230
10231           wide_int mask = wide_int::from (arg1, prec, UNSIGNED);
10232           if (mask == -1)
10233             return
10234               fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
10235         }
10236
10237       goto associate;
10238
10239     case RDIV_EXPR:
10240       /* Don't touch a floating-point divide by zero unless the mode
10241          of the constant can represent infinity.  */
10242       if (TREE_CODE (arg1) == REAL_CST
10243           && !MODE_HAS_INFINITIES (TYPE_MODE (TREE_TYPE (arg1)))
10244           && real_zerop (arg1))
10245         return NULL_TREE;
10246
10247       /* (-A) / (-B) -> A / B  */
10248       if (TREE_CODE (arg0) == NEGATE_EXPR && negate_expr_p (arg1))
10249         return fold_build2_loc (loc, RDIV_EXPR, type,
10250                             TREE_OPERAND (arg0, 0),
10251                             negate_expr (arg1));
10252       if (TREE_CODE (arg1) == NEGATE_EXPR && negate_expr_p (arg0))
10253         return fold_build2_loc (loc, RDIV_EXPR, type,
10254                             negate_expr (arg0),
10255                             TREE_OPERAND (arg1, 0));
10256
10257       /* Convert A/B/C to A/(B*C).  */
10258       if (flag_reciprocal_math
10259           && TREE_CODE (arg0) == RDIV_EXPR)
10260         return fold_build2_loc (loc, RDIV_EXPR, type, TREE_OPERAND (arg0, 0),
10261                             fold_build2_loc (loc, MULT_EXPR, type,
10262                                          TREE_OPERAND (arg0, 1), arg1));
10263
10264       /* Convert A/(B/C) to (A/B)*C.  */
10265       if (flag_reciprocal_math
10266           && TREE_CODE (arg1) == RDIV_EXPR)
10267         return fold_build2_loc (loc, MULT_EXPR, type,
10268                             fold_build2_loc (loc, RDIV_EXPR, type, arg0,
10269                                          TREE_OPERAND (arg1, 0)),
10270                             TREE_OPERAND (arg1, 1));
10271
10272       /* Convert C1/(X*C2) into (C1/C2)/X.  */
10273       if (flag_reciprocal_math
10274           && TREE_CODE (arg1) == MULT_EXPR
10275           && TREE_CODE (arg0) == REAL_CST
10276           && TREE_CODE (TREE_OPERAND (arg1, 1)) == REAL_CST)
10277         {
10278           tree tem = const_binop (RDIV_EXPR, arg0,
10279                                   TREE_OPERAND (arg1, 1));
10280           if (tem)
10281             return fold_build2_loc (loc, RDIV_EXPR, type, tem,
10282                                 TREE_OPERAND (arg1, 0));
10283         }
10284
10285       return NULL_TREE;
10286
10287     case TRUNC_DIV_EXPR:
10288       /* Optimize (X & (-A)) / A where A is a power of 2,
10289          to X >> log2(A) */
10290       if (TREE_CODE (arg0) == BIT_AND_EXPR
10291           && !TYPE_UNSIGNED (type) && TREE_CODE (arg1) == INTEGER_CST
10292           && integer_pow2p (arg1) && tree_int_cst_sgn (arg1) > 0)
10293         {
10294           tree sum = fold_binary_loc (loc, PLUS_EXPR, TREE_TYPE (arg1),
10295                                       arg1, TREE_OPERAND (arg0, 1));
10296           if (sum && integer_zerop (sum)) {
10297             tree pow2 = build_int_cst (integer_type_node,
10298                                        wi::exact_log2 (arg1));
10299             return fold_build2_loc (loc, RSHIFT_EXPR, type,
10300                                     TREE_OPERAND (arg0, 0), pow2);
10301           }
10302         }
10303
10304       /* Fall through */
10305
10306     case FLOOR_DIV_EXPR:
10307       /* Simplify A / (B << N) where A and B are positive and B is
10308          a power of 2, to A >> (N + log2(B)).  */
10309       strict_overflow_p = false;
10310       if (TREE_CODE (arg1) == LSHIFT_EXPR
10311           && (TYPE_UNSIGNED (type)
10312               || tree_expr_nonnegative_warnv_p (op0, &strict_overflow_p)))
10313         {
10314           tree sval = TREE_OPERAND (arg1, 0);
10315           if (integer_pow2p (sval) && tree_int_cst_sgn (sval) > 0)
10316             {
10317               tree sh_cnt = TREE_OPERAND (arg1, 1);
10318               tree pow2 = build_int_cst (TREE_TYPE (sh_cnt),
10319                                          wi::exact_log2 (sval));
10320
10321               if (strict_overflow_p)
10322                 fold_overflow_warning (("assuming signed overflow does not "
10323                                         "occur when simplifying A / (B << N)"),
10324                                        WARN_STRICT_OVERFLOW_MISC);
10325
10326               sh_cnt = fold_build2_loc (loc, PLUS_EXPR, TREE_TYPE (sh_cnt),
10327                                         sh_cnt, pow2);
10328               return fold_build2_loc (loc, RSHIFT_EXPR, type,
10329                                       fold_convert_loc (loc, type, arg0), sh_cnt);
10330             }
10331         }
10332
10333       /* Fall through */
10334
10335     case ROUND_DIV_EXPR:
10336     case CEIL_DIV_EXPR:
10337     case EXACT_DIV_EXPR:
10338       if (integer_zerop (arg1))
10339         return NULL_TREE;
10340
10341       /* Convert -A / -B to A / B when the type is signed and overflow is
10342          undefined.  */
10343       if ((!INTEGRAL_TYPE_P (type) || TYPE_OVERFLOW_UNDEFINED (type))
10344           && TREE_CODE (arg0) == NEGATE_EXPR
10345           && negate_expr_p (arg1))
10346         {
10347           if (INTEGRAL_TYPE_P (type))
10348             fold_overflow_warning (("assuming signed overflow does not occur "
10349                                     "when distributing negation across "
10350                                     "division"),
10351                                    WARN_STRICT_OVERFLOW_MISC);
10352           return fold_build2_loc (loc, code, type,
10353                               fold_convert_loc (loc, type,
10354                                                 TREE_OPERAND (arg0, 0)),
10355                               fold_convert_loc (loc, type,
10356                                                 negate_expr (arg1)));
10357         }
10358       if ((!INTEGRAL_TYPE_P (type) || TYPE_OVERFLOW_UNDEFINED (type))
10359           && TREE_CODE (arg1) == NEGATE_EXPR
10360           && negate_expr_p (arg0))
10361         {
10362           if (INTEGRAL_TYPE_P (type))
10363             fold_overflow_warning (("assuming signed overflow does not occur "
10364                                     "when distributing negation across "
10365                                     "division"),
10366                                    WARN_STRICT_OVERFLOW_MISC);
10367           return fold_build2_loc (loc, code, type,
10368                               fold_convert_loc (loc, type,
10369                                                 negate_expr (arg0)),
10370                               fold_convert_loc (loc, type,
10371                                                 TREE_OPERAND (arg1, 0)));
10372         }
10373
10374       /* If arg0 is a multiple of arg1, then rewrite to the fastest div
10375          operation, EXACT_DIV_EXPR.
10376
10377          Note that only CEIL_DIV_EXPR and FLOOR_DIV_EXPR are rewritten now.
10378          At one time others generated faster code, it's not clear if they do
10379          after the last round to changes to the DIV code in expmed.c.  */
10380       if ((code == CEIL_DIV_EXPR || code == FLOOR_DIV_EXPR)
10381           && multiple_of_p (type, arg0, arg1))
10382         return fold_build2_loc (loc, EXACT_DIV_EXPR, type,
10383                                 fold_convert (type, arg0),
10384                                 fold_convert (type, arg1));
10385
10386       strict_overflow_p = false;
10387       if (TREE_CODE (arg1) == INTEGER_CST
10388           && 0 != (tem = extract_muldiv (op0, arg1, code, NULL_TREE,
10389                                          &strict_overflow_p)))
10390         {
10391           if (strict_overflow_p)
10392             fold_overflow_warning (("assuming signed overflow does not occur "
10393                                     "when simplifying division"),
10394                                    WARN_STRICT_OVERFLOW_MISC);
10395           return fold_convert_loc (loc, type, tem);
10396         }
10397
10398       return NULL_TREE;
10399
10400     case CEIL_MOD_EXPR:
10401     case FLOOR_MOD_EXPR:
10402     case ROUND_MOD_EXPR:
10403     case TRUNC_MOD_EXPR:
10404       strict_overflow_p = false;
10405       if (TREE_CODE (arg1) == INTEGER_CST
10406           && 0 != (tem = extract_muldiv (op0, arg1, code, NULL_TREE,
10407                                          &strict_overflow_p)))
10408         {
10409           if (strict_overflow_p)
10410             fold_overflow_warning (("assuming signed overflow does not occur "
10411                                     "when simplifying modulus"),
10412                                    WARN_STRICT_OVERFLOW_MISC);
10413           return fold_convert_loc (loc, type, tem);
10414         }
10415
10416       return NULL_TREE;
10417
10418     case LROTATE_EXPR:
10419     case RROTATE_EXPR:
10420     case RSHIFT_EXPR:
10421     case LSHIFT_EXPR:
10422       /* Since negative shift count is not well-defined,
10423          don't try to compute it in the compiler.  */
10424       if (TREE_CODE (arg1) == INTEGER_CST && tree_int_cst_sgn (arg1) < 0)
10425         return NULL_TREE;
10426
10427       prec = element_precision (type);
10428
10429       /* If we have a rotate of a bit operation with the rotate count and
10430          the second operand of the bit operation both constant,
10431          permute the two operations.  */
10432       if (code == RROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST
10433           && (TREE_CODE (arg0) == BIT_AND_EXPR
10434               || TREE_CODE (arg0) == BIT_IOR_EXPR
10435               || TREE_CODE (arg0) == BIT_XOR_EXPR)
10436           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
10437         return fold_build2_loc (loc, TREE_CODE (arg0), type,
10438                             fold_build2_loc (loc, code, type,
10439                                          TREE_OPERAND (arg0, 0), arg1),
10440                             fold_build2_loc (loc, code, type,
10441                                          TREE_OPERAND (arg0, 1), arg1));
10442
10443       /* Two consecutive rotates adding up to the some integer
10444          multiple of the precision of the type can be ignored.  */
10445       if (code == RROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST
10446           && TREE_CODE (arg0) == RROTATE_EXPR
10447           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
10448           && wi::umod_trunc (wi::add (arg1, TREE_OPERAND (arg0, 1)),
10449                              prec) == 0)
10450         return TREE_OPERAND (arg0, 0);
10451
10452       return NULL_TREE;
10453
10454     case MIN_EXPR:
10455       tem = fold_minmax (loc, MIN_EXPR, type, arg0, arg1);
10456       if (tem)
10457         return tem;
10458       goto associate;
10459
10460     case MAX_EXPR:
10461       tem = fold_minmax (loc, MAX_EXPR, type, arg0, arg1);
10462       if (tem)
10463         return tem;
10464       goto associate;
10465
10466     case TRUTH_ANDIF_EXPR:
10467       /* Note that the operands of this must be ints
10468          and their values must be 0 or 1.
10469          ("true" is a fixed value perhaps depending on the language.)  */
10470       /* If first arg is constant zero, return it.  */
10471       if (integer_zerop (arg0))
10472         return fold_convert_loc (loc, type, arg0);
10473     case TRUTH_AND_EXPR:
10474       /* If either arg is constant true, drop it.  */
10475       if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
10476         return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg1));
10477       if (TREE_CODE (arg1) == INTEGER_CST && ! integer_zerop (arg1)
10478           /* Preserve sequence points.  */
10479           && (code != TRUTH_ANDIF_EXPR || ! TREE_SIDE_EFFECTS (arg0)))
10480         return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
10481       /* If second arg is constant zero, result is zero, but first arg
10482          must be evaluated.  */
10483       if (integer_zerop (arg1))
10484         return omit_one_operand_loc (loc, type, arg1, arg0);
10485       /* Likewise for first arg, but note that only the TRUTH_AND_EXPR
10486          case will be handled here.  */
10487       if (integer_zerop (arg0))
10488         return omit_one_operand_loc (loc, type, arg0, arg1);
10489
10490       /* !X && X is always false.  */
10491       if (TREE_CODE (arg0) == TRUTH_NOT_EXPR
10492           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
10493         return omit_one_operand_loc (loc, type, integer_zero_node, arg1);
10494       /* X && !X is always false.  */
10495       if (TREE_CODE (arg1) == TRUTH_NOT_EXPR
10496           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
10497         return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
10498
10499       /* A < X && A + 1 > Y ==> A < X && A >= Y.  Normally A + 1 > Y
10500          means A >= Y && A != MAX, but in this case we know that
10501          A < X <= MAX.  */
10502
10503       if (!TREE_SIDE_EFFECTS (arg0)
10504           && !TREE_SIDE_EFFECTS (arg1))
10505         {
10506           tem = fold_to_nonsharp_ineq_using_bound (loc, arg0, arg1);
10507           if (tem && !operand_equal_p (tem, arg0, 0))
10508             return fold_build2_loc (loc, code, type, tem, arg1);
10509
10510           tem = fold_to_nonsharp_ineq_using_bound (loc, arg1, arg0);
10511           if (tem && !operand_equal_p (tem, arg1, 0))
10512             return fold_build2_loc (loc, code, type, arg0, tem);
10513         }
10514
10515       if ((tem = fold_truth_andor (loc, code, type, arg0, arg1, op0, op1))
10516           != NULL_TREE)
10517         return tem;
10518
10519       return NULL_TREE;
10520
10521     case TRUTH_ORIF_EXPR:
10522       /* Note that the operands of this must be ints
10523          and their values must be 0 or true.
10524          ("true" is a fixed value perhaps depending on the language.)  */
10525       /* If first arg is constant true, return it.  */
10526       if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
10527         return fold_convert_loc (loc, type, arg0);
10528     case TRUTH_OR_EXPR:
10529       /* If either arg is constant zero, drop it.  */
10530       if (TREE_CODE (arg0) == INTEGER_CST && integer_zerop (arg0))
10531         return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg1));
10532       if (TREE_CODE (arg1) == INTEGER_CST && integer_zerop (arg1)
10533           /* Preserve sequence points.  */
10534           && (code != TRUTH_ORIF_EXPR || ! TREE_SIDE_EFFECTS (arg0)))
10535         return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
10536       /* If second arg is constant true, result is true, but we must
10537          evaluate first arg.  */
10538       if (TREE_CODE (arg1) == INTEGER_CST && ! integer_zerop (arg1))
10539         return omit_one_operand_loc (loc, type, arg1, arg0);
10540       /* Likewise for first arg, but note this only occurs here for
10541          TRUTH_OR_EXPR.  */
10542       if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
10543         return omit_one_operand_loc (loc, type, arg0, arg1);
10544
10545       /* !X || X is always true.  */
10546       if (TREE_CODE (arg0) == TRUTH_NOT_EXPR
10547           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
10548         return omit_one_operand_loc (loc, type, integer_one_node, arg1);
10549       /* X || !X is always true.  */
10550       if (TREE_CODE (arg1) == TRUTH_NOT_EXPR
10551           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
10552         return omit_one_operand_loc (loc, type, integer_one_node, arg0);
10553
10554       /* (X && !Y) || (!X && Y) is X ^ Y */
10555       if (TREE_CODE (arg0) == TRUTH_AND_EXPR
10556           && TREE_CODE (arg1) == TRUTH_AND_EXPR)
10557         {
10558           tree a0, a1, l0, l1, n0, n1;
10559
10560           a0 = fold_convert_loc (loc, type, TREE_OPERAND (arg1, 0));
10561           a1 = fold_convert_loc (loc, type, TREE_OPERAND (arg1, 1));
10562
10563           l0 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
10564           l1 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 1));
10565
10566           n0 = fold_build1_loc (loc, TRUTH_NOT_EXPR, type, l0);
10567           n1 = fold_build1_loc (loc, TRUTH_NOT_EXPR, type, l1);
10568
10569           if ((operand_equal_p (n0, a0, 0)
10570                && operand_equal_p (n1, a1, 0))
10571               || (operand_equal_p (n0, a1, 0)
10572                   && operand_equal_p (n1, a0, 0)))
10573             return fold_build2_loc (loc, TRUTH_XOR_EXPR, type, l0, n1);
10574         }
10575
10576       if ((tem = fold_truth_andor (loc, code, type, arg0, arg1, op0, op1))
10577           != NULL_TREE)
10578         return tem;
10579
10580       return NULL_TREE;
10581
10582     case TRUTH_XOR_EXPR:
10583       /* If the second arg is constant zero, drop it.  */
10584       if (integer_zerop (arg1))
10585         return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
10586       /* If the second arg is constant true, this is a logical inversion.  */
10587       if (integer_onep (arg1))
10588         {
10589           tem = invert_truthvalue_loc (loc, arg0);
10590           return non_lvalue_loc (loc, fold_convert_loc (loc, type, tem));
10591         }
10592       /* Identical arguments cancel to zero.  */
10593       if (operand_equal_p (arg0, arg1, 0))
10594         return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
10595
10596       /* !X ^ X is always true.  */
10597       if (TREE_CODE (arg0) == TRUTH_NOT_EXPR
10598           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
10599         return omit_one_operand_loc (loc, type, integer_one_node, arg1);
10600
10601       /* X ^ !X is always true.  */
10602       if (TREE_CODE (arg1) == TRUTH_NOT_EXPR
10603           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
10604         return omit_one_operand_loc (loc, type, integer_one_node, arg0);
10605
10606       return NULL_TREE;
10607
10608     case EQ_EXPR:
10609     case NE_EXPR:
10610       STRIP_NOPS (arg0);
10611       STRIP_NOPS (arg1);
10612
10613       tem = fold_comparison (loc, code, type, op0, op1);
10614       if (tem != NULL_TREE)
10615         return tem;
10616
10617       /* bool_var != 1 becomes !bool_var. */
10618       if (TREE_CODE (TREE_TYPE (arg0)) == BOOLEAN_TYPE && integer_onep (arg1)
10619           && code == NE_EXPR)
10620         return fold_convert_loc (loc, type,
10621                                  fold_build1_loc (loc, TRUTH_NOT_EXPR,
10622                                                   TREE_TYPE (arg0), arg0));
10623
10624       /* bool_var == 0 becomes !bool_var. */
10625       if (TREE_CODE (TREE_TYPE (arg0)) == BOOLEAN_TYPE && integer_zerop (arg1)
10626           && code == EQ_EXPR)
10627         return fold_convert_loc (loc, type,
10628                                  fold_build1_loc (loc, TRUTH_NOT_EXPR,
10629                                                   TREE_TYPE (arg0), arg0));
10630
10631       /* !exp != 0 becomes !exp */
10632       if (TREE_CODE (arg0) == TRUTH_NOT_EXPR && integer_zerop (arg1)
10633           && code == NE_EXPR)
10634         return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
10635
10636       /* Transform comparisons of the form X +- Y CMP X to Y CMP 0.  */
10637       if ((TREE_CODE (arg0) == PLUS_EXPR
10638            || TREE_CODE (arg0) == POINTER_PLUS_EXPR
10639            || TREE_CODE (arg0) == MINUS_EXPR)
10640           && operand_equal_p (tree_strip_nop_conversions (TREE_OPERAND (arg0,
10641                                                                         0)),
10642                               arg1, 0)
10643           && (INTEGRAL_TYPE_P (TREE_TYPE (arg0))
10644               || POINTER_TYPE_P (TREE_TYPE (arg0))))
10645         {
10646           tree val = TREE_OPERAND (arg0, 1);
10647           return omit_two_operands_loc (loc, type,
10648                                     fold_build2_loc (loc, code, type,
10649                                                  val,
10650                                                  build_int_cst (TREE_TYPE (val),
10651                                                                 0)),
10652                                     TREE_OPERAND (arg0, 0), arg1);
10653         }
10654
10655       /* Transform comparisons of the form C - X CMP X if C % 2 == 1.  */
10656       if (TREE_CODE (arg0) == MINUS_EXPR
10657           && TREE_CODE (TREE_OPERAND (arg0, 0)) == INTEGER_CST
10658           && operand_equal_p (tree_strip_nop_conversions (TREE_OPERAND (arg0,
10659                                                                         1)),
10660                               arg1, 0)
10661           && wi::extract_uhwi (TREE_OPERAND (arg0, 0), 0, 1) == 1)
10662         {
10663           return omit_two_operands_loc (loc, type,
10664                                     code == NE_EXPR
10665                                     ? boolean_true_node : boolean_false_node,
10666                                     TREE_OPERAND (arg0, 1), arg1);
10667         }
10668
10669       /* If this is an EQ or NE comparison with zero and ARG0 is
10670          (1 << foo) & bar, convert it to (bar >> foo) & 1.  Both require
10671          two operations, but the latter can be done in one less insn
10672          on machines that have only two-operand insns or on which a
10673          constant cannot be the first operand.  */
10674       if (TREE_CODE (arg0) == BIT_AND_EXPR
10675           && integer_zerop (arg1))
10676         {
10677           tree arg00 = TREE_OPERAND (arg0, 0);
10678           tree arg01 = TREE_OPERAND (arg0, 1);
10679           if (TREE_CODE (arg00) == LSHIFT_EXPR
10680               && integer_onep (TREE_OPERAND (arg00, 0)))
10681             {
10682               tree tem = fold_build2_loc (loc, RSHIFT_EXPR, TREE_TYPE (arg00),
10683                                       arg01, TREE_OPERAND (arg00, 1));
10684               tem = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (arg0), tem,
10685                                  build_int_cst (TREE_TYPE (arg0), 1));
10686               return fold_build2_loc (loc, code, type,
10687                                   fold_convert_loc (loc, TREE_TYPE (arg1), tem),
10688                                   arg1);
10689             }
10690           else if (TREE_CODE (arg01) == LSHIFT_EXPR
10691                    && integer_onep (TREE_OPERAND (arg01, 0)))
10692             {
10693               tree tem = fold_build2_loc (loc, RSHIFT_EXPR, TREE_TYPE (arg01),
10694                                       arg00, TREE_OPERAND (arg01, 1));
10695               tem = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (arg0), tem,
10696                                  build_int_cst (TREE_TYPE (arg0), 1));
10697               return fold_build2_loc (loc, code, type,
10698                                   fold_convert_loc (loc, TREE_TYPE (arg1), tem),
10699                                   arg1);
10700             }
10701         }
10702
10703       /* If this is an NE or EQ comparison of zero against the result of a
10704          signed MOD operation whose second operand is a power of 2, make
10705          the MOD operation unsigned since it is simpler and equivalent.  */
10706       if (integer_zerop (arg1)
10707           && !TYPE_UNSIGNED (TREE_TYPE (arg0))
10708           && (TREE_CODE (arg0) == TRUNC_MOD_EXPR
10709               || TREE_CODE (arg0) == CEIL_MOD_EXPR
10710               || TREE_CODE (arg0) == FLOOR_MOD_EXPR
10711               || TREE_CODE (arg0) == ROUND_MOD_EXPR)
10712           && integer_pow2p (TREE_OPERAND (arg0, 1)))
10713         {
10714           tree newtype = unsigned_type_for (TREE_TYPE (arg0));
10715           tree newmod = fold_build2_loc (loc, TREE_CODE (arg0), newtype,
10716                                      fold_convert_loc (loc, newtype,
10717                                                        TREE_OPERAND (arg0, 0)),
10718                                      fold_convert_loc (loc, newtype,
10719                                                        TREE_OPERAND (arg0, 1)));
10720
10721           return fold_build2_loc (loc, code, type, newmod,
10722                               fold_convert_loc (loc, newtype, arg1));
10723         }
10724
10725       /* Fold ((X >> C1) & C2) == 0 and ((X >> C1) & C2) != 0 where
10726          C1 is a valid shift constant, and C2 is a power of two, i.e.
10727          a single bit.  */
10728       if (TREE_CODE (arg0) == BIT_AND_EXPR
10729           && TREE_CODE (TREE_OPERAND (arg0, 0)) == RSHIFT_EXPR
10730           && TREE_CODE (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1))
10731              == INTEGER_CST
10732           && integer_pow2p (TREE_OPERAND (arg0, 1))
10733           && integer_zerop (arg1))
10734         {
10735           tree itype = TREE_TYPE (arg0);
10736           tree arg001 = TREE_OPERAND (TREE_OPERAND (arg0, 0), 1);
10737           prec = TYPE_PRECISION (itype);
10738
10739           /* Check for a valid shift count.  */
10740           if (wi::ltu_p (arg001, prec))
10741             {
10742               tree arg01 = TREE_OPERAND (arg0, 1);
10743               tree arg000 = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
10744               unsigned HOST_WIDE_INT log2 = tree_log2 (arg01);
10745               /* If (C2 << C1) doesn't overflow, then ((X >> C1) & C2) != 0
10746                  can be rewritten as (X & (C2 << C1)) != 0.  */
10747               if ((log2 + TREE_INT_CST_LOW (arg001)) < prec)
10748                 {
10749                   tem = fold_build2_loc (loc, LSHIFT_EXPR, itype, arg01, arg001);
10750                   tem = fold_build2_loc (loc, BIT_AND_EXPR, itype, arg000, tem);
10751                   return fold_build2_loc (loc, code, type, tem,
10752                                           fold_convert_loc (loc, itype, arg1));
10753                 }
10754               /* Otherwise, for signed (arithmetic) shifts,
10755                  ((X >> C1) & C2) != 0 is rewritten as X < 0, and
10756                  ((X >> C1) & C2) == 0 is rewritten as X >= 0.  */
10757               else if (!TYPE_UNSIGNED (itype))
10758                 return fold_build2_loc (loc, code == EQ_EXPR ? GE_EXPR : LT_EXPR, type,
10759                                     arg000, build_int_cst (itype, 0));
10760               /* Otherwise, of unsigned (logical) shifts,
10761                  ((X >> C1) & C2) != 0 is rewritten as (X,false), and
10762                  ((X >> C1) & C2) == 0 is rewritten as (X,true).  */
10763               else
10764                 return omit_one_operand_loc (loc, type,
10765                                          code == EQ_EXPR ? integer_one_node
10766                                                          : integer_zero_node,
10767                                          arg000);
10768             }
10769         }
10770
10771       /* If we have (A & C) == D where D & ~C != 0, convert this into 0.
10772          Similarly for NE_EXPR.  */
10773       if (TREE_CODE (arg0) == BIT_AND_EXPR
10774           && TREE_CODE (arg1) == INTEGER_CST
10775           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
10776         {
10777           tree notc = fold_build1_loc (loc, BIT_NOT_EXPR,
10778                                    TREE_TYPE (TREE_OPERAND (arg0, 1)),
10779                                    TREE_OPERAND (arg0, 1));
10780           tree dandnotc
10781             = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (arg0),
10782                                fold_convert_loc (loc, TREE_TYPE (arg0), arg1),
10783                                notc);
10784           tree rslt = code == EQ_EXPR ? integer_zero_node : integer_one_node;
10785           if (integer_nonzerop (dandnotc))
10786             return omit_one_operand_loc (loc, type, rslt, arg0);
10787         }
10788
10789       /* If this is a comparison of a field, we may be able to simplify it.  */
10790       if ((TREE_CODE (arg0) == COMPONENT_REF
10791            || TREE_CODE (arg0) == BIT_FIELD_REF)
10792           /* Handle the constant case even without -O
10793              to make sure the warnings are given.  */
10794           && (optimize || TREE_CODE (arg1) == INTEGER_CST))
10795         {
10796           t1 = optimize_bit_field_compare (loc, code, type, arg0, arg1);
10797           if (t1)
10798             return t1;
10799         }
10800
10801       /* Optimize comparisons of strlen vs zero to a compare of the
10802          first character of the string vs zero.  To wit,
10803                 strlen(ptr) == 0   =>  *ptr == 0
10804                 strlen(ptr) != 0   =>  *ptr != 0
10805          Other cases should reduce to one of these two (or a constant)
10806          due to the return value of strlen being unsigned.  */
10807       if (TREE_CODE (arg0) == CALL_EXPR
10808           && integer_zerop (arg1))
10809         {
10810           tree fndecl = get_callee_fndecl (arg0);
10811
10812           if (fndecl
10813               && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
10814               && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_STRLEN
10815               && call_expr_nargs (arg0) == 1
10816               && TREE_CODE (TREE_TYPE (CALL_EXPR_ARG (arg0, 0))) == POINTER_TYPE)
10817             {
10818               tree iref = build_fold_indirect_ref_loc (loc,
10819                                                    CALL_EXPR_ARG (arg0, 0));
10820               return fold_build2_loc (loc, code, type, iref,
10821                                   build_int_cst (TREE_TYPE (iref), 0));
10822             }
10823         }
10824
10825       /* Fold (X >> C) != 0 into X < 0 if C is one less than the width
10826          of X.  Similarly fold (X >> C) == 0 into X >= 0.  */
10827       if (TREE_CODE (arg0) == RSHIFT_EXPR
10828           && integer_zerop (arg1)
10829           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
10830         {
10831           tree arg00 = TREE_OPERAND (arg0, 0);
10832           tree arg01 = TREE_OPERAND (arg0, 1);
10833           tree itype = TREE_TYPE (arg00);
10834           if (wi::eq_p (arg01, element_precision (itype) - 1))
10835             {
10836               if (TYPE_UNSIGNED (itype))
10837                 {
10838                   itype = signed_type_for (itype);
10839                   arg00 = fold_convert_loc (loc, itype, arg00);
10840                 }
10841               return fold_build2_loc (loc, code == EQ_EXPR ? GE_EXPR : LT_EXPR,
10842                                   type, arg00, build_zero_cst (itype));
10843             }
10844         }
10845
10846       /* Fold (~X & C) == 0 into (X & C) != 0 and (~X & C) != 0 into
10847          (X & C) == 0 when C is a single bit.  */
10848       if (TREE_CODE (arg0) == BIT_AND_EXPR
10849           && TREE_CODE (TREE_OPERAND (arg0, 0)) == BIT_NOT_EXPR
10850           && integer_zerop (arg1)
10851           && integer_pow2p (TREE_OPERAND (arg0, 1)))
10852         {
10853           tem = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (arg0),
10854                                  TREE_OPERAND (TREE_OPERAND (arg0, 0), 0),
10855                                  TREE_OPERAND (arg0, 1));
10856           return fold_build2_loc (loc, code == EQ_EXPR ? NE_EXPR : EQ_EXPR,
10857                                   type, tem,
10858                                   fold_convert_loc (loc, TREE_TYPE (arg0),
10859                                                     arg1));
10860         }
10861
10862       /* Fold ((X & C) ^ C) eq/ne 0 into (X & C) ne/eq 0, when the
10863          constant C is a power of two, i.e. a single bit.  */
10864       if (TREE_CODE (arg0) == BIT_XOR_EXPR
10865           && TREE_CODE (TREE_OPERAND (arg0, 0)) == BIT_AND_EXPR
10866           && integer_zerop (arg1)
10867           && integer_pow2p (TREE_OPERAND (arg0, 1))
10868           && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1),
10869                               TREE_OPERAND (arg0, 1), OEP_ONLY_CONST))
10870         {
10871           tree arg00 = TREE_OPERAND (arg0, 0);
10872           return fold_build2_loc (loc, code == EQ_EXPR ? NE_EXPR : EQ_EXPR, type,
10873                               arg00, build_int_cst (TREE_TYPE (arg00), 0));
10874         }
10875
10876       /* Likewise, fold ((X ^ C) & C) eq/ne 0 into (X & C) ne/eq 0,
10877          when is C is a power of two, i.e. a single bit.  */
10878       if (TREE_CODE (arg0) == BIT_AND_EXPR
10879           && TREE_CODE (TREE_OPERAND (arg0, 0)) == BIT_XOR_EXPR
10880           && integer_zerop (arg1)
10881           && integer_pow2p (TREE_OPERAND (arg0, 1))
10882           && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1),
10883                               TREE_OPERAND (arg0, 1), OEP_ONLY_CONST))
10884         {
10885           tree arg000 = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
10886           tem = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (arg000),
10887                              arg000, TREE_OPERAND (arg0, 1));
10888           return fold_build2_loc (loc, code == EQ_EXPR ? NE_EXPR : EQ_EXPR, type,
10889                               tem, build_int_cst (TREE_TYPE (tem), 0));
10890         }
10891
10892       if (integer_zerop (arg1)
10893           && tree_expr_nonzero_p (arg0))
10894         {
10895           tree res = constant_boolean_node (code==NE_EXPR, type);
10896           return omit_one_operand_loc (loc, type, res, arg0);
10897         }
10898
10899       /* Fold (X & C) op (Y & C) as (X ^ Y) & C op 0", and symmetries.  */
10900       if (TREE_CODE (arg0) == BIT_AND_EXPR
10901           && TREE_CODE (arg1) == BIT_AND_EXPR)
10902         {
10903           tree arg00 = TREE_OPERAND (arg0, 0);
10904           tree arg01 = TREE_OPERAND (arg0, 1);
10905           tree arg10 = TREE_OPERAND (arg1, 0);
10906           tree arg11 = TREE_OPERAND (arg1, 1);
10907           tree itype = TREE_TYPE (arg0);
10908
10909           if (operand_equal_p (arg01, arg11, 0))
10910             return fold_build2_loc (loc, code, type,
10911                                 fold_build2_loc (loc, BIT_AND_EXPR, itype,
10912                                              fold_build2_loc (loc,
10913                                                           BIT_XOR_EXPR, itype,
10914                                                           arg00, arg10),
10915                                              arg01),
10916                                 build_zero_cst (itype));
10917
10918           if (operand_equal_p (arg01, arg10, 0))
10919             return fold_build2_loc (loc, code, type,
10920                                 fold_build2_loc (loc, BIT_AND_EXPR, itype,
10921                                              fold_build2_loc (loc,
10922                                                           BIT_XOR_EXPR, itype,
10923                                                           arg00, arg11),
10924                                              arg01),
10925                                 build_zero_cst (itype));
10926
10927           if (operand_equal_p (arg00, arg11, 0))
10928             return fold_build2_loc (loc, code, type,
10929                                 fold_build2_loc (loc, BIT_AND_EXPR, itype,
10930                                              fold_build2_loc (loc,
10931                                                           BIT_XOR_EXPR, itype,
10932                                                           arg01, arg10),
10933                                              arg00),
10934                                 build_zero_cst (itype));
10935
10936           if (operand_equal_p (arg00, arg10, 0))
10937             return fold_build2_loc (loc, code, type,
10938                                 fold_build2_loc (loc, BIT_AND_EXPR, itype,
10939                                              fold_build2_loc (loc,
10940                                                           BIT_XOR_EXPR, itype,
10941                                                           arg01, arg11),
10942                                              arg00),
10943                                 build_zero_cst (itype));
10944         }
10945
10946       if (TREE_CODE (arg0) == BIT_XOR_EXPR
10947           && TREE_CODE (arg1) == BIT_XOR_EXPR)
10948         {
10949           tree arg00 = TREE_OPERAND (arg0, 0);
10950           tree arg01 = TREE_OPERAND (arg0, 1);
10951           tree arg10 = TREE_OPERAND (arg1, 0);
10952           tree arg11 = TREE_OPERAND (arg1, 1);
10953           tree itype = TREE_TYPE (arg0);
10954
10955           /* Optimize (X ^ Z) op (Y ^ Z) as X op Y, and symmetries.
10956              operand_equal_p guarantees no side-effects so we don't need
10957              to use omit_one_operand on Z.  */
10958           if (operand_equal_p (arg01, arg11, 0))
10959             return fold_build2_loc (loc, code, type, arg00,
10960                                     fold_convert_loc (loc, TREE_TYPE (arg00),
10961                                                       arg10));
10962           if (operand_equal_p (arg01, arg10, 0))
10963             return fold_build2_loc (loc, code, type, arg00,
10964                                     fold_convert_loc (loc, TREE_TYPE (arg00),
10965                                                       arg11));
10966           if (operand_equal_p (arg00, arg11, 0))
10967             return fold_build2_loc (loc, code, type, arg01,
10968                                     fold_convert_loc (loc, TREE_TYPE (arg01),
10969                                                       arg10));
10970           if (operand_equal_p (arg00, arg10, 0))
10971             return fold_build2_loc (loc, code, type, arg01,
10972                                     fold_convert_loc (loc, TREE_TYPE (arg01),
10973                                                       arg11));
10974
10975           /* Optimize (X ^ C1) op (Y ^ C2) as (X ^ (C1 ^ C2)) op Y.  */
10976           if (TREE_CODE (arg01) == INTEGER_CST
10977               && TREE_CODE (arg11) == INTEGER_CST)
10978             {
10979               tem = fold_build2_loc (loc, BIT_XOR_EXPR, itype, arg01,
10980                                      fold_convert_loc (loc, itype, arg11));
10981               tem = fold_build2_loc (loc, BIT_XOR_EXPR, itype, arg00, tem);
10982               return fold_build2_loc (loc, code, type, tem,
10983                                       fold_convert_loc (loc, itype, arg10));
10984             }
10985         }
10986
10987       /* Attempt to simplify equality/inequality comparisons of complex
10988          values.  Only lower the comparison if the result is known or
10989          can be simplified to a single scalar comparison.  */
10990       if ((TREE_CODE (arg0) == COMPLEX_EXPR
10991            || TREE_CODE (arg0) == COMPLEX_CST)
10992           && (TREE_CODE (arg1) == COMPLEX_EXPR
10993               || TREE_CODE (arg1) == COMPLEX_CST))
10994         {
10995           tree real0, imag0, real1, imag1;
10996           tree rcond, icond;
10997
10998           if (TREE_CODE (arg0) == COMPLEX_EXPR)
10999             {
11000               real0 = TREE_OPERAND (arg0, 0);
11001               imag0 = TREE_OPERAND (arg0, 1);
11002             }
11003           else
11004             {
11005               real0 = TREE_REALPART (arg0);
11006               imag0 = TREE_IMAGPART (arg0);
11007             }
11008
11009           if (TREE_CODE (arg1) == COMPLEX_EXPR)
11010             {
11011               real1 = TREE_OPERAND (arg1, 0);
11012               imag1 = TREE_OPERAND (arg1, 1);
11013             }
11014           else
11015             {
11016               real1 = TREE_REALPART (arg1);
11017               imag1 = TREE_IMAGPART (arg1);
11018             }
11019
11020           rcond = fold_binary_loc (loc, code, type, real0, real1);
11021           if (rcond && TREE_CODE (rcond) == INTEGER_CST)
11022             {
11023               if (integer_zerop (rcond))
11024                 {
11025                   if (code == EQ_EXPR)
11026                     return omit_two_operands_loc (loc, type, boolean_false_node,
11027                                               imag0, imag1);
11028                   return fold_build2_loc (loc, NE_EXPR, type, imag0, imag1);
11029                 }
11030               else
11031                 {
11032                   if (code == NE_EXPR)
11033                     return omit_two_operands_loc (loc, type, boolean_true_node,
11034                                               imag0, imag1);
11035                   return fold_build2_loc (loc, EQ_EXPR, type, imag0, imag1);
11036                 }
11037             }
11038
11039           icond = fold_binary_loc (loc, code, type, imag0, imag1);
11040           if (icond && TREE_CODE (icond) == INTEGER_CST)
11041             {
11042               if (integer_zerop (icond))
11043                 {
11044                   if (code == EQ_EXPR)
11045                     return omit_two_operands_loc (loc, type, boolean_false_node,
11046                                               real0, real1);
11047                   return fold_build2_loc (loc, NE_EXPR, type, real0, real1);
11048                 }
11049               else
11050                 {
11051                   if (code == NE_EXPR)
11052                     return omit_two_operands_loc (loc, type, boolean_true_node,
11053                                               real0, real1);
11054                   return fold_build2_loc (loc, EQ_EXPR, type, real0, real1);
11055                 }
11056             }
11057         }
11058
11059       return NULL_TREE;
11060
11061     case LT_EXPR:
11062     case GT_EXPR:
11063     case LE_EXPR:
11064     case GE_EXPR:
11065       tem = fold_comparison (loc, code, type, op0, op1);
11066       if (tem != NULL_TREE)
11067         return tem;
11068
11069       /* Transform comparisons of the form X +- C CMP X.  */
11070       if ((TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
11071           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
11072           && ((TREE_CODE (TREE_OPERAND (arg0, 1)) == REAL_CST
11073                && !HONOR_SNANS (arg0))
11074               || (TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
11075                   && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))))
11076         {
11077           tree arg01 = TREE_OPERAND (arg0, 1);
11078           enum tree_code code0 = TREE_CODE (arg0);
11079           int is_positive;
11080
11081           if (TREE_CODE (arg01) == REAL_CST)
11082             is_positive = REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg01)) ? -1 : 1;
11083           else
11084             is_positive = tree_int_cst_sgn (arg01);
11085
11086           /* (X - c) > X becomes false.  */
11087           if (code == GT_EXPR
11088               && ((code0 == MINUS_EXPR && is_positive >= 0)
11089                   || (code0 == PLUS_EXPR && is_positive <= 0)))
11090             {
11091               if (TREE_CODE (arg01) == INTEGER_CST
11092                   && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
11093                 fold_overflow_warning (("assuming signed overflow does not "
11094                                         "occur when assuming that (X - c) > X "
11095                                         "is always false"),
11096                                        WARN_STRICT_OVERFLOW_ALL);
11097               return constant_boolean_node (0, type);
11098             }
11099
11100           /* Likewise (X + c) < X becomes false.  */
11101           if (code == LT_EXPR
11102               && ((code0 == PLUS_EXPR && is_positive >= 0)
11103                   || (code0 == MINUS_EXPR && is_positive <= 0)))
11104             {
11105               if (TREE_CODE (arg01) == INTEGER_CST
11106                   && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
11107                 fold_overflow_warning (("assuming signed overflow does not "
11108                                         "occur when assuming that "
11109                                         "(X + c) < X is always false"),
11110                                        WARN_STRICT_OVERFLOW_ALL);
11111               return constant_boolean_node (0, type);
11112             }
11113
11114           /* Convert (X - c) <= X to true.  */
11115           if (!HONOR_NANS (arg1)
11116               && code == LE_EXPR
11117               && ((code0 == MINUS_EXPR && is_positive >= 0)
11118                   || (code0 == PLUS_EXPR && is_positive <= 0)))
11119             {
11120               if (TREE_CODE (arg01) == INTEGER_CST
11121                   && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
11122                 fold_overflow_warning (("assuming signed overflow does not "
11123                                         "occur when assuming that "
11124                                         "(X - c) <= X is always true"),
11125                                        WARN_STRICT_OVERFLOW_ALL);
11126               return constant_boolean_node (1, type);
11127             }
11128
11129           /* Convert (X + c) >= X to true.  */
11130           if (!HONOR_NANS (arg1)
11131               && code == GE_EXPR
11132               && ((code0 == PLUS_EXPR && is_positive >= 0)
11133                   || (code0 == MINUS_EXPR && is_positive <= 0)))
11134             {
11135               if (TREE_CODE (arg01) == INTEGER_CST
11136                   && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
11137                 fold_overflow_warning (("assuming signed overflow does not "
11138                                         "occur when assuming that "
11139                                         "(X + c) >= X is always true"),
11140                                        WARN_STRICT_OVERFLOW_ALL);
11141               return constant_boolean_node (1, type);
11142             }
11143
11144           if (TREE_CODE (arg01) == INTEGER_CST)
11145             {
11146               /* Convert X + c > X and X - c < X to true for integers.  */
11147               if (code == GT_EXPR
11148                   && ((code0 == PLUS_EXPR && is_positive > 0)
11149                       || (code0 == MINUS_EXPR && is_positive < 0)))
11150                 {
11151                   if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
11152                     fold_overflow_warning (("assuming signed overflow does "
11153                                             "not occur when assuming that "
11154                                             "(X + c) > X is always true"),
11155                                            WARN_STRICT_OVERFLOW_ALL);
11156                   return constant_boolean_node (1, type);
11157                 }
11158
11159               if (code == LT_EXPR
11160                   && ((code0 == MINUS_EXPR && is_positive > 0)
11161                       || (code0 == PLUS_EXPR && is_positive < 0)))
11162                 {
11163                   if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
11164                     fold_overflow_warning (("assuming signed overflow does "
11165                                             "not occur when assuming that "
11166                                             "(X - c) < X is always true"),
11167                                            WARN_STRICT_OVERFLOW_ALL);
11168                   return constant_boolean_node (1, type);
11169                 }
11170
11171               /* Convert X + c <= X and X - c >= X to false for integers.  */
11172               if (code == LE_EXPR
11173                   && ((code0 == PLUS_EXPR && is_positive > 0)
11174                       || (code0 == MINUS_EXPR && is_positive < 0)))
11175                 {
11176                   if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
11177                     fold_overflow_warning (("assuming signed overflow does "
11178                                             "not occur when assuming that "
11179                                             "(X + c) <= X is always false"),
11180                                            WARN_STRICT_OVERFLOW_ALL);
11181                   return constant_boolean_node (0, type);
11182                 }
11183
11184               if (code == GE_EXPR
11185                   && ((code0 == MINUS_EXPR && is_positive > 0)
11186                       || (code0 == PLUS_EXPR && is_positive < 0)))
11187                 {
11188                   if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
11189                     fold_overflow_warning (("assuming signed overflow does "
11190                                             "not occur when assuming that "
11191                                             "(X - c) >= X is always false"),
11192                                            WARN_STRICT_OVERFLOW_ALL);
11193                   return constant_boolean_node (0, type);
11194                 }
11195             }
11196         }
11197
11198       /* If we are comparing an ABS_EXPR with a constant, we can
11199          convert all the cases into explicit comparisons, but they may
11200          well not be faster than doing the ABS and one comparison.
11201          But ABS (X) <= C is a range comparison, which becomes a subtraction
11202          and a comparison, and is probably faster.  */
11203       if (code == LE_EXPR
11204           && TREE_CODE (arg1) == INTEGER_CST
11205           && TREE_CODE (arg0) == ABS_EXPR
11206           && ! TREE_SIDE_EFFECTS (arg0)
11207           && (0 != (tem = negate_expr (arg1)))
11208           && TREE_CODE (tem) == INTEGER_CST
11209           && !TREE_OVERFLOW (tem))
11210         return fold_build2_loc (loc, TRUTH_ANDIF_EXPR, type,
11211                             build2 (GE_EXPR, type,
11212                                     TREE_OPERAND (arg0, 0), tem),
11213                             build2 (LE_EXPR, type,
11214                                     TREE_OPERAND (arg0, 0), arg1));
11215
11216       /* Convert ABS_EXPR<x> >= 0 to true.  */
11217       strict_overflow_p = false;
11218       if (code == GE_EXPR
11219           && (integer_zerop (arg1)
11220               || (! HONOR_NANS (arg0)
11221                   && real_zerop (arg1)))
11222           && tree_expr_nonnegative_warnv_p (arg0, &strict_overflow_p))
11223         {
11224           if (strict_overflow_p)
11225             fold_overflow_warning (("assuming signed overflow does not occur "
11226                                     "when simplifying comparison of "
11227                                     "absolute value and zero"),
11228                                    WARN_STRICT_OVERFLOW_CONDITIONAL);
11229           return omit_one_operand_loc (loc, type,
11230                                        constant_boolean_node (true, type),
11231                                        arg0);
11232         }
11233
11234       /* Convert ABS_EXPR<x> < 0 to false.  */
11235       strict_overflow_p = false;
11236       if (code == LT_EXPR
11237           && (integer_zerop (arg1) || real_zerop (arg1))
11238           && tree_expr_nonnegative_warnv_p (arg0, &strict_overflow_p))
11239         {
11240           if (strict_overflow_p)
11241             fold_overflow_warning (("assuming signed overflow does not occur "
11242                                     "when simplifying comparison of "
11243                                     "absolute value and zero"),
11244                                    WARN_STRICT_OVERFLOW_CONDITIONAL);
11245           return omit_one_operand_loc (loc, type,
11246                                        constant_boolean_node (false, type),
11247                                        arg0);
11248         }
11249
11250       /* If X is unsigned, convert X < (1 << Y) into X >> Y == 0
11251          and similarly for >= into !=.  */
11252       if ((code == LT_EXPR || code == GE_EXPR)
11253           && TYPE_UNSIGNED (TREE_TYPE (arg0))
11254           && TREE_CODE (arg1) == LSHIFT_EXPR
11255           && integer_onep (TREE_OPERAND (arg1, 0)))
11256         return build2_loc (loc, code == LT_EXPR ? EQ_EXPR : NE_EXPR, type,
11257                            build2 (RSHIFT_EXPR, TREE_TYPE (arg0), arg0,
11258                                    TREE_OPERAND (arg1, 1)),
11259                            build_zero_cst (TREE_TYPE (arg0)));
11260
11261       /* Similarly for X < (cast) (1 << Y).  But cast can't be narrowing,
11262          otherwise Y might be >= # of bits in X's type and thus e.g.
11263          (unsigned char) (1 << Y) for Y 15 might be 0.
11264          If the cast is widening, then 1 << Y should have unsigned type,
11265          otherwise if Y is number of bits in the signed shift type minus 1,
11266          we can't optimize this.  E.g. (unsigned long long) (1 << Y) for Y
11267          31 might be 0xffffffff80000000.  */
11268       if ((code == LT_EXPR || code == GE_EXPR)
11269           && TYPE_UNSIGNED (TREE_TYPE (arg0))
11270           && CONVERT_EXPR_P (arg1)
11271           && TREE_CODE (TREE_OPERAND (arg1, 0)) == LSHIFT_EXPR
11272           && (element_precision (TREE_TYPE (arg1))
11273               >= element_precision (TREE_TYPE (TREE_OPERAND (arg1, 0))))
11274           && (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg1, 0)))
11275               || (element_precision (TREE_TYPE (arg1))
11276                   == element_precision (TREE_TYPE (TREE_OPERAND (arg1, 0)))))
11277           && integer_onep (TREE_OPERAND (TREE_OPERAND (arg1, 0), 0)))
11278         {
11279           tem = build2 (RSHIFT_EXPR, TREE_TYPE (arg0), arg0,
11280                         TREE_OPERAND (TREE_OPERAND (arg1, 0), 1));
11281           return build2_loc (loc, code == LT_EXPR ? EQ_EXPR : NE_EXPR, type,
11282                              fold_convert_loc (loc, TREE_TYPE (arg0), tem),
11283                              build_zero_cst (TREE_TYPE (arg0)));
11284         }
11285
11286       return NULL_TREE;
11287
11288     case UNORDERED_EXPR:
11289     case ORDERED_EXPR:
11290     case UNLT_EXPR:
11291     case UNLE_EXPR:
11292     case UNGT_EXPR:
11293     case UNGE_EXPR:
11294     case UNEQ_EXPR:
11295     case LTGT_EXPR:
11296       /* Fold (double)float1 CMP (double)float2 into float1 CMP float2.  */
11297       {
11298         tree targ0 = strip_float_extensions (arg0);
11299         tree targ1 = strip_float_extensions (arg1);
11300         tree newtype = TREE_TYPE (targ0);
11301
11302         if (TYPE_PRECISION (TREE_TYPE (targ1)) > TYPE_PRECISION (newtype))
11303           newtype = TREE_TYPE (targ1);
11304
11305         if (TYPE_PRECISION (newtype) < TYPE_PRECISION (TREE_TYPE (arg0)))
11306           return fold_build2_loc (loc, code, type,
11307                               fold_convert_loc (loc, newtype, targ0),
11308                               fold_convert_loc (loc, newtype, targ1));
11309       }
11310
11311       return NULL_TREE;
11312
11313     case COMPOUND_EXPR:
11314       /* When pedantic, a compound expression can be neither an lvalue
11315          nor an integer constant expression.  */
11316       if (TREE_SIDE_EFFECTS (arg0) || TREE_CONSTANT (arg1))
11317         return NULL_TREE;
11318       /* Don't let (0, 0) be null pointer constant.  */
11319       tem = integer_zerop (arg1) ? build1 (NOP_EXPR, type, arg1)
11320                                  : fold_convert_loc (loc, type, arg1);
11321       return pedantic_non_lvalue_loc (loc, tem);
11322
11323     case ASSERT_EXPR:
11324       /* An ASSERT_EXPR should never be passed to fold_binary.  */
11325       gcc_unreachable ();
11326
11327     default:
11328       return NULL_TREE;
11329     } /* switch (code) */
11330 }
11331
11332 /* Callback for walk_tree, looking for LABEL_EXPR.  Return *TP if it is
11333    a LABEL_EXPR; otherwise return NULL_TREE.  Do not check the subtrees
11334    of GOTO_EXPR.  */
11335
11336 static tree
11337 contains_label_1 (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
11338 {
11339   switch (TREE_CODE (*tp))
11340     {
11341     case LABEL_EXPR:
11342       return *tp;
11343
11344     case GOTO_EXPR:
11345       *walk_subtrees = 0;
11346
11347       /* ... fall through ...  */
11348
11349     default:
11350       return NULL_TREE;
11351     }
11352 }
11353
11354 /* Return whether the sub-tree ST contains a label which is accessible from
11355    outside the sub-tree.  */
11356
11357 static bool
11358 contains_label_p (tree st)
11359 {
11360   return
11361    (walk_tree_without_duplicates (&st, contains_label_1 , NULL) != NULL_TREE);
11362 }
11363
11364 /* Fold a ternary expression of code CODE and type TYPE with operands
11365    OP0, OP1, and OP2.  Return the folded expression if folding is
11366    successful.  Otherwise, return NULL_TREE.  */
11367
11368 tree
11369 fold_ternary_loc (location_t loc, enum tree_code code, tree type,
11370                   tree op0, tree op1, tree op2)
11371 {
11372   tree tem;
11373   tree arg0 = NULL_TREE, arg1 = NULL_TREE, arg2 = NULL_TREE;
11374   enum tree_code_class kind = TREE_CODE_CLASS (code);
11375
11376   gcc_assert (IS_EXPR_CODE_CLASS (kind)
11377               && TREE_CODE_LENGTH (code) == 3);
11378
11379   /* If this is a commutative operation, and OP0 is a constant, move it
11380      to OP1 to reduce the number of tests below.  */
11381   if (commutative_ternary_tree_code (code)
11382       && tree_swap_operands_p (op0, op1, true))
11383     return fold_build3_loc (loc, code, type, op1, op0, op2);
11384
11385   tem = generic_simplify (loc, code, type, op0, op1, op2);
11386   if (tem)
11387     return tem;
11388
11389   /* Strip any conversions that don't change the mode.  This is safe
11390      for every expression, except for a comparison expression because
11391      its signedness is derived from its operands.  So, in the latter
11392      case, only strip conversions that don't change the signedness.
11393
11394      Note that this is done as an internal manipulation within the
11395      constant folder, in order to find the simplest representation of
11396      the arguments so that their form can be studied.  In any cases,
11397      the appropriate type conversions should be put back in the tree
11398      that will get out of the constant folder.  */
11399   if (op0)
11400     {
11401       arg0 = op0;
11402       STRIP_NOPS (arg0);
11403     }
11404
11405   if (op1)
11406     {
11407       arg1 = op1;
11408       STRIP_NOPS (arg1);
11409     }
11410
11411   if (op2)
11412     {
11413       arg2 = op2;
11414       STRIP_NOPS (arg2);
11415     }
11416
11417   switch (code)
11418     {
11419     case COMPONENT_REF:
11420       if (TREE_CODE (arg0) == CONSTRUCTOR
11421           && ! type_contains_placeholder_p (TREE_TYPE (arg0)))
11422         {
11423           unsigned HOST_WIDE_INT idx;
11424           tree field, value;
11425           FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (arg0), idx, field, value)
11426             if (field == arg1)
11427               return value;
11428         }
11429       return NULL_TREE;
11430
11431     case COND_EXPR:
11432     case VEC_COND_EXPR:
11433       /* Pedantic ANSI C says that a conditional expression is never an lvalue,
11434          so all simple results must be passed through pedantic_non_lvalue.  */
11435       if (TREE_CODE (arg0) == INTEGER_CST)
11436         {
11437           tree unused_op = integer_zerop (arg0) ? op1 : op2;
11438           tem = integer_zerop (arg0) ? op2 : op1;
11439           /* Only optimize constant conditions when the selected branch
11440              has the same type as the COND_EXPR.  This avoids optimizing
11441              away "c ? x : throw", where the throw has a void type.
11442              Avoid throwing away that operand which contains label.  */
11443           if ((!TREE_SIDE_EFFECTS (unused_op)
11444                || !contains_label_p (unused_op))
11445               && (! VOID_TYPE_P (TREE_TYPE (tem))
11446                   || VOID_TYPE_P (type)))
11447             return pedantic_non_lvalue_loc (loc, tem);
11448           return NULL_TREE;
11449         }
11450       else if (TREE_CODE (arg0) == VECTOR_CST)
11451         {
11452           if ((TREE_CODE (arg1) == VECTOR_CST
11453                || TREE_CODE (arg1) == CONSTRUCTOR)
11454               && (TREE_CODE (arg2) == VECTOR_CST
11455                   || TREE_CODE (arg2) == CONSTRUCTOR))
11456             {
11457               unsigned int nelts = TYPE_VECTOR_SUBPARTS (type), i;
11458               unsigned char *sel = XALLOCAVEC (unsigned char, nelts);
11459               gcc_assert (nelts == VECTOR_CST_NELTS (arg0));
11460               for (i = 0; i < nelts; i++)
11461                 {
11462                   tree val = VECTOR_CST_ELT (arg0, i);
11463                   if (integer_all_onesp (val))
11464                     sel[i] = i;
11465                   else if (integer_zerop (val))
11466                     sel[i] = nelts + i;
11467                   else /* Currently unreachable.  */
11468                     return NULL_TREE;
11469                 }
11470               tree t = fold_vec_perm (type, arg1, arg2, sel);
11471               if (t != NULL_TREE)
11472                 return t;
11473             }
11474         }
11475
11476       /* If we have A op B ? A : C, we may be able to convert this to a
11477          simpler expression, depending on the operation and the values
11478          of B and C.  Signed zeros prevent all of these transformations,
11479          for reasons given above each one.
11480
11481          Also try swapping the arguments and inverting the conditional.  */
11482       if (COMPARISON_CLASS_P (arg0)
11483           && operand_equal_for_comparison_p (TREE_OPERAND (arg0, 0),
11484                                              arg1, TREE_OPERAND (arg0, 1))
11485           && !HONOR_SIGNED_ZEROS (element_mode (arg1)))
11486         {
11487           tem = fold_cond_expr_with_comparison (loc, type, arg0, op1, op2);
11488           if (tem)
11489             return tem;
11490         }
11491
11492       if (COMPARISON_CLASS_P (arg0)
11493           && operand_equal_for_comparison_p (TREE_OPERAND (arg0, 0),
11494                                              op2,
11495                                              TREE_OPERAND (arg0, 1))
11496           && !HONOR_SIGNED_ZEROS (element_mode (op2)))
11497         {
11498           location_t loc0 = expr_location_or (arg0, loc);
11499           tem = fold_invert_truthvalue (loc0, arg0);
11500           if (tem && COMPARISON_CLASS_P (tem))
11501             {
11502               tem = fold_cond_expr_with_comparison (loc, type, tem, op2, op1);
11503               if (tem)
11504                 return tem;
11505             }
11506         }
11507
11508       /* If the second operand is simpler than the third, swap them
11509          since that produces better jump optimization results.  */
11510       if (truth_value_p (TREE_CODE (arg0))
11511           && tree_swap_operands_p (op1, op2, false))
11512         {
11513           location_t loc0 = expr_location_or (arg0, loc);
11514           /* See if this can be inverted.  If it can't, possibly because
11515              it was a floating-point inequality comparison, don't do
11516              anything.  */
11517           tem = fold_invert_truthvalue (loc0, arg0);
11518           if (tem)
11519             return fold_build3_loc (loc, code, type, tem, op2, op1);
11520         }
11521
11522       /* Convert A ? 1 : 0 to simply A.  */
11523       if ((code == VEC_COND_EXPR ? integer_all_onesp (op1)
11524                                  : (integer_onep (op1)
11525                                     && !VECTOR_TYPE_P (type)))
11526           && integer_zerop (op2)
11527           /* If we try to convert OP0 to our type, the
11528              call to fold will try to move the conversion inside
11529              a COND, which will recurse.  In that case, the COND_EXPR
11530              is probably the best choice, so leave it alone.  */
11531           && type == TREE_TYPE (arg0))
11532         return pedantic_non_lvalue_loc (loc, arg0);
11533
11534       /* Convert A ? 0 : 1 to !A.  This prefers the use of NOT_EXPR
11535          over COND_EXPR in cases such as floating point comparisons.  */
11536       if (integer_zerop (op1)
11537           && (code == VEC_COND_EXPR ? integer_all_onesp (op2)
11538                                     : (integer_onep (op2)
11539                                        && !VECTOR_TYPE_P (type)))
11540           && truth_value_p (TREE_CODE (arg0)))
11541         return pedantic_non_lvalue_loc (loc,
11542                                     fold_convert_loc (loc, type,
11543                                               invert_truthvalue_loc (loc,
11544                                                                      arg0)));
11545
11546       /* A < 0 ? <sign bit of A> : 0 is simply (A & <sign bit of A>).  */
11547       if (TREE_CODE (arg0) == LT_EXPR
11548           && integer_zerop (TREE_OPERAND (arg0, 1))
11549           && integer_zerop (op2)
11550           && (tem = sign_bit_p (TREE_OPERAND (arg0, 0), arg1)))
11551         {
11552           /* sign_bit_p looks through both zero and sign extensions,
11553              but for this optimization only sign extensions are
11554              usable.  */
11555           tree tem2 = TREE_OPERAND (arg0, 0);
11556           while (tem != tem2)
11557             {
11558               if (TREE_CODE (tem2) != NOP_EXPR
11559                   || TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (tem2, 0))))
11560                 {
11561                   tem = NULL_TREE;
11562                   break;
11563                 }
11564               tem2 = TREE_OPERAND (tem2, 0);
11565             }
11566           /* sign_bit_p only checks ARG1 bits within A's precision.
11567              If <sign bit of A> has wider type than A, bits outside
11568              of A's precision in <sign bit of A> need to be checked.
11569              If they are all 0, this optimization needs to be done
11570              in unsigned A's type, if they are all 1 in signed A's type,
11571              otherwise this can't be done.  */
11572           if (tem
11573               && TYPE_PRECISION (TREE_TYPE (tem))
11574                  < TYPE_PRECISION (TREE_TYPE (arg1))
11575               && TYPE_PRECISION (TREE_TYPE (tem))
11576                  < TYPE_PRECISION (type))
11577             {
11578               int inner_width, outer_width;
11579               tree tem_type;
11580
11581               inner_width = TYPE_PRECISION (TREE_TYPE (tem));
11582               outer_width = TYPE_PRECISION (TREE_TYPE (arg1));
11583               if (outer_width > TYPE_PRECISION (type))
11584                 outer_width = TYPE_PRECISION (type);
11585
11586               wide_int mask = wi::shifted_mask
11587                 (inner_width, outer_width - inner_width, false,
11588                  TYPE_PRECISION (TREE_TYPE (arg1)));
11589
11590               wide_int common = mask & arg1;
11591               if (common == mask)
11592                 {
11593                   tem_type = signed_type_for (TREE_TYPE (tem));
11594                   tem = fold_convert_loc (loc, tem_type, tem);
11595                 }
11596               else if (common == 0)
11597                 {
11598                   tem_type = unsigned_type_for (TREE_TYPE (tem));
11599                   tem = fold_convert_loc (loc, tem_type, tem);
11600                 }
11601               else
11602                 tem = NULL;
11603             }
11604
11605           if (tem)
11606             return
11607               fold_convert_loc (loc, type,
11608                                 fold_build2_loc (loc, BIT_AND_EXPR,
11609                                              TREE_TYPE (tem), tem,
11610                                              fold_convert_loc (loc,
11611                                                                TREE_TYPE (tem),
11612                                                                arg1)));
11613         }
11614
11615       /* (A >> N) & 1 ? (1 << N) : 0 is simply A & (1 << N).  A & 1 was
11616          already handled above.  */
11617       if (TREE_CODE (arg0) == BIT_AND_EXPR
11618           && integer_onep (TREE_OPERAND (arg0, 1))
11619           && integer_zerop (op2)
11620           && integer_pow2p (arg1))
11621         {
11622           tree tem = TREE_OPERAND (arg0, 0);
11623           STRIP_NOPS (tem);
11624           if (TREE_CODE (tem) == RSHIFT_EXPR
11625               && tree_fits_uhwi_p (TREE_OPERAND (tem, 1))
11626               && (unsigned HOST_WIDE_INT) tree_log2 (arg1) ==
11627                  tree_to_uhwi (TREE_OPERAND (tem, 1)))
11628             return fold_build2_loc (loc, BIT_AND_EXPR, type,
11629                                 TREE_OPERAND (tem, 0), arg1);
11630         }
11631
11632       /* A & N ? N : 0 is simply A & N if N is a power of two.  This
11633          is probably obsolete because the first operand should be a
11634          truth value (that's why we have the two cases above), but let's
11635          leave it in until we can confirm this for all front-ends.  */
11636       if (integer_zerop (op2)
11637           && TREE_CODE (arg0) == NE_EXPR
11638           && integer_zerop (TREE_OPERAND (arg0, 1))
11639           && integer_pow2p (arg1)
11640           && TREE_CODE (TREE_OPERAND (arg0, 0)) == BIT_AND_EXPR
11641           && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1),
11642                               arg1, OEP_ONLY_CONST))
11643         return pedantic_non_lvalue_loc (loc,
11644                                     fold_convert_loc (loc, type,
11645                                                       TREE_OPERAND (arg0, 0)));
11646
11647       /* Disable the transformations below for vectors, since
11648          fold_binary_op_with_conditional_arg may undo them immediately,
11649          yielding an infinite loop.  */
11650       if (code == VEC_COND_EXPR)
11651         return NULL_TREE;
11652
11653       /* Convert A ? B : 0 into A && B if A and B are truth values.  */
11654       if (integer_zerop (op2)
11655           && truth_value_p (TREE_CODE (arg0))
11656           && truth_value_p (TREE_CODE (arg1))
11657           && (code == VEC_COND_EXPR || !VECTOR_TYPE_P (type)))
11658         return fold_build2_loc (loc, code == VEC_COND_EXPR ? BIT_AND_EXPR
11659                                                            : TRUTH_ANDIF_EXPR,
11660                                 type, fold_convert_loc (loc, type, arg0), arg1);
11661
11662       /* Convert A ? B : 1 into !A || B if A and B are truth values.  */
11663       if (code == VEC_COND_EXPR ? integer_all_onesp (op2) : integer_onep (op2)
11664           && truth_value_p (TREE_CODE (arg0))
11665           && truth_value_p (TREE_CODE (arg1))
11666           && (code == VEC_COND_EXPR || !VECTOR_TYPE_P (type)))
11667         {
11668           location_t loc0 = expr_location_or (arg0, loc);
11669           /* Only perform transformation if ARG0 is easily inverted.  */
11670           tem = fold_invert_truthvalue (loc0, arg0);
11671           if (tem)
11672             return fold_build2_loc (loc, code == VEC_COND_EXPR
11673                                          ? BIT_IOR_EXPR
11674                                          : TRUTH_ORIF_EXPR,
11675                                     type, fold_convert_loc (loc, type, tem),
11676                                     arg1);
11677         }
11678
11679       /* Convert A ? 0 : B into !A && B if A and B are truth values.  */
11680       if (integer_zerop (arg1)
11681           && truth_value_p (TREE_CODE (arg0))
11682           && truth_value_p (TREE_CODE (op2))
11683           && (code == VEC_COND_EXPR || !VECTOR_TYPE_P (type)))
11684         {
11685           location_t loc0 = expr_location_or (arg0, loc);
11686           /* Only perform transformation if ARG0 is easily inverted.  */
11687           tem = fold_invert_truthvalue (loc0, arg0);
11688           if (tem)
11689             return fold_build2_loc (loc, code == VEC_COND_EXPR
11690                                          ? BIT_AND_EXPR : TRUTH_ANDIF_EXPR,
11691                                     type, fold_convert_loc (loc, type, tem),
11692                                     op2);
11693         }
11694
11695       /* Convert A ? 1 : B into A || B if A and B are truth values.  */
11696       if (code == VEC_COND_EXPR ? integer_all_onesp (arg1) : integer_onep (arg1)
11697           && truth_value_p (TREE_CODE (arg0))
11698           && truth_value_p (TREE_CODE (op2))
11699           && (code == VEC_COND_EXPR || !VECTOR_TYPE_P (type)))
11700         return fold_build2_loc (loc, code == VEC_COND_EXPR
11701                                      ? BIT_IOR_EXPR : TRUTH_ORIF_EXPR,
11702                                 type, fold_convert_loc (loc, type, arg0), op2);
11703
11704       return NULL_TREE;
11705
11706     case CALL_EXPR:
11707       /* CALL_EXPRs used to be ternary exprs.  Catch any mistaken uses
11708          of fold_ternary on them.  */
11709       gcc_unreachable ();
11710
11711     case BIT_FIELD_REF:
11712       if ((TREE_CODE (arg0) == VECTOR_CST
11713            || (TREE_CODE (arg0) == CONSTRUCTOR
11714                && TREE_CODE (TREE_TYPE (arg0)) == VECTOR_TYPE))
11715           && (type == TREE_TYPE (TREE_TYPE (arg0))
11716               || (TREE_CODE (type) == VECTOR_TYPE
11717                   && TREE_TYPE (type) == TREE_TYPE (TREE_TYPE (arg0)))))
11718         {
11719           tree eltype = TREE_TYPE (TREE_TYPE (arg0));
11720           unsigned HOST_WIDE_INT width = tree_to_uhwi (TYPE_SIZE (eltype));
11721           unsigned HOST_WIDE_INT n = tree_to_uhwi (arg1);
11722           unsigned HOST_WIDE_INT idx = tree_to_uhwi (op2);
11723
11724           if (n != 0
11725               && (idx % width) == 0
11726               && (n % width) == 0
11727               && ((idx + n) / width) <= TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0)))
11728             {
11729               idx = idx / width;
11730               n = n / width;
11731
11732               if (TREE_CODE (arg0) == VECTOR_CST)
11733                 {
11734                   if (n == 1)
11735                     return VECTOR_CST_ELT (arg0, idx);
11736
11737                   tree *vals = XALLOCAVEC (tree, n);
11738                   for (unsigned i = 0; i < n; ++i)
11739                     vals[i] = VECTOR_CST_ELT (arg0, idx + i);
11740                   return build_vector (type, vals);
11741                 }
11742
11743               /* Constructor elements can be subvectors.  */
11744               unsigned HOST_WIDE_INT k = 1;
11745               if (CONSTRUCTOR_NELTS (arg0) != 0)
11746                 {
11747                   tree cons_elem = TREE_TYPE (CONSTRUCTOR_ELT (arg0, 0)->value);
11748                   if (TREE_CODE (cons_elem) == VECTOR_TYPE)
11749                     k = TYPE_VECTOR_SUBPARTS (cons_elem);
11750                 }
11751
11752               /* We keep an exact subset of the constructor elements.  */
11753               if ((idx % k) == 0 && (n % k) == 0)
11754                 {
11755                   if (CONSTRUCTOR_NELTS (arg0) == 0)
11756                     return build_constructor (type, NULL);
11757                   idx /= k;
11758                   n /= k;
11759                   if (n == 1)
11760                     {
11761                       if (idx < CONSTRUCTOR_NELTS (arg0))
11762                         return CONSTRUCTOR_ELT (arg0, idx)->value;
11763                       return build_zero_cst (type);
11764                     }
11765
11766                   vec<constructor_elt, va_gc> *vals;
11767                   vec_alloc (vals, n);
11768                   for (unsigned i = 0;
11769                        i < n && idx + i < CONSTRUCTOR_NELTS (arg0);
11770                        ++i)
11771                     CONSTRUCTOR_APPEND_ELT (vals, NULL_TREE,
11772                                             CONSTRUCTOR_ELT
11773                                               (arg0, idx + i)->value);
11774                   return build_constructor (type, vals);
11775                 }
11776               /* The bitfield references a single constructor element.  */
11777               else if (idx + n <= (idx / k + 1) * k)
11778                 {
11779                   if (CONSTRUCTOR_NELTS (arg0) <= idx / k)
11780                     return build_zero_cst (type);
11781                   else if (n == k)
11782                     return CONSTRUCTOR_ELT (arg0, idx / k)->value;
11783                   else
11784                     return fold_build3_loc (loc, code, type,
11785                       CONSTRUCTOR_ELT (arg0, idx / k)->value, op1,
11786                       build_int_cst (TREE_TYPE (op2), (idx % k) * width));
11787                 }
11788             }
11789         }
11790
11791       /* A bit-field-ref that referenced the full argument can be stripped.  */
11792       if (INTEGRAL_TYPE_P (TREE_TYPE (arg0))
11793           && TYPE_PRECISION (TREE_TYPE (arg0)) == tree_to_uhwi (arg1)
11794           && integer_zerop (op2))
11795         return fold_convert_loc (loc, type, arg0);
11796
11797       /* On constants we can use native encode/interpret to constant
11798          fold (nearly) all BIT_FIELD_REFs.  */
11799       if (CONSTANT_CLASS_P (arg0)
11800           && can_native_interpret_type_p (type)
11801           && tree_fits_uhwi_p (TYPE_SIZE_UNIT (TREE_TYPE (arg0)))
11802           /* This limitation should not be necessary, we just need to
11803              round this up to mode size.  */
11804           && tree_to_uhwi (op1) % BITS_PER_UNIT == 0
11805           /* Need bit-shifting of the buffer to relax the following.  */
11806           && tree_to_uhwi (op2) % BITS_PER_UNIT == 0)
11807         {
11808           unsigned HOST_WIDE_INT bitpos = tree_to_uhwi (op2);
11809           unsigned HOST_WIDE_INT bitsize = tree_to_uhwi (op1);
11810           unsigned HOST_WIDE_INT clen;
11811           clen = tree_to_uhwi (TYPE_SIZE_UNIT (TREE_TYPE (arg0)));
11812           /* ???  We cannot tell native_encode_expr to start at
11813              some random byte only.  So limit us to a reasonable amount
11814              of work.  */
11815           if (clen <= 4096)
11816             {
11817               unsigned char *b = XALLOCAVEC (unsigned char, clen);
11818               unsigned HOST_WIDE_INT len = native_encode_expr (arg0, b, clen);
11819               if (len > 0
11820                   && len * BITS_PER_UNIT >= bitpos + bitsize)
11821                 {
11822                   tree v = native_interpret_expr (type,
11823                                                   b + bitpos / BITS_PER_UNIT,
11824                                                   bitsize / BITS_PER_UNIT);
11825                   if (v)
11826                     return v;
11827                 }
11828             }
11829         }
11830
11831       return NULL_TREE;
11832
11833     case FMA_EXPR:
11834       /* For integers we can decompose the FMA if possible.  */
11835       if (TREE_CODE (arg0) == INTEGER_CST
11836           && TREE_CODE (arg1) == INTEGER_CST)
11837         return fold_build2_loc (loc, PLUS_EXPR, type,
11838                                 const_binop (MULT_EXPR, arg0, arg1), arg2);
11839       if (integer_zerop (arg2))
11840         return fold_build2_loc (loc, MULT_EXPR, type, arg0, arg1);
11841
11842       return fold_fma (loc, type, arg0, arg1, arg2);
11843
11844     case VEC_PERM_EXPR:
11845       if (TREE_CODE (arg2) == VECTOR_CST)
11846         {
11847           unsigned int nelts = TYPE_VECTOR_SUBPARTS (type), i, mask, mask2;
11848           unsigned char *sel = XALLOCAVEC (unsigned char, 2 * nelts);
11849           unsigned char *sel2 = sel + nelts;
11850           bool need_mask_canon = false;
11851           bool need_mask_canon2 = false;
11852           bool all_in_vec0 = true;
11853           bool all_in_vec1 = true;
11854           bool maybe_identity = true;
11855           bool single_arg = (op0 == op1);
11856           bool changed = false;
11857
11858           mask2 = 2 * nelts - 1;
11859           mask = single_arg ? (nelts - 1) : mask2;
11860           gcc_assert (nelts == VECTOR_CST_NELTS (arg2));
11861           for (i = 0; i < nelts; i++)
11862             {
11863               tree val = VECTOR_CST_ELT (arg2, i);
11864               if (TREE_CODE (val) != INTEGER_CST)
11865                 return NULL_TREE;
11866
11867               /* Make sure that the perm value is in an acceptable
11868                  range.  */
11869               wide_int t = val;
11870               need_mask_canon |= wi::gtu_p (t, mask);
11871               need_mask_canon2 |= wi::gtu_p (t, mask2);
11872               sel[i] = t.to_uhwi () & mask;
11873               sel2[i] = t.to_uhwi () & mask2;
11874
11875               if (sel[i] < nelts)
11876                 all_in_vec1 = false;
11877               else
11878                 all_in_vec0 = false;
11879
11880               if ((sel[i] & (nelts-1)) != i)
11881                 maybe_identity = false;
11882             }
11883
11884           if (maybe_identity)
11885             {
11886               if (all_in_vec0)
11887                 return op0;
11888               if (all_in_vec1)
11889                 return op1;
11890             }
11891
11892           if (all_in_vec0)
11893             op1 = op0;
11894           else if (all_in_vec1)
11895             {
11896               op0 = op1;
11897               for (i = 0; i < nelts; i++)
11898                 sel[i] -= nelts;
11899               need_mask_canon = true;
11900             }
11901
11902           if ((TREE_CODE (op0) == VECTOR_CST
11903                || TREE_CODE (op0) == CONSTRUCTOR)
11904               && (TREE_CODE (op1) == VECTOR_CST
11905                   || TREE_CODE (op1) == CONSTRUCTOR))
11906             {
11907               tree t = fold_vec_perm (type, op0, op1, sel);
11908               if (t != NULL_TREE)
11909                 return t;
11910             }
11911
11912           if (op0 == op1 && !single_arg)
11913             changed = true;
11914
11915           /* Some targets are deficient and fail to expand a single
11916              argument permutation while still allowing an equivalent
11917              2-argument version.  */
11918           if (need_mask_canon && arg2 == op2
11919               && !can_vec_perm_p (TYPE_MODE (type), false, sel)
11920               && can_vec_perm_p (TYPE_MODE (type), false, sel2))
11921             {
11922               need_mask_canon = need_mask_canon2;
11923               sel = sel2;
11924             }
11925
11926           if (need_mask_canon && arg2 == op2)
11927             {
11928               tree *tsel = XALLOCAVEC (tree, nelts);
11929               tree eltype = TREE_TYPE (TREE_TYPE (arg2));
11930               for (i = 0; i < nelts; i++)
11931                 tsel[i] = build_int_cst (eltype, sel[i]);
11932               op2 = build_vector (TREE_TYPE (arg2), tsel);
11933               changed = true;
11934             }
11935
11936           if (changed)
11937             return build3_loc (loc, VEC_PERM_EXPR, type, op0, op1, op2);
11938         }
11939       return NULL_TREE;
11940
11941     default:
11942       return NULL_TREE;
11943     } /* switch (code) */
11944 }
11945
11946 /* Perform constant folding and related simplification of EXPR.
11947    The related simplifications include x*1 => x, x*0 => 0, etc.,
11948    and application of the associative law.
11949    NOP_EXPR conversions may be removed freely (as long as we
11950    are careful not to change the type of the overall expression).
11951    We cannot simplify through a CONVERT_EXPR, FIX_EXPR or FLOAT_EXPR,
11952    but we can constant-fold them if they have constant operands.  */
11953
11954 #ifdef ENABLE_FOLD_CHECKING
11955 # define fold(x) fold_1 (x)
11956 static tree fold_1 (tree);
11957 static
11958 #endif
11959 tree
11960 fold (tree expr)
11961 {
11962   const tree t = expr;
11963   enum tree_code code = TREE_CODE (t);
11964   enum tree_code_class kind = TREE_CODE_CLASS (code);
11965   tree tem;
11966   location_t loc = EXPR_LOCATION (expr);
11967
11968   /* Return right away if a constant.  */
11969   if (kind == tcc_constant)
11970     return t;
11971
11972   /* CALL_EXPR-like objects with variable numbers of operands are
11973      treated specially.  */
11974   if (kind == tcc_vl_exp)
11975     {
11976       if (code == CALL_EXPR)
11977         {
11978           tem = fold_call_expr (loc, expr, false);
11979           return tem ? tem : expr;
11980         }
11981       return expr;
11982     }
11983
11984   if (IS_EXPR_CODE_CLASS (kind))
11985     {
11986       tree type = TREE_TYPE (t);
11987       tree op0, op1, op2;
11988
11989       switch (TREE_CODE_LENGTH (code))
11990         {
11991         case 1:
11992           op0 = TREE_OPERAND (t, 0);
11993           tem = fold_unary_loc (loc, code, type, op0);
11994           return tem ? tem : expr;
11995         case 2:
11996           op0 = TREE_OPERAND (t, 0);
11997           op1 = TREE_OPERAND (t, 1);
11998           tem = fold_binary_loc (loc, code, type, op0, op1);
11999           return tem ? tem : expr;
12000         case 3:
12001           op0 = TREE_OPERAND (t, 0);
12002           op1 = TREE_OPERAND (t, 1);
12003           op2 = TREE_OPERAND (t, 2);
12004           tem = fold_ternary_loc (loc, code, type, op0, op1, op2);
12005           return tem ? tem : expr;
12006         default:
12007           break;
12008         }
12009     }
12010
12011   switch (code)
12012     {
12013     case ARRAY_REF:
12014       {
12015         tree op0 = TREE_OPERAND (t, 0);
12016         tree op1 = TREE_OPERAND (t, 1);
12017
12018         if (TREE_CODE (op1) == INTEGER_CST
12019             && TREE_CODE (op0) == CONSTRUCTOR
12020             && ! type_contains_placeholder_p (TREE_TYPE (op0)))
12021           {
12022             vec<constructor_elt, va_gc> *elts = CONSTRUCTOR_ELTS (op0);
12023             unsigned HOST_WIDE_INT end = vec_safe_length (elts);
12024             unsigned HOST_WIDE_INT begin = 0;
12025
12026             /* Find a matching index by means of a binary search.  */
12027             while (begin != end)
12028               {
12029                 unsigned HOST_WIDE_INT middle = (begin + end) / 2;
12030                 tree index = (*elts)[middle].index;
12031
12032                 if (TREE_CODE (index) == INTEGER_CST
12033                     && tree_int_cst_lt (index, op1))
12034                   begin = middle + 1;
12035                 else if (TREE_CODE (index) == INTEGER_CST
12036                          && tree_int_cst_lt (op1, index))
12037                   end = middle;
12038                 else if (TREE_CODE (index) == RANGE_EXPR
12039                          && tree_int_cst_lt (TREE_OPERAND (index, 1), op1))
12040                   begin = middle + 1;
12041                 else if (TREE_CODE (index) == RANGE_EXPR
12042                          && tree_int_cst_lt (op1, TREE_OPERAND (index, 0)))
12043                   end = middle;
12044                 else
12045                   return (*elts)[middle].value;
12046               }
12047           }
12048
12049         return t;
12050       }
12051
12052       /* Return a VECTOR_CST if possible.  */
12053     case CONSTRUCTOR:
12054       {
12055         tree type = TREE_TYPE (t);
12056         if (TREE_CODE (type) != VECTOR_TYPE)
12057           return t;
12058
12059         tree *vec = XALLOCAVEC (tree, TYPE_VECTOR_SUBPARTS (type));
12060         unsigned HOST_WIDE_INT idx, pos = 0;
12061         tree value;
12062
12063         FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (t), idx, value)
12064           {
12065             if (!CONSTANT_CLASS_P (value))
12066               return t;
12067             if (TREE_CODE (value) == VECTOR_CST)
12068               {
12069                 for (unsigned i = 0; i < VECTOR_CST_NELTS (value); ++i)
12070                   vec[pos++] = VECTOR_CST_ELT (value, i);
12071               }
12072             else
12073               vec[pos++] = value;
12074           }
12075         for (; pos < TYPE_VECTOR_SUBPARTS (type); ++pos)
12076           vec[pos] = build_zero_cst (TREE_TYPE (type));
12077
12078         return build_vector (type, vec);
12079       }
12080
12081     case CONST_DECL:
12082       return fold (DECL_INITIAL (t));
12083
12084     default:
12085       return t;
12086     } /* switch (code) */
12087 }
12088
12089 #ifdef ENABLE_FOLD_CHECKING
12090 #undef fold
12091
12092 static void fold_checksum_tree (const_tree, struct md5_ctx *,
12093                                 hash_table<nofree_ptr_hash<const tree_node> > *);
12094 static void fold_check_failed (const_tree, const_tree);
12095 void print_fold_checksum (const_tree);
12096
12097 /* When --enable-checking=fold, compute a digest of expr before
12098    and after actual fold call to see if fold did not accidentally
12099    change original expr.  */
12100
12101 tree
12102 fold (tree expr)
12103 {
12104   tree ret;
12105   struct md5_ctx ctx;
12106   unsigned char checksum_before[16], checksum_after[16];
12107   hash_table<nofree_ptr_hash<const tree_node> > ht (32);
12108
12109   md5_init_ctx (&ctx);
12110   fold_checksum_tree (expr, &ctx, &ht);
12111   md5_finish_ctx (&ctx, checksum_before);
12112   ht.empty ();
12113
12114   ret = fold_1 (expr);
12115
12116   md5_init_ctx (&ctx);
12117   fold_checksum_tree (expr, &ctx, &ht);
12118   md5_finish_ctx (&ctx, checksum_after);
12119
12120   if (memcmp (checksum_before, checksum_after, 16))
12121     fold_check_failed (expr, ret);
12122
12123   return ret;
12124 }
12125
12126 void
12127 print_fold_checksum (const_tree expr)
12128 {
12129   struct md5_ctx ctx;
12130   unsigned char checksum[16], cnt;
12131   hash_table<nofree_ptr_hash<const tree_node> > ht (32);
12132
12133   md5_init_ctx (&ctx);
12134   fold_checksum_tree (expr, &ctx, &ht);
12135   md5_finish_ctx (&ctx, checksum);
12136   for (cnt = 0; cnt < 16; ++cnt)
12137     fprintf (stderr, "%02x", checksum[cnt]);
12138   putc ('\n', stderr);
12139 }
12140
12141 static void
12142 fold_check_failed (const_tree expr ATTRIBUTE_UNUSED, const_tree ret ATTRIBUTE_UNUSED)
12143 {
12144   internal_error ("fold check: original tree changed by fold");
12145 }
12146
12147 static void
12148 fold_checksum_tree (const_tree expr, struct md5_ctx *ctx,
12149                     hash_table<nofree_ptr_hash <const tree_node> > *ht)
12150 {
12151   const tree_node **slot;
12152   enum tree_code code;
12153   union tree_node buf;
12154   int i, len;
12155
12156  recursive_label:
12157   if (expr == NULL)
12158     return;
12159   slot = ht->find_slot (expr, INSERT);
12160   if (*slot != NULL)
12161     return;
12162   *slot = expr;
12163   code = TREE_CODE (expr);
12164   if (TREE_CODE_CLASS (code) == tcc_declaration
12165       && HAS_DECL_ASSEMBLER_NAME_P (expr))
12166     {
12167       /* Allow DECL_ASSEMBLER_NAME and symtab_node to be modified.  */
12168       memcpy ((char *) &buf, expr, tree_size (expr));
12169       SET_DECL_ASSEMBLER_NAME ((tree)&buf, NULL);
12170       buf.decl_with_vis.symtab_node = NULL;
12171       expr = (tree) &buf;
12172     }
12173   else if (TREE_CODE_CLASS (code) == tcc_type
12174            && (TYPE_POINTER_TO (expr)
12175                || TYPE_REFERENCE_TO (expr)
12176                || TYPE_CACHED_VALUES_P (expr)
12177                || TYPE_CONTAINS_PLACEHOLDER_INTERNAL (expr)
12178                || TYPE_NEXT_VARIANT (expr)))
12179     {
12180       /* Allow these fields to be modified.  */
12181       tree tmp;
12182       memcpy ((char *) &buf, expr, tree_size (expr));
12183       expr = tmp = (tree) &buf;
12184       TYPE_CONTAINS_PLACEHOLDER_INTERNAL (tmp) = 0;
12185       TYPE_POINTER_TO (tmp) = NULL;
12186       TYPE_REFERENCE_TO (tmp) = NULL;
12187       TYPE_NEXT_VARIANT (tmp) = NULL;
12188       if (TYPE_CACHED_VALUES_P (tmp))
12189         {
12190           TYPE_CACHED_VALUES_P (tmp) = 0;
12191           TYPE_CACHED_VALUES (tmp) = NULL;
12192         }
12193     }
12194   md5_process_bytes (expr, tree_size (expr), ctx);
12195   if (CODE_CONTAINS_STRUCT (code, TS_TYPED))
12196     fold_checksum_tree (TREE_TYPE (expr), ctx, ht);
12197   if (TREE_CODE_CLASS (code) != tcc_type
12198       && TREE_CODE_CLASS (code) != tcc_declaration
12199       && code != TREE_LIST
12200       && code != SSA_NAME
12201       && CODE_CONTAINS_STRUCT (code, TS_COMMON))
12202     fold_checksum_tree (TREE_CHAIN (expr), ctx, ht);
12203   switch (TREE_CODE_CLASS (code))
12204     {
12205     case tcc_constant:
12206       switch (code)
12207         {
12208         case STRING_CST:
12209           md5_process_bytes (TREE_STRING_POINTER (expr),
12210                              TREE_STRING_LENGTH (expr), ctx);
12211           break;
12212         case COMPLEX_CST:
12213           fold_checksum_tree (TREE_REALPART (expr), ctx, ht);
12214           fold_checksum_tree (TREE_IMAGPART (expr), ctx, ht);
12215           break;
12216         case VECTOR_CST:
12217           for (i = 0; i < (int) VECTOR_CST_NELTS (expr); ++i)
12218             fold_checksum_tree (VECTOR_CST_ELT (expr, i), ctx, ht);
12219           break;
12220         default:
12221           break;
12222         }
12223       break;
12224     case tcc_exceptional:
12225       switch (code)
12226         {
12227         case TREE_LIST:
12228           fold_checksum_tree (TREE_PURPOSE (expr), ctx, ht);
12229           fold_checksum_tree (TREE_VALUE (expr), ctx, ht);
12230           expr = TREE_CHAIN (expr);
12231           goto recursive_label;
12232           break;
12233         case TREE_VEC:
12234           for (i = 0; i < TREE_VEC_LENGTH (expr); ++i)
12235             fold_checksum_tree (TREE_VEC_ELT (expr, i), ctx, ht);
12236           break;
12237         default:
12238           break;
12239         }
12240       break;
12241     case tcc_expression:
12242     case tcc_reference:
12243     case tcc_comparison:
12244     case tcc_unary:
12245     case tcc_binary:
12246     case tcc_statement:
12247     case tcc_vl_exp:
12248       len = TREE_OPERAND_LENGTH (expr);
12249       for (i = 0; i < len; ++i)
12250         fold_checksum_tree (TREE_OPERAND (expr, i), ctx, ht);
12251       break;
12252     case tcc_declaration:
12253       fold_checksum_tree (DECL_NAME (expr), ctx, ht);
12254       fold_checksum_tree (DECL_CONTEXT (expr), ctx, ht);
12255       if (CODE_CONTAINS_STRUCT (TREE_CODE (expr), TS_DECL_COMMON))
12256         {
12257           fold_checksum_tree (DECL_SIZE (expr), ctx, ht);
12258           fold_checksum_tree (DECL_SIZE_UNIT (expr), ctx, ht);
12259           fold_checksum_tree (DECL_INITIAL (expr), ctx, ht);
12260           fold_checksum_tree (DECL_ABSTRACT_ORIGIN (expr), ctx, ht);
12261           fold_checksum_tree (DECL_ATTRIBUTES (expr), ctx, ht);
12262         }
12263
12264       if (CODE_CONTAINS_STRUCT (TREE_CODE (expr), TS_DECL_NON_COMMON))
12265         {
12266           if (TREE_CODE (expr) == FUNCTION_DECL)
12267             {
12268               fold_checksum_tree (DECL_VINDEX (expr), ctx, ht);
12269               fold_checksum_tree (DECL_ARGUMENTS (expr), ctx, ht);
12270             }
12271           fold_checksum_tree (DECL_RESULT_FLD (expr), ctx, ht);
12272         }
12273       break;
12274     case tcc_type:
12275       if (TREE_CODE (expr) == ENUMERAL_TYPE)
12276         fold_checksum_tree (TYPE_VALUES (expr), ctx, ht);
12277       fold_checksum_tree (TYPE_SIZE (expr), ctx, ht);
12278       fold_checksum_tree (TYPE_SIZE_UNIT (expr), ctx, ht);
12279       fold_checksum_tree (TYPE_ATTRIBUTES (expr), ctx, ht);
12280       fold_checksum_tree (TYPE_NAME (expr), ctx, ht);
12281       if (INTEGRAL_TYPE_P (expr)
12282           || SCALAR_FLOAT_TYPE_P (expr))
12283         {
12284           fold_checksum_tree (TYPE_MIN_VALUE (expr), ctx, ht);
12285           fold_checksum_tree (TYPE_MAX_VALUE (expr), ctx, ht);
12286         }
12287       fold_checksum_tree (TYPE_MAIN_VARIANT (expr), ctx, ht);
12288       if (TREE_CODE (expr) == RECORD_TYPE
12289           || TREE_CODE (expr) == UNION_TYPE
12290           || TREE_CODE (expr) == QUAL_UNION_TYPE)
12291         fold_checksum_tree (TYPE_BINFO (expr), ctx, ht);
12292       fold_checksum_tree (TYPE_CONTEXT (expr), ctx, ht);
12293       break;
12294     default:
12295       break;
12296     }
12297 }
12298
12299 /* Helper function for outputting the checksum of a tree T.  When
12300    debugging with gdb, you can "define mynext" to be "next" followed
12301    by "call debug_fold_checksum (op0)", then just trace down till the
12302    outputs differ.  */
12303
12304 DEBUG_FUNCTION void
12305 debug_fold_checksum (const_tree t)
12306 {
12307   int i;
12308   unsigned char checksum[16];
12309   struct md5_ctx ctx;
12310   hash_table<nofree_ptr_hash<const tree_node> > ht (32);
12311
12312   md5_init_ctx (&ctx);
12313   fold_checksum_tree (t, &ctx, &ht);
12314   md5_finish_ctx (&ctx, checksum);
12315   ht.empty ();
12316
12317   for (i = 0; i < 16; i++)
12318     fprintf (stderr, "%d ", checksum[i]);
12319
12320   fprintf (stderr, "\n");
12321 }
12322
12323 #endif
12324
12325 /* Fold a unary tree expression with code CODE of type TYPE with an
12326    operand OP0.  LOC is the location of the resulting expression.
12327    Return a folded expression if successful.  Otherwise, return a tree
12328    expression with code CODE of type TYPE with an operand OP0.  */
12329
12330 tree
12331 fold_build1_stat_loc (location_t loc,
12332                       enum tree_code code, tree type, tree op0 MEM_STAT_DECL)
12333 {
12334   tree tem;
12335 #ifdef ENABLE_FOLD_CHECKING
12336   unsigned char checksum_before[16], checksum_after[16];
12337   struct md5_ctx ctx;
12338   hash_table<nofree_ptr_hash<const tree_node> > ht (32);
12339
12340   md5_init_ctx (&ctx);
12341   fold_checksum_tree (op0, &ctx, &ht);
12342   md5_finish_ctx (&ctx, checksum_before);
12343   ht.empty ();
12344 #endif
12345
12346   tem = fold_unary_loc (loc, code, type, op0);
12347   if (!tem)
12348     tem = build1_stat_loc (loc, code, type, op0 PASS_MEM_STAT);
12349
12350 #ifdef ENABLE_FOLD_CHECKING
12351   md5_init_ctx (&ctx);
12352   fold_checksum_tree (op0, &ctx, &ht);
12353   md5_finish_ctx (&ctx, checksum_after);
12354
12355   if (memcmp (checksum_before, checksum_after, 16))
12356     fold_check_failed (op0, tem);
12357 #endif
12358   return tem;
12359 }
12360
12361 /* Fold a binary tree expression with code CODE of type TYPE with
12362    operands OP0 and OP1.  LOC is the location of the resulting
12363    expression.  Return a folded expression if successful.  Otherwise,
12364    return a tree expression with code CODE of type TYPE with operands
12365    OP0 and OP1.  */
12366
12367 tree
12368 fold_build2_stat_loc (location_t loc,
12369                       enum tree_code code, tree type, tree op0, tree op1
12370                       MEM_STAT_DECL)
12371 {
12372   tree tem;
12373 #ifdef ENABLE_FOLD_CHECKING
12374   unsigned char checksum_before_op0[16],
12375                 checksum_before_op1[16],
12376                 checksum_after_op0[16],
12377                 checksum_after_op1[16];
12378   struct md5_ctx ctx;
12379   hash_table<nofree_ptr_hash<const tree_node> > ht (32);
12380
12381   md5_init_ctx (&ctx);
12382   fold_checksum_tree (op0, &ctx, &ht);
12383   md5_finish_ctx (&ctx, checksum_before_op0);
12384   ht.empty ();
12385
12386   md5_init_ctx (&ctx);
12387   fold_checksum_tree (op1, &ctx, &ht);
12388   md5_finish_ctx (&ctx, checksum_before_op1);
12389   ht.empty ();
12390 #endif
12391
12392   tem = fold_binary_loc (loc, code, type, op0, op1);
12393   if (!tem)
12394     tem = build2_stat_loc (loc, code, type, op0, op1 PASS_MEM_STAT);
12395
12396 #ifdef ENABLE_FOLD_CHECKING
12397   md5_init_ctx (&ctx);
12398   fold_checksum_tree (op0, &ctx, &ht);
12399   md5_finish_ctx (&ctx, checksum_after_op0);
12400   ht.empty ();
12401
12402   if (memcmp (checksum_before_op0, checksum_after_op0, 16))
12403     fold_check_failed (op0, tem);
12404
12405   md5_init_ctx (&ctx);
12406   fold_checksum_tree (op1, &ctx, &ht);
12407   md5_finish_ctx (&ctx, checksum_after_op1);
12408
12409   if (memcmp (checksum_before_op1, checksum_after_op1, 16))
12410     fold_check_failed (op1, tem);
12411 #endif
12412   return tem;
12413 }
12414
12415 /* Fold a ternary tree expression with code CODE of type TYPE with
12416    operands OP0, OP1, and OP2.  Return a folded expression if
12417    successful.  Otherwise, return a tree expression with code CODE of
12418    type TYPE with operands OP0, OP1, and OP2.  */
12419
12420 tree
12421 fold_build3_stat_loc (location_t loc, enum tree_code code, tree type,
12422                       tree op0, tree op1, tree op2 MEM_STAT_DECL)
12423 {
12424   tree tem;
12425 #ifdef ENABLE_FOLD_CHECKING
12426   unsigned char checksum_before_op0[16],
12427                 checksum_before_op1[16],
12428                 checksum_before_op2[16],
12429                 checksum_after_op0[16],
12430                 checksum_after_op1[16],
12431                 checksum_after_op2[16];
12432   struct md5_ctx ctx;
12433   hash_table<nofree_ptr_hash<const tree_node> > ht (32);
12434
12435   md5_init_ctx (&ctx);
12436   fold_checksum_tree (op0, &ctx, &ht);
12437   md5_finish_ctx (&ctx, checksum_before_op0);
12438   ht.empty ();
12439
12440   md5_init_ctx (&ctx);
12441   fold_checksum_tree (op1, &ctx, &ht);
12442   md5_finish_ctx (&ctx, checksum_before_op1);
12443   ht.empty ();
12444
12445   md5_init_ctx (&ctx);
12446   fold_checksum_tree (op2, &ctx, &ht);
12447   md5_finish_ctx (&ctx, checksum_before_op2);
12448   ht.empty ();
12449 #endif
12450
12451   gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
12452   tem = fold_ternary_loc (loc, code, type, op0, op1, op2);
12453   if (!tem)
12454     tem = build3_stat_loc (loc, code, type, op0, op1, op2 PASS_MEM_STAT);
12455
12456 #ifdef ENABLE_FOLD_CHECKING
12457   md5_init_ctx (&ctx);
12458   fold_checksum_tree (op0, &ctx, &ht);
12459   md5_finish_ctx (&ctx, checksum_after_op0);
12460   ht.empty ();
12461
12462   if (memcmp (checksum_before_op0, checksum_after_op0, 16))
12463     fold_check_failed (op0, tem);
12464
12465   md5_init_ctx (&ctx);
12466   fold_checksum_tree (op1, &ctx, &ht);
12467   md5_finish_ctx (&ctx, checksum_after_op1);
12468   ht.empty ();
12469
12470   if (memcmp (checksum_before_op1, checksum_after_op1, 16))
12471     fold_check_failed (op1, tem);
12472
12473   md5_init_ctx (&ctx);
12474   fold_checksum_tree (op2, &ctx, &ht);
12475   md5_finish_ctx (&ctx, checksum_after_op2);
12476
12477   if (memcmp (checksum_before_op2, checksum_after_op2, 16))
12478     fold_check_failed (op2, tem);
12479 #endif
12480   return tem;
12481 }
12482
12483 /* Fold a CALL_EXPR expression of type TYPE with operands FN and NARGS
12484    arguments in ARGARRAY, and a null static chain.
12485    Return a folded expression if successful.  Otherwise, return a CALL_EXPR
12486    of type TYPE from the given operands as constructed by build_call_array.  */
12487
12488 tree
12489 fold_build_call_array_loc (location_t loc, tree type, tree fn,
12490                            int nargs, tree *argarray)
12491 {
12492   tree tem;
12493 #ifdef ENABLE_FOLD_CHECKING
12494   unsigned char checksum_before_fn[16],
12495                 checksum_before_arglist[16],
12496                 checksum_after_fn[16],
12497                 checksum_after_arglist[16];
12498   struct md5_ctx ctx;
12499   hash_table<nofree_ptr_hash<const tree_node> > ht (32);
12500   int i;
12501
12502   md5_init_ctx (&ctx);
12503   fold_checksum_tree (fn, &ctx, &ht);
12504   md5_finish_ctx (&ctx, checksum_before_fn);
12505   ht.empty ();
12506
12507   md5_init_ctx (&ctx);
12508   for (i = 0; i < nargs; i++)
12509     fold_checksum_tree (argarray[i], &ctx, &ht);
12510   md5_finish_ctx (&ctx, checksum_before_arglist);
12511   ht.empty ();
12512 #endif
12513
12514   tem = fold_builtin_call_array (loc, type, fn, nargs, argarray);
12515   if (!tem)
12516     tem = build_call_array_loc (loc, type, fn, nargs, argarray);
12517
12518 #ifdef ENABLE_FOLD_CHECKING
12519   md5_init_ctx (&ctx);
12520   fold_checksum_tree (fn, &ctx, &ht);
12521   md5_finish_ctx (&ctx, checksum_after_fn);
12522   ht.empty ();
12523
12524   if (memcmp (checksum_before_fn, checksum_after_fn, 16))
12525     fold_check_failed (fn, tem);
12526
12527   md5_init_ctx (&ctx);
12528   for (i = 0; i < nargs; i++)
12529     fold_checksum_tree (argarray[i], &ctx, &ht);
12530   md5_finish_ctx (&ctx, checksum_after_arglist);
12531
12532   if (memcmp (checksum_before_arglist, checksum_after_arglist, 16))
12533     fold_check_failed (NULL_TREE, tem);
12534 #endif
12535   return tem;
12536 }
12537
12538 /* Perform constant folding and related simplification of initializer
12539    expression EXPR.  These behave identically to "fold_buildN" but ignore
12540    potential run-time traps and exceptions that fold must preserve.  */
12541
12542 #define START_FOLD_INIT \
12543   int saved_signaling_nans = flag_signaling_nans;\
12544   int saved_trapping_math = flag_trapping_math;\
12545   int saved_rounding_math = flag_rounding_math;\
12546   int saved_trapv = flag_trapv;\
12547   int saved_folding_initializer = folding_initializer;\
12548   flag_signaling_nans = 0;\
12549   flag_trapping_math = 0;\
12550   flag_rounding_math = 0;\
12551   flag_trapv = 0;\
12552   folding_initializer = 1;
12553
12554 #define END_FOLD_INIT \
12555   flag_signaling_nans = saved_signaling_nans;\
12556   flag_trapping_math = saved_trapping_math;\
12557   flag_rounding_math = saved_rounding_math;\
12558   flag_trapv = saved_trapv;\
12559   folding_initializer = saved_folding_initializer;
12560
12561 tree
12562 fold_build1_initializer_loc (location_t loc, enum tree_code code,
12563                              tree type, tree op)
12564 {
12565   tree result;
12566   START_FOLD_INIT;
12567
12568   result = fold_build1_loc (loc, code, type, op);
12569
12570   END_FOLD_INIT;
12571   return result;
12572 }
12573
12574 tree
12575 fold_build2_initializer_loc (location_t loc, enum tree_code code,
12576                              tree type, tree op0, tree op1)
12577 {
12578   tree result;
12579   START_FOLD_INIT;
12580
12581   result = fold_build2_loc (loc, code, type, op0, op1);
12582
12583   END_FOLD_INIT;
12584   return result;
12585 }
12586
12587 tree
12588 fold_build_call_array_initializer_loc (location_t loc, tree type, tree fn,
12589                                        int nargs, tree *argarray)
12590 {
12591   tree result;
12592   START_FOLD_INIT;
12593
12594   result = fold_build_call_array_loc (loc, type, fn, nargs, argarray);
12595
12596   END_FOLD_INIT;
12597   return result;
12598 }
12599
12600 #undef START_FOLD_INIT
12601 #undef END_FOLD_INIT
12602
12603 /* Determine if first argument is a multiple of second argument.  Return 0 if
12604    it is not, or we cannot easily determined it to be.
12605
12606    An example of the sort of thing we care about (at this point; this routine
12607    could surely be made more general, and expanded to do what the *_DIV_EXPR's
12608    fold cases do now) is discovering that
12609
12610      SAVE_EXPR (I) * SAVE_EXPR (J * 8)
12611
12612    is a multiple of
12613
12614      SAVE_EXPR (J * 8)
12615
12616    when we know that the two SAVE_EXPR (J * 8) nodes are the same node.
12617
12618    This code also handles discovering that
12619
12620      SAVE_EXPR (I) * SAVE_EXPR (J * 8)
12621
12622    is a multiple of 8 so we don't have to worry about dealing with a
12623    possible remainder.
12624
12625    Note that we *look* inside a SAVE_EXPR only to determine how it was
12626    calculated; it is not safe for fold to do much of anything else with the
12627    internals of a SAVE_EXPR, since it cannot know when it will be evaluated
12628    at run time.  For example, the latter example above *cannot* be implemented
12629    as SAVE_EXPR (I) * J or any variant thereof, since the value of J at
12630    evaluation time of the original SAVE_EXPR is not necessarily the same at
12631    the time the new expression is evaluated.  The only optimization of this
12632    sort that would be valid is changing
12633
12634      SAVE_EXPR (I) * SAVE_EXPR (SAVE_EXPR (J) * 8)
12635
12636    divided by 8 to
12637
12638      SAVE_EXPR (I) * SAVE_EXPR (J)
12639
12640    (where the same SAVE_EXPR (J) is used in the original and the
12641    transformed version).  */
12642
12643 int
12644 multiple_of_p (tree type, const_tree top, const_tree bottom)
12645 {
12646   if (operand_equal_p (top, bottom, 0))
12647     return 1;
12648
12649   if (TREE_CODE (type) != INTEGER_TYPE)
12650     return 0;
12651
12652   switch (TREE_CODE (top))
12653     {
12654     case BIT_AND_EXPR:
12655       /* Bitwise and provides a power of two multiple.  If the mask is
12656          a multiple of BOTTOM then TOP is a multiple of BOTTOM.  */
12657       if (!integer_pow2p (bottom))
12658         return 0;
12659       /* FALLTHRU */
12660
12661     case MULT_EXPR:
12662       return (multiple_of_p (type, TREE_OPERAND (top, 0), bottom)
12663               || multiple_of_p (type, TREE_OPERAND (top, 1), bottom));
12664
12665     case PLUS_EXPR:
12666     case MINUS_EXPR:
12667       return (multiple_of_p (type, TREE_OPERAND (top, 0), bottom)
12668               && multiple_of_p (type, TREE_OPERAND (top, 1), bottom));
12669
12670     case LSHIFT_EXPR:
12671       if (TREE_CODE (TREE_OPERAND (top, 1)) == INTEGER_CST)
12672         {
12673           tree op1, t1;
12674
12675           op1 = TREE_OPERAND (top, 1);
12676           /* const_binop may not detect overflow correctly,
12677              so check for it explicitly here.  */
12678           if (wi::gtu_p (TYPE_PRECISION (TREE_TYPE (size_one_node)), op1)
12679               && 0 != (t1 = fold_convert (type,
12680                                           const_binop (LSHIFT_EXPR,
12681                                                        size_one_node,
12682                                                        op1)))
12683               && !TREE_OVERFLOW (t1))
12684             return multiple_of_p (type, t1, bottom);
12685         }
12686       return 0;
12687
12688     case NOP_EXPR:
12689       /* Can't handle conversions from non-integral or wider integral type.  */
12690       if ((TREE_CODE (TREE_TYPE (TREE_OPERAND (top, 0))) != INTEGER_TYPE)
12691           || (TYPE_PRECISION (type)
12692               < TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (top, 0)))))
12693         return 0;
12694
12695       /* .. fall through ...  */
12696
12697     case SAVE_EXPR:
12698       return multiple_of_p (type, TREE_OPERAND (top, 0), bottom);
12699
12700     case COND_EXPR:
12701       return (multiple_of_p (type, TREE_OPERAND (top, 1), bottom)
12702               && multiple_of_p (type, TREE_OPERAND (top, 2), bottom));
12703
12704     case INTEGER_CST:
12705       if (TREE_CODE (bottom) != INTEGER_CST
12706           || integer_zerop (bottom)
12707           || (TYPE_UNSIGNED (type)
12708               && (tree_int_cst_sgn (top) < 0
12709                   || tree_int_cst_sgn (bottom) < 0)))
12710         return 0;
12711       return wi::multiple_of_p (wi::to_widest (top), wi::to_widest (bottom),
12712                                 SIGNED);
12713
12714     default:
12715       return 0;
12716     }
12717 }
12718
12719 /* Return true if CODE or TYPE is known to be non-negative. */
12720
12721 static bool
12722 tree_simple_nonnegative_warnv_p (enum tree_code code, tree type)
12723 {
12724   if ((TYPE_PRECISION (type) != 1 || TYPE_UNSIGNED (type))
12725       && truth_value_p (code))
12726     /* Truth values evaluate to 0 or 1, which is nonnegative unless we
12727        have a signed:1 type (where the value is -1 and 0).  */
12728     return true;
12729   return false;
12730 }
12731
12732 /* Return true if (CODE OP0) is known to be non-negative.  If the return
12733    value is based on the assumption that signed overflow is undefined,
12734    set *STRICT_OVERFLOW_P to true; otherwise, don't change
12735    *STRICT_OVERFLOW_P.  */
12736
12737 bool
12738 tree_unary_nonnegative_warnv_p (enum tree_code code, tree type, tree op0,
12739                                 bool *strict_overflow_p)
12740 {
12741   if (TYPE_UNSIGNED (type))
12742     return true;
12743
12744   switch (code)
12745     {
12746     case ABS_EXPR:
12747       /* We can't return 1 if flag_wrapv is set because
12748          ABS_EXPR<INT_MIN> = INT_MIN.  */
12749       if (!ANY_INTEGRAL_TYPE_P (type))
12750         return true;
12751       if (TYPE_OVERFLOW_UNDEFINED (type))
12752         {
12753           *strict_overflow_p = true;
12754           return true;
12755         }
12756       break;
12757
12758     case NON_LVALUE_EXPR:
12759     case FLOAT_EXPR:
12760     case FIX_TRUNC_EXPR:
12761       return tree_expr_nonnegative_warnv_p (op0,
12762                                             strict_overflow_p);
12763
12764     CASE_CONVERT:
12765       {
12766         tree inner_type = TREE_TYPE (op0);
12767         tree outer_type = type;
12768
12769         if (TREE_CODE (outer_type) == REAL_TYPE)
12770           {
12771             if (TREE_CODE (inner_type) == REAL_TYPE)
12772               return tree_expr_nonnegative_warnv_p (op0,
12773                                                     strict_overflow_p);
12774             if (INTEGRAL_TYPE_P (inner_type))
12775               {
12776                 if (TYPE_UNSIGNED (inner_type))
12777                   return true;
12778                 return tree_expr_nonnegative_warnv_p (op0,
12779                                                       strict_overflow_p);
12780               }
12781           }
12782         else if (INTEGRAL_TYPE_P (outer_type))
12783           {
12784             if (TREE_CODE (inner_type) == REAL_TYPE)
12785               return tree_expr_nonnegative_warnv_p (op0,
12786                                                     strict_overflow_p);
12787             if (INTEGRAL_TYPE_P (inner_type))
12788               return TYPE_PRECISION (inner_type) < TYPE_PRECISION (outer_type)
12789                       && TYPE_UNSIGNED (inner_type);
12790           }
12791       }
12792       break;
12793
12794     default:
12795       return tree_simple_nonnegative_warnv_p (code, type);
12796     }
12797
12798   /* We don't know sign of `t', so be conservative and return false.  */
12799   return false;
12800 }
12801
12802 /* Return true if (CODE OP0 OP1) is known to be non-negative.  If the return
12803    value is based on the assumption that signed overflow is undefined,
12804    set *STRICT_OVERFLOW_P to true; otherwise, don't change
12805    *STRICT_OVERFLOW_P.  */
12806
12807 bool
12808 tree_binary_nonnegative_warnv_p (enum tree_code code, tree type, tree op0,
12809                                       tree op1, bool *strict_overflow_p)
12810 {
12811   if (TYPE_UNSIGNED (type))
12812     return true;
12813
12814   switch (code)
12815     {
12816     case POINTER_PLUS_EXPR:
12817     case PLUS_EXPR:
12818       if (FLOAT_TYPE_P (type))
12819         return (tree_expr_nonnegative_warnv_p (op0,
12820                                                strict_overflow_p)
12821                 && tree_expr_nonnegative_warnv_p (op1,
12822                                                   strict_overflow_p));
12823
12824       /* zero_extend(x) + zero_extend(y) is non-negative if x and y are
12825          both unsigned and at least 2 bits shorter than the result.  */
12826       if (TREE_CODE (type) == INTEGER_TYPE
12827           && TREE_CODE (op0) == NOP_EXPR
12828           && TREE_CODE (op1) == NOP_EXPR)
12829         {
12830           tree inner1 = TREE_TYPE (TREE_OPERAND (op0, 0));
12831           tree inner2 = TREE_TYPE (TREE_OPERAND (op1, 0));
12832           if (TREE_CODE (inner1) == INTEGER_TYPE && TYPE_UNSIGNED (inner1)
12833               && TREE_CODE (inner2) == INTEGER_TYPE && TYPE_UNSIGNED (inner2))
12834             {
12835               unsigned int prec = MAX (TYPE_PRECISION (inner1),
12836                                        TYPE_PRECISION (inner2)) + 1;
12837               return prec < TYPE_PRECISION (type);
12838             }
12839         }
12840       break;
12841
12842     case MULT_EXPR:
12843       if (FLOAT_TYPE_P (type) || TYPE_OVERFLOW_UNDEFINED (type))
12844         {
12845           /* x * x is always non-negative for floating point x
12846              or without overflow.  */
12847           if (operand_equal_p (op0, op1, 0)
12848               || (tree_expr_nonnegative_warnv_p (op0, strict_overflow_p)
12849                   && tree_expr_nonnegative_warnv_p (op1, strict_overflow_p)))
12850             {
12851               if (ANY_INTEGRAL_TYPE_P (type)
12852                   && TYPE_OVERFLOW_UNDEFINED (type))
12853                 *strict_overflow_p = true;
12854               return true;
12855             }
12856         }
12857
12858       /* zero_extend(x) * zero_extend(y) is non-negative if x and y are
12859          both unsigned and their total bits is shorter than the result.  */
12860       if (TREE_CODE (type) == INTEGER_TYPE
12861           && (TREE_CODE (op0) == NOP_EXPR || TREE_CODE (op0) == INTEGER_CST)
12862           && (TREE_CODE (op1) == NOP_EXPR || TREE_CODE (op1) == INTEGER_CST))
12863         {
12864           tree inner0 = (TREE_CODE (op0) == NOP_EXPR)
12865             ? TREE_TYPE (TREE_OPERAND (op0, 0))
12866             : TREE_TYPE (op0);
12867           tree inner1 = (TREE_CODE (op1) == NOP_EXPR)
12868             ? TREE_TYPE (TREE_OPERAND (op1, 0))
12869             : TREE_TYPE (op1);
12870
12871           bool unsigned0 = TYPE_UNSIGNED (inner0);
12872           bool unsigned1 = TYPE_UNSIGNED (inner1);
12873
12874           if (TREE_CODE (op0) == INTEGER_CST)
12875             unsigned0 = unsigned0 || tree_int_cst_sgn (op0) >= 0;
12876
12877           if (TREE_CODE (op1) == INTEGER_CST)
12878             unsigned1 = unsigned1 || tree_int_cst_sgn (op1) >= 0;
12879
12880           if (TREE_CODE (inner0) == INTEGER_TYPE && unsigned0
12881               && TREE_CODE (inner1) == INTEGER_TYPE && unsigned1)
12882             {
12883               unsigned int precision0 = (TREE_CODE (op0) == INTEGER_CST)
12884                 ? tree_int_cst_min_precision (op0, UNSIGNED)
12885                 : TYPE_PRECISION (inner0);
12886
12887               unsigned int precision1 = (TREE_CODE (op1) == INTEGER_CST)
12888                 ? tree_int_cst_min_precision (op1, UNSIGNED)
12889                 : TYPE_PRECISION (inner1);
12890
12891               return precision0 + precision1 < TYPE_PRECISION (type);
12892             }
12893         }
12894       return false;
12895
12896     case BIT_AND_EXPR:
12897     case MAX_EXPR:
12898       return (tree_expr_nonnegative_warnv_p (op0,
12899                                              strict_overflow_p)
12900               || tree_expr_nonnegative_warnv_p (op1,
12901                                                 strict_overflow_p));
12902
12903     case BIT_IOR_EXPR:
12904     case BIT_XOR_EXPR:
12905     case MIN_EXPR:
12906     case RDIV_EXPR:
12907     case TRUNC_DIV_EXPR:
12908     case CEIL_DIV_EXPR:
12909     case FLOOR_DIV_EXPR:
12910     case ROUND_DIV_EXPR:
12911       return (tree_expr_nonnegative_warnv_p (op0,
12912                                              strict_overflow_p)
12913               && tree_expr_nonnegative_warnv_p (op1,
12914                                                 strict_overflow_p));
12915
12916     case TRUNC_MOD_EXPR:
12917     case CEIL_MOD_EXPR:
12918     case FLOOR_MOD_EXPR:
12919     case ROUND_MOD_EXPR:
12920       return tree_expr_nonnegative_warnv_p (op0,
12921                                             strict_overflow_p);
12922     default:
12923       return tree_simple_nonnegative_warnv_p (code, type);
12924     }
12925
12926   /* We don't know sign of `t', so be conservative and return false.  */
12927   return false;
12928 }
12929
12930 /* Return true if T is known to be non-negative.  If the return
12931    value is based on the assumption that signed overflow is undefined,
12932    set *STRICT_OVERFLOW_P to true; otherwise, don't change
12933    *STRICT_OVERFLOW_P.  */
12934
12935 bool
12936 tree_single_nonnegative_warnv_p (tree t, bool *strict_overflow_p)
12937 {
12938   if (TYPE_UNSIGNED (TREE_TYPE (t)))
12939     return true;
12940
12941   switch (TREE_CODE (t))
12942     {
12943     case INTEGER_CST:
12944       return tree_int_cst_sgn (t) >= 0;
12945
12946     case REAL_CST:
12947       return ! REAL_VALUE_NEGATIVE (TREE_REAL_CST (t));
12948
12949     case FIXED_CST:
12950       return ! FIXED_VALUE_NEGATIVE (TREE_FIXED_CST (t));
12951
12952     case COND_EXPR:
12953       return (tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 1),
12954                                              strict_overflow_p)
12955               && tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 2),
12956                                                 strict_overflow_p));
12957     default:
12958       return tree_simple_nonnegative_warnv_p (TREE_CODE (t),
12959                                                    TREE_TYPE (t));
12960     }
12961   /* We don't know sign of `t', so be conservative and return false.  */
12962   return false;
12963 }
12964
12965 /* Return true if T is known to be non-negative.  If the return
12966    value is based on the assumption that signed overflow is undefined,
12967    set *STRICT_OVERFLOW_P to true; otherwise, don't change
12968    *STRICT_OVERFLOW_P.  */
12969
12970 bool
12971 tree_call_nonnegative_warnv_p (tree type, tree fndecl,
12972                                tree arg0, tree arg1, bool *strict_overflow_p)
12973 {
12974   if (fndecl && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL)
12975     switch (DECL_FUNCTION_CODE (fndecl))
12976       {
12977         CASE_FLT_FN (BUILT_IN_ACOS):
12978         CASE_FLT_FN (BUILT_IN_ACOSH):
12979         CASE_FLT_FN (BUILT_IN_CABS):
12980         CASE_FLT_FN (BUILT_IN_COSH):
12981         CASE_FLT_FN (BUILT_IN_ERFC):
12982         CASE_FLT_FN (BUILT_IN_EXP):
12983         CASE_FLT_FN (BUILT_IN_EXP10):
12984         CASE_FLT_FN (BUILT_IN_EXP2):
12985         CASE_FLT_FN (BUILT_IN_FABS):
12986         CASE_FLT_FN (BUILT_IN_FDIM):
12987         CASE_FLT_FN (BUILT_IN_HYPOT):
12988         CASE_FLT_FN (BUILT_IN_POW10):
12989         CASE_INT_FN (BUILT_IN_FFS):
12990         CASE_INT_FN (BUILT_IN_PARITY):
12991         CASE_INT_FN (BUILT_IN_POPCOUNT):
12992         CASE_INT_FN (BUILT_IN_CLZ):
12993         CASE_INT_FN (BUILT_IN_CLRSB):
12994       case BUILT_IN_BSWAP32:
12995       case BUILT_IN_BSWAP64:
12996         /* Always true.  */
12997         return true;
12998
12999         CASE_FLT_FN (BUILT_IN_SQRT):
13000         /* sqrt(-0.0) is -0.0.  */
13001         if (!HONOR_SIGNED_ZEROS (element_mode (type)))
13002           return true;
13003         return tree_expr_nonnegative_warnv_p (arg0,
13004                                               strict_overflow_p);
13005
13006         CASE_FLT_FN (BUILT_IN_ASINH):
13007         CASE_FLT_FN (BUILT_IN_ATAN):
13008         CASE_FLT_FN (BUILT_IN_ATANH):
13009         CASE_FLT_FN (BUILT_IN_CBRT):
13010         CASE_FLT_FN (BUILT_IN_CEIL):
13011         CASE_FLT_FN (BUILT_IN_ERF):
13012         CASE_FLT_FN (BUILT_IN_EXPM1):
13013         CASE_FLT_FN (BUILT_IN_FLOOR):
13014         CASE_FLT_FN (BUILT_IN_FMOD):
13015         CASE_FLT_FN (BUILT_IN_FREXP):
13016         CASE_FLT_FN (BUILT_IN_ICEIL):
13017         CASE_FLT_FN (BUILT_IN_IFLOOR):
13018         CASE_FLT_FN (BUILT_IN_IRINT):
13019         CASE_FLT_FN (BUILT_IN_IROUND):
13020         CASE_FLT_FN (BUILT_IN_LCEIL):
13021         CASE_FLT_FN (BUILT_IN_LDEXP):
13022         CASE_FLT_FN (BUILT_IN_LFLOOR):
13023         CASE_FLT_FN (BUILT_IN_LLCEIL):
13024         CASE_FLT_FN (BUILT_IN_LLFLOOR):
13025         CASE_FLT_FN (BUILT_IN_LLRINT):
13026         CASE_FLT_FN (BUILT_IN_LLROUND):
13027         CASE_FLT_FN (BUILT_IN_LRINT):
13028         CASE_FLT_FN (BUILT_IN_LROUND):
13029         CASE_FLT_FN (BUILT_IN_MODF):
13030         CASE_FLT_FN (BUILT_IN_NEARBYINT):
13031         CASE_FLT_FN (BUILT_IN_RINT):
13032         CASE_FLT_FN (BUILT_IN_ROUND):
13033         CASE_FLT_FN (BUILT_IN_SCALB):
13034         CASE_FLT_FN (BUILT_IN_SCALBLN):
13035         CASE_FLT_FN (BUILT_IN_SCALBN):
13036         CASE_FLT_FN (BUILT_IN_SIGNBIT):
13037         CASE_FLT_FN (BUILT_IN_SIGNIFICAND):
13038         CASE_FLT_FN (BUILT_IN_SINH):
13039         CASE_FLT_FN (BUILT_IN_TANH):
13040         CASE_FLT_FN (BUILT_IN_TRUNC):
13041         /* True if the 1st argument is nonnegative.  */
13042         return tree_expr_nonnegative_warnv_p (arg0,
13043                                               strict_overflow_p);
13044
13045         CASE_FLT_FN (BUILT_IN_FMAX):
13046         /* True if the 1st OR 2nd arguments are nonnegative.  */
13047         return (tree_expr_nonnegative_warnv_p (arg0,
13048                                                strict_overflow_p)
13049                 || (tree_expr_nonnegative_warnv_p (arg1,
13050                                                    strict_overflow_p)));
13051
13052         CASE_FLT_FN (BUILT_IN_FMIN):
13053         /* True if the 1st AND 2nd arguments are nonnegative.  */
13054         return (tree_expr_nonnegative_warnv_p (arg0,
13055                                                strict_overflow_p)
13056                 && (tree_expr_nonnegative_warnv_p (arg1,
13057                                                    strict_overflow_p)));
13058
13059         CASE_FLT_FN (BUILT_IN_COPYSIGN):
13060         /* True if the 2nd argument is nonnegative.  */
13061         return tree_expr_nonnegative_warnv_p (arg1,
13062                                               strict_overflow_p);
13063
13064         CASE_FLT_FN (BUILT_IN_POWI):
13065         /* True if the 1st argument is nonnegative or the second
13066            argument is an even integer.  */
13067         if (TREE_CODE (arg1) == INTEGER_CST
13068             && (TREE_INT_CST_LOW (arg1) & 1) == 0)
13069           return true;
13070         return tree_expr_nonnegative_warnv_p (arg0,
13071                                               strict_overflow_p);
13072
13073         CASE_FLT_FN (BUILT_IN_POW):
13074         /* True if the 1st argument is nonnegative or the second
13075            argument is an even integer valued real.  */
13076         if (TREE_CODE (arg1) == REAL_CST)
13077           {
13078             REAL_VALUE_TYPE c;
13079             HOST_WIDE_INT n;
13080
13081             c = TREE_REAL_CST (arg1);
13082             n = real_to_integer (&c);
13083             if ((n & 1) == 0)
13084               {
13085                 REAL_VALUE_TYPE cint;
13086                 real_from_integer (&cint, VOIDmode, n, SIGNED);
13087                 if (real_identical (&c, &cint))
13088                   return true;
13089               }
13090           }
13091         return tree_expr_nonnegative_warnv_p (arg0,
13092                                               strict_overflow_p);
13093
13094       default:
13095         break;
13096       }
13097   return tree_simple_nonnegative_warnv_p (CALL_EXPR,
13098                                           type);
13099 }
13100
13101 /* Return true if T is known to be non-negative.  If the return
13102    value is based on the assumption that signed overflow is undefined,
13103    set *STRICT_OVERFLOW_P to true; otherwise, don't change
13104    *STRICT_OVERFLOW_P.  */
13105
13106 static bool
13107 tree_invalid_nonnegative_warnv_p (tree t, bool *strict_overflow_p)
13108 {
13109   enum tree_code code = TREE_CODE (t);
13110   if (TYPE_UNSIGNED (TREE_TYPE (t)))
13111     return true;
13112
13113   switch (code)
13114     {
13115     case TARGET_EXPR:
13116       {
13117         tree temp = TARGET_EXPR_SLOT (t);
13118         t = TARGET_EXPR_INITIAL (t);
13119
13120         /* If the initializer is non-void, then it's a normal expression
13121            that will be assigned to the slot.  */
13122         if (!VOID_TYPE_P (t))
13123           return tree_expr_nonnegative_warnv_p (t, strict_overflow_p);
13124
13125         /* Otherwise, the initializer sets the slot in some way.  One common
13126            way is an assignment statement at the end of the initializer.  */
13127         while (1)
13128           {
13129             if (TREE_CODE (t) == BIND_EXPR)
13130               t = expr_last (BIND_EXPR_BODY (t));
13131             else if (TREE_CODE (t) == TRY_FINALLY_EXPR
13132                      || TREE_CODE (t) == TRY_CATCH_EXPR)
13133               t = expr_last (TREE_OPERAND (t, 0));
13134             else if (TREE_CODE (t) == STATEMENT_LIST)
13135               t = expr_last (t);
13136             else
13137               break;
13138           }
13139         if (TREE_CODE (t) == MODIFY_EXPR
13140             && TREE_OPERAND (t, 0) == temp)
13141           return tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 1),
13142                                                 strict_overflow_p);
13143
13144         return false;
13145       }
13146
13147     case CALL_EXPR:
13148       {
13149         tree arg0 = call_expr_nargs (t) > 0 ?  CALL_EXPR_ARG (t, 0) : NULL_TREE;
13150         tree arg1 = call_expr_nargs (t) > 1 ?  CALL_EXPR_ARG (t, 1) : NULL_TREE;
13151
13152         return tree_call_nonnegative_warnv_p (TREE_TYPE (t),
13153                                               get_callee_fndecl (t),
13154                                               arg0,
13155                                               arg1,
13156                                               strict_overflow_p);
13157       }
13158     case COMPOUND_EXPR:
13159     case MODIFY_EXPR:
13160       return tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 1),
13161                                             strict_overflow_p);
13162     case BIND_EXPR:
13163       return tree_expr_nonnegative_warnv_p (expr_last (TREE_OPERAND (t, 1)),
13164                                             strict_overflow_p);
13165     case SAVE_EXPR:
13166       return tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 0),
13167                                             strict_overflow_p);
13168
13169     default:
13170       return tree_simple_nonnegative_warnv_p (TREE_CODE (t),
13171                                                    TREE_TYPE (t));
13172     }
13173
13174   /* We don't know sign of `t', so be conservative and return false.  */
13175   return false;
13176 }
13177
13178 /* Return true if T is known to be non-negative.  If the return
13179    value is based on the assumption that signed overflow is undefined,
13180    set *STRICT_OVERFLOW_P to true; otherwise, don't change
13181    *STRICT_OVERFLOW_P.  */
13182
13183 bool
13184 tree_expr_nonnegative_warnv_p (tree t, bool *strict_overflow_p)
13185 {
13186   enum tree_code code;
13187   if (t == error_mark_node)
13188     return false;
13189
13190   code = TREE_CODE (t);
13191   switch (TREE_CODE_CLASS (code))
13192     {
13193     case tcc_binary:
13194     case tcc_comparison:
13195       return tree_binary_nonnegative_warnv_p (TREE_CODE (t),
13196                                               TREE_TYPE (t),
13197                                               TREE_OPERAND (t, 0),
13198                                               TREE_OPERAND (t, 1),
13199                                               strict_overflow_p);
13200
13201     case tcc_unary:
13202       return tree_unary_nonnegative_warnv_p (TREE_CODE (t),
13203                                              TREE_TYPE (t),
13204                                              TREE_OPERAND (t, 0),
13205                                              strict_overflow_p);
13206
13207     case tcc_constant:
13208     case tcc_declaration:
13209     case tcc_reference:
13210       return tree_single_nonnegative_warnv_p (t, strict_overflow_p);
13211
13212     default:
13213       break;
13214     }
13215
13216   switch (code)
13217     {
13218     case TRUTH_AND_EXPR:
13219     case TRUTH_OR_EXPR:
13220     case TRUTH_XOR_EXPR:
13221       return tree_binary_nonnegative_warnv_p (TREE_CODE (t),
13222                                               TREE_TYPE (t),
13223                                               TREE_OPERAND (t, 0),
13224                                               TREE_OPERAND (t, 1),
13225                                               strict_overflow_p);
13226     case TRUTH_NOT_EXPR:
13227       return tree_unary_nonnegative_warnv_p (TREE_CODE (t),
13228                                              TREE_TYPE (t),
13229                                              TREE_OPERAND (t, 0),
13230                                              strict_overflow_p);
13231
13232     case COND_EXPR:
13233     case CONSTRUCTOR:
13234     case OBJ_TYPE_REF:
13235     case ASSERT_EXPR:
13236     case ADDR_EXPR:
13237     case WITH_SIZE_EXPR:
13238     case SSA_NAME:
13239       return tree_single_nonnegative_warnv_p (t, strict_overflow_p);
13240
13241     default:
13242       return tree_invalid_nonnegative_warnv_p (t, strict_overflow_p);
13243     }
13244 }
13245
13246 /* Return true if `t' is known to be non-negative.  Handle warnings
13247    about undefined signed overflow.  */
13248
13249 bool
13250 tree_expr_nonnegative_p (tree t)
13251 {
13252   bool ret, strict_overflow_p;
13253
13254   strict_overflow_p = false;
13255   ret = tree_expr_nonnegative_warnv_p (t, &strict_overflow_p);
13256   if (strict_overflow_p)
13257     fold_overflow_warning (("assuming signed overflow does not occur when "
13258                             "determining that expression is always "
13259                             "non-negative"),
13260                            WARN_STRICT_OVERFLOW_MISC);
13261   return ret;
13262 }
13263
13264
13265 /* Return true when (CODE OP0) is an address and is known to be nonzero.
13266    For floating point we further ensure that T is not denormal.
13267    Similar logic is present in nonzero_address in rtlanal.h.
13268
13269    If the return value is based on the assumption that signed overflow
13270    is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
13271    change *STRICT_OVERFLOW_P.  */
13272
13273 bool
13274 tree_unary_nonzero_warnv_p (enum tree_code code, tree type, tree op0,
13275                                  bool *strict_overflow_p)
13276 {
13277   switch (code)
13278     {
13279     case ABS_EXPR:
13280       return tree_expr_nonzero_warnv_p (op0,
13281                                         strict_overflow_p);
13282
13283     case NOP_EXPR:
13284       {
13285         tree inner_type = TREE_TYPE (op0);
13286         tree outer_type = type;
13287
13288         return (TYPE_PRECISION (outer_type) >= TYPE_PRECISION (inner_type)
13289                 && tree_expr_nonzero_warnv_p (op0,
13290                                               strict_overflow_p));
13291       }
13292       break;
13293
13294     case NON_LVALUE_EXPR:
13295       return tree_expr_nonzero_warnv_p (op0,
13296                                         strict_overflow_p);
13297
13298     default:
13299       break;
13300   }
13301
13302   return false;
13303 }
13304
13305 /* Return true when (CODE OP0 OP1) is an address and is known to be nonzero.
13306    For floating point we further ensure that T is not denormal.
13307    Similar logic is present in nonzero_address in rtlanal.h.
13308
13309    If the return value is based on the assumption that signed overflow
13310    is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
13311    change *STRICT_OVERFLOW_P.  */
13312
13313 bool
13314 tree_binary_nonzero_warnv_p (enum tree_code code,
13315                              tree type,
13316                              tree op0,
13317                              tree op1, bool *strict_overflow_p)
13318 {
13319   bool sub_strict_overflow_p;
13320   switch (code)
13321     {
13322     case POINTER_PLUS_EXPR:
13323     case PLUS_EXPR:
13324       if (ANY_INTEGRAL_TYPE_P (type) && TYPE_OVERFLOW_UNDEFINED (type))
13325         {
13326           /* With the presence of negative values it is hard
13327              to say something.  */
13328           sub_strict_overflow_p = false;
13329           if (!tree_expr_nonnegative_warnv_p (op0,
13330                                               &sub_strict_overflow_p)
13331               || !tree_expr_nonnegative_warnv_p (op1,
13332                                                  &sub_strict_overflow_p))
13333             return false;
13334           /* One of operands must be positive and the other non-negative.  */
13335           /* We don't set *STRICT_OVERFLOW_P here: even if this value
13336              overflows, on a twos-complement machine the sum of two
13337              nonnegative numbers can never be zero.  */
13338           return (tree_expr_nonzero_warnv_p (op0,
13339                                              strict_overflow_p)
13340                   || tree_expr_nonzero_warnv_p (op1,
13341                                                 strict_overflow_p));
13342         }
13343       break;
13344
13345     case MULT_EXPR:
13346       if (TYPE_OVERFLOW_UNDEFINED (type))
13347         {
13348           if (tree_expr_nonzero_warnv_p (op0,
13349                                          strict_overflow_p)
13350               && tree_expr_nonzero_warnv_p (op1,
13351                                             strict_overflow_p))
13352             {
13353               *strict_overflow_p = true;
13354               return true;
13355             }
13356         }
13357       break;
13358
13359     case MIN_EXPR:
13360       sub_strict_overflow_p = false;
13361       if (tree_expr_nonzero_warnv_p (op0,
13362                                      &sub_strict_overflow_p)
13363           && tree_expr_nonzero_warnv_p (op1,
13364                                         &sub_strict_overflow_p))
13365         {
13366           if (sub_strict_overflow_p)
13367             *strict_overflow_p = true;
13368         }
13369       break;
13370
13371     case MAX_EXPR:
13372       sub_strict_overflow_p = false;
13373       if (tree_expr_nonzero_warnv_p (op0,
13374                                      &sub_strict_overflow_p))
13375         {
13376           if (sub_strict_overflow_p)
13377             *strict_overflow_p = true;
13378
13379           /* When both operands are nonzero, then MAX must be too.  */
13380           if (tree_expr_nonzero_warnv_p (op1,
13381                                          strict_overflow_p))
13382             return true;
13383
13384           /* MAX where operand 0 is positive is positive.  */
13385           return tree_expr_nonnegative_warnv_p (op0,
13386                                                strict_overflow_p);
13387         }
13388       /* MAX where operand 1 is positive is positive.  */
13389       else if (tree_expr_nonzero_warnv_p (op1,
13390                                           &sub_strict_overflow_p)
13391                && tree_expr_nonnegative_warnv_p (op1,
13392                                                  &sub_strict_overflow_p))
13393         {
13394           if (sub_strict_overflow_p)
13395             *strict_overflow_p = true;
13396           return true;
13397         }
13398       break;
13399
13400     case BIT_IOR_EXPR:
13401       return (tree_expr_nonzero_warnv_p (op1,
13402                                          strict_overflow_p)
13403               || tree_expr_nonzero_warnv_p (op0,
13404                                             strict_overflow_p));
13405
13406     default:
13407       break;
13408   }
13409
13410   return false;
13411 }
13412
13413 /* Return true when T is an address and is known to be nonzero.
13414    For floating point we further ensure that T is not denormal.
13415    Similar logic is present in nonzero_address in rtlanal.h.
13416
13417    If the return value is based on the assumption that signed overflow
13418    is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
13419    change *STRICT_OVERFLOW_P.  */
13420
13421 bool
13422 tree_single_nonzero_warnv_p (tree t, bool *strict_overflow_p)
13423 {
13424   bool sub_strict_overflow_p;
13425   switch (TREE_CODE (t))
13426     {
13427     case INTEGER_CST:
13428       return !integer_zerop (t);
13429
13430     case ADDR_EXPR:
13431       {
13432         tree base = TREE_OPERAND (t, 0);
13433
13434         if (!DECL_P (base))
13435           base = get_base_address (base);
13436
13437         if (!base)
13438           return false;
13439
13440         /* For objects in symbol table check if we know they are non-zero.
13441            Don't do anything for variables and functions before symtab is built;
13442            it is quite possible that they will be declared weak later.  */
13443         if (DECL_P (base) && decl_in_symtab_p (base))
13444           {
13445             struct symtab_node *symbol;
13446
13447             symbol = symtab_node::get_create (base);
13448             if (symbol)
13449               return symbol->nonzero_address ();
13450             else
13451               return false;
13452           }
13453
13454         /* Function local objects are never NULL.  */
13455         if (DECL_P (base)
13456             && (DECL_CONTEXT (base)
13457                 && TREE_CODE (DECL_CONTEXT (base)) == FUNCTION_DECL
13458                 && auto_var_in_fn_p (base, DECL_CONTEXT (base))))
13459           return true;
13460
13461         /* Constants are never weak.  */
13462         if (CONSTANT_CLASS_P (base))
13463           return true;
13464
13465         return false;
13466       }
13467
13468     case COND_EXPR:
13469       sub_strict_overflow_p = false;
13470       if (tree_expr_nonzero_warnv_p (TREE_OPERAND (t, 1),
13471                                      &sub_strict_overflow_p)
13472           && tree_expr_nonzero_warnv_p (TREE_OPERAND (t, 2),
13473                                         &sub_strict_overflow_p))
13474         {
13475           if (sub_strict_overflow_p)
13476             *strict_overflow_p = true;
13477           return true;
13478         }
13479       break;
13480
13481     default:
13482       break;
13483     }
13484   return false;
13485 }
13486
13487 /* Given the components of a binary expression CODE, TYPE, OP0 and OP1,
13488    attempt to fold the expression to a constant without modifying TYPE,
13489    OP0 or OP1.
13490
13491    If the expression could be simplified to a constant, then return
13492    the constant.  If the expression would not be simplified to a
13493    constant, then return NULL_TREE.  */
13494
13495 tree
13496 fold_binary_to_constant (enum tree_code code, tree type, tree op0, tree op1)
13497 {
13498   tree tem = fold_binary (code, type, op0, op1);
13499   return (tem && TREE_CONSTANT (tem)) ? tem : NULL_TREE;
13500 }
13501
13502 /* Given the components of a unary expression CODE, TYPE and OP0,
13503    attempt to fold the expression to a constant without modifying
13504    TYPE or OP0.
13505
13506    If the expression could be simplified to a constant, then return
13507    the constant.  If the expression would not be simplified to a
13508    constant, then return NULL_TREE.  */
13509
13510 tree
13511 fold_unary_to_constant (enum tree_code code, tree type, tree op0)
13512 {
13513   tree tem = fold_unary (code, type, op0);
13514   return (tem && TREE_CONSTANT (tem)) ? tem : NULL_TREE;
13515 }
13516
13517 /* If EXP represents referencing an element in a constant string
13518    (either via pointer arithmetic or array indexing), return the
13519    tree representing the value accessed, otherwise return NULL.  */
13520
13521 tree
13522 fold_read_from_constant_string (tree exp)
13523 {
13524   if ((TREE_CODE (exp) == INDIRECT_REF
13525        || TREE_CODE (exp) == ARRAY_REF)
13526       && TREE_CODE (TREE_TYPE (exp)) == INTEGER_TYPE)
13527     {
13528       tree exp1 = TREE_OPERAND (exp, 0);
13529       tree index;
13530       tree string;
13531       location_t loc = EXPR_LOCATION (exp);
13532
13533       if (TREE_CODE (exp) == INDIRECT_REF)
13534         string = string_constant (exp1, &index);
13535       else
13536         {
13537           tree low_bound = array_ref_low_bound (exp);
13538           index = fold_convert_loc (loc, sizetype, TREE_OPERAND (exp, 1));
13539
13540           /* Optimize the special-case of a zero lower bound.
13541
13542              We convert the low_bound to sizetype to avoid some problems
13543              with constant folding.  (E.g. suppose the lower bound is 1,
13544              and its mode is QI.  Without the conversion,l (ARRAY
13545              +(INDEX-(unsigned char)1)) becomes ((ARRAY+(-(unsigned char)1))
13546              +INDEX), which becomes (ARRAY+255+INDEX).  Oops!)  */
13547           if (! integer_zerop (low_bound))
13548             index = size_diffop_loc (loc, index,
13549                                  fold_convert_loc (loc, sizetype, low_bound));
13550
13551           string = exp1;
13552         }
13553
13554       if (string
13555           && TYPE_MODE (TREE_TYPE (exp)) == TYPE_MODE (TREE_TYPE (TREE_TYPE (string)))
13556           && TREE_CODE (string) == STRING_CST
13557           && TREE_CODE (index) == INTEGER_CST
13558           && compare_tree_int (index, TREE_STRING_LENGTH (string)) < 0
13559           && (GET_MODE_CLASS (TYPE_MODE (TREE_TYPE (TREE_TYPE (string))))
13560               == MODE_INT)
13561           && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (TREE_TYPE (string)))) == 1))
13562         return build_int_cst_type (TREE_TYPE (exp),
13563                                    (TREE_STRING_POINTER (string)
13564                                     [TREE_INT_CST_LOW (index)]));
13565     }
13566   return NULL;
13567 }
13568
13569 /* Return the tree for neg (ARG0) when ARG0 is known to be either
13570    an integer constant, real, or fixed-point constant.
13571
13572    TYPE is the type of the result.  */
13573
13574 static tree
13575 fold_negate_const (tree arg0, tree type)
13576 {
13577   tree t = NULL_TREE;
13578
13579   switch (TREE_CODE (arg0))
13580     {
13581     case INTEGER_CST:
13582       {
13583         bool overflow;
13584         wide_int val = wi::neg (arg0, &overflow);
13585         t = force_fit_type (type, val, 1,
13586                             (overflow | TREE_OVERFLOW (arg0))
13587                             && !TYPE_UNSIGNED (type));
13588         break;
13589       }
13590
13591     case REAL_CST:
13592       t = build_real (type, real_value_negate (&TREE_REAL_CST (arg0)));
13593       break;
13594
13595     case FIXED_CST:
13596       {
13597         FIXED_VALUE_TYPE f;
13598         bool overflow_p = fixed_arithmetic (&f, NEGATE_EXPR,
13599                                             &(TREE_FIXED_CST (arg0)), NULL,
13600                                             TYPE_SATURATING (type));
13601         t = build_fixed (type, f);
13602         /* Propagate overflow flags.  */
13603         if (overflow_p | TREE_OVERFLOW (arg0))
13604           TREE_OVERFLOW (t) = 1;
13605         break;
13606       }
13607
13608     default:
13609       gcc_unreachable ();
13610     }
13611
13612   return t;
13613 }
13614
13615 /* Return the tree for abs (ARG0) when ARG0 is known to be either
13616    an integer constant or real constant.
13617
13618    TYPE is the type of the result.  */
13619
13620 tree
13621 fold_abs_const (tree arg0, tree type)
13622 {
13623   tree t = NULL_TREE;
13624
13625   switch (TREE_CODE (arg0))
13626     {
13627     case INTEGER_CST:
13628       {
13629         /* If the value is unsigned or non-negative, then the absolute value
13630            is the same as the ordinary value.  */
13631         if (!wi::neg_p (arg0, TYPE_SIGN (type)))
13632           t = arg0;
13633
13634         /* If the value is negative, then the absolute value is
13635            its negation.  */
13636         else
13637           {
13638             bool overflow;
13639             wide_int val = wi::neg (arg0, &overflow);
13640             t = force_fit_type (type, val, -1,
13641                                 overflow | TREE_OVERFLOW (arg0));
13642           }
13643       }
13644       break;
13645
13646     case REAL_CST:
13647       if (REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg0)))
13648         t = build_real (type, real_value_negate (&TREE_REAL_CST (arg0)));
13649       else
13650         t =  arg0;
13651       break;
13652
13653     default:
13654       gcc_unreachable ();
13655     }
13656
13657   return t;
13658 }
13659
13660 /* Return the tree for not (ARG0) when ARG0 is known to be an integer
13661    constant.  TYPE is the type of the result.  */
13662
13663 static tree
13664 fold_not_const (const_tree arg0, tree type)
13665 {
13666   gcc_assert (TREE_CODE (arg0) == INTEGER_CST);
13667
13668   return force_fit_type (type, wi::bit_not (arg0), 0, TREE_OVERFLOW (arg0));
13669 }
13670
13671 /* Given CODE, a relational operator, the target type, TYPE and two
13672    constant operands OP0 and OP1, return the result of the
13673    relational operation.  If the result is not a compile time
13674    constant, then return NULL_TREE.  */
13675
13676 static tree
13677 fold_relational_const (enum tree_code code, tree type, tree op0, tree op1)
13678 {
13679   int result, invert;
13680
13681   /* From here on, the only cases we handle are when the result is
13682      known to be a constant.  */
13683
13684   if (TREE_CODE (op0) == REAL_CST && TREE_CODE (op1) == REAL_CST)
13685     {
13686       const REAL_VALUE_TYPE *c0 = TREE_REAL_CST_PTR (op0);
13687       const REAL_VALUE_TYPE *c1 = TREE_REAL_CST_PTR (op1);
13688
13689       /* Handle the cases where either operand is a NaN.  */
13690       if (real_isnan (c0) || real_isnan (c1))
13691         {
13692           switch (code)
13693             {
13694             case EQ_EXPR:
13695             case ORDERED_EXPR:
13696               result = 0;
13697               break;
13698
13699             case NE_EXPR:
13700             case UNORDERED_EXPR:
13701             case UNLT_EXPR:
13702             case UNLE_EXPR:
13703             case UNGT_EXPR:
13704             case UNGE_EXPR:
13705             case UNEQ_EXPR:
13706               result = 1;
13707               break;
13708
13709             case LT_EXPR:
13710             case LE_EXPR:
13711             case GT_EXPR:
13712             case GE_EXPR:
13713             case LTGT_EXPR:
13714               if (flag_trapping_math)
13715                 return NULL_TREE;
13716               result = 0;
13717               break;
13718
13719             default:
13720               gcc_unreachable ();
13721             }
13722
13723           return constant_boolean_node (result, type);
13724         }
13725
13726       return constant_boolean_node (real_compare (code, c0, c1), type);
13727     }
13728
13729   if (TREE_CODE (op0) == FIXED_CST && TREE_CODE (op1) == FIXED_CST)
13730     {
13731       const FIXED_VALUE_TYPE *c0 = TREE_FIXED_CST_PTR (op0);
13732       const FIXED_VALUE_TYPE *c1 = TREE_FIXED_CST_PTR (op1);
13733       return constant_boolean_node (fixed_compare (code, c0, c1), type);
13734     }
13735
13736   /* Handle equality/inequality of complex constants.  */
13737   if (TREE_CODE (op0) == COMPLEX_CST && TREE_CODE (op1) == COMPLEX_CST)
13738     {
13739       tree rcond = fold_relational_const (code, type,
13740                                           TREE_REALPART (op0),
13741                                           TREE_REALPART (op1));
13742       tree icond = fold_relational_const (code, type,
13743                                           TREE_IMAGPART (op0),
13744                                           TREE_IMAGPART (op1));
13745       if (code == EQ_EXPR)
13746         return fold_build2 (TRUTH_ANDIF_EXPR, type, rcond, icond);
13747       else if (code == NE_EXPR)
13748         return fold_build2 (TRUTH_ORIF_EXPR, type, rcond, icond);
13749       else
13750         return NULL_TREE;
13751     }
13752
13753   if (TREE_CODE (op0) == VECTOR_CST && TREE_CODE (op1) == VECTOR_CST)
13754     {
13755       unsigned count = VECTOR_CST_NELTS (op0);
13756       tree *elts =  XALLOCAVEC (tree, count);
13757       gcc_assert (VECTOR_CST_NELTS (op1) == count
13758                   && TYPE_VECTOR_SUBPARTS (type) == count);
13759
13760       for (unsigned i = 0; i < count; i++)
13761         {
13762           tree elem_type = TREE_TYPE (type);
13763           tree elem0 = VECTOR_CST_ELT (op0, i);
13764           tree elem1 = VECTOR_CST_ELT (op1, i);
13765
13766           tree tem = fold_relational_const (code, elem_type,
13767                                             elem0, elem1);
13768
13769           if (tem == NULL_TREE)
13770             return NULL_TREE;
13771
13772           elts[i] = build_int_cst (elem_type, integer_zerop (tem) ? 0 : -1);
13773         }
13774
13775       return build_vector (type, elts);
13776     }
13777
13778   /* From here on we only handle LT, LE, GT, GE, EQ and NE.
13779
13780      To compute GT, swap the arguments and do LT.
13781      To compute GE, do LT and invert the result.
13782      To compute LE, swap the arguments, do LT and invert the result.
13783      To compute NE, do EQ and invert the result.
13784
13785      Therefore, the code below must handle only EQ and LT.  */
13786
13787   if (code == LE_EXPR || code == GT_EXPR)
13788     {
13789       std::swap (op0, op1);
13790       code = swap_tree_comparison (code);
13791     }
13792
13793   /* Note that it is safe to invert for real values here because we
13794      have already handled the one case that it matters.  */
13795
13796   invert = 0;
13797   if (code == NE_EXPR || code == GE_EXPR)
13798     {
13799       invert = 1;
13800       code = invert_tree_comparison (code, false);
13801     }
13802
13803   /* Compute a result for LT or EQ if args permit;
13804      Otherwise return T.  */
13805   if (TREE_CODE (op0) == INTEGER_CST && TREE_CODE (op1) == INTEGER_CST)
13806     {
13807       if (code == EQ_EXPR)
13808         result = tree_int_cst_equal (op0, op1);
13809       else
13810         result = tree_int_cst_lt (op0, op1);
13811     }
13812   else
13813     return NULL_TREE;
13814
13815   if (invert)
13816     result ^= 1;
13817   return constant_boolean_node (result, type);
13818 }
13819
13820 /* If necessary, return a CLEANUP_POINT_EXPR for EXPR with the
13821    indicated TYPE.  If no CLEANUP_POINT_EXPR is necessary, return EXPR
13822    itself.  */
13823
13824 tree
13825 fold_build_cleanup_point_expr (tree type, tree expr)
13826 {
13827   /* If the expression does not have side effects then we don't have to wrap
13828      it with a cleanup point expression.  */
13829   if (!TREE_SIDE_EFFECTS (expr))
13830     return expr;
13831
13832   /* If the expression is a return, check to see if the expression inside the
13833      return has no side effects or the right hand side of the modify expression
13834      inside the return. If either don't have side effects set we don't need to
13835      wrap the expression in a cleanup point expression.  Note we don't check the
13836      left hand side of the modify because it should always be a return decl.  */
13837   if (TREE_CODE (expr) == RETURN_EXPR)
13838     {
13839       tree op = TREE_OPERAND (expr, 0);
13840       if (!op || !TREE_SIDE_EFFECTS (op))
13841         return expr;
13842       op = TREE_OPERAND (op, 1);
13843       if (!TREE_SIDE_EFFECTS (op))
13844         return expr;
13845     }
13846
13847   return build1 (CLEANUP_POINT_EXPR, type, expr);
13848 }
13849
13850 /* Given a pointer value OP0 and a type TYPE, return a simplified version
13851    of an indirection through OP0, or NULL_TREE if no simplification is
13852    possible.  */
13853
13854 tree
13855 fold_indirect_ref_1 (location_t loc, tree type, tree op0)
13856 {
13857   tree sub = op0;
13858   tree subtype;
13859
13860   STRIP_NOPS (sub);
13861   subtype = TREE_TYPE (sub);
13862   if (!POINTER_TYPE_P (subtype))
13863     return NULL_TREE;
13864
13865   if (TREE_CODE (sub) == ADDR_EXPR)
13866     {
13867       tree op = TREE_OPERAND (sub, 0);
13868       tree optype = TREE_TYPE (op);
13869       /* *&CONST_DECL -> to the value of the const decl.  */
13870       if (TREE_CODE (op) == CONST_DECL)
13871         return DECL_INITIAL (op);
13872       /* *&p => p;  make sure to handle *&"str"[cst] here.  */
13873       if (type == optype)
13874         {
13875           tree fop = fold_read_from_constant_string (op);
13876           if (fop)
13877             return fop;
13878           else
13879             return op;
13880         }
13881       /* *(foo *)&fooarray => fooarray[0] */
13882       else if (TREE_CODE (optype) == ARRAY_TYPE
13883                && type == TREE_TYPE (optype)
13884                && (!in_gimple_form
13885                    || TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST))
13886         {
13887           tree type_domain = TYPE_DOMAIN (optype);
13888           tree min_val = size_zero_node;
13889           if (type_domain && TYPE_MIN_VALUE (type_domain))
13890             min_val = TYPE_MIN_VALUE (type_domain);
13891           if (in_gimple_form
13892               && TREE_CODE (min_val) != INTEGER_CST)
13893             return NULL_TREE;
13894           return build4_loc (loc, ARRAY_REF, type, op, min_val,
13895                              NULL_TREE, NULL_TREE);
13896         }
13897       /* *(foo *)&complexfoo => __real__ complexfoo */
13898       else if (TREE_CODE (optype) == COMPLEX_TYPE
13899                && type == TREE_TYPE (optype))
13900         return fold_build1_loc (loc, REALPART_EXPR, type, op);
13901       /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
13902       else if (TREE_CODE (optype) == VECTOR_TYPE
13903                && type == TREE_TYPE (optype))
13904         {
13905           tree part_width = TYPE_SIZE (type);
13906           tree index = bitsize_int (0);
13907           return fold_build3_loc (loc, BIT_FIELD_REF, type, op, part_width, index);
13908         }
13909     }
13910
13911   if (TREE_CODE (sub) == POINTER_PLUS_EXPR
13912       && TREE_CODE (TREE_OPERAND (sub, 1)) == INTEGER_CST)
13913     {
13914       tree op00 = TREE_OPERAND (sub, 0);
13915       tree op01 = TREE_OPERAND (sub, 1);
13916
13917       STRIP_NOPS (op00);
13918       if (TREE_CODE (op00) == ADDR_EXPR)
13919         {
13920           tree op00type;
13921           op00 = TREE_OPERAND (op00, 0);
13922           op00type = TREE_TYPE (op00);
13923
13924           /* ((foo*)&vectorfoo)[1] => BIT_FIELD_REF<vectorfoo,...> */
13925           if (TREE_CODE (op00type) == VECTOR_TYPE
13926               && type == TREE_TYPE (op00type))
13927             {
13928               HOST_WIDE_INT offset = tree_to_shwi (op01);
13929               tree part_width = TYPE_SIZE (type);
13930               unsigned HOST_WIDE_INT part_widthi = tree_to_shwi (part_width)/BITS_PER_UNIT;
13931               unsigned HOST_WIDE_INT indexi = offset * BITS_PER_UNIT;
13932               tree index = bitsize_int (indexi);
13933
13934               if (offset / part_widthi < TYPE_VECTOR_SUBPARTS (op00type))
13935                 return fold_build3_loc (loc,
13936                                         BIT_FIELD_REF, type, op00,
13937                                         part_width, index);
13938
13939             }
13940           /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */
13941           else if (TREE_CODE (op00type) == COMPLEX_TYPE
13942                    && type == TREE_TYPE (op00type))
13943             {
13944               tree size = TYPE_SIZE_UNIT (type);
13945               if (tree_int_cst_equal (size, op01))
13946                 return fold_build1_loc (loc, IMAGPART_EXPR, type, op00);
13947             }
13948           /* ((foo *)&fooarray)[1] => fooarray[1] */
13949           else if (TREE_CODE (op00type) == ARRAY_TYPE
13950                    && type == TREE_TYPE (op00type))
13951             {
13952               tree type_domain = TYPE_DOMAIN (op00type);
13953               tree min_val = size_zero_node;
13954               if (type_domain && TYPE_MIN_VALUE (type_domain))
13955                 min_val = TYPE_MIN_VALUE (type_domain);
13956               op01 = size_binop_loc (loc, EXACT_DIV_EXPR, op01,
13957                                      TYPE_SIZE_UNIT (type));
13958               op01 = size_binop_loc (loc, PLUS_EXPR, op01, min_val);
13959               return build4_loc (loc, ARRAY_REF, type, op00, op01,
13960                                  NULL_TREE, NULL_TREE);
13961             }
13962         }
13963     }
13964
13965   /* *(foo *)fooarrptr => (*fooarrptr)[0] */
13966   if (TREE_CODE (TREE_TYPE (subtype)) == ARRAY_TYPE
13967       && type == TREE_TYPE (TREE_TYPE (subtype))
13968       && (!in_gimple_form
13969           || TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST))
13970     {
13971       tree type_domain;
13972       tree min_val = size_zero_node;
13973       sub = build_fold_indirect_ref_loc (loc, sub);
13974       type_domain = TYPE_DOMAIN (TREE_TYPE (sub));
13975       if (type_domain && TYPE_MIN_VALUE (type_domain))
13976         min_val = TYPE_MIN_VALUE (type_domain);
13977       if (in_gimple_form
13978           && TREE_CODE (min_val) != INTEGER_CST)
13979         return NULL_TREE;
13980       return build4_loc (loc, ARRAY_REF, type, sub, min_val, NULL_TREE,
13981                          NULL_TREE);
13982     }
13983
13984   return NULL_TREE;
13985 }
13986
13987 /* Builds an expression for an indirection through T, simplifying some
13988    cases.  */
13989
13990 tree
13991 build_fold_indirect_ref_loc (location_t loc, tree t)
13992 {
13993   tree type = TREE_TYPE (TREE_TYPE (t));
13994   tree sub = fold_indirect_ref_1 (loc, type, t);
13995
13996   if (sub)
13997     return sub;
13998
13999   return build1_loc (loc, INDIRECT_REF, type, t);
14000 }
14001
14002 /* Given an INDIRECT_REF T, return either T or a simplified version.  */
14003
14004 tree
14005 fold_indirect_ref_loc (location_t loc, tree t)
14006 {
14007   tree sub = fold_indirect_ref_1 (loc, TREE_TYPE (t), TREE_OPERAND (t, 0));
14008
14009   if (sub)
14010     return sub;
14011   else
14012     return t;
14013 }
14014
14015 /* Strip non-trapping, non-side-effecting tree nodes from an expression
14016    whose result is ignored.  The type of the returned tree need not be
14017    the same as the original expression.  */
14018
14019 tree
14020 fold_ignored_result (tree t)
14021 {
14022   if (!TREE_SIDE_EFFECTS (t))
14023     return integer_zero_node;
14024
14025   for (;;)
14026     switch (TREE_CODE_CLASS (TREE_CODE (t)))
14027       {
14028       case tcc_unary:
14029         t = TREE_OPERAND (t, 0);
14030         break;
14031
14032       case tcc_binary:
14033       case tcc_comparison:
14034         if (!TREE_SIDE_EFFECTS (TREE_OPERAND (t, 1)))
14035           t = TREE_OPERAND (t, 0);
14036         else if (!TREE_SIDE_EFFECTS (TREE_OPERAND (t, 0)))
14037           t = TREE_OPERAND (t, 1);
14038         else
14039           return t;
14040         break;
14041
14042       case tcc_expression:
14043         switch (TREE_CODE (t))
14044           {
14045           case COMPOUND_EXPR:
14046             if (TREE_SIDE_EFFECTS (TREE_OPERAND (t, 1)))
14047               return t;
14048             t = TREE_OPERAND (t, 0);
14049             break;
14050
14051           case COND_EXPR:
14052             if (TREE_SIDE_EFFECTS (TREE_OPERAND (t, 1))
14053                 || TREE_SIDE_EFFECTS (TREE_OPERAND (t, 2)))
14054               return t;
14055             t = TREE_OPERAND (t, 0);
14056             break;
14057
14058           default:
14059             return t;
14060           }
14061         break;
14062
14063       default:
14064         return t;
14065       }
14066 }
14067
14068 /* Return the value of VALUE, rounded up to a multiple of DIVISOR. */
14069
14070 tree
14071 round_up_loc (location_t loc, tree value, unsigned int divisor)
14072 {
14073   tree div = NULL_TREE;
14074
14075   if (divisor == 1)
14076     return value;
14077
14078   /* See if VALUE is already a multiple of DIVISOR.  If so, we don't
14079      have to do anything.  Only do this when we are not given a const,
14080      because in that case, this check is more expensive than just
14081      doing it.  */
14082   if (TREE_CODE (value) != INTEGER_CST)
14083     {
14084       div = build_int_cst (TREE_TYPE (value), divisor);
14085
14086       if (multiple_of_p (TREE_TYPE (value), value, div))
14087         return value;
14088     }
14089
14090   /* If divisor is a power of two, simplify this to bit manipulation.  */
14091   if (divisor == (divisor & -divisor))
14092     {
14093       if (TREE_CODE (value) == INTEGER_CST)
14094         {
14095           wide_int val = value;
14096           bool overflow_p;
14097
14098           if ((val & (divisor - 1)) == 0)
14099             return value;
14100
14101           overflow_p = TREE_OVERFLOW (value);
14102           val += divisor - 1;
14103           val &= - (int) divisor;
14104           if (val == 0)
14105             overflow_p = true;
14106
14107           return force_fit_type (TREE_TYPE (value), val, -1, overflow_p);
14108         }
14109       else
14110         {
14111           tree t;
14112
14113           t = build_int_cst (TREE_TYPE (value), divisor - 1);
14114           value = size_binop_loc (loc, PLUS_EXPR, value, t);
14115           t = build_int_cst (TREE_TYPE (value), - (int) divisor);
14116           value = size_binop_loc (loc, BIT_AND_EXPR, value, t);
14117         }
14118     }
14119   else
14120     {
14121       if (!div)
14122         div = build_int_cst (TREE_TYPE (value), divisor);
14123       value = size_binop_loc (loc, CEIL_DIV_EXPR, value, div);
14124       value = size_binop_loc (loc, MULT_EXPR, value, div);
14125     }
14126
14127   return value;
14128 }
14129
14130 /* Likewise, but round down.  */
14131
14132 tree
14133 round_down_loc (location_t loc, tree value, int divisor)
14134 {
14135   tree div = NULL_TREE;
14136
14137   gcc_assert (divisor > 0);
14138   if (divisor == 1)
14139     return value;
14140
14141   /* See if VALUE is already a multiple of DIVISOR.  If so, we don't
14142      have to do anything.  Only do this when we are not given a const,
14143      because in that case, this check is more expensive than just
14144      doing it.  */
14145   if (TREE_CODE (value) != INTEGER_CST)
14146     {
14147       div = build_int_cst (TREE_TYPE (value), divisor);
14148
14149       if (multiple_of_p (TREE_TYPE (value), value, div))
14150         return value;
14151     }
14152
14153   /* If divisor is a power of two, simplify this to bit manipulation.  */
14154   if (divisor == (divisor & -divisor))
14155     {
14156       tree t;
14157
14158       t = build_int_cst (TREE_TYPE (value), -divisor);
14159       value = size_binop_loc (loc, BIT_AND_EXPR, value, t);
14160     }
14161   else
14162     {
14163       if (!div)
14164         div = build_int_cst (TREE_TYPE (value), divisor);
14165       value = size_binop_loc (loc, FLOOR_DIV_EXPR, value, div);
14166       value = size_binop_loc (loc, MULT_EXPR, value, div);
14167     }
14168
14169   return value;
14170 }
14171
14172 /* Returns the pointer to the base of the object addressed by EXP and
14173    extracts the information about the offset of the access, storing it
14174    to PBITPOS and POFFSET.  */
14175
14176 static tree
14177 split_address_to_core_and_offset (tree exp,
14178                                   HOST_WIDE_INT *pbitpos, tree *poffset)
14179 {
14180   tree core;
14181   machine_mode mode;
14182   int unsignedp, volatilep;
14183   HOST_WIDE_INT bitsize;
14184   location_t loc = EXPR_LOCATION (exp);
14185
14186   if (TREE_CODE (exp) == ADDR_EXPR)
14187     {
14188       core = get_inner_reference (TREE_OPERAND (exp, 0), &bitsize, pbitpos,
14189                                   poffset, &mode, &unsignedp, &volatilep,
14190                                   false);
14191       core = build_fold_addr_expr_loc (loc, core);
14192     }
14193   else
14194     {
14195       core = exp;
14196       *pbitpos = 0;
14197       *poffset = NULL_TREE;
14198     }
14199
14200   return core;
14201 }
14202
14203 /* Returns true if addresses of E1 and E2 differ by a constant, false
14204    otherwise.  If they do, E1 - E2 is stored in *DIFF.  */
14205
14206 bool
14207 ptr_difference_const (tree e1, tree e2, HOST_WIDE_INT *diff)
14208 {
14209   tree core1, core2;
14210   HOST_WIDE_INT bitpos1, bitpos2;
14211   tree toffset1, toffset2, tdiff, type;
14212
14213   core1 = split_address_to_core_and_offset (e1, &bitpos1, &toffset1);
14214   core2 = split_address_to_core_and_offset (e2, &bitpos2, &toffset2);
14215
14216   if (bitpos1 % BITS_PER_UNIT != 0
14217       || bitpos2 % BITS_PER_UNIT != 0
14218       || !operand_equal_p (core1, core2, 0))
14219     return false;
14220
14221   if (toffset1 && toffset2)
14222     {
14223       type = TREE_TYPE (toffset1);
14224       if (type != TREE_TYPE (toffset2))
14225         toffset2 = fold_convert (type, toffset2);
14226
14227       tdiff = fold_build2 (MINUS_EXPR, type, toffset1, toffset2);
14228       if (!cst_and_fits_in_hwi (tdiff))
14229         return false;
14230
14231       *diff = int_cst_value (tdiff);
14232     }
14233   else if (toffset1 || toffset2)
14234     {
14235       /* If only one of the offsets is non-constant, the difference cannot
14236          be a constant.  */
14237       return false;
14238     }
14239   else
14240     *diff = 0;
14241
14242   *diff += (bitpos1 - bitpos2) / BITS_PER_UNIT;
14243   return true;
14244 }
14245
14246 /* Simplify the floating point expression EXP when the sign of the
14247    result is not significant.  Return NULL_TREE if no simplification
14248    is possible.  */
14249
14250 tree
14251 fold_strip_sign_ops (tree exp)
14252 {
14253   tree arg0, arg1;
14254   location_t loc = EXPR_LOCATION (exp);
14255
14256   switch (TREE_CODE (exp))
14257     {
14258     case ABS_EXPR:
14259     case NEGATE_EXPR:
14260       arg0 = fold_strip_sign_ops (TREE_OPERAND (exp, 0));
14261       return arg0 ? arg0 : TREE_OPERAND (exp, 0);
14262
14263     case MULT_EXPR:
14264     case RDIV_EXPR:
14265       if (HONOR_SIGN_DEPENDENT_ROUNDING (element_mode (exp)))
14266         return NULL_TREE;
14267       arg0 = fold_strip_sign_ops (TREE_OPERAND (exp, 0));
14268       arg1 = fold_strip_sign_ops (TREE_OPERAND (exp, 1));
14269       if (arg0 != NULL_TREE || arg1 != NULL_TREE)
14270         return fold_build2_loc (loc, TREE_CODE (exp), TREE_TYPE (exp),
14271                             arg0 ? arg0 : TREE_OPERAND (exp, 0),
14272                             arg1 ? arg1 : TREE_OPERAND (exp, 1));
14273       break;
14274
14275     case COMPOUND_EXPR:
14276       arg0 = TREE_OPERAND (exp, 0);
14277       arg1 = fold_strip_sign_ops (TREE_OPERAND (exp, 1));
14278       if (arg1)
14279         return fold_build2_loc (loc, COMPOUND_EXPR, TREE_TYPE (exp), arg0, arg1);
14280       break;
14281
14282     case COND_EXPR:
14283       arg0 = fold_strip_sign_ops (TREE_OPERAND (exp, 1));
14284       arg1 = fold_strip_sign_ops (TREE_OPERAND (exp, 2));
14285       if (arg0 || arg1)
14286         return fold_build3_loc (loc,
14287                             COND_EXPR, TREE_TYPE (exp), TREE_OPERAND (exp, 0),
14288                             arg0 ? arg0 : TREE_OPERAND (exp, 1),
14289                             arg1 ? arg1 : TREE_OPERAND (exp, 2));
14290       break;
14291
14292     case CALL_EXPR:
14293       {
14294         const enum built_in_function fcode = builtin_mathfn_code (exp);
14295         switch (fcode)
14296         {
14297         CASE_FLT_FN (BUILT_IN_COPYSIGN):
14298           /* Strip copysign function call, return the 1st argument. */
14299           arg0 = CALL_EXPR_ARG (exp, 0);
14300           arg1 = CALL_EXPR_ARG (exp, 1);
14301           return omit_one_operand_loc (loc, TREE_TYPE (exp), arg0, arg1);
14302
14303         default:
14304           /* Strip sign ops from the argument of "odd" math functions.  */
14305           if (negate_mathfn_p (fcode))
14306             {
14307               arg0 = fold_strip_sign_ops (CALL_EXPR_ARG (exp, 0));
14308               if (arg0)
14309                 return build_call_expr_loc (loc, get_callee_fndecl (exp), 1, arg0);
14310             }
14311           break;
14312         }
14313       }
14314       break;
14315
14316     default:
14317       break;
14318     }
14319   return NULL_TREE;
14320 }
14321
14322 /* Return OFF converted to a pointer offset type suitable as offset for
14323    POINTER_PLUS_EXPR.  Use location LOC for this conversion.  */
14324 tree
14325 convert_to_ptrofftype_loc (location_t loc, tree off)
14326 {
14327   return fold_convert_loc (loc, sizetype, off);
14328 }
14329
14330 /* Build and fold a POINTER_PLUS_EXPR at LOC offsetting PTR by OFF.  */
14331 tree
14332 fold_build_pointer_plus_loc (location_t loc, tree ptr, tree off)
14333 {
14334   return fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (ptr),
14335                           ptr, convert_to_ptrofftype_loc (loc, off));
14336 }
14337
14338 /* Build and fold a POINTER_PLUS_EXPR at LOC offsetting PTR by OFF.  */
14339 tree
14340 fold_build_pointer_plus_hwi_loc (location_t loc, tree ptr, HOST_WIDE_INT off)
14341 {
14342   return fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (ptr),
14343                           ptr, size_int (off));
14344 }