gcc/fold-const.c

   1 /* Fold a constant sub-tree into a single node for C-compiler
   2    Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
   3    2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011,
   4    2012 Free Software Foundation, Inc.
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify it under
   9 the terms of the GNU General Public License as published by the Free
  10 Software Foundation; either version 3, or (at your option) any later
  11 version.
  12
  13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16 for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING3.  If not see
  20 <http://www.gnu.org/licenses/>.  */
  21
  22 /*@@ This file should be rewritten to use an arbitrary precision
  23   @@ representation for "struct tree_int_cst" and "struct tree_real_cst".
  24   @@ Perhaps the routines could also be used for bc/dc, and made a lib.
  25   @@ The routines that translate from the ap rep should
  26   @@ warn if precision et. al. is lost.
  27   @@ This would also make life easier when this technology is used
  28   @@ for cross-compilers.  */
  29
  30 /* The entry points in this file are fold, size_int_wide and size_binop.
  31
  32    fold takes a tree as argument and returns a simplified tree.
  33
  34    size_binop takes a tree code for an arithmetic operation
  35    and two operands that are trees, and produces a tree for the
  36    result, assuming the type comes from `sizetype'.
  37
  38    size_int takes an integer value, and creates a tree constant
  39    with type from `sizetype'.
  40
  41    Note: Since the folders get called on non-gimple code as well as
  42    gimple code, we need to handle GIMPLE tuples as well as their
  43    corresponding tree equivalents.  */
  44
  45 #include "config.h"
  46 #include "system.h"
  47 #include "coretypes.h"
  48 #include "tm.h"
  49 #include "flags.h"
  50 #include "tree.h"
  51 #include "realmpfr.h"
  52 #include "rtl.h"
  53 #include "expr.h"
  54 #include "tm_p.h"
  55 #include "target.h"
  56 #include "diagnostic-core.h"
  57 #include "intl.h"
  58 #include "ggc.h"
  59 #include "hashtab.h"
  60 #include "langhooks.h"
  61 #include "md5.h"
  62 #include "gimple.h"
  63 #include "tree-flow.h"
  64
  65 /* Nonzero if we are folding constants inside an initializer; zero
  66    otherwise.  */
  67 int folding_initializer = 0;
  68
  69 /* The following constants represent a bit based encoding of GCC's
  70    comparison operators.  This encoding simplifies transformations
  71    on relational comparison operators, such as AND and OR.  */
  72 enum comparison_code {
  73   COMPCODE_FALSE = 0,
  74   COMPCODE_LT = 1,
  75   COMPCODE_EQ = 2,
  76   COMPCODE_LE = 3,
  77   COMPCODE_GT = 4,
  78   COMPCODE_LTGT = 5,
  79   COMPCODE_GE = 6,
  80   COMPCODE_ORD = 7,
  81   COMPCODE_UNORD = 8,
  82   COMPCODE_UNLT = 9,
  83   COMPCODE_UNEQ = 10,
  84   COMPCODE_UNLE = 11,
  85   COMPCODE_UNGT = 12,
  86   COMPCODE_NE = 13,
  87   COMPCODE_UNGE = 14,
  88   COMPCODE_TRUE = 15
  89 };
  90
  91 static bool negate_mathfn_p (enum built_in_function);
  92 static bool negate_expr_p (tree);
  93 static tree negate_expr (tree);
  94 static tree split_tree (tree, enum tree_code, tree *, tree *, tree *, int);
  95 static tree associate_trees (location_t, tree, tree, enum tree_code, tree);
  96 static tree const_binop (enum tree_code, tree, tree);
  97 static enum comparison_code comparison_to_compcode (enum tree_code);
  98 static enum tree_code compcode_to_comparison (enum comparison_code);
  99 static int operand_equal_for_comparison_p (tree, tree, tree);
 100 static int twoval_comparison_p (tree, tree *, tree *, int *);
 101 static tree eval_subst (location_t, tree, tree, tree, tree, tree);
 102 static tree pedantic_omit_one_operand_loc (location_t, tree, tree, tree);
 103 static tree distribute_bit_expr (location_t, enum tree_code, tree, tree, tree);
 104 static tree make_bit_field_ref (location_t, tree, tree,
 105                                 HOST_WIDE_INT, HOST_WIDE_INT, int);
 106 static tree optimize_bit_field_compare (location_t, enum tree_code,
 107                                         tree, tree, tree);
 108 static tree decode_field_reference (location_t, tree, HOST_WIDE_INT *,
 109                                     HOST_WIDE_INT *,
 110                                     enum machine_mode *, int *, int *,
 111                                     tree *, tree *);
 112 static int all_ones_mask_p (const_tree, int);
 113 static tree sign_bit_p (tree, const_tree);
 114 static int simple_operand_p (const_tree);
 115 static bool simple_operand_p_2 (tree);
 116 static tree range_binop (enum tree_code, tree, tree, int, tree, int);
 117 static tree range_predecessor (tree);
 118 static tree range_successor (tree);
 119 static tree fold_range_test (location_t, enum tree_code, tree, tree, tree);
 120 static tree fold_cond_expr_with_comparison (location_t, tree, tree, tree, tree);
 121 static tree unextend (tree, int, int, tree);
 122 static tree optimize_minmax_comparison (location_t, enum tree_code,
 123                                         tree, tree, tree);
 124 static tree extract_muldiv (tree, tree, enum tree_code, tree, bool *);
 125 static tree extract_muldiv_1 (tree, tree, enum tree_code, tree, bool *);
 126 static tree fold_binary_op_with_conditional_arg (location_t,
 127                                                  enum tree_code, tree,
 128                                                  tree, tree,
 129                                                  tree, tree, int);
 130 static tree fold_mathfn_compare (location_t,
 131                                  enum built_in_function, enum tree_code,
 132                                  tree, tree, tree);
 133 static tree fold_inf_compare (location_t, enum tree_code, tree, tree, tree);
 134 static tree fold_div_compare (location_t, enum tree_code, tree, tree, tree);
 135 static bool reorder_operands_p (const_tree, const_tree);
 136 static tree fold_negate_const (tree, tree);
 137 static tree fold_not_const (const_tree, tree);
 138 static tree fold_relational_const (enum tree_code, tree, tree, tree);
 139 static tree fold_convert_const (enum tree_code, tree, tree);
 140
 141 /* Return EXPR_LOCATION of T if it is not UNKNOWN_LOCATION.
 142    Otherwise, return LOC.  */
 143
 144 static location_t
 145 expr_location_or (tree t, location_t loc)
 146 {
 147   location_t tloc = EXPR_LOCATION (t);
 148   return tloc != UNKNOWN_LOCATION ? tloc : loc;
 149 }
 150
 151 /* Similar to protected_set_expr_location, but never modify x in place,
 152    if location can and needs to be set, unshare it.  */
 153
 154 static inline tree
 155 protected_set_expr_location_unshare (tree x, location_t loc)
 156 {
 157   if (CAN_HAVE_LOCATION_P (x)
 158       && EXPR_LOCATION (x) != loc
 159       && !(TREE_CODE (x) == SAVE_EXPR
 160            || TREE_CODE (x) == TARGET_EXPR
 161            || TREE_CODE (x) == BIND_EXPR))
 162     {
 163       x = copy_node (x);
 164       SET_EXPR_LOCATION (x, loc);
 165     }
 166   return x;
 167 }
 168
 169
 170 /* We know that A1 + B1 = SUM1, using 2's complement arithmetic and ignoring
 171    overflow.  Suppose A, B and SUM have the same respective signs as A1, B1,
 172    and SUM1.  Then this yields nonzero if overflow occurred during the
 173    addition.
 174
 175    Overflow occurs if A and B have the same sign, but A and SUM differ in
 176    sign.  Use `^' to test whether signs differ, and `< 0' to isolate the
 177    sign.  */
 178 #define OVERFLOW_SUM_SIGN(a, b, sum) ((~((a) ^ (b)) & ((a) ^ (sum))) < 0)
 179 \f
 180 /* If ARG2 divides ARG1 with zero remainder, carries out the division
 181    of type CODE and returns the quotient.
 182    Otherwise returns NULL_TREE.  */
 183
 184 tree
 185 div_if_zero_remainder (enum tree_code code, const_tree arg1, const_tree arg2)
 186 {
 187   double_int quo, rem;
 188   int uns;
 189
 190   /* The sign of the division is according to operand two, that
 191      does the correct thing for POINTER_PLUS_EXPR where we want
 192      a signed division.  */
 193   uns = TYPE_UNSIGNED (TREE_TYPE (arg2));
 194   if (TREE_CODE (TREE_TYPE (arg2)) == INTEGER_TYPE
 195       && TYPE_IS_SIZETYPE (TREE_TYPE (arg2)))
 196     uns = false;
 197
 198   quo = double_int_divmod (tree_to_double_int (arg1),
 199                            tree_to_double_int (arg2),
 200                            uns, code, &rem);
 201
 202   if (double_int_zero_p (rem))
 203     return build_int_cst_wide (TREE_TYPE (arg1), quo.low, quo.high);
 204
 205   return NULL_TREE;
 206 }
 207 \f
 208 /* This is nonzero if we should defer warnings about undefined
 209    overflow.  This facility exists because these warnings are a
 210    special case.  The code to estimate loop iterations does not want
 211    to issue any warnings, since it works with expressions which do not
 212    occur in user code.  Various bits of cleanup code call fold(), but
 213    only use the result if it has certain characteristics (e.g., is a
 214    constant); that code only wants to issue a warning if the result is
 215    used.  */
 216
 217 static int fold_deferring_overflow_warnings;
 218
 219 /* If a warning about undefined overflow is deferred, this is the
 220    warning.  Note that this may cause us to turn two warnings into
 221    one, but that is fine since it is sufficient to only give one
 222    warning per expression.  */
 223
 224 static const char* fold_deferred_overflow_warning;
 225
 226 /* If a warning about undefined overflow is deferred, this is the
 227    level at which the warning should be emitted.  */
 228
 229 static enum warn_strict_overflow_code fold_deferred_overflow_code;
 230
 231 /* Start deferring overflow warnings.  We could use a stack here to
 232    permit nested calls, but at present it is not necessary.  */
 233
 234 void
 235 fold_defer_overflow_warnings (void)
 236 {
 237   ++fold_deferring_overflow_warnings;
 238 }
 239
 240 /* Stop deferring overflow warnings.  If there is a pending warning,
 241    and ISSUE is true, then issue the warning if appropriate.  STMT is
 242    the statement with which the warning should be associated (used for
 243    location information); STMT may be NULL.  CODE is the level of the
 244    warning--a warn_strict_overflow_code value.  This function will use
 245    the smaller of CODE and the deferred code when deciding whether to
 246    issue the warning.  CODE may be zero to mean to always use the
 247    deferred code.  */
 248
 249 void
 250 fold_undefer_overflow_warnings (bool issue, const_gimple stmt, int code)
 251 {
 252   const char *warnmsg;
 253   location_t locus;
 254
 255   gcc_assert (fold_deferring_overflow_warnings > 0);
 256   --fold_deferring_overflow_warnings;
 257   if (fold_deferring_overflow_warnings > 0)
 258     {
 259       if (fold_deferred_overflow_warning != NULL
 260           && code != 0
 261           && code < (int) fold_deferred_overflow_code)
 262         fold_deferred_overflow_code = (enum warn_strict_overflow_code) code;
 263       return;
 264     }
 265
 266   warnmsg = fold_deferred_overflow_warning;
 267   fold_deferred_overflow_warning = NULL;
 268
 269   if (!issue || warnmsg == NULL)
 270     return;
 271
 272   if (gimple_no_warning_p (stmt))
 273     return;
 274
 275   /* Use the smallest code level when deciding to issue the
 276      warning.  */
 277   if (code == 0 || code > (int) fold_deferred_overflow_code)
 278     code = fold_deferred_overflow_code;
 279
 280   if (!issue_strict_overflow_warning (code))
 281     return;
 282
 283   if (stmt == NULL)
 284     locus = input_location;
 285   else
 286     locus = gimple_location (stmt);
 287   warning_at (locus, OPT_Wstrict_overflow, "%s", warnmsg);
 288 }
 289
 290 /* Stop deferring overflow warnings, ignoring any deferred
 291    warnings.  */
 292
 293 void
 294 fold_undefer_and_ignore_overflow_warnings (void)
 295 {
 296   fold_undefer_overflow_warnings (false, NULL, 0);
 297 }
 298
 299 /* Whether we are deferring overflow warnings.  */
 300
 301 bool
 302 fold_deferring_overflow_warnings_p (void)
 303 {
 304   return fold_deferring_overflow_warnings > 0;
 305 }
 306
 307 /* This is called when we fold something based on the fact that signed
 308    overflow is undefined.  */
 309
 310 static void
 311 fold_overflow_warning (const char* gmsgid, enum warn_strict_overflow_code wc)
 312 {
 313   if (fold_deferring_overflow_warnings > 0)
 314     {
 315       if (fold_deferred_overflow_warning == NULL
 316           || wc < fold_deferred_overflow_code)
 317         {
 318           fold_deferred_overflow_warning = gmsgid;
 319           fold_deferred_overflow_code = wc;
 320         }
 321     }
 322   else if (issue_strict_overflow_warning (wc))
 323     warning (OPT_Wstrict_overflow, gmsgid);
 324 }
 325 \f
 326 /* Return true if the built-in mathematical function specified by CODE
 327    is odd, i.e. -f(x) == f(-x).  */
 328
 329 static bool
 330 negate_mathfn_p (enum built_in_function code)
 331 {
 332   switch (code)
 333     {
 334     CASE_FLT_FN (BUILT_IN_ASIN):
 335     CASE_FLT_FN (BUILT_IN_ASINH):
 336     CASE_FLT_FN (BUILT_IN_ATAN):
 337     CASE_FLT_FN (BUILT_IN_ATANH):
 338     CASE_FLT_FN (BUILT_IN_CASIN):
 339     CASE_FLT_FN (BUILT_IN_CASINH):
 340     CASE_FLT_FN (BUILT_IN_CATAN):
 341     CASE_FLT_FN (BUILT_IN_CATANH):
 342     CASE_FLT_FN (BUILT_IN_CBRT):
 343     CASE_FLT_FN (BUILT_IN_CPROJ):
 344     CASE_FLT_FN (BUILT_IN_CSIN):
 345     CASE_FLT_FN (BUILT_IN_CSINH):
 346     CASE_FLT_FN (BUILT_IN_CTAN):
 347     CASE_FLT_FN (BUILT_IN_CTANH):
 348     CASE_FLT_FN (BUILT_IN_ERF):
 349     CASE_FLT_FN (BUILT_IN_LLROUND):
 350     CASE_FLT_FN (BUILT_IN_LROUND):
 351     CASE_FLT_FN (BUILT_IN_ROUND):
 352     CASE_FLT_FN (BUILT_IN_SIN):
 353     CASE_FLT_FN (BUILT_IN_SINH):
 354     CASE_FLT_FN (BUILT_IN_TAN):
 355     CASE_FLT_FN (BUILT_IN_TANH):
 356     CASE_FLT_FN (BUILT_IN_TRUNC):
 357       return true;
 358
 359     CASE_FLT_FN (BUILT_IN_LLRINT):
 360     CASE_FLT_FN (BUILT_IN_LRINT):
 361     CASE_FLT_FN (BUILT_IN_NEARBYINT):
 362     CASE_FLT_FN (BUILT_IN_RINT):
 363       return !flag_rounding_math;
 364
 365     default:
 366       break;
 367     }
 368   return false;
 369 }
 370
 371 /* Check whether we may negate an integer constant T without causing
 372    overflow.  */
 373
 374 bool
 375 may_negate_without_overflow_p (const_tree t)
 376 {
 377   unsigned HOST_WIDE_INT val;
 378   unsigned int prec;
 379   tree type;
 380
 381   gcc_assert (TREE_CODE (t) == INTEGER_CST);
 382
 383   type = TREE_TYPE (t);
 384   if (TYPE_UNSIGNED (type))
 385     return false;
 386
 387   prec = TYPE_PRECISION (type);
 388   if (prec > HOST_BITS_PER_WIDE_INT)
 389     {
 390       if (TREE_INT_CST_LOW (t) != 0)
 391         return true;
 392       prec -= HOST_BITS_PER_WIDE_INT;
 393       val = TREE_INT_CST_HIGH (t);
 394     }
 395   else
 396     val = TREE_INT_CST_LOW (t);
 397   if (prec < HOST_BITS_PER_WIDE_INT)
 398     val &= ((unsigned HOST_WIDE_INT) 1 << prec) - 1;
 399   return val != ((unsigned HOST_WIDE_INT) 1 << (prec - 1));
 400 }
 401
 402 /* Determine whether an expression T can be cheaply negated using
 403    the function negate_expr without introducing undefined overflow.  */
 404
 405 static bool
 406 negate_expr_p (tree t)
 407 {
 408   tree type;
 409
 410   if (t == 0)
 411     return false;
 412
 413   type = TREE_TYPE (t);
 414
 415   STRIP_SIGN_NOPS (t);
 416   switch (TREE_CODE (t))
 417     {
 418     case INTEGER_CST:
 419       if (TYPE_OVERFLOW_WRAPS (type))
 420         return true;
 421
 422       /* Check that -CST will not overflow type.  */
 423       return may_negate_without_overflow_p (t);
 424     case BIT_NOT_EXPR:
 425       return (INTEGRAL_TYPE_P (type)
 426               && TYPE_OVERFLOW_WRAPS (type));
 427
 428     case FIXED_CST:
 429     case NEGATE_EXPR:
 430       return true;
 431
 432     case REAL_CST:
 433       /* We want to canonicalize to positive real constants.  Pretend
 434          that only negative ones can be easily negated.  */
 435       return REAL_VALUE_NEGATIVE (TREE_REAL_CST (t));
 436
 437     case COMPLEX_CST:
 438       return negate_expr_p (TREE_REALPART (t))
 439              && negate_expr_p (TREE_IMAGPART (t));
 440
 441     case COMPLEX_EXPR:
 442       return negate_expr_p (TREE_OPERAND (t, 0))
 443              && negate_expr_p (TREE_OPERAND (t, 1));
 444
 445     case CONJ_EXPR:
 446       return negate_expr_p (TREE_OPERAND (t, 0));
 447
 448     case PLUS_EXPR:
 449       if (HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (type))
 450           || HONOR_SIGNED_ZEROS (TYPE_MODE (type)))
 451         return false;
 452       /* -(A + B) -> (-B) - A.  */
 453       if (negate_expr_p (TREE_OPERAND (t, 1))
 454           && reorder_operands_p (TREE_OPERAND (t, 0),
 455                                  TREE_OPERAND (t, 1)))
 456         return true;
 457       /* -(A + B) -> (-A) - B.  */
 458       return negate_expr_p (TREE_OPERAND (t, 0));
 459
 460     case MINUS_EXPR:
 461       /* We can't turn -(A-B) into B-A when we honor signed zeros.  */
 462       return !HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (type))
 463              && !HONOR_SIGNED_ZEROS (TYPE_MODE (type))
 464              && reorder_operands_p (TREE_OPERAND (t, 0),
 465                                     TREE_OPERAND (t, 1));
 466
 467     case MULT_EXPR:
 468       if (TYPE_UNSIGNED (TREE_TYPE (t)))
 469         break;
 470
 471       /* Fall through.  */
 472
 473     case RDIV_EXPR:
 474       if (! HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (TREE_TYPE (t))))
 475         return negate_expr_p (TREE_OPERAND (t, 1))
 476                || negate_expr_p (TREE_OPERAND (t, 0));
 477       break;
 478
 479     case TRUNC_DIV_EXPR:
 480     case ROUND_DIV_EXPR:
 481     case FLOOR_DIV_EXPR:
 482     case CEIL_DIV_EXPR:
 483     case EXACT_DIV_EXPR:
 484       /* In general we can't negate A / B, because if A is INT_MIN and
 485          B is 1, we may turn this into INT_MIN / -1 which is undefined
 486          and actually traps on some architectures.  But if overflow is
 487          undefined, we can negate, because - (INT_MIN / 1) is an
 488          overflow.  */
 489       if (INTEGRAL_TYPE_P (TREE_TYPE (t))
 490           && !TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (t)))
 491         break;
 492       return negate_expr_p (TREE_OPERAND (t, 1))
 493              || negate_expr_p (TREE_OPERAND (t, 0));
 494
 495     case NOP_EXPR:
 496       /* Negate -((double)float) as (double)(-float).  */
 497       if (TREE_CODE (type) == REAL_TYPE)
 498         {
 499           tree tem = strip_float_extensions (t);
 500           if (tem != t)
 501             return negate_expr_p (tem);
 502         }
 503       break;
 504
 505     case CALL_EXPR:
 506       /* Negate -f(x) as f(-x).  */
 507       if (negate_mathfn_p (builtin_mathfn_code (t)))
 508         return negate_expr_p (CALL_EXPR_ARG (t, 0));
 509       break;
 510
 511     case RSHIFT_EXPR:
 512       /* Optimize -((int)x >> 31) into (unsigned)x >> 31.  */
 513       if (TREE_CODE (TREE_OPERAND (t, 1)) == INTEGER_CST)
 514         {
 515           tree op1 = TREE_OPERAND (t, 1);
 516           if (TREE_INT_CST_HIGH (op1) == 0
 517               && (unsigned HOST_WIDE_INT) (TYPE_PRECISION (type) - 1)
 518                  == TREE_INT_CST_LOW (op1))
 519             return true;
 520         }
 521       break;
 522
 523     default:
 524       break;
 525     }
 526   return false;
 527 }
 528
 529 /* Given T, an expression, return a folded tree for -T or NULL_TREE, if no
 530    simplification is possible.
 531    If negate_expr_p would return true for T, NULL_TREE will never be
 532    returned.  */
 533
 534 static tree
 535 fold_negate_expr (location_t loc, tree t)
 536 {
 537   tree type = TREE_TYPE (t);
 538   tree tem;
 539
 540   switch (TREE_CODE (t))
 541     {
 542     /* Convert - (~A) to A + 1.  */
 543     case BIT_NOT_EXPR:
 544       if (INTEGRAL_TYPE_P (type))
 545         return fold_build2_loc (loc, PLUS_EXPR, type, TREE_OPERAND (t, 0),
 546                             build_int_cst (type, 1));
 547       break;
 548
 549     case INTEGER_CST:
 550       tem = fold_negate_const (t, type);
 551       if (TREE_OVERFLOW (tem) == TREE_OVERFLOW (t)
 552           || !TYPE_OVERFLOW_TRAPS (type))
 553         return tem;
 554       break;
 555
 556     case REAL_CST:
 557       tem = fold_negate_const (t, type);
 558       /* Two's complement FP formats, such as c4x, may overflow.  */
 559       if (!TREE_OVERFLOW (tem) || !flag_trapping_math)
 560         return tem;
 561       break;
 562
 563     case FIXED_CST:
 564       tem = fold_negate_const (t, type);
 565       return tem;
 566
 567     case COMPLEX_CST:
 568       {
 569         tree rpart = negate_expr (TREE_REALPART (t));
 570         tree ipart = negate_expr (TREE_IMAGPART (t));
 571
 572         if ((TREE_CODE (rpart) == REAL_CST
 573              && TREE_CODE (ipart) == REAL_CST)
 574             || (TREE_CODE (rpart) == INTEGER_CST
 575                 && TREE_CODE (ipart) == INTEGER_CST))
 576           return build_complex (type, rpart, ipart);
 577       }
 578       break;
 579
 580     case COMPLEX_EXPR:
 581       if (negate_expr_p (t))
 582         return fold_build2_loc (loc, COMPLEX_EXPR, type,
 583                             fold_negate_expr (loc, TREE_OPERAND (t, 0)),
 584                             fold_negate_expr (loc, TREE_OPERAND (t, 1)));
 585       break;
 586
 587     case CONJ_EXPR:
 588       if (negate_expr_p (t))
 589         return fold_build1_loc (loc, CONJ_EXPR, type,
 590                             fold_negate_expr (loc, TREE_OPERAND (t, 0)));
 591       break;
 592
 593     case NEGATE_EXPR:
 594       return TREE_OPERAND (t, 0);
 595
 596     case PLUS_EXPR:
 597       if (!HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (type))
 598           && !HONOR_SIGNED_ZEROS (TYPE_MODE (type)))
 599         {
 600           /* -(A + B) -> (-B) - A.  */
 601           if (negate_expr_p (TREE_OPERAND (t, 1))
 602               && reorder_operands_p (TREE_OPERAND (t, 0),
 603                                      TREE_OPERAND (t, 1)))
 604             {
 605               tem = negate_expr (TREE_OPERAND (t, 1));
 606               return fold_build2_loc (loc, MINUS_EXPR, type,
 607                                   tem, TREE_OPERAND (t, 0));
 608             }
 609
 610           /* -(A + B) -> (-A) - B.  */
 611           if (negate_expr_p (TREE_OPERAND (t, 0)))
 612             {
 613               tem = negate_expr (TREE_OPERAND (t, 0));
 614               return fold_build2_loc (loc, MINUS_EXPR, type,
 615                                   tem, TREE_OPERAND (t, 1));
 616             }
 617         }
 618       break;
 619
 620     case MINUS_EXPR:
 621       /* - (A - B) -> B - A  */
 622       if (!HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (type))
 623           && !HONOR_SIGNED_ZEROS (TYPE_MODE (type))
 624           && reorder_operands_p (TREE_OPERAND (t, 0), TREE_OPERAND (t, 1)))
 625         return fold_build2_loc (loc, MINUS_EXPR, type,
 626                             TREE_OPERAND (t, 1), TREE_OPERAND (t, 0));
 627       break;
 628
 629     case MULT_EXPR:
 630       if (TYPE_UNSIGNED (type))
 631         break;
 632
 633       /* Fall through.  */
 634
 635     case RDIV_EXPR:
 636       if (! HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (type)))
 637         {
 638           tem = TREE_OPERAND (t, 1);
 639           if (negate_expr_p (tem))
 640             return fold_build2_loc (loc, TREE_CODE (t), type,
 641                                 TREE_OPERAND (t, 0), negate_expr (tem));
 642           tem = TREE_OPERAND (t, 0);
 643           if (negate_expr_p (tem))
 644             return fold_build2_loc (loc, TREE_CODE (t), type,
 645                                 negate_expr (tem), TREE_OPERAND (t, 1));
 646         }
 647       break;
 648
 649     case TRUNC_DIV_EXPR:
 650     case ROUND_DIV_EXPR:
 651     case FLOOR_DIV_EXPR:
 652     case CEIL_DIV_EXPR:
 653     case EXACT_DIV_EXPR:
 654       /* In general we can't negate A / B, because if A is INT_MIN and
 655          B is 1, we may turn this into INT_MIN / -1 which is undefined
 656          and actually traps on some architectures.  But if overflow is
 657          undefined, we can negate, because - (INT_MIN / 1) is an
 658          overflow.  */
 659       if (!INTEGRAL_TYPE_P (type) || TYPE_OVERFLOW_UNDEFINED (type))
 660         {
 661           const char * const warnmsg = G_("assuming signed overflow does not "
 662                                           "occur when negating a division");
 663           tem = TREE_OPERAND (t, 1);
 664           if (negate_expr_p (tem))
 665             {
 666               if (INTEGRAL_TYPE_P (type)
 667                   && (TREE_CODE (tem) != INTEGER_CST
 668                       || integer_onep (tem)))
 669                 fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_MISC);
 670               return fold_build2_loc (loc, TREE_CODE (t), type,
 671                                   TREE_OPERAND (t, 0), negate_expr (tem));
 672             }
 673           tem = TREE_OPERAND (t, 0);
 674           if (negate_expr_p (tem))
 675             {
 676               if (INTEGRAL_TYPE_P (type)
 677                   && (TREE_CODE (tem) != INTEGER_CST
 678                       || tree_int_cst_equal (tem, TYPE_MIN_VALUE (type))))
 679                 fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_MISC);
 680               return fold_build2_loc (loc, TREE_CODE (t), type,
 681                                   negate_expr (tem), TREE_OPERAND (t, 1));
 682             }
 683         }
 684       break;
 685
 686     case NOP_EXPR:
 687       /* Convert -((double)float) into (double)(-float).  */
 688       if (TREE_CODE (type) == REAL_TYPE)
 689         {
 690           tem = strip_float_extensions (t);
 691           if (tem != t && negate_expr_p (tem))
 692             return fold_convert_loc (loc, type, negate_expr (tem));
 693         }
 694       break;
 695
 696     case CALL_EXPR:
 697       /* Negate -f(x) as f(-x).  */
 698       if (negate_mathfn_p (builtin_mathfn_code (t))
 699           && negate_expr_p (CALL_EXPR_ARG (t, 0)))
 700         {
 701           tree fndecl, arg;
 702
 703           fndecl = get_callee_fndecl (t);
 704           arg = negate_expr (CALL_EXPR_ARG (t, 0));
 705           return build_call_expr_loc (loc, fndecl, 1, arg);
 706         }
 707       break;
 708
 709     case RSHIFT_EXPR:
 710       /* Optimize -((int)x >> 31) into (unsigned)x >> 31.  */
 711       if (TREE_CODE (TREE_OPERAND (t, 1)) == INTEGER_CST)
 712         {
 713           tree op1 = TREE_OPERAND (t, 1);
 714           if (TREE_INT_CST_HIGH (op1) == 0
 715               && (unsigned HOST_WIDE_INT) (TYPE_PRECISION (type) - 1)
 716                  == TREE_INT_CST_LOW (op1))
 717             {
 718               tree ntype = TYPE_UNSIGNED (type)
 719                            ? signed_type_for (type)
 720                            : unsigned_type_for (type);
 721               tree temp = fold_convert_loc (loc, ntype, TREE_OPERAND (t, 0));
 722               temp = fold_build2_loc (loc, RSHIFT_EXPR, ntype, temp, op1);
 723               return fold_convert_loc (loc, type, temp);
 724             }
 725         }
 726       break;
 727
 728     default:
 729       break;
 730     }
 731
 732   return NULL_TREE;
 733 }
 734
 735 /* Like fold_negate_expr, but return a NEGATE_EXPR tree, if T can not be
 736    negated in a simpler way.  Also allow for T to be NULL_TREE, in which case
 737    return NULL_TREE. */
 738
 739 static tree
 740 negate_expr (tree t)
 741 {
 742   tree type, tem;
 743   location_t loc;
 744
 745   if (t == NULL_TREE)
 746     return NULL_TREE;
 747
 748   loc = EXPR_LOCATION (t);
 749   type = TREE_TYPE (t);
 750   STRIP_SIGN_NOPS (t);
 751
 752   tem = fold_negate_expr (loc, t);
 753   if (!tem)
 754     tem = build1_loc (loc, NEGATE_EXPR, TREE_TYPE (t), t);
 755   return fold_convert_loc (loc, type, tem);
 756 }
 757 \f
 758 /* Split a tree IN into a constant, literal and variable parts that could be
 759    combined with CODE to make IN.  "constant" means an expression with
 760    TREE_CONSTANT but that isn't an actual constant.  CODE must be a
 761    commutative arithmetic operation.  Store the constant part into *CONP,
 762    the literal in *LITP and return the variable part.  If a part isn't
 763    present, set it to null.  If the tree does not decompose in this way,
 764    return the entire tree as the variable part and the other parts as null.
 765
 766    If CODE is PLUS_EXPR we also split trees that use MINUS_EXPR.  In that
 767    case, we negate an operand that was subtracted.  Except if it is a
 768    literal for which we use *MINUS_LITP instead.
 769
 770    If NEGATE_P is true, we are negating all of IN, again except a literal
 771    for which we use *MINUS_LITP instead.
 772
 773    If IN is itself a literal or constant, return it as appropriate.
 774
 775    Note that we do not guarantee that any of the three values will be the
 776    same type as IN, but they will have the same signedness and mode.  */
 777
 778 static tree
 779 split_tree (tree in, enum tree_code code, tree *conp, tree *litp,
 780             tree *minus_litp, int negate_p)
 781 {
 782   tree var = 0;
 783
 784   *conp = 0;
 785   *litp = 0;
 786   *minus_litp = 0;
 787
 788   /* Strip any conversions that don't change the machine mode or signedness.  */
 789   STRIP_SIGN_NOPS (in);
 790
 791   if (TREE_CODE (in) == INTEGER_CST || TREE_CODE (in) == REAL_CST
 792       || TREE_CODE (in) == FIXED_CST)
 793     *litp = in;
 794   else if (TREE_CODE (in) == code
 795            || ((! FLOAT_TYPE_P (TREE_TYPE (in)) || flag_associative_math)
 796                && ! SAT_FIXED_POINT_TYPE_P (TREE_TYPE (in))
 797                /* We can associate addition and subtraction together (even
 798                   though the C standard doesn't say so) for integers because
 799                   the value is not affected.  For reals, the value might be
 800                   affected, so we can't.  */
 801                && ((code == PLUS_EXPR && TREE_CODE (in) == MINUS_EXPR)
 802                    || (code == MINUS_EXPR && TREE_CODE (in) == PLUS_EXPR))))
 803     {
 804       tree op0 = TREE_OPERAND (in, 0);
 805       tree op1 = TREE_OPERAND (in, 1);
 806       int neg1_p = TREE_CODE (in) == MINUS_EXPR;
 807       int neg_litp_p = 0, neg_conp_p = 0, neg_var_p = 0;
 808
 809       /* First see if either of the operands is a literal, then a constant.  */
 810       if (TREE_CODE (op0) == INTEGER_CST || TREE_CODE (op0) == REAL_CST
 811           || TREE_CODE (op0) == FIXED_CST)
 812         *litp = op0, op0 = 0;
 813       else if (TREE_CODE (op1) == INTEGER_CST || TREE_CODE (op1) == REAL_CST
 814                || TREE_CODE (op1) == FIXED_CST)
 815         *litp = op1, neg_litp_p = neg1_p, op1 = 0;
 816
 817       if (op0 != 0 && TREE_CONSTANT (op0))
 818         *conp = op0, op0 = 0;
 819       else if (op1 != 0 && TREE_CONSTANT (op1))
 820         *conp = op1, neg_conp_p = neg1_p, op1 = 0;
 821
 822       /* If we haven't dealt with either operand, this is not a case we can
 823          decompose.  Otherwise, VAR is either of the ones remaining, if any.  */
 824       if (op0 != 0 && op1 != 0)
 825         var = in;
 826       else if (op0 != 0)
 827         var = op0;
 828       else
 829         var = op1, neg_var_p = neg1_p;
 830
 831       /* Now do any needed negations.  */
 832       if (neg_litp_p)
 833         *minus_litp = *litp, *litp = 0;
 834       if (neg_conp_p)
 835         *conp = negate_expr (*conp);
 836       if (neg_var_p)
 837         var = negate_expr (var);
 838     }
 839   else if (TREE_CONSTANT (in))
 840     *conp = in;
 841   else
 842     var = in;
 843
 844   if (negate_p)
 845     {
 846       if (*litp)
 847         *minus_litp = *litp, *litp = 0;
 848       else if (*minus_litp)
 849         *litp = *minus_litp, *minus_litp = 0;
 850       *conp = negate_expr (*conp);
 851       var = negate_expr (var);
 852     }
 853
 854   return var;
 855 }
 856
 857 /* Re-associate trees split by the above function.  T1 and T2 are
 858    either expressions to associate or null.  Return the new
 859    expression, if any.  LOC is the location of the new expression.  If
 860    we build an operation, do it in TYPE and with CODE.  */
 861
 862 static tree
 863 associate_trees (location_t loc, tree t1, tree t2, enum tree_code code, tree type)
 864 {
 865   if (t1 == 0)
 866     return t2;
 867   else if (t2 == 0)
 868     return t1;
 869
 870   /* If either input is CODE, a PLUS_EXPR, or a MINUS_EXPR, don't
 871      try to fold this since we will have infinite recursion.  But do
 872      deal with any NEGATE_EXPRs.  */
 873   if (TREE_CODE (t1) == code || TREE_CODE (t2) == code
 874       || TREE_CODE (t1) == MINUS_EXPR || TREE_CODE (t2) == MINUS_EXPR)
 875     {
 876       if (code == PLUS_EXPR)
 877         {
 878           if (TREE_CODE (t1) == NEGATE_EXPR)
 879             return build2_loc (loc, MINUS_EXPR, type,
 880                                fold_convert_loc (loc, type, t2),
 881                                fold_convert_loc (loc, type,
 882                                                  TREE_OPERAND (t1, 0)));
 883           else if (TREE_CODE (t2) == NEGATE_EXPR)
 884             return build2_loc (loc, MINUS_EXPR, type,
 885                                fold_convert_loc (loc, type, t1),
 886                                fold_convert_loc (loc, type,
 887                                                  TREE_OPERAND (t2, 0)));
 888           else if (integer_zerop (t2))
 889             return fold_convert_loc (loc, type, t1);
 890         }
 891       else if (code == MINUS_EXPR)
 892         {
 893           if (integer_zerop (t2))
 894             return fold_convert_loc (loc, type, t1);
 895         }
 896
 897       return build2_loc (loc, code, type, fold_convert_loc (loc, type, t1),
 898                          fold_convert_loc (loc, type, t2));
 899     }
 900
 901   return fold_build2_loc (loc, code, type, fold_convert_loc (loc, type, t1),
 902                           fold_convert_loc (loc, type, t2));
 903 }
 904 \f
 905 /* Check whether TYPE1 and TYPE2 are equivalent integer types, suitable
 906    for use in int_const_binop, size_binop and size_diffop.  */
 907
 908 static bool
 909 int_binop_types_match_p (enum tree_code code, const_tree type1, const_tree type2)
 910 {
 911   if (TREE_CODE (type1) != INTEGER_TYPE && !POINTER_TYPE_P (type1))
 912     return false;
 913   if (TREE_CODE (type2) != INTEGER_TYPE && !POINTER_TYPE_P (type2))
 914     return false;
 915
 916   switch (code)
 917     {
 918     case LSHIFT_EXPR:
 919     case RSHIFT_EXPR:
 920     case LROTATE_EXPR:
 921     case RROTATE_EXPR:
 922       return true;
 923
 924     default:
 925       break;
 926     }
 927
 928   return TYPE_UNSIGNED (type1) == TYPE_UNSIGNED (type2)
 929          && TYPE_PRECISION (type1) == TYPE_PRECISION (type2)
 930          && TYPE_MODE (type1) == TYPE_MODE (type2);
 931 }
 932
 933
 934 /* Combine two integer constants ARG1 and ARG2 under operation CODE
 935    to produce a new constant.  Return NULL_TREE if we don't know how
 936    to evaluate CODE at compile-time.  */
 937
 938 tree
 939 int_const_binop (enum tree_code code, const_tree arg1, const_tree arg2)
 940 {
 941   double_int op1, op2, res, tmp;
 942   tree t;
 943   tree type = TREE_TYPE (arg1);
 944   bool uns = TYPE_UNSIGNED (type);
 945   bool is_sizetype
 946     = (TREE_CODE (type) == INTEGER_TYPE && TYPE_IS_SIZETYPE (type));
 947   bool overflow = false;
 948
 949   op1 = tree_to_double_int (arg1);
 950   op2 = tree_to_double_int (arg2);
 951
 952   switch (code)
 953     {
 954     case BIT_IOR_EXPR:
 955       res = double_int_ior (op1, op2);
 956       break;
 957
 958     case BIT_XOR_EXPR:
 959       res = double_int_xor (op1, op2);
 960       break;
 961
 962     case BIT_AND_EXPR:
 963       res = double_int_and (op1, op2);
 964       break;
 965
 966     case RSHIFT_EXPR:
 967       res = double_int_rshift (op1, double_int_to_shwi (op2),
 968                                TYPE_PRECISION (type), !uns);
 969       break;
 970
 971     case LSHIFT_EXPR:
 972       /* It's unclear from the C standard whether shifts can overflow.
 973          The following code ignores overflow; perhaps a C standard
 974          interpretation ruling is needed.  */
 975       res = double_int_lshift (op1, double_int_to_shwi (op2),
 976                                TYPE_PRECISION (type), !uns);
 977       break;
 978
 979     case RROTATE_EXPR:
 980       res = double_int_rrotate (op1, double_int_to_shwi (op2),
 981                                 TYPE_PRECISION (type));
 982       break;
 983
 984     case LROTATE_EXPR:
 985       res = double_int_lrotate (op1, double_int_to_shwi (op2),
 986                                 TYPE_PRECISION (type));
 987       break;
 988
 989     case PLUS_EXPR:
 990       overflow = add_double (op1.low, op1.high, op2.low, op2.high,
 991                              &res.low, &res.high);
 992       break;
 993
 994     case MINUS_EXPR:
 995       neg_double (op2.low, op2.high, &res.low, &res.high);
 996       add_double (op1.low, op1.high, res.low, res.high,
 997                   &res.low, &res.high);
 998       overflow = OVERFLOW_SUM_SIGN (res.high, op2.high, op1.high);
 999       break;
1000
1001     case MULT_EXPR:
1002       overflow = mul_double (op1.low, op1.high, op2.low, op2.high,
1003                              &res.low, &res.high);
1004       break;
1005
1006     case TRUNC_DIV_EXPR:
1007     case FLOOR_DIV_EXPR: case CEIL_DIV_EXPR:
1008     case EXACT_DIV_EXPR:
1009       /* This is a shortcut for a common special case.  */
1010       if (op2.high == 0 && (HOST_WIDE_INT) op2.low > 0
1011           && !TREE_OVERFLOW (arg1)
1012           && !TREE_OVERFLOW (arg2)
1013           && op1.high == 0 && (HOST_WIDE_INT) op1.low >= 0)
1014         {
1015           if (code == CEIL_DIV_EXPR)
1016             op1.low += op2.low - 1;
1017
1018           res.low = op1.low / op2.low, res.high = 0;
1019           break;
1020         }
1021
1022       /* ... fall through ...  */
1023
1024     case ROUND_DIV_EXPR:
1025       if (double_int_zero_p (op2))
1026         return NULL_TREE;
1027       if (double_int_one_p (op2))
1028         {
1029           res = op1;
1030           break;
1031         }
1032       if (double_int_equal_p (op1, op2)
1033           && ! double_int_zero_p (op1))
1034         {
1035           res = double_int_one;
1036           break;
1037         }
1038       overflow = div_and_round_double (code, uns,
1039                                        op1.low, op1.high, op2.low, op2.high,
1040                                        &res.low, &res.high,
1041                                        &tmp.low, &tmp.high);
1042       break;
1043
1044     case TRUNC_MOD_EXPR:
1045     case FLOOR_MOD_EXPR: case CEIL_MOD_EXPR:
1046       /* This is a shortcut for a common special case.  */
1047       if (op2.high == 0 && (HOST_WIDE_INT) op2.low > 0
1048           && !TREE_OVERFLOW (arg1)
1049           && !TREE_OVERFLOW (arg2)
1050           && op1.high == 0 && (HOST_WIDE_INT) op1.low >= 0)
1051         {
1052           if (code == CEIL_MOD_EXPR)
1053             op1.low += op2.low - 1;
1054           res.low = op1.low % op2.low, res.high = 0;
1055           break;
1056         }
1057
1058       /* ... fall through ...  */
1059
1060     case ROUND_MOD_EXPR:
1061       if (double_int_zero_p (op2))
1062         return NULL_TREE;
1063       overflow = div_and_round_double (code, uns,
1064                                        op1.low, op1.high, op2.low, op2.high,
1065                                        &tmp.low, &tmp.high,
1066                                        &res.low, &res.high);
1067       break;
1068
1069     case MIN_EXPR:
1070       res = double_int_min (op1, op2, uns);
1071       break;
1072
1073     case MAX_EXPR:
1074       res = double_int_max (op1, op2, uns);
1075       break;
1076
1077     default:
1078       return NULL_TREE;
1079     }
1080
1081   t = force_fit_type_double (TREE_TYPE (arg1), res, 1,
1082                              ((!uns || is_sizetype) && overflow)
1083                              | TREE_OVERFLOW (arg1) | TREE_OVERFLOW (arg2));
1084
1085   return t;
1086 }
1087
1088 /* Combine two constants ARG1 and ARG2 under operation CODE to produce a new
1089    constant.  We assume ARG1 and ARG2 have the same data type, or at least
1090    are the same kind of constant and the same machine mode.  Return zero if
1091    combining the constants is not allowed in the current operating mode.  */
1092
1093 static tree
1094 const_binop (enum tree_code code, tree arg1, tree arg2)
1095 {
1096   /* Sanity check for the recursive cases.  */
1097   if (!arg1 || !arg2)
1098     return NULL_TREE;
1099
1100   STRIP_NOPS (arg1);
1101   STRIP_NOPS (arg2);
1102
1103   if (TREE_CODE (arg1) == INTEGER_CST)
1104     return int_const_binop (code, arg1, arg2);
1105
1106   if (TREE_CODE (arg1) == REAL_CST)
1107     {
1108       enum machine_mode mode;
1109       REAL_VALUE_TYPE d1;
1110       REAL_VALUE_TYPE d2;
1111       REAL_VALUE_TYPE value;
1112       REAL_VALUE_TYPE result;
1113       bool inexact;
1114       tree t, type;
1115
1116       /* The following codes are handled by real_arithmetic.  */
1117       switch (code)
1118         {
1119         case PLUS_EXPR:
1120         case MINUS_EXPR:
1121         case MULT_EXPR:
1122         case RDIV_EXPR:
1123         case MIN_EXPR:
1124         case MAX_EXPR:
1125           break;
1126
1127         default:
1128           return NULL_TREE;
1129         }
1130
1131       d1 = TREE_REAL_CST (arg1);
1132       d2 = TREE_REAL_CST (arg2);
1133
1134       type = TREE_TYPE (arg1);
1135       mode = TYPE_MODE (type);
1136
1137       /* Don't perform operation if we honor signaling NaNs and
1138          either operand is a NaN.  */
1139       if (HONOR_SNANS (mode)
1140           && (REAL_VALUE_ISNAN (d1) || REAL_VALUE_ISNAN (d2)))
1141         return NULL_TREE;
1142
1143       /* Don't perform operation if it would raise a division
1144          by zero exception.  */
1145       if (code == RDIV_EXPR
1146           && REAL_VALUES_EQUAL (d2, dconst0)
1147           && (flag_trapping_math || ! MODE_HAS_INFINITIES (mode)))
1148         return NULL_TREE;
1149
1150       /* If either operand is a NaN, just return it.  Otherwise, set up
1151          for floating-point trap; we return an overflow.  */
1152       if (REAL_VALUE_ISNAN (d1))
1153         return arg1;
1154       else if (REAL_VALUE_ISNAN (d2))
1155         return arg2;
1156
1157       inexact = real_arithmetic (&value, code, &d1, &d2);
1158       real_convert (&result, mode, &value);
1159
1160       /* Don't constant fold this floating point operation if
1161          the result has overflowed and flag_trapping_math.  */
1162       if (flag_trapping_math
1163           && MODE_HAS_INFINITIES (mode)
1164           && REAL_VALUE_ISINF (result)
1165           && !REAL_VALUE_ISINF (d1)
1166           && !REAL_VALUE_ISINF (d2))
1167         return NULL_TREE;
1168
1169       /* Don't constant fold this floating point operation if the
1170          result may dependent upon the run-time rounding mode and
1171          flag_rounding_math is set, or if GCC's software emulation
1172          is unable to accurately represent the result.  */
1173       if ((flag_rounding_math
1174            || (MODE_COMPOSITE_P (mode) && !flag_unsafe_math_optimizations))
1175           && (inexact || !real_identical (&result, &value)))
1176         return NULL_TREE;
1177
1178       t = build_real (type, result);
1179
1180       TREE_OVERFLOW (t) = TREE_OVERFLOW (arg1) | TREE_OVERFLOW (arg2);
1181       return t;
1182     }
1183
1184   if (TREE_CODE (arg1) == FIXED_CST)
1185     {
1186       FIXED_VALUE_TYPE f1;
1187       FIXED_VALUE_TYPE f2;
1188       FIXED_VALUE_TYPE result;
1189       tree t, type;
1190       int sat_p;
1191       bool overflow_p;
1192
1193       /* The following codes are handled by fixed_arithmetic.  */
1194       switch (code)
1195         {
1196         case PLUS_EXPR:
1197         case MINUS_EXPR:
1198         case MULT_EXPR:
1199         case TRUNC_DIV_EXPR:
1200           f2 = TREE_FIXED_CST (arg2);
1201           break;
1202
1203         case LSHIFT_EXPR:
1204         case RSHIFT_EXPR:
1205           f2.data.high = TREE_INT_CST_HIGH (arg2);
1206           f2.data.low = TREE_INT_CST_LOW (arg2);
1207           f2.mode = SImode;
1208           break;
1209
1210         default:
1211           return NULL_TREE;
1212         }
1213
1214       f1 = TREE_FIXED_CST (arg1);
1215       type = TREE_TYPE (arg1);
1216       sat_p = TYPE_SATURATING (type);
1217       overflow_p = fixed_arithmetic (&result, code, &f1, &f2, sat_p);
1218       t = build_fixed (type, result);
1219       /* Propagate overflow flags.  */
1220       if (overflow_p | TREE_OVERFLOW (arg1) | TREE_OVERFLOW (arg2))
1221         TREE_OVERFLOW (t) = 1;
1222       return t;
1223     }
1224
1225   if (TREE_CODE (arg1) == COMPLEX_CST)
1226     {
1227       tree type = TREE_TYPE (arg1);
1228       tree r1 = TREE_REALPART (arg1);
1229       tree i1 = TREE_IMAGPART (arg1);
1230       tree r2 = TREE_REALPART (arg2);
1231       tree i2 = TREE_IMAGPART (arg2);
1232       tree real, imag;
1233
1234       switch (code)
1235         {
1236         case PLUS_EXPR:
1237         case MINUS_EXPR:
1238           real = const_binop (code, r1, r2);
1239           imag = const_binop (code, i1, i2);
1240           break;
1241
1242         case MULT_EXPR:
1243           if (COMPLEX_FLOAT_TYPE_P (type))
1244             return do_mpc_arg2 (arg1, arg2, type,
1245                                 /* do_nonfinite= */ folding_initializer,
1246                                 mpc_mul);
1247
1248           real = const_binop (MINUS_EXPR,
1249                               const_binop (MULT_EXPR, r1, r2),
1250                               const_binop (MULT_EXPR, i1, i2));
1251           imag = const_binop (PLUS_EXPR,
1252                               const_binop (MULT_EXPR, r1, i2),
1253                               const_binop (MULT_EXPR, i1, r2));
1254           break;
1255
1256         case RDIV_EXPR:
1257           if (COMPLEX_FLOAT_TYPE_P (type))
1258             return do_mpc_arg2 (arg1, arg2, type,
1259                                 /* do_nonfinite= */ folding_initializer,
1260                                 mpc_div);
1261           /* Fallthru ... */
1262         case TRUNC_DIV_EXPR:
1263         case CEIL_DIV_EXPR:
1264         case FLOOR_DIV_EXPR:
1265         case ROUND_DIV_EXPR:
1266           if (flag_complex_method == 0)
1267           {
1268             /* Keep this algorithm in sync with
1269                tree-complex.c:expand_complex_div_straight().
1270
1271                Expand complex division to scalars, straightforward algorithm.
1272                a / b = ((ar*br + ai*bi)/t) + i((ai*br - ar*bi)/t)
1273                t = br*br + bi*bi
1274             */
1275             tree magsquared
1276               = const_binop (PLUS_EXPR,
1277                              const_binop (MULT_EXPR, r2, r2),
1278                              const_binop (MULT_EXPR, i2, i2));
1279             tree t1
1280               = const_binop (PLUS_EXPR,
1281                              const_binop (MULT_EXPR, r1, r2),
1282                              const_binop (MULT_EXPR, i1, i2));
1283             tree t2
1284               = const_binop (MINUS_EXPR,
1285                              const_binop (MULT_EXPR, i1, r2),
1286                              const_binop (MULT_EXPR, r1, i2));
1287
1288             real = const_binop (code, t1, magsquared);
1289             imag = const_binop (code, t2, magsquared);
1290           }
1291           else
1292           {
1293             /* Keep this algorithm in sync with
1294                tree-complex.c:expand_complex_div_wide().
1295
1296                Expand complex division to scalars, modified algorithm to minimize
1297                overflow with wide input ranges.  */
1298             tree compare = fold_build2 (LT_EXPR, boolean_type_node,
1299                                         fold_abs_const (r2, TREE_TYPE (type)),
1300                                         fold_abs_const (i2, TREE_TYPE (type)));
1301
1302             if (integer_nonzerop (compare))
1303               {
1304                 /* In the TRUE branch, we compute
1305                    ratio = br/bi;
1306                    div = (br * ratio) + bi;
1307                    tr = (ar * ratio) + ai;
1308                    ti = (ai * ratio) - ar;
1309                    tr = tr / div;
1310                    ti = ti / div;  */
1311                 tree ratio = const_binop (code, r2, i2);
1312                 tree div = const_binop (PLUS_EXPR, i2,
1313                                         const_binop (MULT_EXPR, r2, ratio));
1314                 real = const_binop (MULT_EXPR, r1, ratio);
1315                 real = const_binop (PLUS_EXPR, real, i1);
1316                 real = const_binop (code, real, div);
1317
1318                 imag = const_binop (MULT_EXPR, i1, ratio);
1319                 imag = const_binop (MINUS_EXPR, imag, r1);
1320                 imag = const_binop (code, imag, div);
1321               }
1322             else
1323               {
1324                 /* In the FALSE branch, we compute
1325                    ratio = d/c;
1326                    divisor = (d * ratio) + c;
1327                    tr = (b * ratio) + a;
1328                    ti = b - (a * ratio);
1329                    tr = tr / div;
1330                    ti = ti / div;  */
1331                 tree ratio = const_binop (code, i2, r2);
1332                 tree div = const_binop (PLUS_EXPR, r2,
1333                                         const_binop (MULT_EXPR, i2, ratio));
1334
1335                 real = const_binop (MULT_EXPR, i1, ratio);
1336                 real = const_binop (PLUS_EXPR, real, r1);
1337                 real = const_binop (code, real, div);
1338
1339                 imag = const_binop (MULT_EXPR, r1, ratio);
1340                 imag = const_binop (MINUS_EXPR, i1, imag);
1341                 imag = const_binop (code, imag, div);
1342               }
1343           }
1344           break;
1345
1346         default:
1347           return NULL_TREE;
1348         }
1349
1350       if (real && imag)
1351         return build_complex (type, real, imag);
1352     }
1353
1354   if (TREE_CODE (arg1) == VECTOR_CST)
1355     {
1356       tree type = TREE_TYPE(arg1);
1357       int count = TYPE_VECTOR_SUBPARTS (type), i;
1358       tree elements1, elements2, list = NULL_TREE;
1359
1360       if(TREE_CODE(arg2) != VECTOR_CST)
1361         return NULL_TREE;
1362
1363       elements1 = TREE_VECTOR_CST_ELTS (arg1);
1364       elements2 = TREE_VECTOR_CST_ELTS (arg2);
1365
1366       for (i = 0; i < count; i++)
1367         {
1368           tree elem1, elem2, elem;
1369
1370           /* The trailing elements can be empty and should be treated as 0 */
1371           if(!elements1)
1372             elem1 = fold_convert_const (NOP_EXPR, TREE_TYPE (type), integer_zero_node);
1373           else
1374             {
1375               elem1 = TREE_VALUE(elements1);
1376               elements1 = TREE_CHAIN (elements1);
1377             }
1378
1379           if(!elements2)
1380             elem2 = fold_convert_const (NOP_EXPR, TREE_TYPE (type), integer_zero_node);
1381           else
1382             {
1383               elem2 = TREE_VALUE(elements2);
1384               elements2 = TREE_CHAIN (elements2);
1385             }
1386
1387           elem = const_binop (code, elem1, elem2);
1388
1389           /* It is possible that const_binop cannot handle the given
1390             code and return NULL_TREE */
1391           if(elem == NULL_TREE)
1392             return NULL_TREE;
1393
1394           list = tree_cons (NULL_TREE, elem, list);
1395         }
1396       return build_vector(type, nreverse(list));
1397     }
1398   return NULL_TREE;
1399 }
1400
1401 /* Create a size type INT_CST node with NUMBER sign extended.  KIND
1402    indicates which particular sizetype to create.  */
1403
1404 tree
1405 size_int_kind (HOST_WIDE_INT number, enum size_type_kind kind)
1406 {
1407   return build_int_cst (sizetype_tab[(int) kind], number);
1408 }
1409 \f
1410 /* Combine operands OP1 and OP2 with arithmetic operation CODE.  CODE
1411    is a tree code.  The type of the result is taken from the operands.
1412    Both must be equivalent integer types, ala int_binop_types_match_p.
1413    If the operands are constant, so is the result.  */
1414
1415 tree
1416 size_binop_loc (location_t loc, enum tree_code code, tree arg0, tree arg1)
1417 {
1418   tree type = TREE_TYPE (arg0);
1419
1420   if (arg0 == error_mark_node || arg1 == error_mark_node)
1421     return error_mark_node;
1422
1423   gcc_assert (int_binop_types_match_p (code, TREE_TYPE (arg0),
1424                                        TREE_TYPE (arg1)));
1425
1426   /* Handle the special case of two integer constants faster.  */
1427   if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
1428     {
1429       /* And some specific cases even faster than that.  */
1430       if (code == PLUS_EXPR)
1431         {
1432           if (integer_zerop (arg0) && !TREE_OVERFLOW (arg0))
1433             return arg1;
1434           if (integer_zerop (arg1) && !TREE_OVERFLOW (arg1))
1435             return arg0;
1436         }
1437       else if (code == MINUS_EXPR)
1438         {
1439           if (integer_zerop (arg1) && !TREE_OVERFLOW (arg1))
1440             return arg0;
1441         }
1442       else if (code == MULT_EXPR)
1443         {
1444           if (integer_onep (arg0) && !TREE_OVERFLOW (arg0))
1445             return arg1;
1446         }
1447
1448       /* Handle general case of two integer constants.  */
1449       return int_const_binop (code, arg0, arg1);
1450     }
1451
1452   return fold_build2_loc (loc, code, type, arg0, arg1);
1453 }
1454
1455 /* Given two values, either both of sizetype or both of bitsizetype,
1456    compute the difference between the two values.  Return the value
1457    in signed type corresponding to the type of the operands.  */
1458
1459 tree
1460 size_diffop_loc (location_t loc, tree arg0, tree arg1)
1461 {
1462   tree type = TREE_TYPE (arg0);
1463   tree ctype;
1464
1465   gcc_assert (int_binop_types_match_p (MINUS_EXPR, TREE_TYPE (arg0),
1466                                        TREE_TYPE (arg1)));
1467
1468   /* If the type is already signed, just do the simple thing.  */
1469   if (!TYPE_UNSIGNED (type))
1470     return size_binop_loc (loc, MINUS_EXPR, arg0, arg1);
1471
1472   if (type == sizetype)
1473     ctype = ssizetype;
1474   else if (type == bitsizetype)
1475     ctype = sbitsizetype;
1476   else
1477     ctype = signed_type_for (type);
1478
1479   /* If either operand is not a constant, do the conversions to the signed
1480      type and subtract.  The hardware will do the right thing with any
1481      overflow in the subtraction.  */
1482   if (TREE_CODE (arg0) != INTEGER_CST || TREE_CODE (arg1) != INTEGER_CST)
1483     return size_binop_loc (loc, MINUS_EXPR,
1484                            fold_convert_loc (loc, ctype, arg0),
1485                            fold_convert_loc (loc, ctype, arg1));
1486
1487   /* If ARG0 is larger than ARG1, subtract and return the result in CTYPE.
1488      Otherwise, subtract the other way, convert to CTYPE (we know that can't
1489      overflow) and negate (which can't either).  Special-case a result
1490      of zero while we're here.  */
1491   if (tree_int_cst_equal (arg0, arg1))
1492     return build_int_cst (ctype, 0);
1493   else if (tree_int_cst_lt (arg1, arg0))
1494     return fold_convert_loc (loc, ctype,
1495                              size_binop_loc (loc, MINUS_EXPR, arg0, arg1));
1496   else
1497     return size_binop_loc (loc, MINUS_EXPR, build_int_cst (ctype, 0),
1498                            fold_convert_loc (loc, ctype,
1499                                              size_binop_loc (loc,
1500                                                              MINUS_EXPR,
1501                                                              arg1, arg0)));
1502 }
1503 \f
1504 /* A subroutine of fold_convert_const handling conversions of an
1505    INTEGER_CST to another integer type.  */
1506
1507 static tree
1508 fold_convert_const_int_from_int (tree type, const_tree arg1)
1509 {
1510   tree t;
1511
1512   /* Given an integer constant, make new constant with new type,
1513      appropriately sign-extended or truncated.  */
1514   t = force_fit_type_double (type, tree_to_double_int (arg1),
1515                              !POINTER_TYPE_P (TREE_TYPE (arg1)),
1516                              (TREE_INT_CST_HIGH (arg1) < 0
1517                               && (TYPE_UNSIGNED (type)
1518                                   < TYPE_UNSIGNED (TREE_TYPE (arg1))))
1519                              | TREE_OVERFLOW (arg1));
1520
1521   return t;
1522 }
1523
1524 /* A subroutine of fold_convert_const handling conversions a REAL_CST
1525    to an integer type.  */
1526
1527 static tree
1528 fold_convert_const_int_from_real (enum tree_code code, tree type, const_tree arg1)
1529 {
1530   int overflow = 0;
1531   tree t;
1532
1533   /* The following code implements the floating point to integer
1534      conversion rules required by the Java Language Specification,
1535      that IEEE NaNs are mapped to zero and values that overflow
1536      the target precision saturate, i.e. values greater than
1537      INT_MAX are mapped to INT_MAX, and values less than INT_MIN
1538      are mapped to INT_MIN.  These semantics are allowed by the
1539      C and C++ standards that simply state that the behavior of
1540      FP-to-integer conversion is unspecified upon overflow.  */
1541
1542   double_int val;
1543   REAL_VALUE_TYPE r;
1544   REAL_VALUE_TYPE x = TREE_REAL_CST (arg1);
1545
1546   switch (code)
1547     {
1548     case FIX_TRUNC_EXPR:
1549       real_trunc (&r, VOIDmode, &x);
1550       break;
1551
1552     default:
1553       gcc_unreachable ();
1554     }
1555
1556   /* If R is NaN, return zero and show we have an overflow.  */
1557   if (REAL_VALUE_ISNAN (r))
1558     {
1559       overflow = 1;
1560       val = double_int_zero;
1561     }
1562
1563   /* See if R is less than the lower bound or greater than the
1564      upper bound.  */
1565
1566   if (! overflow)
1567     {
1568       tree lt = TYPE_MIN_VALUE (type);
1569       REAL_VALUE_TYPE l = real_value_from_int_cst (NULL_TREE, lt);
1570       if (REAL_VALUES_LESS (r, l))
1571         {
1572           overflow = 1;
1573           val = tree_to_double_int (lt);
1574         }
1575     }
1576
1577   if (! overflow)
1578     {
1579       tree ut = TYPE_MAX_VALUE (type);
1580       if (ut)
1581         {
1582           REAL_VALUE_TYPE u = real_value_from_int_cst (NULL_TREE, ut);
1583           if (REAL_VALUES_LESS (u, r))
1584             {
1585               overflow = 1;
1586               val = tree_to_double_int (ut);
1587             }
1588         }
1589     }
1590
1591   if (! overflow)
1592     real_to_integer2 ((HOST_WIDE_INT *) &val.low, &val.high, &r);
1593
1594   t = force_fit_type_double (type, val, -1, overflow | TREE_OVERFLOW (arg1));
1595   return t;
1596 }
1597
1598 /* A subroutine of fold_convert_const handling conversions of a
1599    FIXED_CST to an integer type.  */
1600
1601 static tree
1602 fold_convert_const_int_from_fixed (tree type, const_tree arg1)
1603 {
1604   tree t;
1605   double_int temp, temp_trunc;
1606   unsigned int mode;
1607
1608   /* Right shift FIXED_CST to temp by fbit.  */
1609   temp = TREE_FIXED_CST (arg1).data;
1610   mode = TREE_FIXED_CST (arg1).mode;
1611   if (GET_MODE_FBIT (mode) < 2 * HOST_BITS_PER_WIDE_INT)
1612     {
1613       temp = double_int_rshift (temp, GET_MODE_FBIT (mode),
1614                                 HOST_BITS_PER_DOUBLE_INT,
1615                                 SIGNED_FIXED_POINT_MODE_P (mode));
1616
1617       /* Left shift temp to temp_trunc by fbit.  */
1618       temp_trunc = double_int_lshift (temp, GET_MODE_FBIT (mode),
1619                                       HOST_BITS_PER_DOUBLE_INT,
1620                                       SIGNED_FIXED_POINT_MODE_P (mode));
1621     }
1622   else
1623     {
1624       temp = double_int_zero;
1625       temp_trunc = double_int_zero;
1626     }
1627
1628   /* If FIXED_CST is negative, we need to round the value toward 0.
1629      By checking if the fractional bits are not zero to add 1 to temp.  */
1630   if (SIGNED_FIXED_POINT_MODE_P (mode)
1631       && double_int_negative_p (temp_trunc)
1632       && !double_int_equal_p (TREE_FIXED_CST (arg1).data, temp_trunc))
1633     temp = double_int_add (temp, double_int_one);
1634
1635   /* Given a fixed-point constant, make new constant with new type,
1636      appropriately sign-extended or truncated.  */
1637   t = force_fit_type_double (type, temp, -1,
1638                              (double_int_negative_p (temp)
1639                               && (TYPE_UNSIGNED (type)
1640                                   < TYPE_UNSIGNED (TREE_TYPE (arg1))))
1641                              | TREE_OVERFLOW (arg1));
1642
1643   return t;
1644 }
1645
1646 /* A subroutine of fold_convert_const handling conversions a REAL_CST
1647    to another floating point type.  */
1648
1649 static tree
1650 fold_convert_const_real_from_real (tree type, const_tree arg1)
1651 {
1652   REAL_VALUE_TYPE value;
1653   tree t;
1654
1655   real_convert (&value, TYPE_MODE (type), &TREE_REAL_CST (arg1));
1656   t = build_real (type, value);
1657
1658   /* If converting an infinity or NAN to a representation that doesn't
1659      have one, set the overflow bit so that we can produce some kind of
1660      error message at the appropriate point if necessary.  It's not the
1661      most user-friendly message, but it's better than nothing.  */
1662   if (REAL_VALUE_ISINF (TREE_REAL_CST (arg1))
1663       && !MODE_HAS_INFINITIES (TYPE_MODE (type)))
1664     TREE_OVERFLOW (t) = 1;
1665   else if (REAL_VALUE_ISNAN (TREE_REAL_CST (arg1))
1666            && !MODE_HAS_NANS (TYPE_MODE (type)))
1667     TREE_OVERFLOW (t) = 1;
1668   /* Regular overflow, conversion produced an infinity in a mode that
1669      can't represent them.  */
1670   else if (!MODE_HAS_INFINITIES (TYPE_MODE (type))
1671            && REAL_VALUE_ISINF (value)
1672            && !REAL_VALUE_ISINF (TREE_REAL_CST (arg1)))
1673     TREE_OVERFLOW (t) = 1;
1674   else
1675     TREE_OVERFLOW (t) = TREE_OVERFLOW (arg1);
1676   return t;
1677 }
1678
1679 /* A subroutine of fold_convert_const handling conversions a FIXED_CST
1680    to a floating point type.  */
1681
1682 static tree
1683 fold_convert_const_real_from_fixed (tree type, const_tree arg1)
1684 {
1685   REAL_VALUE_TYPE value;
1686   tree t;
1687
1688   real_convert_from_fixed (&value, TYPE_MODE (type), &TREE_FIXED_CST (arg1));
1689   t = build_real (type, value);
1690
1691   TREE_OVERFLOW (t) = TREE_OVERFLOW (arg1);
1692   return t;
1693 }
1694
1695 /* A subroutine of fold_convert_const handling conversions a FIXED_CST
1696    to another fixed-point type.  */
1697
1698 static tree
1699 fold_convert_const_fixed_from_fixed (tree type, const_tree arg1)
1700 {
1701   FIXED_VALUE_TYPE value;
1702   tree t;
1703   bool overflow_p;
1704
1705   overflow_p = fixed_convert (&value, TYPE_MODE (type), &TREE_FIXED_CST (arg1),
1706                               TYPE_SATURATING (type));
1707   t = build_fixed (type, value);
1708
1709   /* Propagate overflow flags.  */
1710   if (overflow_p | TREE_OVERFLOW (arg1))
1711     TREE_OVERFLOW (t) = 1;
1712   return t;
1713 }
1714
1715 /* A subroutine of fold_convert_const handling conversions an INTEGER_CST
1716    to a fixed-point type.  */
1717
1718 static tree
1719 fold_convert_const_fixed_from_int (tree type, const_tree arg1)
1720 {
1721   FIXED_VALUE_TYPE value;
1722   tree t;
1723   bool overflow_p;
1724
1725   overflow_p = fixed_convert_from_int (&value, TYPE_MODE (type),
1726                                        TREE_INT_CST (arg1),
1727                                        TYPE_UNSIGNED (TREE_TYPE (arg1)),
1728                                        TYPE_SATURATING (type));
1729   t = build_fixed (type, value);
1730
1731   /* Propagate overflow flags.  */
1732   if (overflow_p | TREE_OVERFLOW (arg1))
1733     TREE_OVERFLOW (t) = 1;
1734   return t;
1735 }
1736
1737 /* A subroutine of fold_convert_const handling conversions a REAL_CST
1738    to a fixed-point type.  */
1739
1740 static tree
1741 fold_convert_const_fixed_from_real (tree type, const_tree arg1)
1742 {
1743   FIXED_VALUE_TYPE value;
1744   tree t;
1745   bool overflow_p;
1746
1747   overflow_p = fixed_convert_from_real (&value, TYPE_MODE (type),
1748                                         &TREE_REAL_CST (arg1),
1749                                         TYPE_SATURATING (type));
1750   t = build_fixed (type, value);
1751
1752   /* Propagate overflow flags.  */
1753   if (overflow_p | TREE_OVERFLOW (arg1))
1754     TREE_OVERFLOW (t) = 1;
1755   return t;
1756 }
1757
1758 /* Attempt to fold type conversion operation CODE of expression ARG1 to
1759    type TYPE.  If no simplification can be done return NULL_TREE.  */
1760
1761 static tree
1762 fold_convert_const (enum tree_code code, tree type, tree arg1)
1763 {
1764   if (TREE_TYPE (arg1) == type)
1765     return arg1;
1766
1767   if (POINTER_TYPE_P (type) || INTEGRAL_TYPE_P (type)
1768       || TREE_CODE (type) == OFFSET_TYPE)
1769     {
1770       if (TREE_CODE (arg1) == INTEGER_CST)
1771         return fold_convert_const_int_from_int (type, arg1);
1772       else if (TREE_CODE (arg1) == REAL_CST)
1773         return fold_convert_const_int_from_real (code, type, arg1);
1774       else if (TREE_CODE (arg1) == FIXED_CST)
1775         return fold_convert_const_int_from_fixed (type, arg1);
1776     }
1777   else if (TREE_CODE (type) == REAL_TYPE)
1778     {
1779       if (TREE_CODE (arg1) == INTEGER_CST)
1780         return build_real_from_int_cst (type, arg1);
1781       else if (TREE_CODE (arg1) == REAL_CST)
1782         return fold_convert_const_real_from_real (type, arg1);
1783       else if (TREE_CODE (arg1) == FIXED_CST)
1784         return fold_convert_const_real_from_fixed (type, arg1);
1785     }
1786   else if (TREE_CODE (type) == FIXED_POINT_TYPE)
1787     {
1788       if (TREE_CODE (arg1) == FIXED_CST)
1789         return fold_convert_const_fixed_from_fixed (type, arg1);
1790       else if (TREE_CODE (arg1) == INTEGER_CST)
1791         return fold_convert_const_fixed_from_int (type, arg1);
1792       else if (TREE_CODE (arg1) == REAL_CST)
1793         return fold_convert_const_fixed_from_real (type, arg1);
1794     }
1795   return NULL_TREE;
1796 }
1797
1798 /* Construct a vector of zero elements of vector type TYPE.  */
1799
1800 static tree
1801 build_zero_vector (tree type)
1802 {
1803   tree t;
1804
1805   t = fold_convert_const (NOP_EXPR, TREE_TYPE (type), integer_zero_node);
1806   return build_vector_from_val (type, t);
1807 }
1808
1809 /* Returns true, if ARG is convertible to TYPE using a NOP_EXPR.  */
1810
1811 bool
1812 fold_convertible_p (const_tree type, const_tree arg)
1813 {
1814   tree orig = TREE_TYPE (arg);
1815
1816   if (type == orig)
1817     return true;
1818
1819   if (TREE_CODE (arg) == ERROR_MARK
1820       || TREE_CODE (type) == ERROR_MARK
1821       || TREE_CODE (orig) == ERROR_MARK)
1822     return false;
1823
1824   if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (orig))
1825     return true;
1826
1827   switch (TREE_CODE (type))
1828     {
1829     case INTEGER_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE:
1830     case POINTER_TYPE: case REFERENCE_TYPE:
1831     case OFFSET_TYPE:
1832       if (INTEGRAL_TYPE_P (orig) || POINTER_TYPE_P (orig)
1833           || TREE_CODE (orig) == OFFSET_TYPE)
1834         return true;
1835       return (TREE_CODE (orig) == VECTOR_TYPE
1836               && tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (orig)));
1837
1838     case REAL_TYPE:
1839     case FIXED_POINT_TYPE:
1840     case COMPLEX_TYPE:
1841     case VECTOR_TYPE:
1842     case VOID_TYPE:
1843       return TREE_CODE (type) == TREE_CODE (orig);
1844
1845     default:
1846       return false;
1847     }
1848 }
1849
1850 /* Convert expression ARG to type TYPE.  Used by the middle-end for
1851    simple conversions in preference to calling the front-end's convert.  */
1852
1853 tree
1854 fold_convert_loc (location_t loc, tree type, tree arg)
1855 {
1856   tree orig = TREE_TYPE (arg);
1857   tree tem;
1858
1859   if (type == orig)
1860     return arg;
1861
1862   if (TREE_CODE (arg) == ERROR_MARK
1863       || TREE_CODE (type) == ERROR_MARK
1864       || TREE_CODE (orig) == ERROR_MARK)
1865     return error_mark_node;
1866
1867   switch (TREE_CODE (type))
1868     {
1869     case POINTER_TYPE:
1870     case REFERENCE_TYPE:
1871       /* Handle conversions between pointers to different address spaces.  */
1872       if (POINTER_TYPE_P (orig)
1873           && (TYPE_ADDR_SPACE (TREE_TYPE (type))
1874               != TYPE_ADDR_SPACE (TREE_TYPE (orig))))
1875         return fold_build1_loc (loc, ADDR_SPACE_CONVERT_EXPR, type, arg);
1876       /* fall through */
1877
1878     case INTEGER_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE:
1879     case OFFSET_TYPE:
1880       if (TREE_CODE (arg) == INTEGER_CST)
1881         {
1882           tem = fold_convert_const (NOP_EXPR, type, arg);
1883           if (tem != NULL_TREE)
1884             return tem;
1885         }
1886       if (INTEGRAL_TYPE_P (orig) || POINTER_TYPE_P (orig)
1887           || TREE_CODE (orig) == OFFSET_TYPE)
1888         return fold_build1_loc (loc, NOP_EXPR, type, arg);
1889       if (TREE_CODE (orig) == COMPLEX_TYPE)
1890         return fold_convert_loc (loc, type,
1891                              fold_build1_loc (loc, REALPART_EXPR,
1892                                           TREE_TYPE (orig), arg));
1893       gcc_assert (TREE_CODE (orig) == VECTOR_TYPE
1894                   && tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (orig)));
1895       return fold_build1_loc (loc, NOP_EXPR, type, arg);
1896
1897     case REAL_TYPE:
1898       if (TREE_CODE (arg) == INTEGER_CST)
1899         {
1900           tem = fold_convert_const (FLOAT_EXPR, type, arg);
1901           if (tem != NULL_TREE)
1902             return tem;
1903         }
1904       else if (TREE_CODE (arg) == REAL_CST)
1905         {
1906           tem = fold_convert_const (NOP_EXPR, type, arg);
1907           if (tem != NULL_TREE)
1908             return tem;
1909         }
1910       else if (TREE_CODE (arg) == FIXED_CST)
1911         {
1912           tem = fold_convert_const (FIXED_CONVERT_EXPR, type, arg);
1913           if (tem != NULL_TREE)
1914             return tem;
1915         }
1916
1917       switch (TREE_CODE (orig))
1918         {
1919         case INTEGER_TYPE:
1920         case BOOLEAN_TYPE: case ENUMERAL_TYPE:
1921         case POINTER_TYPE: case REFERENCE_TYPE:
1922           return fold_build1_loc (loc, FLOAT_EXPR, type, arg);
1923
1924         case REAL_TYPE:
1925           return fold_build1_loc (loc, NOP_EXPR, type, arg);
1926
1927         case FIXED_POINT_TYPE:
1928           return fold_build1_loc (loc, FIXED_CONVERT_EXPR, type, arg);
1929
1930         case COMPLEX_TYPE:
1931           tem = fold_build1_loc (loc, REALPART_EXPR, TREE_TYPE (orig), arg);
1932           return fold_convert_loc (loc, type, tem);
1933
1934         default:
1935           gcc_unreachable ();
1936         }
1937
1938     case FIXED_POINT_TYPE:
1939       if (TREE_CODE (arg) == FIXED_CST || TREE_CODE (arg) == INTEGER_CST
1940           || TREE_CODE (arg) == REAL_CST)
1941         {
1942           tem = fold_convert_const (FIXED_CONVERT_EXPR, type, arg);
1943           if (tem != NULL_TREE)
1944             goto fold_convert_exit;
1945         }
1946
1947       switch (TREE_CODE (orig))
1948         {
1949         case FIXED_POINT_TYPE:
1950         case INTEGER_TYPE:
1951         case ENUMERAL_TYPE:
1952         case BOOLEAN_TYPE:
1953         case REAL_TYPE:
1954           return fold_build1_loc (loc, FIXED_CONVERT_EXPR, type, arg);
1955
1956         case COMPLEX_TYPE:
1957           tem = fold_build1_loc (loc, REALPART_EXPR, TREE_TYPE (orig), arg);
1958           return fold_convert_loc (loc, type, tem);
1959
1960         default:
1961           gcc_unreachable ();
1962         }
1963
1964     case COMPLEX_TYPE:
1965       switch (TREE_CODE (orig))
1966         {
1967         case INTEGER_TYPE:
1968         case BOOLEAN_TYPE: case ENUMERAL_TYPE:
1969         case POINTER_TYPE: case REFERENCE_TYPE:
1970         case REAL_TYPE:
1971         case FIXED_POINT_TYPE:
1972           return fold_build2_loc (loc, COMPLEX_EXPR, type,
1973                               fold_convert_loc (loc, TREE_TYPE (type), arg),
1974                               fold_convert_loc (loc, TREE_TYPE (type),
1975                                             integer_zero_node));
1976         case COMPLEX_TYPE:
1977           {
1978             tree rpart, ipart;
1979
1980             if (TREE_CODE (arg) == COMPLEX_EXPR)
1981               {
1982                 rpart = fold_convert_loc (loc, TREE_TYPE (type),
1983                                       TREE_OPERAND (arg, 0));
1984                 ipart = fold_convert_loc (loc, TREE_TYPE (type),
1985                                       TREE_OPERAND (arg, 1));
1986                 return fold_build2_loc (loc, COMPLEX_EXPR, type, rpart, ipart);
1987               }
1988
1989             arg = save_expr (arg);
1990             rpart = fold_build1_loc (loc, REALPART_EXPR, TREE_TYPE (orig), arg);
1991             ipart = fold_build1_loc (loc, IMAGPART_EXPR, TREE_TYPE (orig), arg);
1992             rpart = fold_convert_loc (loc, TREE_TYPE (type), rpart);
1993             ipart = fold_convert_loc (loc, TREE_TYPE (type), ipart);
1994             return fold_build2_loc (loc, COMPLEX_EXPR, type, rpart, ipart);
1995           }
1996
1997         default:
1998           gcc_unreachable ();
1999         }
2000
2001     case VECTOR_TYPE:
2002       if (integer_zerop (arg))
2003         return build_zero_vector (type);
2004       gcc_assert (tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (orig)));
2005       gcc_assert (INTEGRAL_TYPE_P (orig) || POINTER_TYPE_P (orig)
2006                   || TREE_CODE (orig) == VECTOR_TYPE);
2007       return fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, arg);
2008
2009     case VOID_TYPE:
2010       tem = fold_ignored_result (arg);
2011       return fold_build1_loc (loc, NOP_EXPR, type, tem);
2012
2013     default:
2014       if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (orig))
2015         return fold_build1_loc (loc, NOP_EXPR, type, arg);
2016       gcc_unreachable ();
2017     }
2018  fold_convert_exit:
2019   protected_set_expr_location_unshare (tem, loc);
2020   return tem;
2021 }
2022 \f
2023 /* Return false if expr can be assumed not to be an lvalue, true
2024    otherwise.  */
2025
2026 static bool
2027 maybe_lvalue_p (const_tree x)
2028 {
2029   /* We only need to wrap lvalue tree codes.  */
2030   switch (TREE_CODE (x))
2031   {
2032   case VAR_DECL:
2033   case PARM_DECL:
2034   case RESULT_DECL:
2035   case LABEL_DECL:
2036   case FUNCTION_DECL:
2037   case SSA_NAME:
2038
2039   case COMPONENT_REF:
2040   case MEM_REF:
2041   case INDIRECT_REF:
2042   case ARRAY_REF:
2043   case ARRAY_RANGE_REF:
2044   case BIT_FIELD_REF:
2045   case OBJ_TYPE_REF:
2046
2047   case REALPART_EXPR:
2048   case IMAGPART_EXPR:
2049   case PREINCREMENT_EXPR:
2050   case PREDECREMENT_EXPR:
2051   case SAVE_EXPR:
2052   case TRY_CATCH_EXPR:
2053   case WITH_CLEANUP_EXPR:
2054   case COMPOUND_EXPR:
2055   case MODIFY_EXPR:
2056   case TARGET_EXPR:
2057   case COND_EXPR:
2058   case BIND_EXPR:
2059     break;
2060
2061   default:
2062     /* Assume the worst for front-end tree codes.  */
2063     if ((int)TREE_CODE (x) >= NUM_TREE_CODES)
2064       break;
2065     return false;
2066   }
2067
2068   return true;
2069 }
2070
2071 /* Return an expr equal to X but certainly not valid as an lvalue.  */
2072
2073 tree
2074 non_lvalue_loc (location_t loc, tree x)
2075 {
2076   /* While we are in GIMPLE, NON_LVALUE_EXPR doesn't mean anything to
2077      us.  */
2078   if (in_gimple_form)
2079     return x;
2080
2081   if (! maybe_lvalue_p (x))
2082     return x;
2083   return build1_loc (loc, NON_LVALUE_EXPR, TREE_TYPE (x), x);
2084 }
2085
2086 /* Nonzero means lvalues are limited to those valid in pedantic ANSI C.
2087    Zero means allow extended lvalues.  */
2088
2089 int pedantic_lvalues;
2090
2091 /* When pedantic, return an expr equal to X but certainly not valid as a
2092    pedantic lvalue.  Otherwise, return X.  */
2093
2094 static tree
2095 pedantic_non_lvalue_loc (location_t loc, tree x)
2096 {
2097   if (pedantic_lvalues)
2098     return non_lvalue_loc (loc, x);
2099
2100   return protected_set_expr_location_unshare (x, loc);
2101 }
2102 \f
2103 /* Given a tree comparison code, return the code that is the logical inverse.
2104    It is generally not safe to do this for floating-point comparisons, except
2105    for EQ_EXPR and NE_EXPR, so we return ERROR_MARK in this case.  */
2106
2107 enum tree_code
2108 invert_tree_comparison (enum tree_code code, bool honor_nans)
2109 {
2110   if (honor_nans && flag_trapping_math && code != EQ_EXPR && code != NE_EXPR)
2111     return ERROR_MARK;
2112
2113   switch (code)
2114     {
2115     case EQ_EXPR:
2116       return NE_EXPR;
2117     case NE_EXPR:
2118       return EQ_EXPR;
2119     case GT_EXPR:
2120       return honor_nans ? UNLE_EXPR : LE_EXPR;
2121     case GE_EXPR:
2122       return honor_nans ? UNLT_EXPR : LT_EXPR;
2123     case LT_EXPR:
2124       return honor_nans ? UNGE_EXPR : GE_EXPR;
2125     case LE_EXPR:
2126       return honor_nans ? UNGT_EXPR : GT_EXPR;
2127     case LTGT_EXPR:
2128       return UNEQ_EXPR;
2129     case UNEQ_EXPR:
2130       return LTGT_EXPR;
2131     case UNGT_EXPR:
2132       return LE_EXPR;
2133     case UNGE_EXPR:
2134       return LT_EXPR;
2135     case UNLT_EXPR:
2136       return GE_EXPR;
2137     case UNLE_EXPR:
2138       return GT_EXPR;
2139     case ORDERED_EXPR:
2140       return UNORDERED_EXPR;
2141     case UNORDERED_EXPR:
2142       return ORDERED_EXPR;
2143     default:
2144       gcc_unreachable ();
2145     }
2146 }
2147
2148 /* Similar, but return the comparison that results if the operands are
2149    swapped.  This is safe for floating-point.  */
2150
2151 enum tree_code
2152 swap_tree_comparison (enum tree_code code)
2153 {
2154   switch (code)
2155     {
2156     case EQ_EXPR:
2157     case NE_EXPR:
2158     case ORDERED_EXPR:
2159     case UNORDERED_EXPR:
2160     case LTGT_EXPR:
2161     case UNEQ_EXPR:
2162       return code;
2163     case GT_EXPR:
2164       return LT_EXPR;
2165     case GE_EXPR:
2166       return LE_EXPR;
2167     case LT_EXPR:
2168       return GT_EXPR;
2169     case LE_EXPR:
2170       return GE_EXPR;
2171     case UNGT_EXPR:
2172       return UNLT_EXPR;
2173     case UNGE_EXPR:
2174       return UNLE_EXPR;
2175     case UNLT_EXPR:
2176       return UNGT_EXPR;
2177     case UNLE_EXPR:
2178       return UNGE_EXPR;
2179     default:
2180       gcc_unreachable ();
2181     }
2182 }
2183
2184
2185 /* Convert a comparison tree code from an enum tree_code representation
2186    into a compcode bit-based encoding.  This function is the inverse of
2187    compcode_to_comparison.  */
2188
2189 static enum comparison_code
2190 comparison_to_compcode (enum tree_code code)
2191 {
2192   switch (code)
2193     {
2194     case LT_EXPR:
2195       return COMPCODE_LT;
2196     case EQ_EXPR:
2197       return COMPCODE_EQ;
2198     case LE_EXPR:
2199       return COMPCODE_LE;
2200     case GT_EXPR:
2201       return COMPCODE_GT;
2202     case NE_EXPR:
2203       return COMPCODE_NE;
2204     case GE_EXPR:
2205       return COMPCODE_GE;
2206     case ORDERED_EXPR:
2207       return COMPCODE_ORD;
2208     case UNORDERED_EXPR:
2209       return COMPCODE_UNORD;
2210     case UNLT_EXPR:
2211       return COMPCODE_UNLT;
2212     case UNEQ_EXPR:
2213       return COMPCODE_UNEQ;
2214     case UNLE_EXPR:
2215       return COMPCODE_UNLE;
2216     case UNGT_EXPR:
2217       return COMPCODE_UNGT;
2218     case LTGT_EXPR:
2219       return COMPCODE_LTGT;
2220     case UNGE_EXPR:
2221       return COMPCODE_UNGE;
2222     default:
2223       gcc_unreachable ();
2224     }
2225 }
2226
2227 /* Convert a compcode bit-based encoding of a comparison operator back
2228    to GCC's enum tree_code representation.  This function is the
2229    inverse of comparison_to_compcode.  */
2230
2231 static enum tree_code
2232 compcode_to_comparison (enum comparison_code code)
2233 {
2234   switch (code)
2235     {
2236     case COMPCODE_LT:
2237       return LT_EXPR;
2238     case COMPCODE_EQ:
2239       return EQ_EXPR;
2240     case COMPCODE_LE:
2241       return LE_EXPR;
2242     case COMPCODE_GT:
2243       return GT_EXPR;
2244     case COMPCODE_NE:
2245       return NE_EXPR;
2246     case COMPCODE_GE:
2247       return GE_EXPR;
2248     case COMPCODE_ORD:
2249       return ORDERED_EXPR;
2250     case COMPCODE_UNORD:
2251       return UNORDERED_EXPR;
2252     case COMPCODE_UNLT:
2253       return UNLT_EXPR;
2254     case COMPCODE_UNEQ:
2255       return UNEQ_EXPR;
2256     case COMPCODE_UNLE:
2257       return UNLE_EXPR;
2258     case COMPCODE_UNGT:
2259       return UNGT_EXPR;
2260     case COMPCODE_LTGT:
2261       return LTGT_EXPR;
2262     case COMPCODE_UNGE:
2263       return UNGE_EXPR;
2264     default:
2265       gcc_unreachable ();
2266     }
2267 }
2268
2269 /* Return a tree for the comparison which is the combination of
2270    doing the AND or OR (depending on CODE) of the two operations LCODE
2271    and RCODE on the identical operands LL_ARG and LR_ARG.  Take into account
2272    the possibility of trapping if the mode has NaNs, and return NULL_TREE
2273    if this makes the transformation invalid.  */
2274
2275 tree
2276 combine_comparisons (location_t loc,
2277                      enum tree_code code, enum tree_code lcode,
2278                      enum tree_code rcode, tree truth_type,
2279                      tree ll_arg, tree lr_arg)
2280 {
2281   bool honor_nans = HONOR_NANS (TYPE_MODE (TREE_TYPE (ll_arg)));
2282   enum comparison_code lcompcode = comparison_to_compcode (lcode);
2283   enum comparison_code rcompcode = comparison_to_compcode (rcode);
2284   int compcode;
2285
2286   switch (code)
2287     {
2288     case TRUTH_AND_EXPR: case TRUTH_ANDIF_EXPR:
2289       compcode = lcompcode & rcompcode;
2290       break;
2291
2292     case TRUTH_OR_EXPR: case TRUTH_ORIF_EXPR:
2293       compcode = lcompcode | rcompcode;
2294       break;
2295
2296     default:
2297       return NULL_TREE;
2298     }
2299
2300   if (!honor_nans)
2301     {
2302       /* Eliminate unordered comparisons, as well as LTGT and ORD
2303          which are not used unless the mode has NaNs.  */
2304       compcode &= ~COMPCODE_UNORD;
2305       if (compcode == COMPCODE_LTGT)
2306         compcode = COMPCODE_NE;
2307       else if (compcode == COMPCODE_ORD)
2308         compcode = COMPCODE_TRUE;
2309     }
2310    else if (flag_trapping_math)
2311      {
2312         /* Check that the original operation and the optimized ones will trap
2313            under the same condition.  */
2314         bool ltrap = (lcompcode & COMPCODE_UNORD) == 0
2315                      && (lcompcode != COMPCODE_EQ)
2316                      && (lcompcode != COMPCODE_ORD);
2317         bool rtrap = (rcompcode & COMPCODE_UNORD) == 0
2318                      && (rcompcode != COMPCODE_EQ)
2319                      && (rcompcode != COMPCODE_ORD);
2320         bool trap = (compcode & COMPCODE_UNORD) == 0
2321                     && (compcode != COMPCODE_EQ)
2322                     && (compcode != COMPCODE_ORD);
2323
2324         /* In a short-circuited boolean expression the LHS might be
2325            such that the RHS, if evaluated, will never trap.  For
2326            example, in ORD (x, y) && (x < y), we evaluate the RHS only
2327            if neither x nor y is NaN.  (This is a mixed blessing: for
2328            example, the expression above will never trap, hence
2329            optimizing it to x < y would be invalid).  */
2330         if ((code == TRUTH_ORIF_EXPR && (lcompcode & COMPCODE_UNORD))
2331             || (code == TRUTH_ANDIF_EXPR && !(lcompcode & COMPCODE_UNORD)))
2332           rtrap = false;
2333
2334         /* If the comparison was short-circuited, and only the RHS
2335            trapped, we may now generate a spurious trap.  */
2336         if (rtrap && !ltrap
2337             && (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR))
2338           return NULL_TREE;
2339
2340         /* If we changed the conditions that cause a trap, we lose.  */
2341         if ((ltrap || rtrap) != trap)
2342           return NULL_TREE;
2343       }
2344
2345   if (compcode == COMPCODE_TRUE)
2346     return constant_boolean_node (true, truth_type);
2347   else if (compcode == COMPCODE_FALSE)
2348     return constant_boolean_node (false, truth_type);
2349   else
2350     {
2351       enum tree_code tcode;
2352
2353       tcode = compcode_to_comparison ((enum comparison_code) compcode);
2354       return fold_build2_loc (loc, tcode, truth_type, ll_arg, lr_arg);
2355     }
2356 }
2357 \f
2358 /* Return nonzero if two operands (typically of the same tree node)
2359    are necessarily equal.  If either argument has side-effects this
2360    function returns zero.  FLAGS modifies behavior as follows:
2361
2362    If OEP_ONLY_CONST is set, only return nonzero for constants.
2363    This function tests whether the operands are indistinguishable;
2364    it does not test whether they are equal using C's == operation.
2365    The distinction is important for IEEE floating point, because
2366    (1) -0.0 and 0.0 are distinguishable, but -0.0==0.0, and
2367    (2) two NaNs may be indistinguishable, but NaN!=NaN.
2368
2369    If OEP_ONLY_CONST is unset, a VAR_DECL is considered equal to itself
2370    even though it may hold multiple values during a function.
2371    This is because a GCC tree node guarantees that nothing else is
2372    executed between the evaluation of its "operands" (which may often
2373    be evaluated in arbitrary order).  Hence if the operands themselves
2374    don't side-effect, the VAR_DECLs, PARM_DECLs etc... must hold the
2375    same value in each operand/subexpression.  Hence leaving OEP_ONLY_CONST
2376    unset means assuming isochronic (or instantaneous) tree equivalence.
2377    Unless comparing arbitrary expression trees, such as from different
2378    statements, this flag can usually be left unset.
2379
2380    If OEP_PURE_SAME is set, then pure functions with identical arguments
2381    are considered the same.  It is used when the caller has other ways
2382    to ensure that global memory is unchanged in between.  */
2383
2384 int
2385 operand_equal_p (const_tree arg0, const_tree arg1, unsigned int flags)
2386 {
2387   /* If either is ERROR_MARK, they aren't equal.  */
2388   if (TREE_CODE (arg0) == ERROR_MARK || TREE_CODE (arg1) == ERROR_MARK
2389       || TREE_TYPE (arg0) == error_mark_node
2390       || TREE_TYPE (arg1) == error_mark_node)
2391     return 0;
2392
2393   /* Similar, if either does not have a type (like a released SSA name),
2394      they aren't equal.  */
2395   if (!TREE_TYPE (arg0) || !TREE_TYPE (arg1))
2396     return 0;
2397
2398   /* Check equality of integer constants before bailing out due to
2399      precision differences.  */
2400   if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
2401     return tree_int_cst_equal (arg0, arg1);
2402
2403   /* If both types don't have the same signedness, then we can't consider
2404      them equal.  We must check this before the STRIP_NOPS calls
2405      because they may change the signedness of the arguments.  As pointers
2406      strictly don't have a signedness, require either two pointers or
2407      two non-pointers as well.  */
2408   if (TYPE_UNSIGNED (TREE_TYPE (arg0)) != TYPE_UNSIGNED (TREE_TYPE (arg1))
2409       || POINTER_TYPE_P (TREE_TYPE (arg0)) != POINTER_TYPE_P (TREE_TYPE (arg1)))
2410     return 0;
2411
2412   /* We cannot consider pointers to different address space equal.  */
2413   if (POINTER_TYPE_P (TREE_TYPE (arg0)) && POINTER_TYPE_P (TREE_TYPE (arg1))
2414       && (TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (arg0)))
2415           != TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (arg1)))))
2416     return 0;
2417
2418   /* If both types don't have the same precision, then it is not safe
2419      to strip NOPs.  */
2420   if (TYPE_PRECISION (TREE_TYPE (arg0)) != TYPE_PRECISION (TREE_TYPE (arg1)))
2421     return 0;
2422
2423   STRIP_NOPS (arg0);
2424   STRIP_NOPS (arg1);
2425
2426   /* In case both args are comparisons but with different comparison
2427      code, try to swap the comparison operands of one arg to produce
2428      a match and compare that variant.  */
2429   if (TREE_CODE (arg0) != TREE_CODE (arg1)
2430       && COMPARISON_CLASS_P (arg0)
2431       && COMPARISON_CLASS_P (arg1))
2432     {
2433       enum tree_code swap_code = swap_tree_comparison (TREE_CODE (arg1));
2434
2435       if (TREE_CODE (arg0) == swap_code)
2436         return operand_equal_p (TREE_OPERAND (arg0, 0),
2437                                 TREE_OPERAND (arg1, 1), flags)
2438                && operand_equal_p (TREE_OPERAND (arg0, 1),
2439                                    TREE_OPERAND (arg1, 0), flags);
2440     }
2441
2442   if (TREE_CODE (arg0) != TREE_CODE (arg1)
2443       /* This is needed for conversions and for COMPONENT_REF.
2444          Might as well play it safe and always test this.  */
2445       || TREE_CODE (TREE_TYPE (arg0)) == ERROR_MARK
2446       || TREE_CODE (TREE_TYPE (arg1)) == ERROR_MARK
2447       || TYPE_MODE (TREE_TYPE (arg0)) != TYPE_MODE (TREE_TYPE (arg1)))
2448     return 0;
2449
2450   /* If ARG0 and ARG1 are the same SAVE_EXPR, they are necessarily equal.
2451      We don't care about side effects in that case because the SAVE_EXPR
2452      takes care of that for us. In all other cases, two expressions are
2453      equal if they have no side effects.  If we have two identical
2454      expressions with side effects that should be treated the same due
2455      to the only side effects being identical SAVE_EXPR's, that will
2456      be detected in the recursive calls below.
2457      If we are taking an invariant address of two identical objects
2458      they are necessarily equal as well.  */
2459   if (arg0 == arg1 && ! (flags & OEP_ONLY_CONST)
2460       && (TREE_CODE (arg0) == SAVE_EXPR
2461           || (flags & OEP_CONSTANT_ADDRESS_OF)
2462           || (! TREE_SIDE_EFFECTS (arg0) && ! TREE_SIDE_EFFECTS (arg1))))
2463     return 1;
2464
2465   /* Next handle constant cases, those for which we can return 1 even
2466      if ONLY_CONST is set.  */
2467   if (TREE_CONSTANT (arg0) && TREE_CONSTANT (arg1))
2468     switch (TREE_CODE (arg0))
2469       {
2470       case INTEGER_CST:
2471         return tree_int_cst_equal (arg0, arg1);
2472
2473       case FIXED_CST:
2474         return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (arg0),
2475                                        TREE_FIXED_CST (arg1));
2476
2477       case REAL_CST:
2478         if (REAL_VALUES_IDENTICAL (TREE_REAL_CST (arg0),
2479                                    TREE_REAL_CST (arg1)))
2480           return 1;
2481
2482
2483         if (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0))))
2484           {
2485             /* If we do not distinguish between signed and unsigned zero,
2486                consider them equal.  */
2487             if (real_zerop (arg0) && real_zerop (arg1))
2488               return 1;
2489           }
2490         return 0;
2491
2492       case VECTOR_CST:
2493         {
2494           tree v1, v2;
2495
2496           v1 = TREE_VECTOR_CST_ELTS (arg0);
2497           v2 = TREE_VECTOR_CST_ELTS (arg1);
2498           while (v1 && v2)
2499             {
2500               if (!operand_equal_p (TREE_VALUE (v1), TREE_VALUE (v2),
2501                                     flags))
2502                 return 0;
2503               v1 = TREE_CHAIN (v1);
2504               v2 = TREE_CHAIN (v2);
2505             }
2506
2507           return v1 == v2;
2508         }
2509
2510       case COMPLEX_CST:
2511         return (operand_equal_p (TREE_REALPART (arg0), TREE_REALPART (arg1),
2512                                  flags)
2513                 && operand_equal_p (TREE_IMAGPART (arg0), TREE_IMAGPART (arg1),
2514                                     flags));
2515
2516       case STRING_CST:
2517         return (TREE_STRING_LENGTH (arg0) == TREE_STRING_LENGTH (arg1)
2518                 && ! memcmp (TREE_STRING_POINTER (arg0),
2519                               TREE_STRING_POINTER (arg1),
2520                               TREE_STRING_LENGTH (arg0)));
2521
2522       case ADDR_EXPR:
2523         return operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1, 0),
2524                                 TREE_CONSTANT (arg0) && TREE_CONSTANT (arg1)
2525                                 ? OEP_CONSTANT_ADDRESS_OF : 0);
2526       default:
2527         break;
2528       }
2529
2530   if (flags & OEP_ONLY_CONST)
2531     return 0;
2532
2533 /* Define macros to test an operand from arg0 and arg1 for equality and a
2534    variant that allows null and views null as being different from any
2535    non-null value.  In the latter case, if either is null, the both
2536    must be; otherwise, do the normal comparison.  */
2537 #define OP_SAME(N) operand_equal_p (TREE_OPERAND (arg0, N),     \
2538                                     TREE_OPERAND (arg1, N), flags)
2539
2540 #define OP_SAME_WITH_NULL(N)                            \
2541   ((!TREE_OPERAND (arg0, N) || !TREE_OPERAND (arg1, N)) \
2542    ? TREE_OPERAND (arg0, N) == TREE_OPERAND (arg1, N) : OP_SAME (N))
2543
2544   switch (TREE_CODE_CLASS (TREE_CODE (arg0)))
2545     {
2546     case tcc_unary:
2547       /* Two conversions are equal only if signedness and modes match.  */
2548       switch (TREE_CODE (arg0))
2549         {
2550         CASE_CONVERT:
2551         case FIX_TRUNC_EXPR:
2552           if (TYPE_UNSIGNED (TREE_TYPE (arg0))
2553               != TYPE_UNSIGNED (TREE_TYPE (arg1)))
2554             return 0;
2555           break;
2556         default:
2557           break;
2558         }
2559
2560       return OP_SAME (0);
2561
2562
2563     case tcc_comparison:
2564     case tcc_binary:
2565       if (OP_SAME (0) && OP_SAME (1))
2566         return 1;
2567
2568       /* For commutative ops, allow the other order.  */
2569       return (commutative_tree_code (TREE_CODE (arg0))
2570               && operand_equal_p (TREE_OPERAND (arg0, 0),
2571                                   TREE_OPERAND (arg1, 1), flags)
2572               && operand_equal_p (TREE_OPERAND (arg0, 1),
2573                                   TREE_OPERAND (arg1, 0), flags));
2574
2575     case tcc_reference:
2576       /* If either of the pointer (or reference) expressions we are
2577          dereferencing contain a side effect, these cannot be equal.  */
2578       if (TREE_SIDE_EFFECTS (arg0)
2579           || TREE_SIDE_EFFECTS (arg1))
2580         return 0;
2581
2582       switch (TREE_CODE (arg0))
2583         {
2584         case INDIRECT_REF:
2585         case REALPART_EXPR:
2586         case IMAGPART_EXPR:
2587           return OP_SAME (0);
2588
2589         case MEM_REF:
2590           /* Require equal access sizes, and similar pointer types.
2591              We can have incomplete types for array references of
2592              variable-sized arrays from the Fortran frontent
2593              though.  */
2594           return ((TYPE_SIZE (TREE_TYPE (arg0)) == TYPE_SIZE (TREE_TYPE (arg1))
2595                    || (TYPE_SIZE (TREE_TYPE (arg0))
2596                        && TYPE_SIZE (TREE_TYPE (arg1))
2597                        && operand_equal_p (TYPE_SIZE (TREE_TYPE (arg0)),
2598                                            TYPE_SIZE (TREE_TYPE (arg1)), flags)))
2599                   && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (arg0, 1)))
2600                       == TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (arg1, 1))))
2601                   && OP_SAME (0) && OP_SAME (1));
2602
2603         case ARRAY_REF:
2604         case ARRAY_RANGE_REF:
2605           /* Operands 2 and 3 may be null.
2606              Compare the array index by value if it is constant first as we
2607              may have different types but same value here.  */
2608           return (OP_SAME (0)
2609                   && (tree_int_cst_equal (TREE_OPERAND (arg0, 1),
2610                                           TREE_OPERAND (arg1, 1))
2611                       || OP_SAME (1))
2612                   && OP_SAME_WITH_NULL (2)
2613                   && OP_SAME_WITH_NULL (3));
2614
2615         case COMPONENT_REF:
2616           /* Handle operand 2 the same as for ARRAY_REF.  Operand 0
2617              may be NULL when we're called to compare MEM_EXPRs.  */
2618           return OP_SAME_WITH_NULL (0)
2619                  && OP_SAME (1)
2620                  && OP_SAME_WITH_NULL (2);
2621
2622         case BIT_FIELD_REF:
2623           return OP_SAME (0) && OP_SAME (1) && OP_SAME (2);
2624
2625         default:
2626           return 0;
2627         }
2628
2629     case tcc_expression:
2630       switch (TREE_CODE (arg0))
2631         {
2632         case ADDR_EXPR:
2633         case TRUTH_NOT_EXPR:
2634           return OP_SAME (0);
2635
2636         case TRUTH_ANDIF_EXPR:
2637         case TRUTH_ORIF_EXPR:
2638           return OP_SAME (0) && OP_SAME (1);
2639
2640         case FMA_EXPR:
2641         case WIDEN_MULT_PLUS_EXPR:
2642         case WIDEN_MULT_MINUS_EXPR:
2643           if (!OP_SAME (2))
2644             return 0;
2645           /* The multiplcation operands are commutative.  */
2646           /* FALLTHRU */
2647
2648         case TRUTH_AND_EXPR:
2649         case TRUTH_OR_EXPR:
2650         case TRUTH_XOR_EXPR:
2651           if (OP_SAME (0) && OP_SAME (1))
2652             return 1;
2653
2654           /* Otherwise take into account this is a commutative operation.  */
2655           return (operand_equal_p (TREE_OPERAND (arg0, 0),
2656                                    TREE_OPERAND (arg1, 1), flags)
2657                   && operand_equal_p (TREE_OPERAND (arg0, 1),
2658                                       TREE_OPERAND (arg1, 0), flags));
2659
2660         case COND_EXPR:
2661         case VEC_COND_EXPR:
2662         case DOT_PROD_EXPR:
2663           return OP_SAME (0) && OP_SAME (1) && OP_SAME (2);
2664
2665         default:
2666           return 0;
2667         }
2668
2669     case tcc_vl_exp:
2670       switch (TREE_CODE (arg0))
2671         {
2672         case CALL_EXPR:
2673           /* If the CALL_EXPRs call different functions, then they
2674              clearly can not be equal.  */
2675           if (! operand_equal_p (CALL_EXPR_FN (arg0), CALL_EXPR_FN (arg1),
2676                                  flags))
2677             return 0;
2678
2679           {
2680             unsigned int cef = call_expr_flags (arg0);
2681             if (flags & OEP_PURE_SAME)
2682               cef &= ECF_CONST | ECF_PURE;
2683             else
2684               cef &= ECF_CONST;
2685             if (!cef)
2686               return 0;
2687           }
2688
2689           /* Now see if all the arguments are the same.  */
2690           {
2691             const_call_expr_arg_iterator iter0, iter1;
2692             const_tree a0, a1;
2693             for (a0 = first_const_call_expr_arg (arg0, &iter0),
2694                    a1 = first_const_call_expr_arg (arg1, &iter1);
2695                  a0 && a1;
2696                  a0 = next_const_call_expr_arg (&iter0),
2697                    a1 = next_const_call_expr_arg (&iter1))
2698               if (! operand_equal_p (a0, a1, flags))
2699                 return 0;
2700
2701             /* If we get here and both argument lists are exhausted
2702                then the CALL_EXPRs are equal.  */
2703             return ! (a0 || a1);
2704           }
2705         default:
2706           return 0;
2707         }
2708
2709     case tcc_declaration:
2710       /* Consider __builtin_sqrt equal to sqrt.  */
2711       return (TREE_CODE (arg0) == FUNCTION_DECL
2712               && DECL_BUILT_IN (arg0) && DECL_BUILT_IN (arg1)
2713               && DECL_BUILT_IN_CLASS (arg0) == DECL_BUILT_IN_CLASS (arg1)
2714               && DECL_FUNCTION_CODE (arg0) == DECL_FUNCTION_CODE (arg1));
2715
2716     default:
2717       return 0;
2718     }
2719
2720 #undef OP_SAME
2721 #undef OP_SAME_WITH_NULL
2722 }
2723 \f
2724 /* Similar to operand_equal_p, but see if ARG0 might have been made by
2725    shorten_compare from ARG1 when ARG1 was being compared with OTHER.
2726
2727    When in doubt, return 0.  */
2728
2729 static int
2730 operand_equal_for_comparison_p (tree arg0, tree arg1, tree other)
2731 {
2732   int unsignedp1, unsignedpo;
2733   tree primarg0, primarg1, primother;
2734   unsigned int correct_width;
2735
2736   if (operand_equal_p (arg0, arg1, 0))
2737     return 1;
2738
2739   if (! INTEGRAL_TYPE_P (TREE_TYPE (arg0))
2740       || ! INTEGRAL_TYPE_P (TREE_TYPE (arg1)))
2741     return 0;
2742
2743   /* Discard any conversions that don't change the modes of ARG0 and ARG1
2744      and see if the inner values are the same.  This removes any
2745      signedness comparison, which doesn't matter here.  */
2746   primarg0 = arg0, primarg1 = arg1;
2747   STRIP_NOPS (primarg0);
2748   STRIP_NOPS (primarg1);
2749   if (operand_equal_p (primarg0, primarg1, 0))
2750     return 1;
2751
2752   /* Duplicate what shorten_compare does to ARG1 and see if that gives the
2753      actual comparison operand, ARG0.
2754
2755      First throw away any conversions to wider types
2756      already present in the operands.  */
2757
2758   primarg1 = get_narrower (arg1, &unsignedp1);
2759   primother = get_narrower (other, &unsignedpo);
2760
2761   correct_width = TYPE_PRECISION (TREE_TYPE (arg1));
2762   if (unsignedp1 == unsignedpo
2763       && TYPE_PRECISION (TREE_TYPE (primarg1)) < correct_width
2764       && TYPE_PRECISION (TREE_TYPE (primother)) < correct_width)
2765     {
2766       tree type = TREE_TYPE (arg0);
2767
2768       /* Make sure shorter operand is extended the right way
2769          to match the longer operand.  */
2770       primarg1 = fold_convert (signed_or_unsigned_type_for
2771                                (unsignedp1, TREE_TYPE (primarg1)), primarg1);
2772
2773       if (operand_equal_p (arg0, fold_convert (type, primarg1), 0))
2774         return 1;
2775     }
2776
2777   return 0;
2778 }
2779 \f
2780 /* See if ARG is an expression that is either a comparison or is performing
2781    arithmetic on comparisons.  The comparisons must only be comparing
2782    two different values, which will be stored in *CVAL1 and *CVAL2; if
2783    they are nonzero it means that some operands have already been found.
2784    No variables may be used anywhere else in the expression except in the
2785    comparisons.  If SAVE_P is true it means we removed a SAVE_EXPR around
2786    the expression and save_expr needs to be called with CVAL1 and CVAL2.
2787
2788    If this is true, return 1.  Otherwise, return zero.  */
2789
2790 static int
2791 twoval_comparison_p (tree arg, tree *cval1, tree *cval2, int *save_p)
2792 {
2793   enum tree_code code = TREE_CODE (arg);
2794   enum tree_code_class tclass = TREE_CODE_CLASS (code);
2795
2796   /* We can handle some of the tcc_expression cases here.  */
2797   if (tclass == tcc_expression && code == TRUTH_NOT_EXPR)
2798     tclass = tcc_unary;
2799   else if (tclass == tcc_expression
2800            && (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR
2801                || code == COMPOUND_EXPR))
2802     tclass = tcc_binary;
2803
2804   else if (tclass == tcc_expression && code == SAVE_EXPR
2805            && ! TREE_SIDE_EFFECTS (TREE_OPERAND (arg, 0)))
2806     {
2807       /* If we've already found a CVAL1 or CVAL2, this expression is
2808          two complex to handle.  */
2809       if (*cval1 || *cval2)
2810         return 0;
2811
2812       tclass = tcc_unary;
2813       *save_p = 1;
2814     }
2815
2816   switch (tclass)
2817     {
2818     case tcc_unary:
2819       return twoval_comparison_p (TREE_OPERAND (arg, 0), cval1, cval2, save_p);
2820
2821     case tcc_binary:
2822       return (twoval_comparison_p (TREE_OPERAND (arg, 0), cval1, cval2, save_p)
2823               && twoval_comparison_p (TREE_OPERAND (arg, 1),
2824                                       cval1, cval2, save_p));
2825
2826     case tcc_constant:
2827       return 1;
2828
2829     case tcc_expression:
2830       if (code == COND_EXPR)
2831         return (twoval_comparison_p (TREE_OPERAND (arg, 0),
2832                                      cval1, cval2, save_p)
2833                 && twoval_comparison_p (TREE_OPERAND (arg, 1),
2834                                         cval1, cval2, save_p)
2835                 && twoval_comparison_p (TREE_OPERAND (arg, 2),
2836                                         cval1, cval2, save_p));
2837       return 0;
2838
2839     case tcc_comparison:
2840       /* First see if we can handle the first operand, then the second.  For
2841          the second operand, we know *CVAL1 can't be zero.  It must be that
2842          one side of the comparison is each of the values; test for the
2843          case where this isn't true by failing if the two operands
2844          are the same.  */
2845
2846       if (operand_equal_p (TREE_OPERAND (arg, 0),
2847                            TREE_OPERAND (arg, 1), 0))
2848         return 0;
2849
2850       if (*cval1 == 0)
2851         *cval1 = TREE_OPERAND (arg, 0);
2852       else if (operand_equal_p (*cval1, TREE_OPERAND (arg, 0), 0))
2853         ;
2854       else if (*cval2 == 0)
2855         *cval2 = TREE_OPERAND (arg, 0);
2856       else if (operand_equal_p (*cval2, TREE_OPERAND (arg, 0), 0))
2857         ;
2858       else
2859         return 0;
2860
2861       if (operand_equal_p (*cval1, TREE_OPERAND (arg, 1), 0))
2862         ;
2863       else if (*cval2 == 0)
2864         *cval2 = TREE_OPERAND (arg, 1);
2865       else if (operand_equal_p (*cval2, TREE_OPERAND (arg, 1), 0))
2866         ;
2867       else
2868         return 0;
2869
2870       return 1;
2871
2872     default:
2873       return 0;
2874     }
2875 }
2876 \f
2877 /* ARG is a tree that is known to contain just arithmetic operations and
2878    comparisons.  Evaluate the operations in the tree substituting NEW0 for
2879    any occurrence of OLD0 as an operand of a comparison and likewise for
2880    NEW1 and OLD1.  */
2881
2882 static tree
2883 eval_subst (location_t loc, tree arg, tree old0, tree new0,
2884             tree old1, tree new1)
2885 {
2886   tree type = TREE_TYPE (arg);
2887   enum tree_code code = TREE_CODE (arg);
2888   enum tree_code_class tclass = TREE_CODE_CLASS (code);
2889
2890   /* We can handle some of the tcc_expression cases here.  */
2891   if (tclass == tcc_expression && code == TRUTH_NOT_EXPR)
2892     tclass = tcc_unary;
2893   else if (tclass == tcc_expression
2894            && (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR))
2895     tclass = tcc_binary;
2896
2897   switch (tclass)
2898     {
2899     case tcc_unary:
2900       return fold_build1_loc (loc, code, type,
2901                           eval_subst (loc, TREE_OPERAND (arg, 0),
2902                                       old0, new0, old1, new1));
2903
2904     case tcc_binary:
2905       return fold_build2_loc (loc, code, type,
2906                           eval_subst (loc, TREE_OPERAND (arg, 0),
2907                                       old0, new0, old1, new1),
2908                           eval_subst (loc, TREE_OPERAND (arg, 1),
2909                                       old0, new0, old1, new1));
2910
2911     case tcc_expression:
2912       switch (code)
2913         {
2914         case SAVE_EXPR:
2915           return eval_subst (loc, TREE_OPERAND (arg, 0), old0, new0,
2916                              old1, new1);
2917
2918         case COMPOUND_EXPR:
2919           return eval_subst (loc, TREE_OPERAND (arg, 1), old0, new0,
2920                              old1, new1);
2921
2922         case COND_EXPR:
2923           return fold_build3_loc (loc, code, type,
2924                               eval_subst (loc, TREE_OPERAND (arg, 0),
2925                                           old0, new0, old1, new1),
2926                               eval_subst (loc, TREE_OPERAND (arg, 1),
2927                                           old0, new0, old1, new1),
2928                               eval_subst (loc, TREE_OPERAND (arg, 2),
2929                                           old0, new0, old1, new1));
2930         default:
2931           break;
2932         }
2933       /* Fall through - ???  */
2934
2935     case tcc_comparison:
2936       {
2937         tree arg0 = TREE_OPERAND (arg, 0);
2938         tree arg1 = TREE_OPERAND (arg, 1);
2939
2940         /* We need to check both for exact equality and tree equality.  The
2941            former will be true if the operand has a side-effect.  In that
2942            case, we know the operand occurred exactly once.  */
2943
2944         if (arg0 == old0 || operand_equal_p (arg0, old0, 0))
2945           arg0 = new0;
2946         else if (arg0 == old1 || operand_equal_p (arg0, old1, 0))
2947           arg0 = new1;
2948
2949         if (arg1 == old0 || operand_equal_p (arg1, old0, 0))
2950           arg1 = new0;
2951         else if (arg1 == old1 || operand_equal_p (arg1, old1, 0))
2952           arg1 = new1;
2953
2954         return fold_build2_loc (loc, code, type, arg0, arg1);
2955       }
2956
2957     default:
2958       return arg;
2959     }
2960 }
2961 \f
2962 /* Return a tree for the case when the result of an expression is RESULT
2963    converted to TYPE and OMITTED was previously an operand of the expression
2964    but is now not needed (e.g., we folded OMITTED * 0).
2965
2966    If OMITTED has side effects, we must evaluate it.  Otherwise, just do
2967    the conversion of RESULT to TYPE.  */
2968
2969 tree
2970 omit_one_operand_loc (location_t loc, tree type, tree result, tree omitted)
2971 {
2972   tree t = fold_convert_loc (loc, type, result);
2973
2974   /* If the resulting operand is an empty statement, just return the omitted
2975      statement casted to void. */
2976   if (IS_EMPTY_STMT (t) && TREE_SIDE_EFFECTS (omitted))
2977     return build1_loc (loc, NOP_EXPR, void_type_node,
2978                        fold_ignored_result (omitted));
2979
2980   if (TREE_SIDE_EFFECTS (omitted))
2981     return build2_loc (loc, COMPOUND_EXPR, type,
2982                        fold_ignored_result (omitted), t);
2983
2984   return non_lvalue_loc (loc, t);
2985 }
2986
2987 /* Similar, but call pedantic_non_lvalue instead of non_lvalue.  */
2988
2989 static tree
2990 pedantic_omit_one_operand_loc (location_t loc, tree type, tree result,
2991                                tree omitted)
2992 {
2993   tree t = fold_convert_loc (loc, type, result);
2994
2995   /* If the resulting operand is an empty statement, just return the omitted
2996      statement casted to void. */
2997   if (IS_EMPTY_STMT (t) && TREE_SIDE_EFFECTS (omitted))
2998     return build1_loc (loc, NOP_EXPR, void_type_node,
2999                        fold_ignored_result (omitted));
3000
3001   if (TREE_SIDE_EFFECTS (omitted))
3002     return build2_loc (loc, COMPOUND_EXPR, type,
3003                        fold_ignored_result (omitted), t);
3004
3005   return pedantic_non_lvalue_loc (loc, t);
3006 }
3007
3008 /* Return a tree for the case when the result of an expression is RESULT
3009    converted to TYPE and OMITTED1 and OMITTED2 were previously operands
3010    of the expression but are now not needed.
3011
3012    If OMITTED1 or OMITTED2 has side effects, they must be evaluated.
3013    If both OMITTED1 and OMITTED2 have side effects, OMITTED1 is
3014    evaluated before OMITTED2.  Otherwise, if neither has side effects,
3015    just do the conversion of RESULT to TYPE.  */
3016
3017 tree
3018 omit_two_operands_loc (location_t loc, tree type, tree result,
3019                        tree omitted1, tree omitted2)
3020 {
3021   tree t = fold_convert_loc (loc, type, result);
3022
3023   if (TREE_SIDE_EFFECTS (omitted2))
3024     t = build2_loc (loc, COMPOUND_EXPR, type, omitted2, t);
3025   if (TREE_SIDE_EFFECTS (omitted1))
3026     t = build2_loc (loc, COMPOUND_EXPR, type, omitted1, t);
3027
3028   return TREE_CODE (t) != COMPOUND_EXPR ? non_lvalue_loc (loc, t) : t;
3029 }
3030
3031 \f
3032 /* Return a simplified tree node for the truth-negation of ARG.  This
3033    never alters ARG itself.  We assume that ARG is an operation that
3034    returns a truth value (0 or 1).
3035
3036    FIXME: one would think we would fold the result, but it causes
3037    problems with the dominator optimizer.  */
3038
3039 tree
3040 fold_truth_not_expr (location_t loc, tree arg)
3041 {
3042   tree type = TREE_TYPE (arg);
3043   enum tree_code code = TREE_CODE (arg);
3044   location_t loc1, loc2;
3045
3046   /* If this is a comparison, we can simply invert it, except for
3047      floating-point non-equality comparisons, in which case we just
3048      enclose a TRUTH_NOT_EXPR around what we have.  */
3049
3050   if (TREE_CODE_CLASS (code) == tcc_comparison)
3051     {
3052       tree op_type = TREE_TYPE (TREE_OPERAND (arg, 0));
3053       if (FLOAT_TYPE_P (op_type)
3054           && flag_trapping_math
3055           && code != ORDERED_EXPR && code != UNORDERED_EXPR
3056           && code != NE_EXPR && code != EQ_EXPR)
3057         return NULL_TREE;
3058
3059       code = invert_tree_comparison (code, HONOR_NANS (TYPE_MODE (op_type)));
3060       if (code == ERROR_MARK)
3061         return NULL_TREE;
3062
3063       return build2_loc (loc, code, type, TREE_OPERAND (arg, 0),
3064                          TREE_OPERAND (arg, 1));
3065     }
3066
3067   switch (code)
3068     {
3069     case INTEGER_CST:
3070       return constant_boolean_node (integer_zerop (arg), type);
3071
3072     case TRUTH_AND_EXPR:
3073       loc1 = expr_location_or (TREE_OPERAND (arg, 0), loc);
3074       loc2 = expr_location_or (TREE_OPERAND (arg, 1), loc);
3075       return build2_loc (loc, TRUTH_OR_EXPR, type,
3076                          invert_truthvalue_loc (loc1, TREE_OPERAND (arg, 0)),
3077                          invert_truthvalue_loc (loc2, TREE_OPERAND (arg, 1)));
3078
3079     case TRUTH_OR_EXPR:
3080       loc1 = expr_location_or (TREE_OPERAND (arg, 0), loc);
3081       loc2 = expr_location_or (TREE_OPERAND (arg, 1), loc);
3082       return build2_loc (loc, TRUTH_AND_EXPR, type,
3083                          invert_truthvalue_loc (loc1, TREE_OPERAND (arg, 0)),
3084                          invert_truthvalue_loc (loc2, TREE_OPERAND (arg, 1)));
3085
3086     case TRUTH_XOR_EXPR:
3087       /* Here we can invert either operand.  We invert the first operand
3088          unless the second operand is a TRUTH_NOT_EXPR in which case our
3089          result is the XOR of the first operand with the inside of the
3090          negation of the second operand.  */
3091
3092       if (TREE_CODE (TREE_OPERAND (arg, 1)) == TRUTH_NOT_EXPR)
3093         return build2_loc (loc, TRUTH_XOR_EXPR, type, TREE_OPERAND (arg, 0),
3094                            TREE_OPERAND (TREE_OPERAND (arg, 1), 0));
3095       else
3096         return build2_loc (loc, TRUTH_XOR_EXPR, type,
3097                            invert_truthvalue_loc (loc, TREE_OPERAND (arg, 0)),
3098                            TREE_OPERAND (arg, 1));
3099
3100     case TRUTH_ANDIF_EXPR:
3101       loc1 = expr_location_or (TREE_OPERAND (arg, 0), loc);
3102       loc2 = expr_location_or (TREE_OPERAND (arg, 1), loc);
3103       return build2_loc (loc, TRUTH_ORIF_EXPR, type,
3104                          invert_truthvalue_loc (loc1, TREE_OPERAND (arg, 0)),
3105                          invert_truthvalue_loc (loc2, TREE_OPERAND (arg, 1)));
3106
3107     case TRUTH_ORIF_EXPR:
3108       loc1 = expr_location_or (TREE_OPERAND (arg, 0), loc);
3109       loc2 = expr_location_or (TREE_OPERAND (arg, 1), loc);
3110       return build2_loc (loc, TRUTH_ANDIF_EXPR, type,
3111                          invert_truthvalue_loc (loc1, TREE_OPERAND (arg, 0)),
3112                          invert_truthvalue_loc (loc2, TREE_OPERAND (arg, 1)));
3113
3114     case TRUTH_NOT_EXPR:
3115       return TREE_OPERAND (arg, 0);
3116
3117     case COND_EXPR:
3118       {
3119         tree arg1 = TREE_OPERAND (arg, 1);
3120         tree arg2 = TREE_OPERAND (arg, 2);
3121
3122         loc1 = expr_location_or (TREE_OPERAND (arg, 1), loc);
3123         loc2 = expr_location_or (TREE_OPERAND (arg, 2), loc);
3124
3125         /* A COND_EXPR may have a throw as one operand, which
3126            then has void type.  Just leave void operands
3127            as they are.  */
3128         return build3_loc (loc, COND_EXPR, type, TREE_OPERAND (arg, 0),
3129                            VOID_TYPE_P (TREE_TYPE (arg1))
3130                            ? arg1 : invert_truthvalue_loc (loc1, arg1),
3131                            VOID_TYPE_P (TREE_TYPE (arg2))
3132                            ? arg2 : invert_truthvalue_loc (loc2, arg2));
3133       }
3134
3135     case COMPOUND_EXPR:
3136       loc1 = expr_location_or (TREE_OPERAND (arg, 1), loc);
3137       return build2_loc (loc, COMPOUND_EXPR, type,
3138                          TREE_OPERAND (arg, 0),
3139                          invert_truthvalue_loc (loc1, TREE_OPERAND (arg, 1)));
3140
3141     case NON_LVALUE_EXPR:
3142       loc1 = expr_location_or (TREE_OPERAND (arg, 0), loc);
3143       return invert_truthvalue_loc (loc1, TREE_OPERAND (arg, 0));
3144
3145     CASE_CONVERT:
3146       if (TREE_CODE (TREE_TYPE (arg)) == BOOLEAN_TYPE)
3147         return build1_loc (loc, TRUTH_NOT_EXPR, type, arg);
3148
3149       /* ... fall through ...  */
3150
3151     case FLOAT_EXPR:
3152       loc1 = expr_location_or (TREE_OPERAND (arg, 0), loc);
3153       return build1_loc (loc, TREE_CODE (arg), type,
3154                          invert_truthvalue_loc (loc1, TREE_OPERAND (arg, 0)));
3155
3156     case BIT_AND_EXPR:
3157       if (!integer_onep (TREE_OPERAND (arg, 1)))
3158         return NULL_TREE;
3159       return build2_loc (loc, EQ_EXPR, type, arg, build_int_cst (type, 0));
3160
3161     case SAVE_EXPR:
3162       return build1_loc (loc, TRUTH_NOT_EXPR, type, arg);
3163
3164     case CLEANUP_POINT_EXPR:
3165       loc1 = expr_location_or (TREE_OPERAND (arg, 0), loc);
3166       return build1_loc (loc, CLEANUP_POINT_EXPR, type,
3167                          invert_truthvalue_loc (loc1, TREE_OPERAND (arg, 0)));
3168
3169     default:
3170       return NULL_TREE;
3171     }
3172 }
3173
3174 /* Return a simplified tree node for the truth-negation of ARG.  This
3175    never alters ARG itself.  We assume that ARG is an operation that
3176    returns a truth value (0 or 1).
3177
3178    FIXME: one would think we would fold the result, but it causes
3179    problems with the dominator optimizer.  */
3180
3181 tree
3182 invert_truthvalue_loc (location_t loc, tree arg)
3183 {
3184   tree tem;
3185
3186   if (TREE_CODE (arg) == ERROR_MARK)
3187     return arg;
3188
3189   tem = fold_truth_not_expr (loc, arg);
3190   if (!tem)
3191     tem = build1_loc (loc, TRUTH_NOT_EXPR, TREE_TYPE (arg), arg);
3192
3193   return tem;
3194 }
3195
3196 /* Given a bit-wise operation CODE applied to ARG0 and ARG1, see if both
3197    operands are another bit-wise operation with a common input.  If so,
3198    distribute the bit operations to save an operation and possibly two if
3199    constants are involved.  For example, convert
3200         (A | B) & (A | C) into A | (B & C)
3201    Further simplification will occur if B and C are constants.
3202
3203    If this optimization cannot be done, 0 will be returned.  */
3204
3205 static tree
3206 distribute_bit_expr (location_t loc, enum tree_code code, tree type,
3207                      tree arg0, tree arg1)
3208 {
3209   tree common;
3210   tree left, right;
3211
3212   if (TREE_CODE (arg0) != TREE_CODE (arg1)
3213       || TREE_CODE (arg0) == code
3214       || (TREE_CODE (arg0) != BIT_AND_EXPR
3215           && TREE_CODE (arg0) != BIT_IOR_EXPR))
3216     return 0;
3217
3218   if (operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1, 0), 0))
3219     {
3220       common = TREE_OPERAND (arg0, 0);
3221       left = TREE_OPERAND (arg0, 1);
3222       right = TREE_OPERAND (arg1, 1);
3223     }
3224   else if (operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1, 1), 0))
3225     {
3226       common = TREE_OPERAND (arg0, 0);
3227       left = TREE_OPERAND (arg0, 1);
3228       right = TREE_OPERAND (arg1, 0);
3229     }
3230   else if (operand_equal_p (TREE_OPERAND (arg0, 1), TREE_OPERAND (arg1, 0), 0))
3231     {
3232       common = TREE_OPERAND (arg0, 1);
3233       left = TREE_OPERAND (arg0, 0);
3234       right = TREE_OPERAND (arg1, 1);
3235     }
3236   else if (operand_equal_p (TREE_OPERAND (arg0, 1), TREE_OPERAND (arg1, 1), 0))
3237     {
3238       common = TREE_OPERAND (arg0, 1);
3239       left = TREE_OPERAND (arg0, 0);
3240       right = TREE_OPERAND (arg1, 0);
3241     }
3242   else
3243     return 0;
3244
3245   common = fold_convert_loc (loc, type, common);
3246   left = fold_convert_loc (loc, type, left);
3247   right = fold_convert_loc (loc, type, right);
3248   return fold_build2_loc (loc, TREE_CODE (arg0), type, common,
3249                       fold_build2_loc (loc, code, type, left, right));
3250 }
3251
3252 /* Knowing that ARG0 and ARG1 are both RDIV_EXPRs, simplify a binary operation
3253    with code CODE.  This optimization is unsafe.  */
3254 static tree
3255 distribute_real_division (location_t loc, enum tree_code code, tree type,
3256                           tree arg0, tree arg1)
3257 {
3258   bool mul0 = TREE_CODE (arg0) == MULT_EXPR;
3259   bool mul1 = TREE_CODE (arg1) == MULT_EXPR;
3260
3261   /* (A / C) +- (B / C) -> (A +- B) / C.  */
3262   if (mul0 == mul1
3263       && operand_equal_p (TREE_OPERAND (arg0, 1),
3264                        TREE_OPERAND (arg1, 1), 0))
3265     return fold_build2_loc (loc, mul0 ? MULT_EXPR : RDIV_EXPR, type,
3266                         fold_build2_loc (loc, code, type,
3267                                      TREE_OPERAND (arg0, 0),
3268                                      TREE_OPERAND (arg1, 0)),
3269                         TREE_OPERAND (arg0, 1));
3270
3271   /* (A / C1) +- (A / C2) -> A * (1 / C1 +- 1 / C2).  */
3272   if (operand_equal_p (TREE_OPERAND (arg0, 0),
3273                        TREE_OPERAND (arg1, 0), 0)
3274       && TREE_CODE (TREE_OPERAND (arg0, 1)) == REAL_CST
3275       && TREE_CODE (TREE_OPERAND (arg1, 1)) == REAL_CST)
3276     {
3277       REAL_VALUE_TYPE r0, r1;
3278       r0 = TREE_REAL_CST (TREE_OPERAND (arg0, 1));
3279       r1 = TREE_REAL_CST (TREE_OPERAND (arg1, 1));
3280       if (!mul0)
3281         real_arithmetic (&r0, RDIV_EXPR, &dconst1, &r0);
3282       if (!mul1)
3283         real_arithmetic (&r1, RDIV_EXPR, &dconst1, &r1);
3284       real_arithmetic (&r0, code, &r0, &r1);
3285       return fold_build2_loc (loc, MULT_EXPR, type,
3286                           TREE_OPERAND (arg0, 0),
3287                           build_real (type, r0));
3288     }
3289
3290   return NULL_TREE;
3291 }
3292 \f
3293 /* Return a BIT_FIELD_REF of type TYPE to refer to BITSIZE bits of INNER
3294    starting at BITPOS.  The field is unsigned if UNSIGNEDP is nonzero.  */
3295
3296 static tree
3297 make_bit_field_ref (location_t loc, tree inner, tree type,
3298                     HOST_WIDE_INT bitsize, HOST_WIDE_INT bitpos, int unsignedp)
3299 {
3300   tree result, bftype;
3301
3302   if (bitpos == 0)
3303     {
3304       tree size = TYPE_SIZE (TREE_TYPE (inner));
3305       if ((INTEGRAL_TYPE_P (TREE_TYPE (inner))
3306            || POINTER_TYPE_P (TREE_TYPE (inner)))
3307           && host_integerp (size, 0)
3308           && tree_low_cst (size, 0) == bitsize)
3309         return fold_convert_loc (loc, type, inner);
3310     }
3311
3312   bftype = type;
3313   if (TYPE_PRECISION (bftype) != bitsize
3314       || TYPE_UNSIGNED (bftype) == !unsignedp)
3315     bftype = build_nonstandard_integer_type (bitsize, 0);
3316
3317   result = build3_loc (loc, BIT_FIELD_REF, bftype, inner,
3318                        size_int (bitsize), bitsize_int (bitpos));
3319
3320   if (bftype != type)
3321     result = fold_convert_loc (loc, type, result);
3322
3323   return result;
3324 }
3325
3326 /* Optimize a bit-field compare.
3327
3328    There are two cases:  First is a compare against a constant and the
3329    second is a comparison of two items where the fields are at the same
3330    bit position relative to the start of a chunk (byte, halfword, word)
3331    large enough to contain it.  In these cases we can avoid the shift
3332    implicit in bitfield extractions.
3333
3334    For constants, we emit a compare of the shifted constant with the
3335    BIT_AND_EXPR of a mask and a byte, halfword, or word of the operand being
3336    compared.  For two fields at the same position, we do the ANDs with the
3337    similar mask and compare the result of the ANDs.
3338
3339    CODE is the comparison code, known to be either NE_EXPR or EQ_EXPR.
3340    COMPARE_TYPE is the type of the comparison, and LHS and RHS
3341    are the left and right operands of the comparison, respectively.
3342
3343    If the optimization described above can be done, we return the resulting
3344    tree.  Otherwise we return zero.  */
3345
3346 static tree
3347 optimize_bit_field_compare (location_t loc, enum tree_code code,
3348                             tree compare_type, tree lhs, tree rhs)
3349 {
3350   HOST_WIDE_INT lbitpos, lbitsize, rbitpos, rbitsize, nbitpos, nbitsize;
3351   tree type = TREE_TYPE (lhs);
3352   tree signed_type, unsigned_type;
3353   int const_p = TREE_CODE (rhs) == INTEGER_CST;
3354   enum machine_mode lmode, rmode, nmode;
3355   int lunsignedp, runsignedp;
3356   int lvolatilep = 0, rvolatilep = 0;
3357   tree linner, rinner = NULL_TREE;
3358   tree mask;
3359   tree offset;
3360
3361   /* Get all the information about the extractions being done.  If the bit size
3362      if the same as the size of the underlying object, we aren't doing an
3363      extraction at all and so can do nothing.  We also don't want to
3364      do anything if the inner expression is a PLACEHOLDER_EXPR since we
3365      then will no longer be able to replace it.  */
3366   linner = get_inner_reference (lhs, &lbitsize, &lbitpos, &offset, &lmode,
3367                                 &lunsignedp, &lvolatilep, false);
3368   if (linner == lhs || lbitsize == GET_MODE_BITSIZE (lmode) || lbitsize < 0
3369       || offset != 0 || TREE_CODE (linner) == PLACEHOLDER_EXPR)
3370     return 0;
3371
3372  if (!const_p)
3373    {
3374      /* If this is not a constant, we can only do something if bit positions,
3375         sizes, and signedness are the same.  */
3376      rinner = get_inner_reference (rhs, &rbitsize, &rbitpos, &offset, &rmode,
3377                                    &runsignedp, &rvolatilep, false);
3378
3379      if (rinner == rhs || lbitpos != rbitpos || lbitsize != rbitsize
3380          || lunsignedp != runsignedp || offset != 0
3381          || TREE_CODE (rinner) == PLACEHOLDER_EXPR)
3382        return 0;
3383    }
3384
3385   /* See if we can find a mode to refer to this field.  We should be able to,
3386      but fail if we can't.  */
3387   if (lvolatilep
3388       && GET_MODE_BITSIZE (lmode) > 0
3389       && flag_strict_volatile_bitfields > 0)
3390     nmode = lmode;
3391   else
3392     nmode = get_best_mode (lbitsize, lbitpos, 0, 0,
3393                            const_p ? TYPE_ALIGN (TREE_TYPE (linner))
3394                            : MIN (TYPE_ALIGN (TREE_TYPE (linner)),
3395                                   TYPE_ALIGN (TREE_TYPE (rinner))),
3396                            word_mode, lvolatilep || rvolatilep);
3397   if (nmode == VOIDmode)
3398     return 0;
3399
3400   /* Set signed and unsigned types of the precision of this mode for the
3401      shifts below.  */
3402   signed_type = lang_hooks.types.type_for_mode (nmode, 0);
3403   unsigned_type = lang_hooks.types.type_for_mode (nmode, 1);
3404
3405   /* Compute the bit position and size for the new reference and our offset
3406      within it. If the new reference is the same size as the original, we
3407      won't optimize anything, so return zero.  */
3408   nbitsize = GET_MODE_BITSIZE (nmode);
3409   nbitpos = lbitpos & ~ (nbitsize - 1);
3410   lbitpos -= nbitpos;
3411   if (nbitsize == lbitsize)
3412     return 0;
3413
3414   if (BYTES_BIG_ENDIAN)
3415     lbitpos = nbitsize - lbitsize - lbitpos;
3416
3417   /* Make the mask to be used against the extracted field.  */
3418   mask = build_int_cst_type (unsigned_type, -1);
3419   mask = const_binop (LSHIFT_EXPR, mask, size_int (nbitsize - lbitsize));
3420   mask = const_binop (RSHIFT_EXPR, mask,
3421                       size_int (nbitsize - lbitsize - lbitpos));
3422
3423   if (! const_p)
3424     /* If not comparing with constant, just rework the comparison
3425        and return.  */
3426     return fold_build2_loc (loc, code, compare_type,
3427                         fold_build2_loc (loc, BIT_AND_EXPR, unsigned_type,
3428                                      make_bit_field_ref (loc, linner,
3429                                                          unsigned_type,
3430                                                          nbitsize, nbitpos,
3431                                                          1),
3432                                      mask),
3433                         fold_build2_loc (loc, BIT_AND_EXPR, unsigned_type,
3434                                      make_bit_field_ref (loc, rinner,
3435                                                          unsigned_type,
3436                                                          nbitsize, nbitpos,
3437                                                          1),
3438                                      mask));
3439
3440   /* Otherwise, we are handling the constant case. See if the constant is too
3441      big for the field.  Warn and return a tree of for 0 (false) if so.  We do
3442      this not only for its own sake, but to avoid having to test for this
3443      error case below.  If we didn't, we might generate wrong code.
3444
3445      For unsigned fields, the constant shifted right by the field length should
3446      be all zero.  For signed fields, the high-order bits should agree with
3447      the sign bit.  */
3448
3449   if (lunsignedp)
3450     {
3451       if (! integer_zerop (const_binop (RSHIFT_EXPR,
3452                                         fold_convert_loc (loc,
3453                                                           unsigned_type, rhs),
3454                                         size_int (lbitsize))))
3455         {
3456           warning (0, "comparison is always %d due to width of bit-field",
3457                    code == NE_EXPR);
3458           return constant_boolean_node (code == NE_EXPR, compare_type);
3459         }
3460     }
3461   else
3462     {
3463       tree tem = const_binop (RSHIFT_EXPR,
3464                               fold_convert_loc (loc, signed_type, rhs),
3465                               size_int (lbitsize - 1));
3466       if (! integer_zerop (tem) && ! integer_all_onesp (tem))
3467         {
3468           warning (0, "comparison is always %d due to width of bit-field",
3469                    code == NE_EXPR);
3470           return constant_boolean_node (code == NE_EXPR, compare_type);
3471         }
3472     }
3473
3474   /* Single-bit compares should always be against zero.  */
3475   if (lbitsize == 1 && ! integer_zerop (rhs))
3476     {
3477       code = code == EQ_EXPR ? NE_EXPR : EQ_EXPR;
3478       rhs = build_int_cst (type, 0);
3479     }
3480
3481   /* Make a new bitfield reference, shift the constant over the
3482      appropriate number of bits and mask it with the computed mask
3483      (in case this was a signed field).  If we changed it, make a new one.  */
3484   lhs = make_bit_field_ref (loc, linner, unsigned_type, nbitsize, nbitpos, 1);
3485   if (lvolatilep)
3486     {
3487       TREE_SIDE_EFFECTS (lhs) = 1;
3488       TREE_THIS_VOLATILE (lhs) = 1;
3489     }
3490
3491   rhs = const_binop (BIT_AND_EXPR,
3492                      const_binop (LSHIFT_EXPR,
3493                                   fold_convert_loc (loc, unsigned_type, rhs),
3494                                   size_int (lbitpos)),
3495                      mask);
3496
3497   lhs = build2_loc (loc, code, compare_type,
3498                     build2 (BIT_AND_EXPR, unsigned_type, lhs, mask), rhs);
3499   return lhs;
3500 }
3501 \f
3502 /* Subroutine for fold_truth_andor_1: decode a field reference.
3503
3504    If EXP is a comparison reference, we return the innermost reference.
3505
3506    *PBITSIZE is set to the number of bits in the reference, *PBITPOS is
3507    set to the starting bit number.
3508
3509    If the innermost field can be completely contained in a mode-sized
3510    unit, *PMODE is set to that mode.  Otherwise, it is set to VOIDmode.
3511
3512    *PVOLATILEP is set to 1 if the any expression encountered is volatile;
3513    otherwise it is not changed.
3514
3515    *PUNSIGNEDP is set to the signedness of the field.
3516
3517    *PMASK is set to the mask used.  This is either contained in a
3518    BIT_AND_EXPR or derived from the width of the field.
3519
3520    *PAND_MASK is set to the mask found in a BIT_AND_EXPR, if any.
3521
3522    Return 0 if this is not a component reference or is one that we can't
3523    do anything with.  */
3524
3525 static tree
3526 decode_field_reference (location_t loc, tree exp, HOST_WIDE_INT *pbitsize,
3527                         HOST_WIDE_INT *pbitpos, enum machine_mode *pmode,
3528                         int *punsignedp, int *pvolatilep,
3529                         tree *pmask, tree *pand_mask)
3530 {
3531   tree outer_type = 0;
3532   tree and_mask = 0;
3533   tree mask, inner, offset;
3534   tree unsigned_type;
3535   unsigned int precision;
3536
3537   /* All the optimizations using this function assume integer fields.
3538      There are problems with FP fields since the type_for_size call
3539      below can fail for, e.g., XFmode.  */
3540   if (! INTEGRAL_TYPE_P (TREE_TYPE (exp)))
3541     return 0;
3542
3543   /* We are interested in the bare arrangement of bits, so strip everything
3544      that doesn't affect the machine mode.  However, record the type of the
3545      outermost expression if it may matter below.  */
3546   if (CONVERT_EXPR_P (exp)
3547       || TREE_CODE (exp) == NON_LVALUE_EXPR)
3548     outer_type = TREE_TYPE (exp);
3549   STRIP_NOPS (exp);
3550
3551   if (TREE_CODE (exp) == BIT_AND_EXPR)
3552     {
3553       and_mask = TREE_OPERAND (exp, 1);
3554       exp = TREE_OPERAND (exp, 0);
3555       STRIP_NOPS (exp); STRIP_NOPS (and_mask);
3556       if (TREE_CODE (and_mask) != INTEGER_CST)
3557         return 0;
3558     }
3559
3560   inner = get_inner_reference (exp, pbitsize, pbitpos, &offset, pmode,
3561                                punsignedp, pvolatilep, false);
3562   if ((inner == exp && and_mask == 0)
3563       || *pbitsize < 0 || offset != 0
3564       || TREE_CODE (inner) == PLACEHOLDER_EXPR)
3565     return 0;
3566
3567   /* If the number of bits in the reference is the same as the bitsize of
3568      the outer type, then the outer type gives the signedness. Otherwise
3569      (in case of a small bitfield) the signedness is unchanged.  */
3570   if (outer_type && *pbitsize == TYPE_PRECISION (outer_type))
3571     *punsignedp = TYPE_UNSIGNED (outer_type);
3572
3573   /* Compute the mask to access the bitfield.  */
3574   unsigned_type = lang_hooks.types.type_for_size (*pbitsize, 1);
3575   precision = TYPE_PRECISION (unsigned_type);
3576
3577   mask = build_int_cst_type (unsigned_type, -1);
3578
3579   mask = const_binop (LSHIFT_EXPR, mask, size_int (precision - *pbitsize));
3580   mask = const_binop (RSHIFT_EXPR, mask, size_int (precision - *pbitsize));
3581
3582   /* Merge it with the mask we found in the BIT_AND_EXPR, if any.  */
3583   if (and_mask != 0)
3584     mask = fold_build2_loc (loc, BIT_AND_EXPR, unsigned_type,
3585                         fold_convert_loc (loc, unsigned_type, and_mask), mask);
3586
3587   *pmask = mask;
3588   *pand_mask = and_mask;
3589   return inner;
3590 }
3591
3592 /* Return nonzero if MASK represents a mask of SIZE ones in the low-order
3593    bit positions.  */
3594
3595 static int
3596 all_ones_mask_p (const_tree mask, int size)
3597 {
3598   tree type = TREE_TYPE (mask);
3599   unsigned int precision = TYPE_PRECISION (type);
3600   tree tmask;
3601
3602   tmask = build_int_cst_type (signed_type_for (type), -1);
3603
3604   return
3605     tree_int_cst_equal (mask,
3606                         const_binop (RSHIFT_EXPR,
3607                                      const_binop (LSHIFT_EXPR, tmask,
3608                                                   size_int (precision - size)),
3609                                      size_int (precision - size)));
3610 }
3611
3612 /* Subroutine for fold: determine if VAL is the INTEGER_CONST that
3613    represents the sign bit of EXP's type.  If EXP represents a sign
3614    or zero extension, also test VAL against the unextended type.
3615    The return value is the (sub)expression whose sign bit is VAL,
3616    or NULL_TREE otherwise.  */
3617
3618 static tree
3619 sign_bit_p (tree exp, const_tree val)
3620 {
3621   unsigned HOST_WIDE_INT mask_lo, lo;
3622   HOST_WIDE_INT mask_hi, hi;
3623   int width;
3624   tree t;
3625
3626   /* Tree EXP must have an integral type.  */
3627   t = TREE_TYPE (exp);
3628   if (! INTEGRAL_TYPE_P (t))
3629     return NULL_TREE;
3630
3631   /* Tree VAL must be an integer constant.  */
3632   if (TREE_CODE (val) != INTEGER_CST
3633       || TREE_OVERFLOW (val))
3634     return NULL_TREE;
3635
3636   width = TYPE_PRECISION (t);
3637   if (width > HOST_BITS_PER_WIDE_INT)
3638     {
3639       hi = (unsigned HOST_WIDE_INT) 1 << (width - HOST_BITS_PER_WIDE_INT - 1);
3640       lo = 0;
3641
3642       mask_hi = ((unsigned HOST_WIDE_INT) -1
3643                  >> (2 * HOST_BITS_PER_WIDE_INT - width));
3644       mask_lo = -1;
3645     }
3646   else
3647     {
3648       hi = 0;
3649       lo = (unsigned HOST_WIDE_INT) 1 << (width - 1);
3650
3651       mask_hi = 0;
3652       mask_lo = ((unsigned HOST_WIDE_INT) -1
3653                  >> (HOST_BITS_PER_WIDE_INT - width));
3654     }
3655
3656   /* We mask off those bits beyond TREE_TYPE (exp) so that we can
3657      treat VAL as if it were unsigned.  */
3658   if ((TREE_INT_CST_HIGH (val) & mask_hi) == hi
3659       && (TREE_INT_CST_LOW (val) & mask_lo) == lo)
3660     return exp;
3661
3662   /* Handle extension from a narrower type.  */
3663   if (TREE_CODE (exp) == NOP_EXPR
3664       && TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (exp, 0))) < width)
3665     return sign_bit_p (TREE_OPERAND (exp, 0), val);
3666
3667   return NULL_TREE;
3668 }
3669
3670 /* Subroutine for fold_truth_andor_1: determine if an operand is simple enough
3671    to be evaluated unconditionally.  */
3672
3673 static int
3674 simple_operand_p (const_tree exp)
3675 {
3676   /* Strip any conversions that don't change the machine mode.  */
3677   STRIP_NOPS (exp);
3678
3679   return (CONSTANT_CLASS_P (exp)
3680           || TREE_CODE (exp) == SSA_NAME
3681           || (DECL_P (exp)
3682               && ! TREE_ADDRESSABLE (exp)
3683               && ! TREE_THIS_VOLATILE (exp)
3684               && ! DECL_NONLOCAL (exp)
3685               /* Don't regard global variables as simple.  They may be
3686                  allocated in ways unknown to the compiler (shared memory,
3687                  #pragma weak, etc).  */
3688               && ! TREE_PUBLIC (exp)
3689               && ! DECL_EXTERNAL (exp)
3690               /* Loading a static variable is unduly expensive, but global
3691                  registers aren't expensive.  */
3692               && (! TREE_STATIC (exp) || DECL_REGISTER (exp))));
3693 }
3694
3695 /* Subroutine for fold_truth_andor: determine if an operand is simple enough
3696    to be evaluated unconditionally.
3697    I addition to simple_operand_p, we assume that comparisons, conversions,
3698    and logic-not operations are simple, if their operands are simple, too.  */
3699
3700 static bool
3701 simple_operand_p_2 (tree exp)
3702 {
3703   enum tree_code code;
3704
3705   if (TREE_SIDE_EFFECTS (exp)
3706       || tree_could_trap_p (exp))
3707     return false;
3708
3709   while (CONVERT_EXPR_P (exp))
3710     exp = TREE_OPERAND (exp, 0);
3711
3712   code = TREE_CODE (exp);
3713
3714   if (TREE_CODE_CLASS (code) == tcc_comparison)
3715     return (simple_operand_p (TREE_OPERAND (exp, 0))
3716             && simple_operand_p (TREE_OPERAND (exp, 1)));
3717
3718   if (code == TRUTH_NOT_EXPR)
3719       return simple_operand_p_2 (TREE_OPERAND (exp, 0));
3720
3721   return simple_operand_p (exp);
3722 }
3723
3724 \f
3725 /* The following functions are subroutines to fold_range_test and allow it to
3726    try to change a logical combination of comparisons into a range test.
3727
3728    For example, both
3729         X == 2 || X == 3 || X == 4 || X == 5
3730    and
3731         X >= 2 && X <= 5
3732    are converted to
3733         (unsigned) (X - 2) <= 3
3734
3735    We describe each set of comparisons as being either inside or outside
3736    a range, using a variable named like IN_P, and then describe the
3737    range with a lower and upper bound.  If one of the bounds is omitted,
3738    it represents either the highest or lowest value of the type.
3739
3740    In the comments below, we represent a range by two numbers in brackets
3741    preceded by a "+" to designate being inside that range, or a "-" to
3742    designate being outside that range, so the condition can be inverted by
3743    flipping the prefix.  An omitted bound is represented by a "-".  For
3744    example, "- [-, 10]" means being outside the range starting at the lowest
3745    possible value and ending at 10, in other words, being greater than 10.
3746    The range "+ [-, -]" is always true and hence the range "- [-, -]" is
3747    always false.
3748
3749    We set up things so that the missing bounds are handled in a consistent
3750    manner so neither a missing bound nor "true" and "false" need to be
3751    handled using a special case.  */
3752
3753 /* Return the result of applying CODE to ARG0 and ARG1, but handle the case
3754    of ARG0 and/or ARG1 being omitted, meaning an unlimited range. UPPER0_P
3755    and UPPER1_P are nonzero if the respective argument is an upper bound
3756    and zero for a lower.  TYPE, if nonzero, is the type of the result; it
3757    must be specified for a comparison.  ARG1 will be converted to ARG0's
3758    type if both are specified.  */
3759
3760 static tree
3761 range_binop (enum tree_code code, tree type, tree arg0, int upper0_p,
3762              tree arg1, int upper1_p)
3763 {
3764   tree tem;
3765   int result;
3766   int sgn0, sgn1;
3767
3768   /* If neither arg represents infinity, do the normal operation.
3769      Else, if not a comparison, return infinity.  Else handle the special
3770      comparison rules. Note that most of the cases below won't occur, but
3771      are handled for consistency.  */
3772
3773   if (arg0 != 0 && arg1 != 0)
3774     {
3775       tem = fold_build2 (code, type != 0 ? type : TREE_TYPE (arg0),
3776                          arg0, fold_convert (TREE_TYPE (arg0), arg1));
3777       STRIP_NOPS (tem);
3778       return TREE_CODE (tem) == INTEGER_CST ? tem : 0;
3779     }
3780
3781   if (TREE_CODE_CLASS (code) != tcc_comparison)
3782     return 0;
3783
3784   /* Set SGN[01] to -1 if ARG[01] is a lower bound, 1 for upper, and 0
3785      for neither.  In real maths, we cannot assume open ended ranges are
3786      the same. But, this is computer arithmetic, where numbers are finite.
3787      We can therefore make the transformation of any unbounded range with
3788      the value Z, Z being greater than any representable number. This permits
3789      us to treat unbounded ranges as equal.  */
3790   sgn0 = arg0 != 0 ? 0 : (upper0_p ? 1 : -1);
3791   sgn1 = arg1 != 0 ? 0 : (upper1_p ? 1 : -1);
3792   switch (code)
3793     {
3794     case EQ_EXPR:
3795       result = sgn0 == sgn1;
3796       break;
3797     case NE_EXPR:
3798       result = sgn0 != sgn1;
3799       break;
3800     case LT_EXPR:
3801       result = sgn0 < sgn1;
3802       break;
3803     case LE_EXPR:
3804       result = sgn0 <= sgn1;
3805       break;
3806     case GT_EXPR:
3807       result = sgn0 > sgn1;
3808       break;
3809     case GE_EXPR:
3810       result = sgn0 >= sgn1;
3811       break;
3812     default:
3813       gcc_unreachable ();
3814     }
3815
3816   return constant_boolean_node (result, type);
3817 }
3818 \f
3819 /* Helper routine for make_range.  Perform one step for it, return
3820    new expression if the loop should continue or NULL_TREE if it should
3821    stop.  */
3822
3823 tree
3824 make_range_step (location_t loc, enum tree_code code, tree arg0, tree arg1,
3825                  tree exp_type, tree *p_low, tree *p_high, int *p_in_p,
3826                  bool *strict_overflow_p)
3827 {
3828   tree arg0_type = TREE_TYPE (arg0);
3829   tree n_low, n_high, low = *p_low, high = *p_high;
3830   int in_p = *p_in_p, n_in_p;
3831
3832   switch (code)
3833     {
3834     case TRUTH_NOT_EXPR:
3835       *p_in_p = ! in_p;
3836       return arg0;
3837
3838     case EQ_EXPR: case NE_EXPR:
3839     case LT_EXPR: case LE_EXPR: case GE_EXPR: case GT_EXPR:
3840       /* We can only do something if the range is testing for zero
3841          and if the second operand is an integer constant.  Note that
3842          saying something is "in" the range we make is done by
3843          complementing IN_P since it will set in the initial case of
3844          being not equal to zero; "out" is leaving it alone.  */
3845       if (low == NULL_TREE || high == NULL_TREE
3846           || ! integer_zerop (low) || ! integer_zerop (high)
3847           || TREE_CODE (arg1) != INTEGER_CST)
3848         return NULL_TREE;
3849
3850       switch (code)
3851         {
3852         case NE_EXPR:  /* - [c, c]  */
3853           low = high = arg1;
3854           break;
3855         case EQ_EXPR:  /* + [c, c]  */
3856           in_p = ! in_p, low = high = arg1;
3857           break;
3858         case GT_EXPR:  /* - [-, c] */
3859           low = 0, high = arg1;
3860           break;
3861         case GE_EXPR:  /* + [c, -] */
3862           in_p = ! in_p, low = arg1, high = 0;
3863           break;
3864         case LT_EXPR:  /* - [c, -] */
3865           low = arg1, high = 0;
3866           break;
3867         case LE_EXPR:  /* + [-, c] */
3868           in_p = ! in_p, low = 0, high = arg1;
3869           break;
3870         default:
3871           gcc_unreachable ();
3872         }
3873
3874       /* If this is an unsigned comparison, we also know that EXP is
3875          greater than or equal to zero.  We base the range tests we make
3876          on that fact, so we record it here so we can parse existing
3877          range tests.  We test arg0_type since often the return type
3878          of, e.g. EQ_EXPR, is boolean.  */
3879       if (TYPE_UNSIGNED (arg0_type) && (low == 0 || high == 0))
3880         {
3881           if (! merge_ranges (&n_in_p, &n_low, &n_high,
3882                               in_p, low, high, 1,
3883                               build_int_cst (arg0_type, 0),
3884                               NULL_TREE))
3885             return NULL_TREE;
3886
3887           in_p = n_in_p, low = n_low, high = n_high;
3888
3889           /* If the high bound is missing, but we have a nonzero low
3890              bound, reverse the range so it goes from zero to the low bound
3891              minus 1.  */
3892           if (high == 0 && low && ! integer_zerop (low))
3893             {
3894               in_p = ! in_p;
3895               high = range_binop (MINUS_EXPR, NULL_TREE, low, 0,
3896                                   integer_one_node, 0);
3897               low = build_int_cst (arg0_type, 0);
3898             }
3899         }
3900
3901       *p_low = low;
3902       *p_high = high;
3903       *p_in_p = in_p;
3904       return arg0;
3905
3906     case NEGATE_EXPR:
3907       /* (-x) IN [a,b] -> x in [-b, -a]  */
3908       n_low = range_binop (MINUS_EXPR, exp_type,
3909                            build_int_cst (exp_type, 0),
3910                            0, high, 1);
3911       n_high = range_binop (MINUS_EXPR, exp_type,
3912                             build_int_cst (exp_type, 0),
3913                             0, low, 0);
3914       if (n_high != 0 && TREE_OVERFLOW (n_high))
3915         return NULL_TREE;
3916       goto normalize;
3917
3918     case BIT_NOT_EXPR:
3919       /* ~ X -> -X - 1  */
3920       return build2_loc (loc, MINUS_EXPR, exp_type, negate_expr (arg0),
3921                          build_int_cst (exp_type, 1));
3922
3923     case PLUS_EXPR:
3924     case MINUS_EXPR:
3925       if (TREE_CODE (arg1) != INTEGER_CST)
3926         return NULL_TREE;
3927
3928       /* If flag_wrapv and ARG0_TYPE is signed, then we cannot
3929          move a constant to the other side.  */
3930       if (!TYPE_UNSIGNED (arg0_type)
3931           && !TYPE_OVERFLOW_UNDEFINED (arg0_type))
3932         return NULL_TREE;
3933
3934       /* If EXP is signed, any overflow in the computation is undefined,
3935          so we don't worry about it so long as our computations on
3936          the bounds don't overflow.  For unsigned, overflow is defined
3937          and this is exactly the right thing.  */
3938       n_low = range_binop (code == MINUS_EXPR ? PLUS_EXPR : MINUS_EXPR,
3939                            arg0_type, low, 0, arg1, 0);
3940       n_high = range_binop (code == MINUS_EXPR ? PLUS_EXPR : MINUS_EXPR,
3941                             arg0_type, high, 1, arg1, 0);
3942       if ((n_low != 0 && TREE_OVERFLOW (n_low))
3943           || (n_high != 0 && TREE_OVERFLOW (n_high)))
3944         return NULL_TREE;
3945
3946       if (TYPE_OVERFLOW_UNDEFINED (arg0_type))
3947         *strict_overflow_p = true;
3948
3949       normalize:
3950         /* Check for an unsigned range which has wrapped around the maximum
3951            value thus making n_high < n_low, and normalize it.  */
3952         if (n_low && n_high && tree_int_cst_lt (n_high, n_low))
3953           {
3954             low = range_binop (PLUS_EXPR, arg0_type, n_high, 0,
3955                                integer_one_node, 0);
3956             high = range_binop (MINUS_EXPR, arg0_type, n_low, 0,
3957                                 integer_one_node, 0);
3958
3959             /* If the range is of the form +/- [ x+1, x ], we won't
3960                be able to normalize it.  But then, it represents the
3961                whole range or the empty set, so make it
3962                +/- [ -, - ].  */
3963             if (tree_int_cst_equal (n_low, low)
3964                 && tree_int_cst_equal (n_high, high))
3965               low = high = 0;
3966             else
3967               in_p = ! in_p;
3968           }
3969         else
3970           low = n_low, high = n_high;
3971
3972         *p_low = low;
3973         *p_high = high;
3974         *p_in_p = in_p;
3975         return arg0;
3976
3977     CASE_CONVERT:
3978     case NON_LVALUE_EXPR:
3979       if (TYPE_PRECISION (arg0_type) > TYPE_PRECISION (exp_type))
3980         return NULL_TREE;
3981
3982       if (! INTEGRAL_TYPE_P (arg0_type)
3983           || (low != 0 && ! int_fits_type_p (low, arg0_type))
3984           || (high != 0 && ! int_fits_type_p (high, arg0_type)))
3985         return NULL_TREE;
3986
3987       n_low = low, n_high = high;
3988
3989       if (n_low != 0)
3990         n_low = fold_convert_loc (loc, arg0_type, n_low);
3991
3992       if (n_high != 0)
3993         n_high = fold_convert_loc (loc, arg0_type, n_high);
3994
3995       /* If we're converting arg0 from an unsigned type, to exp,
3996          a signed type,  we will be doing the comparison as unsigned.
3997          The tests above have already verified that LOW and HIGH
3998          are both positive.
3999
4000          So we have to ensure that we will handle large unsigned
4001          values the same way that the current signed bounds treat
4002          negative values.  */
4003
4004       if (!TYPE_UNSIGNED (exp_type) && TYPE_UNSIGNED (arg0_type))
4005         {
4006           tree high_positive;
4007           tree equiv_type;
4008           /* For fixed-point modes, we need to pass the saturating flag
4009              as the 2nd parameter.  */
4010           if (ALL_FIXED_POINT_MODE_P (TYPE_MODE (arg0_type)))
4011             equiv_type
4012               = lang_hooks.types.type_for_mode (TYPE_MODE (arg0_type),
4013                                                 TYPE_SATURATING (arg0_type));
4014           else
4015             equiv_type
4016               = lang_hooks.types.type_for_mode (TYPE_MODE (arg0_type), 1);
4017
4018           /* A range without an upper bound is, naturally, unbounded.
4019              Since convert would have cropped a very large value, use
4020              the max value for the destination type.  */
4021           high_positive
4022             = TYPE_MAX_VALUE (equiv_type) ? TYPE_MAX_VALUE (equiv_type)
4023               : TYPE_MAX_VALUE (arg0_type);
4024
4025           if (TYPE_PRECISION (exp_type) == TYPE_PRECISION (arg0_type))
4026             high_positive = fold_build2_loc (loc, RSHIFT_EXPR, arg0_type,
4027                                              fold_convert_loc (loc, arg0_type,
4028                                                                high_positive),
4029                                              build_int_cst (arg0_type, 1));
4030
4031           /* If the low bound is specified, "and" the range with the
4032              range for which the original unsigned value will be
4033              positive.  */
4034           if (low != 0)
4035             {
4036               if (! merge_ranges (&n_in_p, &n_low, &n_high, 1, n_low, n_high,
4037                                   1, fold_convert_loc (loc, arg0_type,
4038                                                        integer_zero_node),
4039                                   high_positive))
4040                 return NULL_TREE;
4041
4042               in_p = (n_in_p == in_p);
4043             }
4044           else
4045             {
4046               /* Otherwise, "or" the range with the range of the input
4047                  that will be interpreted as negative.  */
4048               if (! merge_ranges (&n_in_p, &n_low, &n_high, 0, n_low, n_high,
4049                                   1, fold_convert_loc (loc, arg0_type,
4050                                                        integer_zero_node),
4051                                   high_positive))
4052                 return NULL_TREE;
4053
4054               in_p = (in_p != n_in_p);
4055             }
4056         }
4057
4058       *p_low = n_low;
4059       *p_high = n_high;
4060       *p_in_p = in_p;
4061       return arg0;
4062
4063     default:
4064       return NULL_TREE;
4065     }
4066 }
4067
4068 /* Given EXP, a logical expression, set the range it is testing into
4069    variables denoted by PIN_P, PLOW, and PHIGH.  Return the expression
4070    actually being tested.  *PLOW and *PHIGH will be made of the same
4071    type as the returned expression.  If EXP is not a comparison, we
4072    will most likely not be returning a useful value and range.  Set
4073    *STRICT_OVERFLOW_P to true if the return value is only valid
4074    because signed overflow is undefined; otherwise, do not change
4075    *STRICT_OVERFLOW_P.  */
4076
4077 tree
4078 make_range (tree exp, int *pin_p, tree *plow, tree *phigh,
4079             bool *strict_overflow_p)
4080 {
4081   enum tree_code code;
4082   tree arg0, arg1 = NULL_TREE;
4083   tree exp_type, nexp;
4084   int in_p;
4085   tree low, high;
4086   location_t loc = EXPR_LOCATION (exp);
4087
4088   /* Start with simply saying "EXP != 0" and then look at the code of EXP
4089      and see if we can refine the range.  Some of the cases below may not
4090      happen, but it doesn't seem worth worrying about this.  We "continue"
4091      the outer loop when we've changed something; otherwise we "break"
4092      the switch, which will "break" the while.  */
4093
4094   in_p = 0;
4095   low = high = build_int_cst (TREE_TYPE (exp), 0);
4096
4097   while (1)
4098     {
4099       code = TREE_CODE (exp);
4100       exp_type = TREE_TYPE (exp);
4101       arg0 = NULL_TREE;
4102
4103       if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code)))
4104         {
4105           if (TREE_OPERAND_LENGTH (exp) > 0)
4106             arg0 = TREE_OPERAND (exp, 0);
4107           if (TREE_CODE_CLASS (code) == tcc_binary
4108               || TREE_CODE_CLASS (code) == tcc_comparison
4109               || (TREE_CODE_CLASS (code) == tcc_expression
4110                   && TREE_OPERAND_LENGTH (exp) > 1))
4111             arg1 = TREE_OPERAND (exp, 1);
4112         }
4113       if (arg0 == NULL_TREE)
4114         break;
4115
4116       nexp = make_range_step (loc, code, arg0, arg1, exp_type, &low,
4117                               &high, &in_p, strict_overflow_p);
4118       if (nexp == NULL_TREE)
4119         break;
4120       exp = nexp;
4121     }
4122
4123   /* If EXP is a constant, we can evaluate whether this is true or false.  */
4124   if (TREE_CODE (exp) == INTEGER_CST)
4125     {
4126       in_p = in_p == (integer_onep (range_binop (GE_EXPR, integer_type_node,
4127                                                  exp, 0, low, 0))
4128                       && integer_onep (range_binop (LE_EXPR, integer_type_node,
4129                                                     exp, 1, high, 1)));
4130       low = high = 0;
4131       exp = 0;
4132     }
4133
4134   *pin_p = in_p, *plow = low, *phigh = high;
4135   return exp;
4136 }
4137 \f
4138 /* Given a range, LOW, HIGH, and IN_P, an expression, EXP, and a result
4139    type, TYPE, return an expression to test if EXP is in (or out of, depending
4140    on IN_P) the range.  Return 0 if the test couldn't be created.  */
4141
4142 tree
4143 build_range_check (location_t loc, tree type, tree exp, int in_p,
4144                    tree low, tree high)
4145 {
4146   tree etype = TREE_TYPE (exp), value;
4147
4148 #ifdef HAVE_canonicalize_funcptr_for_compare
4149   /* Disable this optimization for function pointer expressions
4150      on targets that require function pointer canonicalization.  */
4151   if (HAVE_canonicalize_funcptr_for_compare
4152       && TREE_CODE (etype) == POINTER_TYPE
4153       && TREE_CODE (TREE_TYPE (etype)) == FUNCTION_TYPE)
4154     return NULL_TREE;
4155 #endif
4156
4157   if (! in_p)
4158     {
4159       value = build_range_check (loc, type, exp, 1, low, high);
4160       if (value != 0)
4161         return invert_truthvalue_loc (loc, value);
4162
4163       return 0;
4164     }
4165
4166   if (low == 0 && high == 0)
4167     return build_int_cst (type, 1);
4168
4169   if (low == 0)
4170     return fold_build2_loc (loc, LE_EXPR, type, exp,
4171                         fold_convert_loc (loc, etype, high));
4172
4173   if (high == 0)
4174     return fold_build2_loc (loc, GE_EXPR, type, exp,
4175                         fold_convert_loc (loc, etype, low));
4176
4177   if (operand_equal_p (low, high, 0))
4178     return fold_build2_loc (loc, EQ_EXPR, type, exp,
4179                         fold_convert_loc (loc, etype, low));
4180
4181   if (integer_zerop (low))
4182     {
4183       if (! TYPE_UNSIGNED (etype))
4184         {
4185           etype = unsigned_type_for (etype);
4186           high = fold_convert_loc (loc, etype, high);
4187           exp = fold_convert_loc (loc, etype, exp);
4188         }
4189       return build_range_check (loc, type, exp, 1, 0, high);
4190     }
4191
4192   /* Optimize (c>=1) && (c<=127) into (signed char)c > 0.  */
4193   if (integer_onep (low) && TREE_CODE (high) == INTEGER_CST)
4194     {
4195       unsigned HOST_WIDE_INT lo;
4196       HOST_WIDE_INT hi;
4197       int prec;
4198
4199       prec = TYPE_PRECISION (etype);
4200       if (prec <= HOST_BITS_PER_WIDE_INT)
4201         {
4202           hi = 0;
4203           lo = ((unsigned HOST_WIDE_INT) 1 << (prec - 1)) - 1;
4204         }
4205       else
4206         {
4207           hi = ((HOST_WIDE_INT) 1 << (prec - HOST_BITS_PER_WIDE_INT - 1)) - 1;
4208           lo = (unsigned HOST_WIDE_INT) -1;
4209         }
4210
4211       if (TREE_INT_CST_HIGH (high) == hi && TREE_INT_CST_LOW (high) == lo)
4212         {
4213           if (TYPE_UNSIGNED (etype))
4214             {
4215               tree signed_etype = signed_type_for (etype);
4216               if (TYPE_PRECISION (signed_etype) != TYPE_PRECISION (etype))
4217                 etype
4218                   = build_nonstandard_integer_type (TYPE_PRECISION (etype), 0);
4219               else
4220                 etype = signed_etype;
4221               exp = fold_convert_loc (loc, etype, exp);
4222             }
4223           return fold_build2_loc (loc, GT_EXPR, type, exp,
4224                               build_int_cst (etype, 0));
4225         }
4226     }
4227
4228   /* Optimize (c>=low) && (c<=high) into (c-low>=0) && (c-low<=high-low).
4229      This requires wrap-around arithmetics for the type of the expression.
4230      First make sure that arithmetics in this type is valid, then make sure
4231      that it wraps around.  */
4232   if (TREE_CODE (etype) == ENUMERAL_TYPE || TREE_CODE (etype) == BOOLEAN_TYPE)
4233     etype = lang_hooks.types.type_for_size (TYPE_PRECISION (etype),
4234                                             TYPE_UNSIGNED (etype));
4235
4236   if (TREE_CODE (etype) == INTEGER_TYPE && !TYPE_OVERFLOW_WRAPS (etype))
4237     {
4238       tree utype, minv, maxv;
4239
4240       /* Check if (unsigned) INT_MAX + 1 == (unsigned) INT_MIN
4241          for the type in question, as we rely on this here.  */
4242       utype = unsigned_type_for (etype);
4243       maxv = fold_convert_loc (loc, utype, TYPE_MAX_VALUE (etype));
4244       maxv = range_binop (PLUS_EXPR, NULL_TREE, maxv, 1,
4245                           integer_one_node, 1);
4246       minv = fold_convert_loc (loc, utype, TYPE_MIN_VALUE (etype));
4247
4248       if (integer_zerop (range_binop (NE_EXPR, integer_type_node,
4249                                       minv, 1, maxv, 1)))
4250         etype = utype;
4251       else
4252         return 0;
4253     }
4254
4255   high = fold_convert_loc (loc, etype, high);
4256   low = fold_convert_loc (loc, etype, low);
4257   exp = fold_convert_loc (loc, etype, exp);
4258
4259   value = const_binop (MINUS_EXPR, high, low);
4260
4261
4262   if (POINTER_TYPE_P (etype))
4263     {
4264       if (value != 0 && !TREE_OVERFLOW (value))
4265         {
4266           low = fold_build1_loc (loc, NEGATE_EXPR, TREE_TYPE (low), low);
4267           return build_range_check (loc, type,
4268                                     fold_build_pointer_plus_loc (loc, exp, low),
4269                                     1, build_int_cst (etype, 0), value);
4270         }
4271       return 0;
4272     }
4273
4274   if (value != 0 && !TREE_OVERFLOW (value))
4275     return build_range_check (loc, type,
4276                               fold_build2_loc (loc, MINUS_EXPR, etype, exp, low),
4277                               1, build_int_cst (etype, 0), value);
4278
4279   return 0;
4280 }
4281 \f
4282 /* Return the predecessor of VAL in its type, handling the infinite case.  */
4283
4284 static tree
4285 range_predecessor (tree val)
4286 {
4287   tree type = TREE_TYPE (val);
4288
4289   if (INTEGRAL_TYPE_P (type)
4290       && operand_equal_p (val, TYPE_MIN_VALUE (type), 0))
4291     return 0;
4292   else
4293     return range_binop (MINUS_EXPR, NULL_TREE, val, 0, integer_one_node, 0);
4294 }
4295
4296 /* Return the successor of VAL in its type, handling the infinite case.  */
4297
4298 static tree
4299 range_successor (tree val)
4300 {
4301   tree type = TREE_TYPE (val);
4302
4303   if (INTEGRAL_TYPE_P (type)
4304       && operand_equal_p (val, TYPE_MAX_VALUE (type), 0))
4305     return 0;
4306   else
4307     return range_binop (PLUS_EXPR, NULL_TREE, val, 0, integer_one_node, 0);
4308 }
4309
4310 /* Given two ranges, see if we can merge them into one.  Return 1 if we
4311    can, 0 if we can't.  Set the output range into the specified parameters.  */
4312
4313 bool
4314 merge_ranges (int *pin_p, tree *plow, tree *phigh, int in0_p, tree low0,
4315               tree high0, int in1_p, tree low1, tree high1)
4316 {
4317   int no_overlap;
4318   int subset;
4319   int temp;
4320   tree tem;
4321   int in_p;
4322   tree low, high;
4323   int lowequal = ((low0 == 0 && low1 == 0)
4324                   || integer_onep (range_binop (EQ_EXPR, integer_type_node,
4325                                                 low0, 0, low1, 0)));
4326   int highequal = ((high0 == 0 && high1 == 0)
4327                    || integer_onep (range_binop (EQ_EXPR, integer_type_node,
4328                                                  high0, 1, high1, 1)));
4329
4330   /* Make range 0 be the range that starts first, or ends last if they
4331      start at the same value.  Swap them if it isn't.  */
4332   if (integer_onep (range_binop (GT_EXPR, integer_type_node,
4333                                  low0, 0, low1, 0))
4334       || (lowequal
4335           && integer_onep (range_binop (GT_EXPR, integer_type_node,
4336                                         high1, 1, high0, 1))))
4337     {
4338       temp = in0_p, in0_p = in1_p, in1_p = temp;
4339       tem = low0, low0 = low1, low1 = tem;
4340       tem = high0, high0 = high1, high1 = tem;
4341     }
4342
4343   /* Now flag two cases, whether the ranges are disjoint or whether the
4344      second range is totally subsumed in the first.  Note that the tests
4345      below are simplified by the ones above.  */
4346   no_overlap = integer_onep (range_binop (LT_EXPR, integer_type_node,
4347                                           high0, 1, low1, 0));
4348   subset = integer_onep (range_binop (LE_EXPR, integer_type_node,
4349                                       high1, 1, high0, 1));
4350
4351   /* We now have four cases, depending on whether we are including or
4352      excluding the two ranges.  */
4353   if (in0_p && in1_p)
4354     {
4355       /* If they don't overlap, the result is false.  If the second range
4356          is a subset it is the result.  Otherwise, the range is from the start
4357          of the second to the end of the first.  */
4358       if (no_overlap)
4359         in_p = 0, low = high = 0;
4360       else if (subset)
4361         in_p = 1, low = low1, high = high1;
4362       else
4363         in_p = 1, low = low1, high = high0;
4364     }
4365
4366   else if (in0_p && ! in1_p)
4367     {
4368       /* If they don't overlap, the result is the first range.  If they are
4369          equal, the result is false.  If the second range is a subset of the
4370          first, and the ranges begin at the same place, we go from just after
4371          the end of the second range to the end of the first.  If the second
4372          range is not a subset of the first, or if it is a subset and both
4373          ranges end at the same place, the range starts at the start of the
4374          first range and ends just before the second range.
4375          Otherwise, we can't describe this as a single range.  */
4376       if (no_overlap)
4377         in_p = 1, low = low0, high = high0;
4378       else if (lowequal && highequal)
4379         in_p = 0, low = high = 0;
4380       else if (subset && lowequal)
4381         {
4382           low = range_successor (high1);
4383           high = high0;
4384           in_p = 1;
4385           if (low == 0)
4386             {
4387               /* We are in the weird situation where high0 > high1 but
4388                  high1 has no successor.  Punt.  */
4389               return 0;
4390             }
4391         }
4392       else if (! subset || highequal)
4393         {
4394           low = low0;
4395           high = range_predecessor (low1);
4396           in_p = 1;
4397           if (high == 0)
4398             {
4399               /* low0 < low1 but low1 has no predecessor.  Punt.  */
4400               return 0;
4401             }
4402         }
4403       else
4404         return 0;
4405     }
4406
4407   else if (! in0_p && in1_p)
4408     {
4409       /* If they don't overlap, the result is the second range.  If the second
4410          is a subset of the first, the result is false.  Otherwise,
4411          the range starts just after the first range and ends at the
4412          end of the second.  */
4413       if (no_overlap)
4414         in_p = 1, low = low1, high = high1;
4415       else if (subset || highequal)
4416         in_p = 0, low = high = 0;
4417       else
4418         {
4419           low = range_successor (high0);
4420           high = high1;
4421           in_p = 1;
4422           if (low == 0)
4423             {
4424               /* high1 > high0 but high0 has no successor.  Punt.  */
4425               return 0;
4426             }
4427         }
4428     }
4429
4430   else
4431     {
4432       /* The case where we are excluding both ranges.  Here the complex case
4433          is if they don't overlap.  In that case, the only time we have a
4434          range is if they are adjacent.  If the second is a subset of the
4435          first, the result is the first.  Otherwise, the range to exclude
4436          starts at the beginning of the first range and ends at the end of the
4437          second.  */
4438       if (no_overlap)
4439         {
4440           if (integer_onep (range_binop (EQ_EXPR, integer_type_node,
4441                                          range_successor (high0),
4442                                          1, low1, 0)))
4443             in_p = 0, low = low0, high = high1;
4444           else
4445             {
4446               /* Canonicalize - [min, x] into - [-, x].  */
4447               if (low0 && TREE_CODE (low0) == INTEGER_CST)
4448                 switch (TREE_CODE (TREE_TYPE (low0)))
4449                   {
4450                   case ENUMERAL_TYPE:
4451                     if (TYPE_PRECISION (TREE_TYPE (low0))
4452                         != GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (low0))))
4453                       break;
4454                     /* FALLTHROUGH */
4455                   case INTEGER_TYPE:
4456                     if (tree_int_cst_equal (low0,
4457                                             TYPE_MIN_VALUE (TREE_TYPE (low0))))
4458                       low0 = 0;
4459                     break;
4460                   case POINTER_TYPE:
4461                     if (TYPE_UNSIGNED (TREE_TYPE (low0))
4462                         && integer_zerop (low0))
4463                       low0 = 0;
4464                     break;
4465                   default:
4466                     break;
4467                   }
4468
4469               /* Canonicalize - [x, max] into - [x, -].  */
4470               if (high1 && TREE_CODE (high1) == INTEGER_CST)
4471                 switch (TREE_CODE (TREE_TYPE (high1)))
4472                   {
4473                   case ENUMERAL_TYPE:
4474                     if (TYPE_PRECISION (TREE_TYPE (high1))
4475                         != GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (high1))))
4476                       break;
4477                     /* FALLTHROUGH */
4478                   case INTEGER_TYPE:
4479                     if (tree_int_cst_equal (high1,
4480                                             TYPE_MAX_VALUE (TREE_TYPE (high1))))
4481                       high1 = 0;
4482                     break;
4483                   case POINTER_TYPE:
4484                     if (TYPE_UNSIGNED (TREE_TYPE (high1))
4485                         && integer_zerop (range_binop (PLUS_EXPR, NULL_TREE,
4486                                                        high1, 1,
4487                                                        integer_one_node, 1)))
4488                       high1 = 0;
4489                     break;
4490                   default:
4491                     break;
4492                   }
4493
4494               /* The ranges might be also adjacent between the maximum and
4495                  minimum values of the given type.  For
4496                  - [{min,-}, x] and - [y, {max,-}] ranges where x + 1 < y
4497                  return + [x + 1, y - 1].  */
4498               if (low0 == 0 && high1 == 0)
4499                 {
4500                   low = range_successor (high0);
4501                   high = range_predecessor (low1);
4502                   if (low == 0 || high == 0)
4503                     return 0;
4504
4505                   in_p = 1;
4506                 }
4507               else
4508                 return 0;
4509             }
4510         }
4511       else if (subset)
4512         in_p = 0, low = low0, high = high0;
4513       else
4514         in_p = 0, low = low0, high = high1;
4515     }
4516
4517   *pin_p = in_p, *plow = low, *phigh = high;
4518   return 1;
4519 }
4520 \f
4521
4522 /* Subroutine of fold, looking inside expressions of the form
4523    A op B ? A : C, where ARG0, ARG1 and ARG2 are the three operands
4524    of the COND_EXPR.  This function is being used also to optimize
4525    A op B ? C : A, by reversing the comparison first.
4526
4527    Return a folded expression whose code is not a COND_EXPR
4528    anymore, or NULL_TREE if no folding opportunity is found.  */
4529
4530 static tree
4531 fold_cond_expr_with_comparison (location_t loc, tree type,
4532                                 tree arg0, tree arg1, tree arg2)
4533 {
4534   enum tree_code comp_code = TREE_CODE (arg0);
4535   tree arg00 = TREE_OPERAND (arg0, 0);
4536   tree arg01 = TREE_OPERAND (arg0, 1);
4537   tree arg1_type = TREE_TYPE (arg1);
4538   tree tem;
4539
4540   STRIP_NOPS (arg1);
4541   STRIP_NOPS (arg2);
4542
4543   /* If we have A op 0 ? A : -A, consider applying the following
4544      transformations:
4545
4546      A == 0? A : -A    same as -A
4547      A != 0? A : -A    same as A
4548      A >= 0? A : -A    same as abs (A)
4549      A > 0?  A : -A    same as abs (A)
4550      A <= 0? A : -A    same as -abs (A)
4551      A < 0?  A : -A    same as -abs (A)
4552
4553      None of these transformations work for modes with signed
4554      zeros.  If A is +/-0, the first two transformations will
4555      change the sign of the result (from +0 to -0, or vice
4556      versa).  The last four will fix the sign of the result,
4557      even though the original expressions could be positive or
4558      negative, depending on the sign of A.
4559
4560      Note that all these transformations are correct if A is
4561      NaN, since the two alternatives (A and -A) are also NaNs.  */
4562   if (!HONOR_SIGNED_ZEROS (TYPE_MODE (type))
4563       && (FLOAT_TYPE_P (TREE_TYPE (arg01))
4564           ? real_zerop (arg01)
4565           : integer_zerop (arg01))
4566       && ((TREE_CODE (arg2) == NEGATE_EXPR
4567            && operand_equal_p (TREE_OPERAND (arg2, 0), arg1, 0))
4568              /* In the case that A is of the form X-Y, '-A' (arg2) may
4569                 have already been folded to Y-X, check for that. */
4570           || (TREE_CODE (arg1) == MINUS_EXPR
4571               && TREE_CODE (arg2) == MINUS_EXPR
4572               && operand_equal_p (TREE_OPERAND (arg1, 0),
4573                                   TREE_OPERAND (arg2, 1), 0)
4574               && operand_equal_p (TREE_OPERAND (arg1, 1),
4575                                   TREE_OPERAND (arg2, 0), 0))))
4576     switch (comp_code)
4577       {
4578       case EQ_EXPR:
4579       case UNEQ_EXPR:
4580         tem = fold_convert_loc (loc, arg1_type, arg1);
4581         return pedantic_non_lvalue_loc (loc,
4582                                     fold_convert_loc (loc, type,
4583                                                   negate_expr (tem)));
4584       case NE_EXPR:
4585       case LTGT_EXPR:
4586         return pedantic_non_lvalue_loc (loc, fold_convert_loc (loc, type, arg1));
4587       case UNGE_EXPR:
4588       case UNGT_EXPR:
4589         if (flag_trapping_math)
4590           break;
4591         /* Fall through.  */
4592       case GE_EXPR:
4593       case GT_EXPR:
4594         if (TYPE_UNSIGNED (TREE_TYPE (arg1)))
4595           arg1 = fold_convert_loc (loc, signed_type_for
4596                                (TREE_TYPE (arg1)), arg1);
4597         tem = fold_build1_loc (loc, ABS_EXPR, TREE_TYPE (arg1), arg1);
4598         return pedantic_non_lvalue_loc (loc, fold_convert_loc (loc, type, tem));
4599       case UNLE_EXPR:
4600       case UNLT_EXPR:
4601         if (flag_trapping_math)
4602           break;
4603       case LE_EXPR:
4604       case LT_EXPR:
4605         if (TYPE_UNSIGNED (TREE_TYPE (arg1)))
4606           arg1 = fold_convert_loc (loc, signed_type_for
4607                                (TREE_TYPE (arg1)), arg1);
4608         tem = fold_build1_loc (loc, ABS_EXPR, TREE_TYPE (arg1), arg1);
4609         return negate_expr (fold_convert_loc (loc, type, tem));
4610       default:
4611         gcc_assert (TREE_CODE_CLASS (comp_code) == tcc_comparison);
4612         break;
4613       }
4614
4615   /* A != 0 ? A : 0 is simply A, unless A is -0.  Likewise
4616      A == 0 ? A : 0 is always 0 unless A is -0.  Note that
4617      both transformations are correct when A is NaN: A != 0
4618      is then true, and A == 0 is false.  */
4619
4620   if (!HONOR_SIGNED_ZEROS (TYPE_MODE (type))
4621       && integer_zerop (arg01) && integer_zerop (arg2))
4622     {
4623       if (comp_code == NE_EXPR)
4624         return pedantic_non_lvalue_loc (loc, fold_convert_loc (loc, type, arg1));
4625       else if (comp_code == EQ_EXPR)
4626         return build_int_cst (type, 0);
4627     }
4628
4629   /* Try some transformations of A op B ? A : B.
4630
4631      A == B? A : B    same as B
4632      A != B? A : B    same as A
4633      A >= B? A : B    same as max (A, B)
4634      A > B?  A : B    same as max (B, A)
4635      A <= B? A : B    same as min (A, B)
4636      A < B?  A : B    same as min (B, A)
4637
4638      As above, these transformations don't work in the presence
4639      of signed zeros.  For example, if A and B are zeros of
4640      opposite sign, the first two transformations will change
4641      the sign of the result.  In the last four, the original
4642      expressions give different results for (A=+0, B=-0) and
4643      (A=-0, B=+0), but the transformed expressions do not.
4644
4645      The first two transformations are correct if either A or B
4646      is a NaN.  In the first transformation, the condition will
4647      be false, and B will indeed be chosen.  In the case of the
4648      second transformation, the condition A != B will be true,
4649      and A will be chosen.
4650
4651      The conversions to max() and min() are not correct if B is
4652      a number and A is not.  The conditions in the original
4653      expressions will be false, so all four give B.  The min()
4654      and max() versions would give a NaN instead.  */
4655   if (!HONOR_SIGNED_ZEROS (TYPE_MODE (type))
4656       && operand_equal_for_comparison_p (arg01, arg2, arg00)
4657       /* Avoid these transformations if the COND_EXPR may be used
4658          as an lvalue in the C++ front-end.  PR c++/19199.  */
4659       && (in_gimple_form
4660           || (strcmp (lang_hooks.name, "GNU C++") != 0
4661               && strcmp (lang_hooks.name, "GNU Objective-C++") != 0)
4662           || ! maybe_lvalue_p (arg1)
4663           || ! maybe_lvalue_p (arg2)))
4664     {
4665       tree comp_op0 = arg00;
4666       tree comp_op1 = arg01;
4667       tree comp_type = TREE_TYPE (comp_op0);
4668
4669       /* Avoid adding NOP_EXPRs in case this is an lvalue.  */
4670       if (TYPE_MAIN_VARIANT (comp_type) == TYPE_MAIN_VARIANT (type))
4671         {
4672           comp_type = type;
4673           comp_op0 = arg1;
4674           comp_op1 = arg2;
4675         }
4676
4677       switch (comp_code)
4678         {
4679         case EQ_EXPR:
4680           return pedantic_non_lvalue_loc (loc, fold_convert_loc (loc, type, arg2));
4681         case NE_EXPR:
4682           return pedantic_non_lvalue_loc (loc, fold_convert_loc (loc, type, arg1));
4683         case LE_EXPR:
4684         case LT_EXPR:
4685         case UNLE_EXPR:
4686         case UNLT_EXPR:
4687           /* In C++ a ?: expression can be an lvalue, so put the
4688              operand which will be used if they are equal first
4689              so that we can convert this back to the
4690              corresponding COND_EXPR.  */
4691           if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1))))
4692             {
4693               comp_op0 = fold_convert_loc (loc, comp_type, comp_op0);
4694               comp_op1 = fold_convert_loc (loc, comp_type, comp_op1);
4695               tem = (comp_code == LE_EXPR || comp_code == UNLE_EXPR)
4696                     ? fold_build2_loc (loc, MIN_EXPR, comp_type, comp_op0, comp_op1)
4697                     : fold_build2_loc (loc, MIN_EXPR, comp_type,
4698                                    comp_op1, comp_op0);
4699               return pedantic_non_lvalue_loc (loc,
4700                                           fold_convert_loc (loc, type, tem));
4701             }
4702           break;
4703         case GE_EXPR:
4704         case GT_EXPR:
4705         case UNGE_EXPR:
4706         case UNGT_EXPR:
4707           if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1))))
4708             {
4709               comp_op0 = fold_convert_loc (loc, comp_type, comp_op0);
4710               comp_op1 = fold_convert_loc (loc, comp_type, comp_op1);
4711               tem = (comp_code == GE_EXPR || comp_code == UNGE_EXPR)
4712                     ? fold_build2_loc (loc, MAX_EXPR, comp_type, comp_op0, comp_op1)
4713                     : fold_build2_loc (loc, MAX_EXPR, comp_type,
4714                                    comp_op1, comp_op0);
4715               return pedantic_non_lvalue_loc (loc,
4716                                           fold_convert_loc (loc, type, tem));
4717             }
4718           break;
4719         case UNEQ_EXPR:
4720           if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1))))
4721             return pedantic_non_lvalue_loc (loc,
4722                                         fold_convert_loc (loc, type, arg2));
4723           break;
4724         case LTGT_EXPR:
4725           if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1))))
4726             return pedantic_non_lvalue_loc (loc,
4727                                         fold_convert_loc (loc, type, arg1));
4728           break;
4729         default:
4730           gcc_assert (TREE_CODE_CLASS (comp_code) == tcc_comparison);
4731           break;
4732         }
4733     }
4734
4735   /* If this is A op C1 ? A : C2 with C1 and C2 constant integers,
4736      we might still be able to simplify this.  For example,
4737      if C1 is one less or one more than C2, this might have started
4738      out as a MIN or MAX and been transformed by this function.
4739      Only good for INTEGER_TYPEs, because we need TYPE_MAX_VALUE.  */
4740
4741   if (INTEGRAL_TYPE_P (type)
4742       && TREE_CODE (arg01) == INTEGER_CST
4743       && TREE_CODE (arg2) == INTEGER_CST)
4744     switch (comp_code)
4745       {
4746       case EQ_EXPR:
4747         if (TREE_CODE (arg1) == INTEGER_CST)
4748           break;
4749         /* We can replace A with C1 in this case.  */
4750         arg1 = fold_convert_loc (loc, type, arg01);
4751         return fold_build3_loc (loc, COND_EXPR, type, arg0, arg1, arg2);
4752
4753       case LT_EXPR:
4754         /* If C1 is C2 + 1, this is min(A, C2), but use ARG00's type for
4755            MIN_EXPR, to preserve the signedness of the comparison.  */
4756         if (! operand_equal_p (arg2, TYPE_MAX_VALUE (type),
4757                                OEP_ONLY_CONST)
4758             && operand_equal_p (arg01,
4759                                 const_binop (PLUS_EXPR, arg2,
4760                                              build_int_cst (type, 1)),
4761                                 OEP_ONLY_CONST))
4762           {
4763             tem = fold_build2_loc (loc, MIN_EXPR, TREE_TYPE (arg00), arg00,
4764                                    fold_convert_loc (loc, TREE_TYPE (arg00),
4765                                                      arg2));
4766             return pedantic_non_lvalue_loc (loc,
4767                                             fold_convert_loc (loc, type, tem));
4768           }
4769         break;
4770
4771       case LE_EXPR:
4772         /* If C1 is C2 - 1, this is min(A, C2), with the same care
4773            as above.  */
4774         if (! operand_equal_p (arg2, TYPE_MIN_VALUE (type),
4775                                OEP_ONLY_CONST)
4776             && operand_equal_p (arg01,
4777                                 const_binop (MINUS_EXPR, arg2,
4778                                              build_int_cst (type, 1)),
4779                                 OEP_ONLY_CONST))
4780           {
4781             tem = fold_build2_loc (loc, MIN_EXPR, TREE_TYPE (arg00), arg00,
4782                                    fold_convert_loc (loc, TREE_TYPE (arg00),
4783                                                      arg2));
4784             return pedantic_non_lvalue_loc (loc,
4785                                             fold_convert_loc (loc, type, tem));
4786           }
4787         break;
4788
4789       case GT_EXPR:
4790         /* If C1 is C2 - 1, this is max(A, C2), but use ARG00's type for
4791            MAX_EXPR, to preserve the signedness of the comparison.  */
4792         if (! operand_equal_p (arg2, TYPE_MIN_VALUE (type),
4793                                OEP_ONLY_CONST)
4794             && operand_equal_p (arg01,
4795                                 const_binop (MINUS_EXPR, arg2,
4796                                              build_int_cst (type, 1)),
4797                                 OEP_ONLY_CONST))
4798           {
4799             tem = fold_build2_loc (loc, MAX_EXPR, TREE_TYPE (arg00), arg00,
4800                                    fold_convert_loc (loc, TREE_TYPE (arg00),
4801                                                      arg2));
4802             return pedantic_non_lvalue_loc (loc, fold_convert_loc (loc, type, tem));
4803           }
4804         break;
4805
4806       case GE_EXPR:
4807         /* If C1 is C2 + 1, this is max(A, C2), with the same care as above.  */
4808         if (! operand_equal_p (arg2, TYPE_MAX_VALUE (type),
4809                                OEP_ONLY_CONST)
4810             && operand_equal_p (arg01,
4811                                 const_binop (PLUS_EXPR, arg2,
4812                                              build_int_cst (type, 1)),
4813                                 OEP_ONLY_CONST))
4814           {
4815             tem = fold_build2_loc (loc, MAX_EXPR, TREE_TYPE (arg00), arg00,
4816                                    fold_convert_loc (loc, TREE_TYPE (arg00),
4817                                                      arg2));
4818             return pedantic_non_lvalue_loc (loc, fold_convert_loc (loc, type, tem));
4819           }
4820         break;
4821       case NE_EXPR:
4822         break;
4823       default:
4824         gcc_unreachable ();
4825       }
4826
4827   return NULL_TREE;
4828 }
4829
4830
4831 \f
4832 #ifndef LOGICAL_OP_NON_SHORT_CIRCUIT
4833 #define LOGICAL_OP_NON_SHORT_CIRCUIT \
4834   (BRANCH_COST (optimize_function_for_speed_p (cfun), \
4835                 false) >= 2)
4836 #endif
4837
4838 /* EXP is some logical combination of boolean tests.  See if we can
4839    merge it into some range test.  Return the new tree if so.  */
4840
4841 static tree
4842 fold_range_test (location_t loc, enum tree_code code, tree type,
4843                  tree op0, tree op1)
4844 {
4845   int or_op = (code == TRUTH_ORIF_EXPR
4846                || code == TRUTH_OR_EXPR);
4847   int in0_p, in1_p, in_p;
4848   tree low0, low1, low, high0, high1, high;
4849   bool strict_overflow_p = false;
4850   tree lhs = make_range (op0, &in0_p, &low0, &high0, &strict_overflow_p);
4851   tree rhs = make_range (op1, &in1_p, &low1, &high1, &strict_overflow_p);
4852   tree tem;
4853   const char * const warnmsg = G_("assuming signed overflow does not occur "
4854                                   "when simplifying range test");
4855
4856   /* If this is an OR operation, invert both sides; we will invert
4857      again at the end.  */
4858   if (or_op)
4859     in0_p = ! in0_p, in1_p = ! in1_p;
4860
4861   /* If both expressions are the same, if we can merge the ranges, and we
4862      can build the range test, return it or it inverted.  If one of the
4863      ranges is always true or always false, consider it to be the same
4864      expression as the other.  */
4865   if ((lhs == 0 || rhs == 0 || operand_equal_p (lhs, rhs, 0))
4866       && merge_ranges (&in_p, &low, &high, in0_p, low0, high0,
4867                        in1_p, low1, high1)
4868       && 0 != (tem = (build_range_check (loc, type,
4869                                          lhs != 0 ? lhs
4870                                          : rhs != 0 ? rhs : integer_zero_node,
4871                                          in_p, low, high))))
4872     {
4873       if (strict_overflow_p)
4874         fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_COMPARISON);
4875       return or_op ? invert_truthvalue_loc (loc, tem) : tem;
4876     }
4877
4878   /* On machines where the branch cost is expensive, if this is a
4879      short-circuited branch and the underlying object on both sides
4880      is the same, make a non-short-circuit operation.  */
4881   else if (LOGICAL_OP_NON_SHORT_CIRCUIT
4882            && lhs != 0 && rhs != 0
4883            && (code == TRUTH_ANDIF_EXPR
4884                || code == TRUTH_ORIF_EXPR)
4885            && operand_equal_p (lhs, rhs, 0))
4886     {
4887       /* If simple enough, just rewrite.  Otherwise, make a SAVE_EXPR
4888          unless we are at top level or LHS contains a PLACEHOLDER_EXPR, in
4889          which cases we can't do this.  */
4890       if (simple_operand_p (lhs))
4891         return build2_loc (loc, code == TRUTH_ANDIF_EXPR
4892                            ? TRUTH_AND_EXPR : TRUTH_OR_EXPR,
4893                            type, op0, op1);
4894
4895       else if (!lang_hooks.decls.global_bindings_p ()
4896                && !CONTAINS_PLACEHOLDER_P (lhs))
4897         {
4898           tree common = save_expr (lhs);
4899
4900           if (0 != (lhs = build_range_check (loc, type, common,
4901                                              or_op ? ! in0_p : in0_p,
4902                                              low0, high0))
4903               && (0 != (rhs = build_range_check (loc, type, common,
4904                                                  or_op ? ! in1_p : in1_p,
4905                                                  low1, high1))))
4906             {
4907               if (strict_overflow_p)
4908                 fold_overflow_warning (warnmsg,
4909                                        WARN_STRICT_OVERFLOW_COMPARISON);
4910               return build2_loc (loc, code == TRUTH_ANDIF_EXPR
4911                                  ? TRUTH_AND_EXPR : TRUTH_OR_EXPR,
4912                                  type, lhs, rhs);
4913             }
4914         }
4915     }
4916
4917   return 0;
4918 }
4919 \f
4920 /* Subroutine for fold_truth_andor_1: C is an INTEGER_CST interpreted as a P
4921    bit value.  Arrange things so the extra bits will be set to zero if and
4922    only if C is signed-extended to its full width.  If MASK is nonzero,
4923    it is an INTEGER_CST that should be AND'ed with the extra bits.  */
4924
4925 static tree
4926 unextend (tree c, int p, int unsignedp, tree mask)
4927 {
4928   tree type = TREE_TYPE (c);
4929   int modesize = GET_MODE_BITSIZE (TYPE_MODE (type));
4930   tree temp;
4931
4932   if (p == modesize || unsignedp)
4933     return c;
4934
4935   /* We work by getting just the sign bit into the low-order bit, then
4936      into the high-order bit, then sign-extend.  We then XOR that value
4937      with C.  */
4938   temp = const_binop (RSHIFT_EXPR, c, size_int (p - 1));
4939   temp = const_binop (BIT_AND_EXPR, temp, size_int (1));
4940
4941   /* We must use a signed type in order to get an arithmetic right shift.
4942      However, we must also avoid introducing accidental overflows, so that
4943      a subsequent call to integer_zerop will work.  Hence we must
4944      do the type conversion here.  At this point, the constant is either
4945      zero or one, and the conversion to a signed type can never overflow.
4946      We could get an overflow if this conversion is done anywhere else.  */
4947   if (TYPE_UNSIGNED (type))
4948     temp = fold_convert (signed_type_for (type), temp);
4949
4950   temp = const_binop (LSHIFT_EXPR, temp, size_int (modesize - 1));
4951   temp = const_binop (RSHIFT_EXPR, temp, size_int (modesize - p - 1));
4952   if (mask != 0)
4953     temp = const_binop (BIT_AND_EXPR, temp,
4954                         fold_convert (TREE_TYPE (c), mask));
4955   /* If necessary, convert the type back to match the type of C.  */
4956   if (TYPE_UNSIGNED (type))
4957     temp = fold_convert (type, temp);
4958
4959   return fold_convert (type, const_binop (BIT_XOR_EXPR, c, temp));
4960 }
4961 \f
4962 /* For an expression that has the form
4963      (A && B) || ~B
4964    or
4965      (A || B) && ~B,
4966    we can drop one of the inner expressions and simplify to
4967      A || ~B
4968    or
4969      A && ~B
4970    LOC is the location of the resulting expression.  OP is the inner
4971    logical operation; the left-hand side in the examples above, while CMPOP
4972    is the right-hand side.  RHS_ONLY is used to prevent us from accidentally
4973    removing a condition that guards another, as in
4974      (A != NULL && A->...) || A == NULL
4975    which we must not transform.  If RHS_ONLY is true, only eliminate the
4976    right-most operand of the inner logical operation.  */
4977
4978 static tree
4979 merge_truthop_with_opposite_arm (location_t loc, tree op, tree cmpop,
4980                                  bool rhs_only)
4981 {
4982   tree type = TREE_TYPE (cmpop);
4983   enum tree_code code = TREE_CODE (cmpop);
4984   enum tree_code truthop_code = TREE_CODE (op);
4985   tree lhs = TREE_OPERAND (op, 0);
4986   tree rhs = TREE_OPERAND (op, 1);
4987   tree orig_lhs = lhs, orig_rhs = rhs;
4988   enum tree_code rhs_code = TREE_CODE (rhs);
4989   enum tree_code lhs_code = TREE_CODE (lhs);
4990   enum tree_code inv_code;
4991
4992   if (TREE_SIDE_EFFECTS (op) || TREE_SIDE_EFFECTS (cmpop))
4993     return NULL_TREE;
4994
4995   if (TREE_CODE_CLASS (code) != tcc_comparison)
4996     return NULL_TREE;
4997
4998   if (rhs_code == truthop_code)
4999     {
5000       tree newrhs = merge_truthop_with_opposite_arm (loc, rhs, cmpop, rhs_only);
5001       if (newrhs != NULL_TREE)
5002         {
5003           rhs = newrhs;
5004           rhs_code = TREE_CODE (rhs);
5005         }
5006     }
5007   if (lhs_code == truthop_code && !rhs_only)
5008     {
5009       tree newlhs = merge_truthop_with_opposite_arm (loc, lhs, cmpop, false);
5010       if (newlhs != NULL_TREE)
5011         {
5012           lhs = newlhs;
5013           lhs_code = TREE_CODE (lhs);
5014         }
5015     }
5016
5017   inv_code = invert_tree_comparison (code, HONOR_NANS (TYPE_MODE (type)));
5018   if (inv_code == rhs_code
5019       && operand_equal_p (TREE_OPERAND (rhs, 0), TREE_OPERAND (cmpop, 0), 0)
5020       && operand_equal_p (TREE_OPERAND (rhs, 1), TREE_OPERAND (cmpop, 1), 0))
5021     return lhs;
5022   if (!rhs_only && inv_code == lhs_code
5023       && operand_equal_p (TREE_OPERAND (lhs, 0), TREE_OPERAND (cmpop, 0), 0)
5024       && operand_equal_p (TREE_OPERAND (lhs, 1), TREE_OPERAND (cmpop, 1), 0))
5025     return rhs;
5026   if (rhs != orig_rhs || lhs != orig_lhs)
5027     return fold_build2_loc (loc, truthop_code, TREE_TYPE (cmpop),
5028                             lhs, rhs);
5029   return NULL_TREE;
5030 }
5031
5032 /* Find ways of folding logical expressions of LHS and RHS:
5033    Try to merge two comparisons to the same innermost item.
5034    Look for range tests like "ch >= '0' && ch <= '9'".
5035    Look for combinations of simple terms on machines with expensive branches
5036    and evaluate the RHS unconditionally.
5037
5038    For example, if we have p->a == 2 && p->b == 4 and we can make an
5039    object large enough to span both A and B, we can do this with a comparison
5040    against the object ANDed with the a mask.
5041
5042    If we have p->a == q->a && p->b == q->b, we may be able to use bit masking
5043    operations to do this with one comparison.
5044
5045    We check for both normal comparisons and the BIT_AND_EXPRs made this by
5046    function and the one above.
5047
5048    CODE is the logical operation being done.  It can be TRUTH_ANDIF_EXPR,
5049    TRUTH_AND_EXPR, TRUTH_ORIF_EXPR, or TRUTH_OR_EXPR.
5050
5051    TRUTH_TYPE is the type of the logical operand and LHS and RHS are its
5052    two operands.
5053
5054    We return the simplified tree or 0 if no optimization is possible.  */
5055
5056 static tree
5057 fold_truth_andor_1 (location_t loc, enum tree_code code, tree truth_type,
5058                     tree lhs, tree rhs)
5059 {
5060   /* If this is the "or" of two comparisons, we can do something if
5061      the comparisons are NE_EXPR.  If this is the "and", we can do something
5062      if the comparisons are EQ_EXPR.  I.e.,
5063         (a->b == 2 && a->c == 4) can become (a->new == NEW).
5064
5065      WANTED_CODE is this operation code.  For single bit fields, we can
5066      convert EQ_EXPR to NE_EXPR so we need not reject the "wrong"
5067      comparison for one-bit fields.  */
5068
5069   enum tree_code wanted_code;
5070   enum tree_code lcode, rcode;
5071   tree ll_arg, lr_arg, rl_arg, rr_arg;
5072   tree ll_inner, lr_inner, rl_inner, rr_inner;
5073   HOST_WIDE_INT ll_bitsize, ll_bitpos, lr_bitsize, lr_bitpos;
5074   HOST_WIDE_INT rl_bitsize, rl_bitpos, rr_bitsize, rr_bitpos;
5075   HOST_WIDE_INT xll_bitpos, xlr_bitpos, xrl_bitpos, xrr_bitpos;
5076   HOST_WIDE_INT lnbitsize, lnbitpos, rnbitsize, rnbitpos;
5077   int ll_unsignedp, lr_unsignedp, rl_unsignedp, rr_unsignedp;
5078   enum machine_mode ll_mode, lr_mode, rl_mode, rr_mode;
5079   enum machine_mode lnmode, rnmode;
5080   tree ll_mask, lr_mask, rl_mask, rr_mask;
5081   tree ll_and_mask, lr_and_mask, rl_and_mask, rr_and_mask;
5082   tree l_const, r_const;
5083   tree lntype, rntype, result;
5084   HOST_WIDE_INT first_bit, end_bit;
5085   int volatilep;
5086
5087   /* Start by getting the comparison codes.  Fail if anything is volatile.
5088      If one operand is a BIT_AND_EXPR with the constant one, treat it as if
5089      it were surrounded with a NE_EXPR.  */
5090
5091   if (TREE_SIDE_EFFECTS (lhs) || TREE_SIDE_EFFECTS (rhs))
5092     return 0;
5093
5094   lcode = TREE_CODE (lhs);
5095   rcode = TREE_CODE (rhs);
5096
5097   if (lcode == BIT_AND_EXPR && integer_onep (TREE_OPERAND (lhs, 1)))
5098     {
5099       lhs = build2 (NE_EXPR, truth_type, lhs,
5100                     build_int_cst (TREE_TYPE (lhs), 0));
5101       lcode = NE_EXPR;
5102     }
5103
5104   if (rcode == BIT_AND_EXPR && integer_onep (TREE_OPERAND (rhs, 1)))
5105     {
5106       rhs = build2 (NE_EXPR, truth_type, rhs,
5107                     build_int_cst (TREE_TYPE (rhs), 0));
5108       rcode = NE_EXPR;
5109     }
5110
5111   if (TREE_CODE_CLASS (lcode) != tcc_comparison
5112       || TREE_CODE_CLASS (rcode) != tcc_comparison)
5113     return 0;
5114
5115   ll_arg = TREE_OPERAND (lhs, 0);
5116   lr_arg = TREE_OPERAND (lhs, 1);
5117   rl_arg = TREE_OPERAND (rhs, 0);
5118   rr_arg = TREE_OPERAND (rhs, 1);
5119
5120   /* Simplify (x<y) && (x==y) into (x<=y) and related optimizations.  */
5121   if (simple_operand_p (ll_arg)
5122       && simple_operand_p (lr_arg))
5123     {
5124       if (operand_equal_p (ll_arg, rl_arg, 0)
5125           && operand_equal_p (lr_arg, rr_arg, 0))
5126         {
5127           result = combine_comparisons (loc, code, lcode, rcode,
5128                                         truth_type, ll_arg, lr_arg);
5129           if (result)
5130             return result;
5131         }
5132       else if (operand_equal_p (ll_arg, rr_arg, 0)
5133                && operand_equal_p (lr_arg, rl_arg, 0))
5134         {
5135           result = combine_comparisons (loc, code, lcode,
5136                                         swap_tree_comparison (rcode),
5137                                         truth_type, ll_arg, lr_arg);
5138           if (result)
5139             return result;
5140         }
5141     }
5142
5143   code = ((code == TRUTH_AND_EXPR || code == TRUTH_ANDIF_EXPR)
5144           ? TRUTH_AND_EXPR : TRUTH_OR_EXPR);
5145
5146   /* If the RHS can be evaluated unconditionally and its operands are
5147      simple, it wins to evaluate the RHS unconditionally on machines
5148      with expensive branches.  In this case, this isn't a comparison
5149      that can be merged.  */
5150
5151   if (BRANCH_COST (optimize_function_for_speed_p (cfun),
5152                    false) >= 2
5153       && ! FLOAT_TYPE_P (TREE_TYPE (rl_arg))
5154       && simple_operand_p (rl_arg)
5155       && simple_operand_p (rr_arg))
5156     {
5157       /* Convert (a != 0) || (b != 0) into (a | b) != 0.  */
5158       if (code == TRUTH_OR_EXPR
5159           && lcode == NE_EXPR && integer_zerop (lr_arg)
5160           && rcode == NE_EXPR && integer_zerop (rr_arg)
5161           && TREE_TYPE (ll_arg) == TREE_TYPE (rl_arg)
5162           && INTEGRAL_TYPE_P (TREE_TYPE (ll_arg)))
5163         return build2_loc (loc, NE_EXPR, truth_type,
5164                            build2 (BIT_IOR_EXPR, TREE_TYPE (ll_arg),
5165                                    ll_arg, rl_arg),
5166                            build_int_cst (TREE_TYPE (ll_arg), 0));
5167
5168       /* Convert (a == 0) && (b == 0) into (a | b) == 0.  */
5169       if (code == TRUTH_AND_EXPR
5170           && lcode == EQ_EXPR && integer_zerop (lr_arg)
5171           && rcode == EQ_EXPR && integer_zerop (rr_arg)
5172           && TREE_TYPE (ll_arg) == TREE_TYPE (rl_arg)
5173           && INTEGRAL_TYPE_P (TREE_TYPE (ll_arg)))
5174         return build2_loc (loc, EQ_EXPR, truth_type,
5175                            build2 (BIT_IOR_EXPR, TREE_TYPE (ll_arg),
5176                                    ll_arg, rl_arg),
5177                            build_int_cst (TREE_TYPE (ll_arg), 0));
5178     }
5179
5180   /* See if the comparisons can be merged.  Then get all the parameters for
5181      each side.  */
5182
5183   if ((lcode != EQ_EXPR && lcode != NE_EXPR)
5184       || (rcode != EQ_EXPR && rcode != NE_EXPR))
5185     return 0;
5186
5187   volatilep = 0;
5188   ll_inner = decode_field_reference (loc, ll_arg,
5189                                      &ll_bitsize, &ll_bitpos, &ll_mode,
5190                                      &ll_unsignedp, &volatilep, &ll_mask,
5191                                      &ll_and_mask);
5192   lr_inner = decode_field_reference (loc, lr_arg,
5193                                      &lr_bitsize, &lr_bitpos, &lr_mode,
5194                                      &lr_unsignedp, &volatilep, &lr_mask,
5195                                      &lr_and_mask);
5196   rl_inner = decode_field_reference (loc, rl_arg,
5197                                      &rl_bitsize, &rl_bitpos, &rl_mode,
5198                                      &rl_unsignedp, &volatilep, &rl_mask,
5199                                      &rl_and_mask);
5200   rr_inner = decode_field_reference (loc, rr_arg,
5201                                      &rr_bitsize, &rr_bitpos, &rr_mode,
5202                                      &rr_unsignedp, &volatilep, &rr_mask,
5203                                      &rr_and_mask);
5204
5205   /* It must be true that the inner operation on the lhs of each
5206      comparison must be the same if we are to be able to do anything.
5207      Then see if we have constants.  If not, the same must be true for
5208      the rhs's.  */
5209   if (volatilep || ll_inner == 0 || rl_inner == 0
5210       || ! operand_equal_p (ll_inner, rl_inner, 0))
5211     return 0;
5212
5213   if (TREE_CODE (lr_arg) == INTEGER_CST
5214       && TREE_CODE (rr_arg) == INTEGER_CST)
5215     l_const = lr_arg, r_const = rr_arg;
5216   else if (lr_inner == 0 || rr_inner == 0
5217            || ! operand_equal_p (lr_inner, rr_inner, 0))
5218     return 0;
5219   else
5220     l_const = r_const = 0;
5221
5222   /* If either comparison code is not correct for our logical operation,
5223      fail.  However, we can convert a one-bit comparison against zero into
5224      the opposite comparison against that bit being set in the field.  */
5225
5226   wanted_code = (code == TRUTH_AND_EXPR ? EQ_EXPR : NE_EXPR);
5227   if (lcode != wanted_code)
5228     {
5229       if (l_const && integer_zerop (l_const) && integer_pow2p (ll_mask))
5230         {
5231           /* Make the left operand unsigned, since we are only interested
5232              in the value of one bit.  Otherwise we are doing the wrong
5233              thing below.  */
5234           ll_unsignedp = 1;
5235           l_const = ll_mask;
5236         }
5237       else
5238         return 0;
5239     }
5240
5241   /* This is analogous to the code for l_const above.  */
5242   if (rcode != wanted_code)
5243     {
5244       if (r_const && integer_zerop (r_const) && integer_pow2p (rl_mask))
5245         {
5246           rl_unsignedp = 1;
5247           r_const = rl_mask;
5248         }
5249       else
5250         return 0;
5251     }
5252
5253   /* See if we can find a mode that contains both fields being compared on
5254      the left.  If we can't, fail.  Otherwise, update all constants and masks
5255      to be relative to a field of that size.  */
5256   first_bit = MIN (ll_bitpos, rl_bitpos);
5257   end_bit = MAX (ll_bitpos + ll_bitsize, rl_bitpos + rl_bitsize);
5258   lnmode = get_best_mode (end_bit - first_bit, first_bit, 0, 0,
5259                           TYPE_ALIGN (TREE_TYPE (ll_inner)), word_mode,
5260                           volatilep);
5261   if (lnmode == VOIDmode)
5262     return 0;
5263
5264   lnbitsize = GET_MODE_BITSIZE (lnmode);
5265   lnbitpos = first_bit & ~ (lnbitsize - 1);
5266   lntype = lang_hooks.types.type_for_size (lnbitsize, 1);
5267   xll_bitpos = ll_bitpos - lnbitpos, xrl_bitpos = rl_bitpos - lnbitpos;
5268
5269   if (BYTES_BIG_ENDIAN)
5270     {
5271       xll_bitpos = lnbitsize - xll_bitpos - ll_bitsize;
5272       xrl_bitpos = lnbitsize - xrl_bitpos - rl_bitsize;
5273     }
5274
5275   ll_mask = const_binop (LSHIFT_EXPR, fold_convert_loc (loc, lntype, ll_mask),
5276                          size_int (xll_bitpos));
5277   rl_mask = const_binop (LSHIFT_EXPR, fold_convert_loc (loc, lntype, rl_mask),
5278                          size_int (xrl_bitpos));
5279
5280   if (l_const)
5281     {
5282       l_const = fold_convert_loc (loc, lntype, l_const);
5283       l_const = unextend (l_const, ll_bitsize, ll_unsignedp, ll_and_mask);
5284       l_const = const_binop (LSHIFT_EXPR, l_const, size_int (xll_bitpos));
5285       if (! integer_zerop (const_binop (BIT_AND_EXPR, l_const,
5286                                         fold_build1_loc (loc, BIT_NOT_EXPR,
5287                                                      lntype, ll_mask))))
5288         {
5289           warning (0, "comparison is always %d", wanted_code == NE_EXPR);
5290
5291           return constant_boolean_node (wanted_code == NE_EXPR, truth_type);
5292         }
5293     }
5294   if (r_const)
5295     {
5296       r_const = fold_convert_loc (loc, lntype, r_const);
5297       r_const = unextend (r_const, rl_bitsize, rl_unsignedp, rl_and_mask);
5298       r_const = const_binop (LSHIFT_EXPR, r_const, size_int (xrl_bitpos));
5299       if (! integer_zerop (const_binop (BIT_AND_EXPR, r_const,
5300                                         fold_build1_loc (loc, BIT_NOT_EXPR,
5301                                                      lntype, rl_mask))))
5302         {
5303           warning (0, "comparison is always %d", wanted_code == NE_EXPR);
5304
5305           return constant_boolean_node (wanted_code == NE_EXPR, truth_type);
5306         }
5307     }
5308
5309   /* If the right sides are not constant, do the same for it.  Also,
5310      disallow this optimization if a size or signedness mismatch occurs
5311      between the left and right sides.  */
5312   if (l_const == 0)
5313     {
5314       if (ll_bitsize != lr_bitsize || rl_bitsize != rr_bitsize
5315           || ll_unsignedp != lr_unsignedp || rl_unsignedp != rr_unsignedp
5316           /* Make sure the two fields on the right
5317              correspond to the left without being swapped.  */
5318           || ll_bitpos - rl_bitpos != lr_bitpos - rr_bitpos)
5319         return 0;
5320
5321       first_bit = MIN (lr_bitpos, rr_bitpos);
5322       end_bit = MAX (lr_bitpos + lr_bitsize, rr_bitpos + rr_bitsize);
5323       rnmode = get_best_mode (end_bit - first_bit, first_bit, 0, 0,
5324                               TYPE_ALIGN (TREE_TYPE (lr_inner)), word_mode,
5325                               volatilep);
5326       if (rnmode == VOIDmode)
5327         return 0;
5328
5329       rnbitsize = GET_MODE_BITSIZE (rnmode);
5330       rnbitpos = first_bit & ~ (rnbitsize - 1);
5331       rntype = lang_hooks.types.type_for_size (rnbitsize, 1);
5332       xlr_bitpos = lr_bitpos - rnbitpos, xrr_bitpos = rr_bitpos - rnbitpos;
5333
5334       if (BYTES_BIG_ENDIAN)
5335         {
5336           xlr_bitpos = rnbitsize - xlr_bitpos - lr_bitsize;
5337           xrr_bitpos = rnbitsize - xrr_bitpos - rr_bitsize;
5338         }
5339
5340       lr_mask = const_binop (LSHIFT_EXPR, fold_convert_loc (loc,
5341                                                             rntype, lr_mask),
5342                              size_int (xlr_bitpos));
5343       rr_mask = const_binop (LSHIFT_EXPR, fold_convert_loc (loc,
5344                                                             rntype, rr_mask),
5345                              size_int (xrr_bitpos));
5346
5347       /* Make a mask that corresponds to both fields being compared.
5348          Do this for both items being compared.  If the operands are the
5349          same size and the bits being compared are in the same position
5350          then we can do this by masking both and comparing the masked
5351          results.  */
5352       ll_mask = const_binop (BIT_IOR_EXPR, ll_mask, rl_mask);
5353       lr_mask = const_binop (BIT_IOR_EXPR, lr_mask, rr_mask);
5354       if (lnbitsize == rnbitsize && xll_bitpos == xlr_bitpos)
5355         {
5356           lhs = make_bit_field_ref (loc, ll_inner, lntype, lnbitsize, lnbitpos,
5357                                     ll_unsignedp || rl_unsignedp);
5358           if (! all_ones_mask_p (ll_mask, lnbitsize))
5359             lhs = build2 (BIT_AND_EXPR, lntype, lhs, ll_mask);
5360
5361           rhs = make_bit_field_ref (loc, lr_inner, rntype, rnbitsize, rnbitpos,
5362                                     lr_unsignedp || rr_unsignedp);
5363           if (! all_ones_mask_p (lr_mask, rnbitsize))
5364             rhs = build2 (BIT_AND_EXPR, rntype, rhs, lr_mask);
5365
5366           return build2_loc (loc, wanted_code, truth_type, lhs, rhs);
5367         }
5368
5369       /* There is still another way we can do something:  If both pairs of
5370          fields being compared are adjacent, we may be able to make a wider
5371          field containing them both.
5372
5373          Note that we still must mask the lhs/rhs expressions.  Furthermore,
5374          the mask must be shifted to account for the shift done by
5375          make_bit_field_ref.  */
5376       if ((ll_bitsize + ll_bitpos == rl_bitpos
5377            && lr_bitsize + lr_bitpos == rr_bitpos)
5378           || (ll_bitpos == rl_bitpos + rl_bitsize
5379               && lr_bitpos == rr_bitpos + rr_bitsize))
5380         {
5381           tree type;
5382
5383           lhs = make_bit_field_ref (loc, ll_inner, lntype,
5384                                     ll_bitsize + rl_bitsize,
5385                                     MIN (ll_bitpos, rl_bitpos), ll_unsignedp);
5386           rhs = make_bit_field_ref (loc, lr_inner, rntype,
5387                                     lr_bitsize + rr_bitsize,
5388                                     MIN (lr_bitpos, rr_bitpos), lr_unsignedp);
5389
5390           ll_mask = const_binop (RSHIFT_EXPR, ll_mask,
5391                                  size_int (MIN (xll_bitpos, xrl_bitpos)));
5392           lr_mask = const_binop (RSHIFT_EXPR, lr_mask,
5393                                  size_int (MIN (xlr_bitpos, xrr_bitpos)));
5394
5395           /* Convert to the smaller type before masking out unwanted bits.  */
5396           type = lntype;
5397           if (lntype != rntype)
5398             {
5399               if (lnbitsize > rnbitsize)
5400                 {
5401                   lhs = fold_convert_loc (loc, rntype, lhs);
5402                   ll_mask = fold_convert_loc (loc, rntype, ll_mask);
5403                   type = rntype;
5404                 }
5405               else if (lnbitsize < rnbitsize)
5406                 {
5407                   rhs = fold_convert_loc (loc, lntype, rhs);
5408                   lr_mask = fold_convert_loc (loc, lntype, lr_mask);
5409                   type = lntype;
5410                 }
5411             }
5412
5413           if (! all_ones_mask_p (ll_mask, ll_bitsize + rl_bitsize))
5414             lhs = build2 (BIT_AND_EXPR, type, lhs, ll_mask);
5415
5416           if (! all_ones_mask_p (lr_mask, lr_bitsize + rr_bitsize))
5417             rhs = build2 (BIT_AND_EXPR, type, rhs, lr_mask);
5418
5419           return build2_loc (loc, wanted_code, truth_type, lhs, rhs);
5420         }
5421
5422       return 0;
5423     }
5424
5425   /* Handle the case of comparisons with constants.  If there is something in
5426      common between the masks, those bits of the constants must be the same.
5427      If not, the condition is always false.  Test for this to avoid generating
5428      incorrect code below.  */
5429   result = const_binop (BIT_AND_EXPR, ll_mask, rl_mask);
5430   if (! integer_zerop (result)
5431       && simple_cst_equal (const_binop (BIT_AND_EXPR, result, l_const),
5432                            const_binop (BIT_AND_EXPR, result, r_const)) != 1)
5433     {
5434       if (wanted_code == NE_EXPR)
5435         {
5436           warning (0, "%<or%> of unmatched not-equal tests is always 1");
5437           return constant_boolean_node (true, truth_type);
5438         }
5439       else
5440         {
5441           warning (0, "%<and%> of mutually exclusive equal-tests is always 0");
5442           return constant_boolean_node (false, truth_type);
5443         }
5444     }
5445
5446   /* Construct the expression we will return.  First get the component
5447      reference we will make.  Unless the mask is all ones the width of
5448      that field, perform the mask operation.  Then compare with the
5449      merged constant.  */
5450   result = make_bit_field_ref (loc, ll_inner, lntype, lnbitsize, lnbitpos,
5451                                ll_unsignedp || rl_unsignedp);
5452
5453   ll_mask = const_binop (BIT_IOR_EXPR, ll_mask, rl_mask);
5454   if (! all_ones_mask_p (ll_mask, lnbitsize))
5455     result = build2_loc (loc, BIT_AND_EXPR, lntype, result, ll_mask);
5456
5457   return build2_loc (loc, wanted_code, truth_type, result,
5458                      const_binop (BIT_IOR_EXPR, l_const, r_const));
5459 }
5460 \f
5461 /* Optimize T, which is a comparison of a MIN_EXPR or MAX_EXPR with a
5462    constant.  */
5463
5464 static tree
5465 optimize_minmax_comparison (location_t loc, enum tree_code code, tree type,
5466                             tree op0, tree op1)
5467 {
5468   tree arg0 = op0;
5469   enum tree_code op_code;
5470   tree comp_const;
5471   tree minmax_const;
5472   int consts_equal, consts_lt;
5473   tree inner;
5474
5475   STRIP_SIGN_NOPS (arg0);
5476
5477   op_code = TREE_CODE (arg0);
5478   minmax_const = TREE_OPERAND (arg0, 1);
5479   comp_const = fold_convert_loc (loc, TREE_TYPE (arg0), op1);
5480   consts_equal = tree_int_cst_equal (minmax_const, comp_const);
5481   consts_lt = tree_int_cst_lt (minmax_const, comp_const);
5482   inner = TREE_OPERAND (arg0, 0);
5483
5484   /* If something does not permit us to optimize, return the original tree.  */
5485   if ((op_code != MIN_EXPR && op_code != MAX_EXPR)
5486       || TREE_CODE (comp_const) != INTEGER_CST
5487       || TREE_OVERFLOW (comp_const)
5488       || TREE_CODE (minmax_const) != INTEGER_CST
5489       || TREE_OVERFLOW (minmax_const))
5490     return NULL_TREE;
5491
5492   /* Now handle all the various comparison codes.  We only handle EQ_EXPR
5493      and GT_EXPR, doing the rest with recursive calls using logical
5494      simplifications.  */
5495   switch (code)
5496     {
5497     case NE_EXPR:  case LT_EXPR:  case LE_EXPR:
5498       {
5499         tree tem
5500           = optimize_minmax_comparison (loc,
5501                                         invert_tree_comparison (code, false),
5502                                         type, op0, op1);
5503         if (tem)
5504           return invert_truthvalue_loc (loc, tem);
5505         return NULL_TREE;
5506       }
5507
5508     case GE_EXPR:
5509       return
5510         fold_build2_loc (loc, TRUTH_ORIF_EXPR, type,
5511                      optimize_minmax_comparison
5512                      (loc, EQ_EXPR, type, arg0, comp_const),
5513                      optimize_minmax_comparison
5514                      (loc, GT_EXPR, type, arg0, comp_const));
5515
5516     case EQ_EXPR:
5517       if (op_code == MAX_EXPR && consts_equal)
5518         /* MAX (X, 0) == 0  ->  X <= 0  */
5519         return fold_build2_loc (loc, LE_EXPR, type, inner, comp_const);
5520
5521       else if (op_code == MAX_EXPR && consts_lt)
5522         /* MAX (X, 0) == 5  ->  X == 5   */
5523         return fold_build2_loc (loc, EQ_EXPR, type, inner, comp_const);
5524
5525       else if (op_code == MAX_EXPR)
5526         /* MAX (X, 0) == -1  ->  false  */
5527         return omit_one_operand_loc (loc, type, integer_zero_node, inner);
5528
5529       else if (consts_equal)
5530         /* MIN (X, 0) == 0  ->  X >= 0  */
5531         return fold_build2_loc (loc, GE_EXPR, type, inner, comp_const);
5532
5533       else if (consts_lt)
5534         /* MIN (X, 0) == 5  ->  false  */
5535         return omit_one_operand_loc (loc, type, integer_zero_node, inner);
5536
5537       else
5538         /* MIN (X, 0) == -1  ->  X == -1  */
5539         return fold_build2_loc (loc, EQ_EXPR, type, inner, comp_const);
5540
5541     case GT_EXPR:
5542       if (op_code == MAX_EXPR && (consts_equal || consts_lt))
5543         /* MAX (X, 0) > 0  ->  X > 0
5544            MAX (X, 0) > 5  ->  X > 5  */
5545         return fold_build2_loc (loc, GT_EXPR, type, inner, comp_const);
5546
5547       else if (op_code == MAX_EXPR)
5548         /* MAX (X, 0) > -1  ->  true  */
5549         return omit_one_operand_loc (loc, type, integer_one_node, inner);
5550
5551       else if (op_code == MIN_EXPR && (consts_equal || consts_lt))
5552         /* MIN (X, 0) > 0  ->  false
5553            MIN (X, 0) > 5  ->  false  */
5554         return omit_one_operand_loc (loc, type, integer_zero_node, inner);
5555
5556       else
5557         /* MIN (X, 0) > -1  ->  X > -1  */
5558         return fold_build2_loc (loc, GT_EXPR, type, inner, comp_const);
5559
5560     default:
5561       return NULL_TREE;
5562     }
5563 }
5564 \f
5565 /* T is an integer expression that is being multiplied, divided, or taken a
5566    modulus (CODE says which and what kind of divide or modulus) by a
5567    constant C.  See if we can eliminate that operation by folding it with
5568    other operations already in T.  WIDE_TYPE, if non-null, is a type that
5569    should be used for the computation if wider than our type.
5570
5571    For example, if we are dividing (X * 8) + (Y * 16) by 4, we can return
5572    (X * 2) + (Y * 4).  We must, however, be assured that either the original
5573    expression would not overflow or that overflow is undefined for the type
5574    in the language in question.
5575
5576    If we return a non-null expression, it is an equivalent form of the
5577    original computation, but need not be in the original type.
5578
5579    We set *STRICT_OVERFLOW_P to true if the return values depends on
5580    signed overflow being undefined.  Otherwise we do not change
5581    *STRICT_OVERFLOW_P.  */
5582
5583 static tree
5584 extract_muldiv (tree t, tree c, enum tree_code code, tree wide_type,
5585                 bool *strict_overflow_p)
5586 {
5587   /* To avoid exponential search depth, refuse to allow recursion past
5588      three levels.  Beyond that (1) it's highly unlikely that we'll find
5589      something interesting and (2) we've probably processed it before
5590      when we built the inner expression.  */
5591
5592   static int depth;
5593   tree ret;
5594
5595   if (depth > 3)
5596     return NULL;
5597
5598   depth++;
5599   ret = extract_muldiv_1 (t, c, code, wide_type, strict_overflow_p);
5600   depth--;
5601
5602   return ret;
5603 }
5604
5605 static tree
5606 extract_muldiv_1 (tree t, tree c, enum tree_code code, tree wide_type,
5607                   bool *strict_overflow_p)
5608 {
5609   tree type = TREE_TYPE (t);
5610   enum tree_code tcode = TREE_CODE (t);
5611   tree ctype = (wide_type != 0 && (GET_MODE_SIZE (TYPE_MODE (wide_type))
5612                                    > GET_MODE_SIZE (TYPE_MODE (type)))
5613                 ? wide_type : type);
5614   tree t1, t2;
5615   int same_p = tcode == code;
5616   tree op0 = NULL_TREE, op1 = NULL_TREE;
5617   bool sub_strict_overflow_p;
5618
5619   /* Don't deal with constants of zero here; they confuse the code below.  */
5620   if (integer_zerop (c))
5621     return NULL_TREE;
5622
5623   if (TREE_CODE_CLASS (tcode) == tcc_unary)
5624     op0 = TREE_OPERAND (t, 0);
5625
5626   if (TREE_CODE_CLASS (tcode) == tcc_binary)
5627     op0 = TREE_OPERAND (t, 0), op1 = TREE_OPERAND (t, 1);
5628
5629   /* Note that we need not handle conditional operations here since fold
5630      already handles those cases.  So just do arithmetic here.  */
5631   switch (tcode)
5632     {
5633     case INTEGER_CST:
5634       /* For a constant, we can always simplify if we are a multiply
5635          or (for divide and modulus) if it is a multiple of our constant.  */
5636       if (code == MULT_EXPR
5637           || integer_zerop (const_binop (TRUNC_MOD_EXPR, t, c)))
5638         return const_binop (code, fold_convert (ctype, t),
5639                             fold_convert (ctype, c));
5640       break;
5641
5642     CASE_CONVERT: case NON_LVALUE_EXPR:
5643       /* If op0 is an expression ...  */
5644       if ((COMPARISON_CLASS_P (op0)
5645            || UNARY_CLASS_P (op0)
5646            || BINARY_CLASS_P (op0)
5647            || VL_EXP_CLASS_P (op0)
5648            || EXPRESSION_CLASS_P (op0))
5649           /* ... and has wrapping overflow, and its type is smaller
5650              than ctype, then we cannot pass through as widening.  */
5651           && ((TYPE_OVERFLOW_WRAPS (TREE_TYPE (op0))
5652                && ! (TREE_CODE (TREE_TYPE (op0)) == INTEGER_TYPE
5653                      && TYPE_IS_SIZETYPE (TREE_TYPE (op0)))
5654                && (TYPE_PRECISION (ctype)
5655                    > TYPE_PRECISION (TREE_TYPE (op0))))
5656               /* ... or this is a truncation (t is narrower than op0),
5657                  then we cannot pass through this narrowing.  */
5658               || (TYPE_PRECISION (type)
5659                   < TYPE_PRECISION (TREE_TYPE (op0)))
5660               /* ... or signedness changes for division or modulus,
5661                  then we cannot pass through this conversion.  */
5662               || (code != MULT_EXPR
5663                   && (TYPE_UNSIGNED (ctype)
5664                       != TYPE_UNSIGNED (TREE_TYPE (op0))))
5665               /* ... or has undefined overflow while the converted to
5666                  type has not, we cannot do the operation in the inner type
5667                  as that would introduce undefined overflow.  */
5668               || (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (op0))
5669                   && !TYPE_OVERFLOW_UNDEFINED (type))))
5670         break;
5671
5672       /* Pass the constant down and see if we can make a simplification.  If
5673          we can, replace this expression with the inner simplification for
5674          possible later conversion to our or some other type.  */
5675       if ((t2 = fold_convert (TREE_TYPE (op0), c)) != 0
5676           && TREE_CODE (t2) == INTEGER_CST
5677           && !TREE_OVERFLOW (t2)
5678           && (0 != (t1 = extract_muldiv (op0, t2, code,
5679                                          code == MULT_EXPR
5680                                          ? ctype : NULL_TREE,
5681                                          strict_overflow_p))))
5682         return t1;
5683       break;
5684
5685     case ABS_EXPR:
5686       /* If widening the type changes it from signed to unsigned, then we
5687          must avoid building ABS_EXPR itself as unsigned.  */
5688       if (TYPE_UNSIGNED (ctype) && !TYPE_UNSIGNED (type))
5689         {
5690           tree cstype = (*signed_type_for) (ctype);
5691           if ((t1 = extract_muldiv (op0, c, code, cstype, strict_overflow_p))
5692               != 0)
5693             {
5694               t1 = fold_build1 (tcode, cstype, fold_convert (cstype, t1));
5695               return fold_convert (ctype, t1);
5696             }
5697           break;
5698         }
5699       /* If the constant is negative, we cannot simplify this.  */
5700       if (tree_int_cst_sgn (c) == -1)
5701         break;
5702       /* FALLTHROUGH */
5703     case NEGATE_EXPR:
5704       if ((t1 = extract_muldiv (op0, c, code, wide_type, strict_overflow_p))
5705           != 0)
5706         return fold_build1 (tcode, ctype, fold_convert (ctype, t1));
5707       break;
5708
5709     case MIN_EXPR:  case MAX_EXPR:
5710       /* If widening the type changes the signedness, then we can't perform
5711          this optimization as that changes the result.  */
5712       if (TYPE_UNSIGNED (ctype) != TYPE_UNSIGNED (type))
5713         break;
5714
5715       /* MIN (a, b) / 5 -> MIN (a / 5, b / 5)  */
5716       sub_strict_overflow_p = false;
5717       if ((t1 = extract_muldiv (op0, c, code, wide_type,
5718                                 &sub_strict_overflow_p)) != 0
5719           && (t2 = extract_muldiv (op1, c, code, wide_type,
5720                                    &sub_strict_overflow_p)) != 0)
5721         {
5722           if (tree_int_cst_sgn (c) < 0)
5723             tcode = (tcode == MIN_EXPR ? MAX_EXPR : MIN_EXPR);
5724           if (sub_strict_overflow_p)
5725             *strict_overflow_p = true;
5726           return fold_build2 (tcode, ctype, fold_convert (ctype, t1),
5727                               fold_convert (ctype, t2));
5728         }
5729       break;
5730
5731     case LSHIFT_EXPR:  case RSHIFT_EXPR:
5732       /* If the second operand is constant, this is a multiplication
5733          or floor division, by a power of two, so we can treat it that
5734          way unless the multiplier or divisor overflows.  Signed
5735          left-shift overflow is implementation-defined rather than
5736          undefined in C90, so do not convert signed left shift into
5737          multiplication.  */
5738       if (TREE_CODE (op1) == INTEGER_CST
5739           && (tcode == RSHIFT_EXPR || TYPE_UNSIGNED (TREE_TYPE (op0)))
5740           /* const_binop may not detect overflow correctly,
5741              so check for it explicitly here.  */
5742           && TYPE_PRECISION (TREE_TYPE (size_one_node)) > TREE_INT_CST_LOW (op1)
5743           && TREE_INT_CST_HIGH (op1) == 0
5744           && 0 != (t1 = fold_convert (ctype,
5745                                       const_binop (LSHIFT_EXPR,
5746                                                    size_one_node,
5747                                                    op1)))
5748           && !TREE_OVERFLOW (t1))
5749         return extract_muldiv (build2 (tcode == LSHIFT_EXPR
5750                                        ? MULT_EXPR : FLOOR_DIV_EXPR,
5751                                        ctype,
5752                                        fold_convert (ctype, op0),
5753                                        t1),
5754                                c, code, wide_type, strict_overflow_p);
5755       break;
5756
5757     case PLUS_EXPR:  case MINUS_EXPR:
5758       /* See if we can eliminate the operation on both sides.  If we can, we
5759          can return a new PLUS or MINUS.  If we can't, the only remaining
5760          cases where we can do anything are if the second operand is a
5761          constant.  */
5762       sub_strict_overflow_p = false;
5763       t1 = extract_muldiv (op0, c, code, wide_type, &sub_strict_overflow_p);
5764       t2 = extract_muldiv (op1, c, code, wide_type, &sub_strict_overflow_p);
5765       if (t1 != 0 && t2 != 0
5766           && (code == MULT_EXPR
5767               /* If not multiplication, we can only do this if both operands
5768                  are divisible by c.  */
5769               || (multiple_of_p (ctype, op0, c)
5770                   && multiple_of_p (ctype, op1, c))))
5771         {
5772           if (sub_strict_overflow_p)
5773             *strict_overflow_p = true;
5774           return fold_build2 (tcode, ctype, fold_convert (ctype, t1),
5775                               fold_convert (ctype, t2));
5776         }
5777
5778       /* If this was a subtraction, negate OP1 and set it to be an addition.
5779          This simplifies the logic below.  */
5780       if (tcode == MINUS_EXPR)
5781         {
5782           tcode = PLUS_EXPR, op1 = negate_expr (op1);
5783           /* If OP1 was not easily negatable, the constant may be OP0.  */
5784           if (TREE_CODE (op0) == INTEGER_CST)
5785             {
5786               tree tem = op0;
5787               op0 = op1;
5788               op1 = tem;
5789               tem = t1;
5790               t1 = t2;
5791               t2 = tem;
5792             }
5793         }
5794
5795       if (TREE_CODE (op1) != INTEGER_CST)
5796         break;
5797
5798       /* If either OP1 or C are negative, this optimization is not safe for
5799          some of the division and remainder types while for others we need
5800          to change the code.  */
5801       if (tree_int_cst_sgn (op1) < 0 || tree_int_cst_sgn (c) < 0)
5802         {
5803           if (code == CEIL_DIV_EXPR)
5804             code = FLOOR_DIV_EXPR;
5805           else if (code == FLOOR_DIV_EXPR)
5806             code = CEIL_DIV_EXPR;
5807           else if (code != MULT_EXPR
5808                    && code != CEIL_MOD_EXPR && code != FLOOR_MOD_EXPR)
5809             break;
5810         }
5811
5812       /* If it's a multiply or a division/modulus operation of a multiple
5813          of our constant, do the operation and verify it doesn't overflow.  */
5814       if (code == MULT_EXPR
5815           || integer_zerop (const_binop (TRUNC_MOD_EXPR, op1, c)))
5816         {
5817           op1 = const_binop (code, fold_convert (ctype, op1),
5818                              fold_convert (ctype, c));
5819           /* We allow the constant to overflow with wrapping semantics.  */
5820           if (op1 == 0
5821               || (TREE_OVERFLOW (op1) && !TYPE_OVERFLOW_WRAPS (ctype)))
5822             break;
5823         }
5824       else
5825         break;
5826
5827       /* If we have an unsigned type is not a sizetype, we cannot widen
5828          the operation since it will change the result if the original
5829          computation overflowed.  */
5830       if (TYPE_UNSIGNED (ctype)
5831           && ! (TREE_CODE (ctype) == INTEGER_TYPE && TYPE_IS_SIZETYPE (ctype))
5832           && ctype != type)
5833         break;
5834
5835       /* If we were able to eliminate our operation from the first side,
5836          apply our operation to the second side and reform the PLUS.  */
5837       if (t1 != 0 && (TREE_CODE (t1) != code || code == MULT_EXPR))
5838         return fold_build2 (tcode, ctype, fold_convert (ctype, t1), op1);
5839
5840       /* The last case is if we are a multiply.  In that case, we can
5841          apply the distributive law to commute the multiply and addition
5842          if the multiplication of the constants doesn't overflow.  */
5843       if (code == MULT_EXPR)
5844         return fold_build2 (tcode, ctype,
5845                             fold_build2 (code, ctype,
5846                                          fold_convert (ctype, op0),
5847                                          fold_convert (ctype, c)),
5848                             op1);
5849
5850       break;
5851
5852     case MULT_EXPR:
5853       /* We have a special case here if we are doing something like
5854          (C * 8) % 4 since we know that's zero.  */
5855       if ((code == TRUNC_MOD_EXPR || code == CEIL_MOD_EXPR
5856            || code == FLOOR_MOD_EXPR || code == ROUND_MOD_EXPR)
5857           /* If the multiplication can overflow we cannot optimize this.
5858              ???  Until we can properly mark individual operations as
5859              not overflowing we need to treat sizetype special here as
5860              stor-layout relies on this opimization to make
5861              DECL_FIELD_BIT_OFFSET always a constant.  */
5862           && (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (t))
5863               || (TREE_CODE (TREE_TYPE (t)) == INTEGER_TYPE
5864                   && TYPE_IS_SIZETYPE (TREE_TYPE (t))))
5865           && TREE_CODE (TREE_OPERAND (t, 1)) == INTEGER_CST
5866           && integer_zerop (const_binop (TRUNC_MOD_EXPR, op1, c)))
5867         {
5868           *strict_overflow_p = true;
5869           return omit_one_operand (type, integer_zero_node, op0);
5870         }
5871
5872       /* ... fall through ...  */
5873
5874     case TRUNC_DIV_EXPR:  case CEIL_DIV_EXPR:  case FLOOR_DIV_EXPR:
5875     case ROUND_DIV_EXPR:  case EXACT_DIV_EXPR:
5876       /* If we can extract our operation from the LHS, do so and return a
5877          new operation.  Likewise for the RHS from a MULT_EXPR.  Otherwise,
5878          do something only if the second operand is a constant.  */
5879       if (same_p
5880           && (t1 = extract_muldiv (op0, c, code, wide_type,
5881                                    strict_overflow_p)) != 0)
5882         return fold_build2 (tcode, ctype, fold_convert (ctype, t1),
5883                             fold_convert (ctype, op1));
5884       else if (tcode == MULT_EXPR && code == MULT_EXPR
5885                && (t1 = extract_muldiv (op1, c, code, wide_type,
5886                                         strict_overflow_p)) != 0)
5887         return fold_build2 (tcode, ctype, fold_convert (ctype, op0),
5888                             fold_convert (ctype, t1));
5889       else if (TREE_CODE (op1) != INTEGER_CST)
5890         return 0;
5891
5892       /* If these are the same operation types, we can associate them
5893          assuming no overflow.  */
5894       if (tcode == code)
5895         {
5896           double_int mul;
5897           int overflow_p;
5898           mul = double_int_mul_with_sign
5899                   (double_int_ext
5900                      (tree_to_double_int (op1),
5901                       TYPE_PRECISION (ctype), TYPE_UNSIGNED (ctype)),
5902                    double_int_ext
5903                      (tree_to_double_int (c),
5904                       TYPE_PRECISION (ctype), TYPE_UNSIGNED (ctype)),
5905                    false, &overflow_p);
5906           overflow_p = (((!TYPE_UNSIGNED (ctype)
5907                           || (TREE_CODE (ctype) == INTEGER_TYPE
5908                               && TYPE_IS_SIZETYPE (ctype)))
5909                          && overflow_p)
5910                         | TREE_OVERFLOW (c) | TREE_OVERFLOW (op1));
5911           if (!double_int_fits_to_tree_p (ctype, mul)
5912               && ((TYPE_UNSIGNED (ctype) && tcode != MULT_EXPR)
5913                   || !TYPE_UNSIGNED (ctype)
5914                   || (TREE_CODE (ctype) == INTEGER_TYPE
5915                       && TYPE_IS_SIZETYPE (ctype))))
5916             overflow_p = 1;
5917           if (!overflow_p)
5918             return fold_build2 (tcode, ctype, fold_convert (ctype, op0),
5919                                 double_int_to_tree (ctype, mul));
5920         }
5921
5922       /* If these operations "cancel" each other, we have the main
5923          optimizations of this pass, which occur when either constant is a
5924          multiple of the other, in which case we replace this with either an
5925          operation or CODE or TCODE.
5926
5927          If we have an unsigned type that is not a sizetype, we cannot do
5928          this since it will change the result if the original computation
5929          overflowed.  */
5930       if ((TYPE_OVERFLOW_UNDEFINED (ctype)
5931            || (TREE_CODE (ctype) == INTEGER_TYPE && TYPE_IS_SIZETYPE (ctype)))
5932           && ((code == MULT_EXPR && tcode == EXACT_DIV_EXPR)
5933               || (tcode == MULT_EXPR
5934                   && code != TRUNC_MOD_EXPR && code != CEIL_MOD_EXPR
5935                   && code != FLOOR_MOD_EXPR && code != ROUND_MOD_EXPR
5936                   && code != MULT_EXPR)))
5937         {
5938           if (integer_zerop (const_binop (TRUNC_MOD_EXPR, op1, c)))
5939             {
5940               if (TYPE_OVERFLOW_UNDEFINED (ctype))
5941                 *strict_overflow_p = true;
5942               return fold_build2 (tcode, ctype, fold_convert (ctype, op0),
5943                                   fold_convert (ctype,
5944                                                 const_binop (TRUNC_DIV_EXPR,
5945                                                              op1, c)));
5946             }
5947           else if (integer_zerop (const_binop (TRUNC_MOD_EXPR, c, op1)))
5948             {
5949               if (TYPE_OVERFLOW_UNDEFINED (ctype))
5950                 *strict_overflow_p = true;
5951               return fold_build2 (code, ctype, fold_convert (ctype, op0),
5952                                   fold_convert (ctype,
5953                                                 const_binop (TRUNC_DIV_EXPR,
5954                                                              c, op1)));
5955             }
5956         }
5957       break;
5958
5959     default:
5960       break;
5961     }
5962
5963   return 0;
5964 }
5965 \f
5966 /* Return a node which has the indicated constant VALUE (either 0 or
5967    1 for scalars or {-1,-1,..} or {0,0,...} for vectors),
5968    and is of the indicated TYPE.  */
5969
5970 tree
5971 constant_boolean_node (bool value, tree type)
5972 {
5973   if (type == integer_type_node)
5974     return value ? integer_one_node : integer_zero_node;
5975   else if (type == boolean_type_node)
5976     return value ? boolean_true_node : boolean_false_node;
5977   else if (TREE_CODE (type) == VECTOR_TYPE)
5978     return build_vector_from_val (type,
5979                                   build_int_cst (TREE_TYPE (type),
5980                                                  value ? -1 : 0));
5981   else
5982     return fold_convert (type, value ? integer_one_node : integer_zero_node);
5983 }
5984
5985
5986 /* Transform `a + (b ? x : y)' into `b ? (a + x) : (a + y)'.
5987    Transform, `a + (x < y)' into `(x < y) ? (a + 1) : (a + 0)'.  Here
5988    CODE corresponds to the `+', COND to the `(b ? x : y)' or `(x < y)'
5989    expression, and ARG to `a'.  If COND_FIRST_P is nonzero, then the
5990    COND is the first argument to CODE; otherwise (as in the example
5991    given here), it is the second argument.  TYPE is the type of the
5992    original expression.  Return NULL_TREE if no simplification is
5993    possible.  */
5994
5995 static tree
5996 fold_binary_op_with_conditional_arg (location_t loc,
5997                                      enum tree_code code,
5998                                      tree type, tree op0, tree op1,
5999                                      tree cond, tree arg, int cond_first_p)
6000 {
6001   tree cond_type = cond_first_p ? TREE_TYPE (op0) : TREE_TYPE (op1);
6002   tree arg_type = cond_first_p ? TREE_TYPE (op1) : TREE_TYPE (op0);
6003   tree test, true_value, false_value;
6004   tree lhs = NULL_TREE;
6005   tree rhs = NULL_TREE;
6006
6007   if (TREE_CODE (cond) == COND_EXPR)
6008     {
6009       test = TREE_OPERAND (cond, 0);
6010       true_value = TREE_OPERAND (cond, 1);
6011       false_value = TREE_OPERAND (cond, 2);
6012       /* If this operand throws an expression, then it does not make
6013          sense to try to perform a logical or arithmetic operation
6014          involving it.  */
6015       if (VOID_TYPE_P (TREE_TYPE (true_value)))
6016         lhs = true_value;
6017       if (VOID_TYPE_P (TREE_TYPE (false_value)))
6018         rhs = false_value;
6019     }
6020   else
6021     {
6022       tree testtype = TREE_TYPE (cond);
6023       test = cond;
6024       true_value = constant_boolean_node (true, testtype);
6025       false_value = constant_boolean_node (false, testtype);
6026     }
6027
6028   /* This transformation is only worthwhile if we don't have to wrap ARG
6029      in a SAVE_EXPR and the operation can be simplified on at least one
6030      of the branches once its pushed inside the COND_EXPR.  */
6031   if (!TREE_CONSTANT (arg)
6032       && (TREE_SIDE_EFFECTS (arg)
6033           || TREE_CONSTANT (true_value) || TREE_CONSTANT (false_value)))
6034     return NULL_TREE;
6035
6036   arg = fold_convert_loc (loc, arg_type, arg);
6037   if (lhs == 0)
6038     {
6039       true_value = fold_convert_loc (loc, cond_type, true_value);
6040       if (cond_first_p)
6041         lhs = fold_build2_loc (loc, code, type, true_value, arg);
6042       else
6043         lhs = fold_build2_loc (loc, code, type, arg, true_value);
6044     }
6045   if (rhs == 0)
6046     {
6047       false_value = fold_convert_loc (loc, cond_type, false_value);
6048       if (cond_first_p)
6049         rhs = fold_build2_loc (loc, code, type, false_value, arg);
6050       else
6051         rhs = fold_build2_loc (loc, code, type, arg, false_value);
6052     }
6053
6054   /* Check that we have simplified at least one of the branches.  */
6055   if (!TREE_CONSTANT (arg) && !TREE_CONSTANT (lhs) && !TREE_CONSTANT (rhs))
6056     return NULL_TREE;
6057
6058   return fold_build3_loc (loc, COND_EXPR, type, test, lhs, rhs);
6059 }
6060
6061 \f
6062 /* Subroutine of fold() that checks for the addition of +/- 0.0.
6063
6064    If !NEGATE, return true if ADDEND is +/-0.0 and, for all X of type
6065    TYPE, X + ADDEND is the same as X.  If NEGATE, return true if X -
6066    ADDEND is the same as X.
6067
6068    X + 0 and X - 0 both give X when X is NaN, infinite, or nonzero
6069    and finite.  The problematic cases are when X is zero, and its mode
6070    has signed zeros.  In the case of rounding towards -infinity,
6071    X - 0 is not the same as X because 0 - 0 is -0.  In other rounding
6072    modes, X + 0 is not the same as X because -0 + 0 is 0.  */
6073
6074 bool
6075 fold_real_zero_addition_p (const_tree type, const_tree addend, int negate)
6076 {
6077   if (!real_zerop (addend))
6078     return false;
6079
6080   /* Don't allow the fold with -fsignaling-nans.  */
6081   if (HONOR_SNANS (TYPE_MODE (type)))
6082     return false;
6083
6084   /* Allow the fold if zeros aren't signed, or their sign isn't important.  */
6085   if (!HONOR_SIGNED_ZEROS (TYPE_MODE (type)))
6086     return true;
6087
6088   /* Treat x + -0 as x - 0 and x - -0 as x + 0.  */
6089   if (TREE_CODE (addend) == REAL_CST
6090       && REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (addend)))
6091     negate = !negate;
6092
6093   /* The mode has signed zeros, and we have to honor their sign.
6094      In this situation, there is only one case we can return true for.
6095      X - 0 is the same as X unless rounding towards -infinity is
6096      supported.  */
6097   return negate && !HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (type));
6098 }
6099
6100 /* Subroutine of fold() that checks comparisons of built-in math
6101    functions against real constants.
6102
6103    FCODE is the DECL_FUNCTION_CODE of the built-in, CODE is the comparison
6104    operator: EQ_EXPR, NE_EXPR, GT_EXPR, LT_EXPR, GE_EXPR or LE_EXPR.  TYPE
6105    is the type of the result and ARG0 and ARG1 are the operands of the
6106    comparison.  ARG1 must be a TREE_REAL_CST.
6107
6108    The function returns the constant folded tree if a simplification
6109    can be made, and NULL_TREE otherwise.  */
6110
6111 static tree
6112 fold_mathfn_compare (location_t loc,
6113                      enum built_in_function fcode, enum tree_code code,
6114                      tree type, tree arg0, tree arg1)
6115 {
6116   REAL_VALUE_TYPE c;
6117
6118   if (BUILTIN_SQRT_P (fcode))
6119     {
6120       tree arg = CALL_EXPR_ARG (arg0, 0);
6121       enum machine_mode mode = TYPE_MODE (TREE_TYPE (arg0));
6122
6123       c = TREE_REAL_CST (arg1);
6124       if (REAL_VALUE_NEGATIVE (c))
6125         {
6126           /* sqrt(x) < y is always false, if y is negative.  */
6127           if (code == EQ_EXPR || code == LT_EXPR || code == LE_EXPR)
6128             return omit_one_operand_loc (loc, type, integer_zero_node, arg);
6129
6130           /* sqrt(x) > y is always true, if y is negative and we
6131              don't care about NaNs, i.e. negative values of x.  */
6132           if (code == NE_EXPR || !HONOR_NANS (mode))
6133             return omit_one_operand_loc (loc, type, integer_one_node, arg);
6134
6135           /* sqrt(x) > y is the same as x >= 0, if y is negative.  */
6136           return fold_build2_loc (loc, GE_EXPR, type, arg,
6137                               build_real (TREE_TYPE (arg), dconst0));
6138         }
6139       else if (code == GT_EXPR || code == GE_EXPR)
6140         {
6141           REAL_VALUE_TYPE c2;
6142
6143           REAL_ARITHMETIC (c2, MULT_EXPR, c, c);
6144           real_convert (&c2, mode, &c2);
6145
6146           if (REAL_VALUE_ISINF (c2))
6147             {
6148               /* sqrt(x) > y is x == +Inf, when y is very large.  */
6149               if (HONOR_INFINITIES (mode))
6150                 return fold_build2_loc (loc, EQ_EXPR, type, arg,
6151                                     build_real (TREE_TYPE (arg), c2));
6152
6153               /* sqrt(x) > y is always false, when y is very large
6154                  and we don't care about infinities.  */
6155               return omit_one_operand_loc (loc, type, integer_zero_node, arg);
6156             }
6157
6158           /* sqrt(x) > c is the same as x > c*c.  */
6159           return fold_build2_loc (loc, code, type, arg,
6160                               build_real (TREE_TYPE (arg), c2));
6161         }
6162       else if (code == LT_EXPR || code == LE_EXPR)
6163         {
6164           REAL_VALUE_TYPE c2;
6165
6166           REAL_ARITHMETIC (c2, MULT_EXPR, c, c);
6167           real_convert (&c2, mode, &c2);
6168
6169           if (REAL_VALUE_ISINF (c2))
6170             {
6171               /* sqrt(x) < y is always true, when y is a very large
6172                  value and we don't care about NaNs or Infinities.  */
6173               if (! HONOR_NANS (mode) && ! HONOR_INFINITIES (mode))
6174                 return omit_one_operand_loc (loc, type, integer_one_node, arg);
6175
6176               /* sqrt(x) < y is x != +Inf when y is very large and we
6177                  don't care about NaNs.  */
6178               if (! HONOR_NANS (mode))
6179                 return fold_build2_loc (loc, NE_EXPR, type, arg,
6180                                     build_real (TREE_TYPE (arg), c2));
6181
6182               /* sqrt(x) < y is x >= 0 when y is very large and we
6183                  don't care about Infinities.  */
6184               if (! HONOR_INFINITIES (mode))
6185                 return fold_build2_loc (loc, GE_EXPR, type, arg,
6186                                     build_real (TREE_TYPE (arg), dconst0));
6187
6188               /* sqrt(x) < y is x >= 0 && x != +Inf, when y is large.  */
6189               arg = save_expr (arg);
6190               return fold_build2_loc (loc, TRUTH_ANDIF_EXPR, type,
6191                                   fold_build2_loc (loc, GE_EXPR, type, arg,
6192                                                build_real (TREE_TYPE (arg),
6193                                                            dconst0)),
6194                                   fold_build2_loc (loc, NE_EXPR, type, arg,
6195                                                build_real (TREE_TYPE (arg),
6196                                                            c2)));
6197             }
6198
6199           /* sqrt(x) < c is the same as x < c*c, if we ignore NaNs.  */
6200           if (! HONOR_NANS (mode))
6201             return fold_build2_loc (loc, code, type, arg,
6202                                 build_real (TREE_TYPE (arg), c2));
6203
6204           /* sqrt(x) < c is the same as x >= 0 && x < c*c.  */
6205           arg = save_expr (arg);
6206           return fold_build2_loc (loc, TRUTH_ANDIF_EXPR, type,
6207                                   fold_build2_loc (loc, GE_EXPR, type, arg,
6208                                                build_real (TREE_TYPE (arg),
6209                                                            dconst0)),
6210                                   fold_build2_loc (loc, code, type, arg,
6211                                                build_real (TREE_TYPE (arg),
6212                                                            c2)));
6213         }
6214     }
6215
6216   return NULL_TREE;
6217 }
6218
6219 /* Subroutine of fold() that optimizes comparisons against Infinities,
6220    either +Inf or -Inf.
6221
6222    CODE is the comparison operator: EQ_EXPR, NE_EXPR, GT_EXPR, LT_EXPR,
6223    GE_EXPR or LE_EXPR.  TYPE is the type of the result and ARG0 and ARG1
6224    are the operands of the comparison.  ARG1 must be a TREE_REAL_CST.
6225
6226    The function returns the constant folded tree if a simplification
6227    can be made, and NULL_TREE otherwise.  */
6228
6229 static tree
6230 fold_inf_compare (location_t loc, enum tree_code code, tree type,
6231                   tree arg0, tree arg1)
6232 {
6233   enum machine_mode mode;
6234   REAL_VALUE_TYPE max;
6235   tree temp;
6236   bool neg;
6237
6238   mode = TYPE_MODE (TREE_TYPE (arg0));
6239
6240   /* For negative infinity swap the sense of the comparison.  */
6241   neg = REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg1));
6242   if (neg)
6243     code = swap_tree_comparison (code);
6244
6245   switch (code)
6246     {
6247     case GT_EXPR:
6248       /* x > +Inf is always false, if with ignore sNANs.  */
6249       if (HONOR_SNANS (mode))
6250         return NULL_TREE;
6251       return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
6252
6253     case LE_EXPR:
6254       /* x <= +Inf is always true, if we don't case about NaNs.  */
6255       if (! HONOR_NANS (mode))
6256         return omit_one_operand_loc (loc, type, integer_one_node, arg0);
6257
6258       /* x <= +Inf is the same as x == x, i.e. isfinite(x).  */
6259       arg0 = save_expr (arg0);
6260       return fold_build2_loc (loc, EQ_EXPR, type, arg0, arg0);
6261
6262     case EQ_EXPR:
6263     case GE_EXPR:
6264       /* x == +Inf and x >= +Inf are always equal to x > DBL_MAX.  */
6265       real_maxval (&max, neg, mode);
6266       return fold_build2_loc (loc, neg ? LT_EXPR : GT_EXPR, type,
6267                           arg0, build_real (TREE_TYPE (arg0), max));
6268
6269     case LT_EXPR:
6270       /* x < +Inf is always equal to x <= DBL_MAX.  */
6271       real_maxval (&max, neg, mode);
6272       return fold_build2_loc (loc, neg ? GE_EXPR : LE_EXPR, type,
6273                           arg0, build_real (TREE_TYPE (arg0), max));
6274
6275     case NE_EXPR:
6276       /* x != +Inf is always equal to !(x > DBL_MAX).  */
6277       real_maxval (&max, neg, mode);
6278       if (! HONOR_NANS (mode))
6279         return fold_build2_loc (loc, neg ? GE_EXPR : LE_EXPR, type,
6280                             arg0, build_real (TREE_TYPE (arg0), max));
6281
6282       temp = fold_build2_loc (loc, neg ? LT_EXPR : GT_EXPR, type,
6283                           arg0, build_real (TREE_TYPE (arg0), max));
6284       return fold_build1_loc (loc, TRUTH_NOT_EXPR, type, temp);
6285
6286     default:
6287       break;
6288     }
6289
6290   return NULL_TREE;
6291 }
6292
6293 /* Subroutine of fold() that optimizes comparisons of a division by
6294    a nonzero integer constant against an integer constant, i.e.
6295    X/C1 op C2.
6296
6297    CODE is the comparison operator: EQ_EXPR, NE_EXPR, GT_EXPR, LT_EXPR,
6298    GE_EXPR or LE_EXPR.  TYPE is the type of the result and ARG0 and ARG1
6299    are the operands of the comparison.  ARG1 must be a TREE_REAL_CST.
6300
6301    The function returns the constant folded tree if a simplification
6302    can be made, and NULL_TREE otherwise.  */
6303
6304 static tree
6305 fold_div_compare (location_t loc,
6306                   enum tree_code code, tree type, tree arg0, tree arg1)
6307 {
6308   tree prod, tmp, hi, lo;
6309   tree arg00 = TREE_OPERAND (arg0, 0);
6310   tree arg01 = TREE_OPERAND (arg0, 1);
6311   double_int val;
6312   bool unsigned_p = TYPE_UNSIGNED (TREE_TYPE (arg0));
6313   bool neg_overflow;
6314   int overflow;
6315
6316   /* We have to do this the hard way to detect unsigned overflow.
6317      prod = int_const_binop (MULT_EXPR, arg01, arg1);  */
6318   overflow = mul_double_with_sign (TREE_INT_CST_LOW (arg01),
6319                                    TREE_INT_CST_HIGH (arg01),
6320                                    TREE_INT_CST_LOW (arg1),
6321                                    TREE_INT_CST_HIGH (arg1),
6322                                    &val.low, &val.high, unsigned_p);
6323   prod = force_fit_type_double (TREE_TYPE (arg00), val, -1, overflow);
6324   neg_overflow = false;
6325
6326   if (unsigned_p)
6327     {
6328       tmp = int_const_binop (MINUS_EXPR, arg01,
6329                              build_int_cst (TREE_TYPE (arg01), 1));
6330       lo = prod;
6331
6332       /* Likewise hi = int_const_binop (PLUS_EXPR, prod, tmp).  */
6333       overflow = add_double_with_sign (TREE_INT_CST_LOW (prod),
6334                                        TREE_INT_CST_HIGH (prod),
6335                                        TREE_INT_CST_LOW (tmp),
6336                                        TREE_INT_CST_HIGH (tmp),
6337                                        &val.low, &val.high, unsigned_p);
6338       hi = force_fit_type_double (TREE_TYPE (arg00), val,
6339                                   -1, overflow | TREE_OVERFLOW (prod));
6340     }
6341   else if (tree_int_cst_sgn (arg01) >= 0)
6342     {
6343       tmp = int_const_binop (MINUS_EXPR, arg01,
6344                              build_int_cst (TREE_TYPE (arg01), 1));
6345       switch (tree_int_cst_sgn (arg1))
6346         {
6347         case -1:
6348           neg_overflow = true;
6349           lo = int_const_binop (MINUS_EXPR, prod, tmp);
6350           hi = prod;
6351           break;
6352
6353         case  0:
6354           lo = fold_negate_const (tmp, TREE_TYPE (arg0));
6355           hi = tmp;
6356           break;
6357
6358         case  1:
6359           hi = int_const_binop (PLUS_EXPR, prod, tmp);
6360           lo = prod;
6361           break;
6362
6363         default:
6364           gcc_unreachable ();
6365         }
6366     }
6367   else
6368     {
6369       /* A negative divisor reverses the relational operators.  */
6370       code = swap_tree_comparison (code);
6371
6372       tmp = int_const_binop (PLUS_EXPR, arg01,
6373                              build_int_cst (TREE_TYPE (arg01), 1));
6374       switch (tree_int_cst_sgn (arg1))
6375         {
6376         case -1:
6377           hi = int_const_binop (MINUS_EXPR, prod, tmp);
6378           lo = prod;
6379           break;
6380
6381         case  0:
6382           hi = fold_negate_const (tmp, TREE_TYPE (arg0));
6383           lo = tmp;
6384           break;
6385
6386         case  1:
6387           neg_overflow = true;
6388           lo = int_const_binop (PLUS_EXPR, prod, tmp);
6389           hi = prod;
6390           break;
6391
6392         default:
6393           gcc_unreachable ();
6394         }
6395     }
6396
6397   switch (code)
6398     {
6399     case EQ_EXPR:
6400       if (TREE_OVERFLOW (lo) && TREE_OVERFLOW (hi))
6401         return omit_one_operand_loc (loc, type, integer_zero_node, arg00);
6402       if (TREE_OVERFLOW (hi))
6403         return fold_build2_loc (loc, GE_EXPR, type, arg00, lo);
6404       if (TREE_OVERFLOW (lo))
6405         return fold_build2_loc (loc, LE_EXPR, type, arg00, hi);
6406       return build_range_check (loc, type, arg00, 1, lo, hi);
6407
6408     case NE_EXPR:
6409       if (TREE_OVERFLOW (lo) && TREE_OVERFLOW (hi))
6410         return omit_one_operand_loc (loc, type, integer_one_node, arg00);
6411       if (TREE_OVERFLOW (hi))
6412         return fold_build2_loc (loc, LT_EXPR, type, arg00, lo);
6413       if (TREE_OVERFLOW (lo))
6414         return fold_build2_loc (loc, GT_EXPR, type, arg00, hi);
6415       return build_range_check (loc, type, arg00, 0, lo, hi);
6416
6417     case LT_EXPR:
6418       if (TREE_OVERFLOW (lo))
6419         {
6420           tmp = neg_overflow ? integer_zero_node : integer_one_node;
6421           return omit_one_operand_loc (loc, type, tmp, arg00);
6422         }
6423       return fold_build2_loc (loc, LT_EXPR, type, arg00, lo);
6424
6425     case LE_EXPR:
6426       if (TREE_OVERFLOW (hi))
6427         {
6428           tmp = neg_overflow ? integer_zero_node : integer_one_node;
6429           return omit_one_operand_loc (loc, type, tmp, arg00);
6430         }
6431       return fold_build2_loc (loc, LE_EXPR, type, arg00, hi);
6432
6433     case GT_EXPR:
6434       if (TREE_OVERFLOW (hi))
6435         {
6436           tmp = neg_overflow ? integer_one_node : integer_zero_node;
6437           return omit_one_operand_loc (loc, type, tmp, arg00);
6438         }
6439       return fold_build2_loc (loc, GT_EXPR, type, arg00, hi);
6440
6441     case GE_EXPR:
6442       if (TREE_OVERFLOW (lo))
6443         {
6444           tmp = neg_overflow ? integer_one_node : integer_zero_node;
6445           return omit_one_operand_loc (loc, type, tmp, arg00);
6446         }
6447       return fold_build2_loc (loc, GE_EXPR, type, arg00, lo);
6448
6449     default:
6450       break;
6451     }
6452
6453   return NULL_TREE;
6454 }
6455
6456
6457 /* If CODE with arguments ARG0 and ARG1 represents a single bit
6458    equality/inequality test, then return a simplified form of the test
6459    using a sign testing.  Otherwise return NULL.  TYPE is the desired
6460    result type.  */
6461
6462 static tree
6463 fold_single_bit_test_into_sign_test (location_t loc,
6464                                      enum tree_code code, tree arg0, tree arg1,
6465                                      tree result_type)
6466 {
6467   /* If this is testing a single bit, we can optimize the test.  */
6468   if ((code == NE_EXPR || code == EQ_EXPR)
6469       && TREE_CODE (arg0) == BIT_AND_EXPR && integer_zerop (arg1)
6470       && integer_pow2p (TREE_OPERAND (arg0, 1)))
6471     {
6472       /* If we have (A & C) != 0 where C is the sign bit of A, convert
6473          this into A < 0.  Similarly for (A & C) == 0 into A >= 0.  */
6474       tree arg00 = sign_bit_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg0, 1));
6475
6476       if (arg00 != NULL_TREE
6477           /* This is only a win if casting to a signed type is cheap,
6478              i.e. when arg00's type is not a partial mode.  */
6479           && TYPE_PRECISION (TREE_TYPE (arg00))
6480              == GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (arg00))))
6481         {
6482           tree stype = signed_type_for (TREE_TYPE (arg00));
6483           return fold_build2_loc (loc, code == EQ_EXPR ? GE_EXPR : LT_EXPR,
6484                               result_type,
6485                               fold_convert_loc (loc, stype, arg00),
6486                               build_int_cst (stype, 0));
6487         }
6488     }
6489
6490   return NULL_TREE;
6491 }
6492
6493 /* If CODE with arguments ARG0 and ARG1 represents a single bit
6494    equality/inequality test, then return a simplified form of
6495    the test using shifts and logical operations.  Otherwise return
6496    NULL.  TYPE is the desired result type.  */
6497
6498 tree
6499 fold_single_bit_test (location_t loc, enum tree_code code,
6500                       tree arg0, tree arg1, tree result_type)
6501 {
6502   /* If this is testing a single bit, we can optimize the test.  */
6503   if ((code == NE_EXPR || code == EQ_EXPR)
6504       && TREE_CODE (arg0) == BIT_AND_EXPR && integer_zerop (arg1)
6505       && integer_pow2p (TREE_OPERAND (arg0, 1)))
6506     {
6507       tree inner = TREE_OPERAND (arg0, 0);
6508       tree type = TREE_TYPE (arg0);
6509       int bitnum = tree_log2 (TREE_OPERAND (arg0, 1));
6510       enum machine_mode operand_mode = TYPE_MODE (type);
6511       int ops_unsigned;
6512       tree signed_type, unsigned_type, intermediate_type;
6513       tree tem, one;
6514
6515       /* First, see if we can fold the single bit test into a sign-bit
6516          test.  */
6517       tem = fold_single_bit_test_into_sign_test (loc, code, arg0, arg1,
6518                                                  result_type);
6519       if (tem)
6520         return tem;
6521
6522       /* Otherwise we have (A & C) != 0 where C is a single bit,
6523          convert that into ((A >> C2) & 1).  Where C2 = log2(C).
6524          Similarly for (A & C) == 0.  */
6525
6526       /* If INNER is a right shift of a constant and it plus BITNUM does
6527          not overflow, adjust BITNUM and INNER.  */
6528       if (TREE_CODE (inner) == RSHIFT_EXPR
6529           && TREE_CODE (TREE_OPERAND (inner, 1)) == INTEGER_CST
6530           && TREE_INT_CST_HIGH (TREE_OPERAND (inner, 1)) == 0
6531           && bitnum < TYPE_PRECISION (type)
6532           && 0 > compare_tree_int (TREE_OPERAND (inner, 1),
6533                                    bitnum - TYPE_PRECISION (type)))
6534         {
6535           bitnum += TREE_INT_CST_LOW (TREE_OPERAND (inner, 1));
6536           inner = TREE_OPERAND (inner, 0);
6537         }
6538
6539       /* If we are going to be able to omit the AND below, we must do our
6540          operations as unsigned.  If we must use the AND, we have a choice.
6541          Normally unsigned is faster, but for some machines signed is.  */
6542 #ifdef LOAD_EXTEND_OP
6543       ops_unsigned = (LOAD_EXTEND_OP (operand_mode) == SIGN_EXTEND
6544                       && !flag_syntax_only) ? 0 : 1;
6545 #else
6546       ops_unsigned = 1;
6547 #endif
6548
6549       signed_type = lang_hooks.types.type_for_mode (operand_mode, 0);
6550       unsigned_type = lang_hooks.types.type_for_mode (operand_mode, 1);
6551       intermediate_type = ops_unsigned ? unsigned_type : signed_type;
6552       inner = fold_convert_loc (loc, intermediate_type, inner);
6553
6554       if (bitnum != 0)
6555         inner = build2 (RSHIFT_EXPR, intermediate_type,
6556                         inner, size_int (bitnum));
6557
6558       one = build_int_cst (intermediate_type, 1);
6559
6560       if (code == EQ_EXPR)
6561         inner = fold_build2_loc (loc, BIT_XOR_EXPR, intermediate_type, inner, one);
6562
6563       /* Put the AND last so it can combine with more things.  */
6564       inner = build2 (BIT_AND_EXPR, intermediate_type, inner, one);
6565
6566       /* Make sure to return the proper type.  */
6567       inner = fold_convert_loc (loc, result_type, inner);
6568
6569       return inner;
6570     }
6571   return NULL_TREE;
6572 }
6573
6574 /* Check whether we are allowed to reorder operands arg0 and arg1,
6575    such that the evaluation of arg1 occurs before arg0.  */
6576
6577 static bool
6578 reorder_operands_p (const_tree arg0, const_tree arg1)
6579 {
6580   if (! flag_evaluation_order)
6581       return true;
6582   if (TREE_CONSTANT (arg0) || TREE_CONSTANT (arg1))
6583     return true;
6584   return ! TREE_SIDE_EFFECTS (arg0)
6585          && ! TREE_SIDE_EFFECTS (arg1);
6586 }
6587
6588 /* Test whether it is preferable two swap two operands, ARG0 and
6589    ARG1, for example because ARG0 is an integer constant and ARG1
6590    isn't.  If REORDER is true, only recommend swapping if we can
6591    evaluate the operands in reverse order.  */
6592
6593 bool
6594 tree_swap_operands_p (const_tree arg0, const_tree arg1, bool reorder)
6595 {
6596   STRIP_SIGN_NOPS (arg0);
6597   STRIP_SIGN_NOPS (arg1);
6598
6599   if (TREE_CODE (arg1) == INTEGER_CST)
6600     return 0;
6601   if (TREE_CODE (arg0) == INTEGER_CST)
6602     return 1;
6603
6604   if (TREE_CODE (arg1) == REAL_CST)
6605     return 0;
6606   if (TREE_CODE (arg0) == REAL_CST)
6607     return 1;
6608
6609   if (TREE_CODE (arg1) == FIXED_CST)
6610     return 0;
6611   if (TREE_CODE (arg0) == FIXED_CST)
6612     return 1;
6613
6614   if (TREE_CODE (arg1) == COMPLEX_CST)
6615     return 0;
6616   if (TREE_CODE (arg0) == COMPLEX_CST)
6617     return 1;
6618
6619   if (TREE_CONSTANT (arg1))
6620     return 0;
6621   if (TREE_CONSTANT (arg0))
6622     return 1;
6623
6624   if (optimize_function_for_size_p (cfun))
6625     return 0;
6626
6627   if (reorder && flag_evaluation_order
6628       && (TREE_SIDE_EFFECTS (arg0) || TREE_SIDE_EFFECTS (arg1)))
6629     return 0;
6630
6631   /* It is preferable to swap two SSA_NAME to ensure a canonical form
6632      for commutative and comparison operators.  Ensuring a canonical
6633      form allows the optimizers to find additional redundancies without
6634      having to explicitly check for both orderings.  */
6635   if (TREE_CODE (arg0) == SSA_NAME
6636       && TREE_CODE (arg1) == SSA_NAME
6637       && SSA_NAME_VERSION (arg0) > SSA_NAME_VERSION (arg1))
6638     return 1;
6639
6640   /* Put SSA_NAMEs last.  */
6641   if (TREE_CODE (arg1) == SSA_NAME)
6642     return 0;
6643   if (TREE_CODE (arg0) == SSA_NAME)
6644     return 1;
6645
6646   /* Put variables last.  */
6647   if (DECL_P (arg1))
6648     return 0;
6649   if (DECL_P (arg0))
6650     return 1;
6651
6652   return 0;
6653 }
6654
6655 /* Fold comparison ARG0 CODE ARG1 (with result in TYPE), where
6656    ARG0 is extended to a wider type.  */
6657
6658 static tree
6659 fold_widened_comparison (location_t loc, enum tree_code code,
6660                          tree type, tree arg0, tree arg1)
6661 {
6662   tree arg0_unw = get_unwidened (arg0, NULL_TREE);
6663   tree arg1_unw;
6664   tree shorter_type, outer_type;
6665   tree min, max;
6666   bool above, below;
6667
6668   if (arg0_unw == arg0)
6669     return NULL_TREE;
6670   shorter_type = TREE_TYPE (arg0_unw);
6671
6672 #ifdef HAVE_canonicalize_funcptr_for_compare
6673   /* Disable this optimization if we're casting a function pointer
6674      type on targets that require function pointer canonicalization.  */
6675   if (HAVE_canonicalize_funcptr_for_compare
6676       && TREE_CODE (shorter_type) == POINTER_TYPE
6677       && TREE_CODE (TREE_TYPE (shorter_type)) == FUNCTION_TYPE)
6678     return NULL_TREE;
6679 #endif
6680
6681   if (TYPE_PRECISION (TREE_TYPE (arg0)) <= TYPE_PRECISION (shorter_type))
6682     return NULL_TREE;
6683
6684   arg1_unw = get_unwidened (arg1, NULL_TREE);
6685
6686   /* If possible, express the comparison in the shorter mode.  */
6687   if ((code == EQ_EXPR || code == NE_EXPR
6688        || TYPE_UNSIGNED (TREE_TYPE (arg0)) == TYPE_UNSIGNED (shorter_type))
6689       && (TREE_TYPE (arg1_unw) == shorter_type
6690           || ((TYPE_PRECISION (shorter_type)
6691                >= TYPE_PRECISION (TREE_TYPE (arg1_unw)))
6692               && (TYPE_UNSIGNED (shorter_type)
6693                   == TYPE_UNSIGNED (TREE_TYPE (arg1_unw))))
6694           || (TREE_CODE (arg1_unw) == INTEGER_CST
6695               && (TREE_CODE (shorter_type) == INTEGER_TYPE
6696                   || TREE_CODE (shorter_type) == BOOLEAN_TYPE)
6697               && int_fits_type_p (arg1_unw, shorter_type))))
6698     return fold_build2_loc (loc, code, type, arg0_unw,
6699                         fold_convert_loc (loc, shorter_type, arg1_unw));
6700
6701   if (TREE_CODE (arg1_unw) != INTEGER_CST
6702       || TREE_CODE (shorter_type) != INTEGER_TYPE
6703       || !int_fits_type_p (arg1_unw, shorter_type))
6704     return NULL_TREE;
6705
6706   /* If we are comparing with the integer that does not fit into the range
6707      of the shorter type, the result is known.  */
6708   outer_type = TREE_TYPE (arg1_unw);
6709   min = lower_bound_in_type (outer_type, shorter_type);
6710   max = upper_bound_in_type (outer_type, shorter_type);
6711
6712   above = integer_nonzerop (fold_relational_const (LT_EXPR, type,
6713                                                    max, arg1_unw));
6714   below = integer_nonzerop (fold_relational_const (LT_EXPR, type,
6715                                                    arg1_unw, min));
6716
6717   switch (code)
6718     {
6719     case EQ_EXPR:
6720       if (above || below)
6721         return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
6722       break;
6723
6724     case NE_EXPR:
6725       if (above || below)
6726         return omit_one_operand_loc (loc, type, integer_one_node, arg0);
6727       break;
6728
6729     case LT_EXPR:
6730     case LE_EXPR:
6731       if (above)
6732         return omit_one_operand_loc (loc, type, integer_one_node, arg0);
6733       else if (below)
6734         return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
6735
6736     case GT_EXPR:
6737     case GE_EXPR:
6738       if (above)
6739         return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
6740       else if (below)
6741         return omit_one_operand_loc (loc, type, integer_one_node, arg0);
6742
6743     default:
6744       break;
6745     }
6746
6747   return NULL_TREE;
6748 }
6749
6750 /* Fold comparison ARG0 CODE ARG1 (with result in TYPE), where for
6751    ARG0 just the signedness is changed.  */
6752
6753 static tree
6754 fold_sign_changed_comparison (location_t loc, enum tree_code code, tree type,
6755                               tree arg0, tree arg1)
6756 {
6757   tree arg0_inner;
6758   tree inner_type, outer_type;
6759
6760   if (!CONVERT_EXPR_P (arg0))
6761     return NULL_TREE;
6762
6763   outer_type = TREE_TYPE (arg0);
6764   arg0_inner = TREE_OPERAND (arg0, 0);
6765   inner_type = TREE_TYPE (arg0_inner);
6766
6767 #ifdef HAVE_canonicalize_funcptr_for_compare
6768   /* Disable this optimization if we're casting a function pointer
6769      type on targets that require function pointer canonicalization.  */
6770   if (HAVE_canonicalize_funcptr_for_compare
6771       && TREE_CODE (inner_type) == POINTER_TYPE
6772       && TREE_CODE (TREE_TYPE (inner_type)) == FUNCTION_TYPE)
6773     return NULL_TREE;
6774 #endif
6775
6776   if (TYPE_PRECISION (inner_type) != TYPE_PRECISION (outer_type))
6777     return NULL_TREE;
6778
6779   if (TREE_CODE (arg1) != INTEGER_CST
6780       && !(CONVERT_EXPR_P (arg1)
6781            && TREE_TYPE (TREE_OPERAND (arg1, 0)) == inner_type))
6782     return NULL_TREE;
6783
6784   if ((TYPE_UNSIGNED (inner_type) != TYPE_UNSIGNED (outer_type)
6785        || POINTER_TYPE_P (inner_type) != POINTER_TYPE_P (outer_type))
6786       && code != NE_EXPR
6787       && code != EQ_EXPR)
6788     return NULL_TREE;
6789
6790   if (TREE_CODE (arg1) == INTEGER_CST)
6791     arg1 = force_fit_type_double (inner_type, tree_to_double_int (arg1),
6792                                   0, TREE_OVERFLOW (arg1));
6793   else
6794     arg1 = fold_convert_loc (loc, inner_type, arg1);
6795
6796   return fold_build2_loc (loc, code, type, arg0_inner, arg1);
6797 }
6798
6799 /* Tries to replace &a[idx] p+ s * delta with &a[idx + delta], if s is
6800    step of the array.  Reconstructs s and delta in the case of s *
6801    delta being an integer constant (and thus already folded).  ADDR is
6802    the address. MULT is the multiplicative expression.  If the
6803    function succeeds, the new address expression is returned.
6804    Otherwise NULL_TREE is returned.  LOC is the location of the
6805    resulting expression.  */
6806
6807 static tree
6808 try_move_mult_to_index (location_t loc, tree addr, tree op1)
6809 {
6810   tree s, delta, step;
6811   tree ref = TREE_OPERAND (addr, 0), pref;
6812   tree ret, pos;
6813   tree itype;
6814   bool mdim = false;
6815
6816   /*  Strip the nops that might be added when converting op1 to sizetype. */
6817   STRIP_NOPS (op1);
6818
6819   /* Canonicalize op1 into a possibly non-constant delta
6820      and an INTEGER_CST s.  */
6821   if (TREE_CODE (op1) == MULT_EXPR)
6822     {
6823       tree arg0 = TREE_OPERAND (op1, 0), arg1 = TREE_OPERAND (op1, 1);
6824
6825       STRIP_NOPS (arg0);
6826       STRIP_NOPS (arg1);
6827
6828       if (TREE_CODE (arg0) == INTEGER_CST)
6829         {
6830           s = arg0;
6831           delta = arg1;
6832         }
6833       else if (TREE_CODE (arg1) == INTEGER_CST)
6834         {
6835           s = arg1;
6836           delta = arg0;
6837         }
6838       else
6839         return NULL_TREE;
6840     }
6841   else if (TREE_CODE (op1) == INTEGER_CST)
6842     {
6843       delta = op1;
6844       s = NULL_TREE;
6845     }
6846   else
6847     {
6848       /* Simulate we are delta * 1.  */
6849       delta = op1;
6850       s = integer_one_node;
6851     }
6852
6853   /* Handle &x.array the same as we would handle &x.array[0].  */
6854   if (TREE_CODE (ref) == COMPONENT_REF
6855       && TREE_CODE (TREE_TYPE (ref)) == ARRAY_TYPE)
6856     {
6857       tree domain;
6858
6859       /* Remember if this was a multi-dimensional array.  */
6860       if (TREE_CODE (TREE_OPERAND (ref, 0)) == ARRAY_REF)
6861         mdim = true;
6862
6863       domain = TYPE_DOMAIN (TREE_TYPE (ref));
6864       if (! domain)
6865         goto cont;
6866       itype = TREE_TYPE (domain);
6867
6868       step = TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (ref)));
6869       if (TREE_CODE (step) != INTEGER_CST)
6870         goto cont;
6871
6872       if (s)
6873         {
6874           if (! tree_int_cst_equal (step, s))
6875             goto cont;
6876         }
6877       else
6878         {
6879           /* Try if delta is a multiple of step.  */
6880           tree tmp = div_if_zero_remainder (EXACT_DIV_EXPR, op1, step);
6881           if (! tmp)
6882             goto cont;
6883           delta = tmp;
6884         }
6885
6886       /* Only fold here if we can verify we do not overflow one
6887          dimension of a multi-dimensional array.  */
6888       if (mdim)
6889         {
6890           tree tmp;
6891
6892           if (!TYPE_MIN_VALUE (domain)
6893               || !TYPE_MAX_VALUE (domain)
6894               || TREE_CODE (TYPE_MAX_VALUE (domain)) != INTEGER_CST)
6895             goto cont;
6896
6897           tmp = fold_binary_loc (loc, PLUS_EXPR, itype,
6898                                  fold_convert_loc (loc, itype,
6899                                                    TYPE_MIN_VALUE (domain)),
6900                                  fold_convert_loc (loc, itype, delta));
6901           if (TREE_CODE (tmp) != INTEGER_CST
6902               || tree_int_cst_lt (TYPE_MAX_VALUE (domain), tmp))
6903             goto cont;
6904         }
6905
6906       /* We found a suitable component reference.  */
6907
6908       pref = TREE_OPERAND (addr, 0);
6909       ret = copy_node (pref);
6910       SET_EXPR_LOCATION (ret, loc);
6911
6912       ret = build4_loc (loc, ARRAY_REF, TREE_TYPE (TREE_TYPE (ref)), ret,
6913                         fold_build2_loc
6914                           (loc, PLUS_EXPR, itype,
6915                            fold_convert_loc (loc, itype,
6916                                              TYPE_MIN_VALUE
6917                                                (TYPE_DOMAIN (TREE_TYPE (ref)))),
6918                            fold_convert_loc (loc, itype, delta)),
6919                         NULL_TREE, NULL_TREE);
6920       return build_fold_addr_expr_loc (loc, ret);
6921     }
6922
6923 cont:
6924
6925   for (;; ref = TREE_OPERAND (ref, 0))
6926     {
6927       if (TREE_CODE (ref) == ARRAY_REF)
6928         {
6929           tree domain;
6930
6931           /* Remember if this was a multi-dimensional array.  */
6932           if (TREE_CODE (TREE_OPERAND (ref, 0)) == ARRAY_REF)
6933             mdim = true;
6934
6935           domain = TYPE_DOMAIN (TREE_TYPE (TREE_OPERAND (ref, 0)));
6936           if (! domain)
6937             continue;
6938           itype = TREE_TYPE (domain);
6939
6940           step = array_ref_element_size (ref);
6941           if (TREE_CODE (step) != INTEGER_CST)
6942             continue;
6943
6944           if (s)
6945             {
6946               if (! tree_int_cst_equal (step, s))
6947                 continue;
6948             }
6949           else
6950             {
6951               /* Try if delta is a multiple of step.  */
6952               tree tmp = div_if_zero_remainder (EXACT_DIV_EXPR, op1, step);
6953               if (! tmp)
6954                 continue;
6955               delta = tmp;
6956             }
6957
6958           /* Only fold here if we can verify we do not overflow one
6959              dimension of a multi-dimensional array.  */
6960           if (mdim)
6961             {
6962               tree tmp;
6963
6964               if (TREE_CODE (TREE_OPERAND (ref, 1)) != INTEGER_CST
6965                   || !TYPE_MAX_VALUE (domain)
6966                   || TREE_CODE (TYPE_MAX_VALUE (domain)) != INTEGER_CST)
6967                 continue;
6968
6969               tmp = fold_binary_loc (loc, PLUS_EXPR, itype,
6970                                      fold_convert_loc (loc, itype,
6971                                                        TREE_OPERAND (ref, 1)),
6972                                      fold_convert_loc (loc, itype, delta));
6973               if (!tmp
6974                   || TREE_CODE (tmp) != INTEGER_CST
6975                   || tree_int_cst_lt (TYPE_MAX_VALUE (domain), tmp))
6976                 continue;
6977             }
6978
6979           break;
6980         }
6981       else
6982         mdim = false;
6983
6984       if (!handled_component_p (ref))
6985         return NULL_TREE;
6986     }
6987
6988   /* We found the suitable array reference.  So copy everything up to it,
6989      and replace the index.  */
6990
6991   pref = TREE_OPERAND (addr, 0);
6992   ret = copy_node (pref);
6993   SET_EXPR_LOCATION (ret, loc);
6994   pos = ret;
6995
6996   while (pref != ref)
6997     {
6998       pref = TREE_OPERAND (pref, 0);
6999       TREE_OPERAND (pos, 0) = copy_node (pref);
7000       pos = TREE_OPERAND (pos, 0);
7001     }
7002
7003   TREE_OPERAND (pos, 1)
7004     = fold_build2_loc (loc, PLUS_EXPR, itype,
7005                        fold_convert_loc (loc, itype, TREE_OPERAND (pos, 1)),
7006                        fold_convert_loc (loc, itype, delta));
7007   return fold_build1_loc (loc, ADDR_EXPR, TREE_TYPE (addr), ret);
7008 }
7009
7010
7011 /* Fold A < X && A + 1 > Y to A < X && A >= Y.  Normally A + 1 > Y
7012    means A >= Y && A != MAX, but in this case we know that
7013    A < X <= MAX.  INEQ is A + 1 > Y, BOUND is A < X.  */
7014
7015 static tree
7016 fold_to_nonsharp_ineq_using_bound (location_t loc, tree ineq, tree bound)
7017 {
7018   tree a, typea, type = TREE_TYPE (ineq), a1, diff, y;
7019
7020   if (TREE_CODE (bound) == LT_EXPR)
7021     a = TREE_OPERAND (bound, 0);
7022   else if (TREE_CODE (bound) == GT_EXPR)
7023     a = TREE_OPERAND (bound, 1);
7024   else
7025     return NULL_TREE;
7026
7027   typea = TREE_TYPE (a);
7028   if (!INTEGRAL_TYPE_P (typea)
7029       && !POINTER_TYPE_P (typea))
7030     return NULL_TREE;
7031
7032   if (TREE_CODE (ineq) == LT_EXPR)
7033     {
7034       a1 = TREE_OPERAND (ineq, 1);
7035       y = TREE_OPERAND (ineq, 0);
7036     }
7037   else if (TREE_CODE (ineq) == GT_EXPR)
7038     {
7039       a1 = TREE_OPERAND (ineq, 0);
7040       y = TREE_OPERAND (ineq, 1);
7041     }
7042   else
7043     return NULL_TREE;
7044
7045   if (TREE_TYPE (a1) != typea)
7046     return NULL_TREE;
7047
7048   if (POINTER_TYPE_P (typea))
7049     {
7050       /* Convert the pointer types into integer before taking the difference.  */
7051       tree ta = fold_convert_loc (loc, ssizetype, a);
7052       tree ta1 = fold_convert_loc (loc, ssizetype, a1);
7053       diff = fold_binary_loc (loc, MINUS_EXPR, ssizetype, ta1, ta);
7054     }
7055   else
7056     diff = fold_binary_loc (loc, MINUS_EXPR, typea, a1, a);
7057
7058   if (!diff || !integer_onep (diff))
7059    return NULL_TREE;
7060
7061   return fold_build2_loc (loc, GE_EXPR, type, a, y);
7062 }
7063
7064 /* Fold a sum or difference of at least one multiplication.
7065    Returns the folded tree or NULL if no simplification could be made.  */
7066
7067 static tree
7068 fold_plusminus_mult_expr (location_t loc, enum tree_code code, tree type,
7069                           tree arg0, tree arg1)
7070 {
7071   tree arg00, arg01, arg10, arg11;
7072   tree alt0 = NULL_TREE, alt1 = NULL_TREE, same;
7073
7074   /* (A * C) +- (B * C) -> (A+-B) * C.
7075      (A * C) +- A -> A * (C+-1).
7076      We are most concerned about the case where C is a constant,
7077      but other combinations show up during loop reduction.  Since
7078      it is not difficult, try all four possibilities.  */
7079
7080   if (TREE_CODE (arg0) == MULT_EXPR)
7081     {
7082       arg00 = TREE_OPERAND (arg0, 0);
7083       arg01 = TREE_OPERAND (arg0, 1);
7084     }
7085   else if (TREE_CODE (arg0) == INTEGER_CST)
7086     {
7087       arg00 = build_one_cst (type);
7088       arg01 = arg0;
7089     }
7090   else
7091     {
7092       /* We cannot generate constant 1 for fract.  */
7093       if (ALL_FRACT_MODE_P (TYPE_MODE (type)))
7094         return NULL_TREE;
7095       arg00 = arg0;
7096       arg01 = build_one_cst (type);
7097     }
7098   if (TREE_CODE (arg1) == MULT_EXPR)
7099     {
7100       arg10 = TREE_OPERAND (arg1, 0);
7101       arg11 = TREE_OPERAND (arg1, 1);
7102     }
7103   else if (TREE_CODE (arg1) == INTEGER_CST)
7104     {
7105       arg10 = build_one_cst (type);
7106       /* As we canonicalize A - 2 to A + -2 get rid of that sign for
7107          the purpose of this canonicalization.  */
7108       if (TREE_INT_CST_HIGH (arg1) == -1
7109           && negate_expr_p (arg1)
7110           && code == PLUS_EXPR)
7111         {
7112           arg11 = negate_expr (arg1);
7113           code = MINUS_EXPR;
7114         }
7115       else
7116         arg11 = arg1;
7117     }
7118   else
7119     {
7120       /* We cannot generate constant 1 for fract.  */
7121       if (ALL_FRACT_MODE_P (TYPE_MODE (type)))
7122         return NULL_TREE;
7123       arg10 = arg1;
7124       arg11 = build_one_cst (type);
7125     }
7126   same = NULL_TREE;
7127
7128   if (operand_equal_p (arg01, arg11, 0))
7129     same = arg01, alt0 = arg00, alt1 = arg10;
7130   else if (operand_equal_p (arg00, arg10, 0))
7131     same = arg00, alt0 = arg01, alt1 = arg11;
7132   else if (operand_equal_p (arg00, arg11, 0))
7133     same = arg00, alt0 = arg01, alt1 = arg10;
7134   else if (operand_equal_p (arg01, arg10, 0))
7135     same = arg01, alt0 = arg00, alt1 = arg11;
7136
7137   /* No identical multiplicands; see if we can find a common
7138      power-of-two factor in non-power-of-two multiplies.  This
7139      can help in multi-dimensional array access.  */
7140   else if (host_integerp (arg01, 0)
7141            && host_integerp (arg11, 0))
7142     {
7143       HOST_WIDE_INT int01, int11, tmp;
7144       bool swap = false;
7145       tree maybe_same;
7146       int01 = TREE_INT_CST_LOW (arg01);
7147       int11 = TREE_INT_CST_LOW (arg11);
7148
7149       /* Move min of absolute values to int11.  */
7150       if (absu_hwi (int01) < absu_hwi (int11))
7151         {
7152           tmp = int01, int01 = int11, int11 = tmp;
7153           alt0 = arg00, arg00 = arg10, arg10 = alt0;
7154           maybe_same = arg01;
7155           swap = true;
7156         }
7157       else
7158         maybe_same = arg11;
7159
7160       if (exact_log2 (absu_hwi (int11)) > 0 && int01 % int11 == 0
7161           /* The remainder should not be a constant, otherwise we
7162              end up folding i * 4 + 2 to (i * 2 + 1) * 2 which has
7163              increased the number of multiplications necessary.  */
7164           && TREE_CODE (arg10) != INTEGER_CST)
7165         {
7166           alt0 = fold_build2_loc (loc, MULT_EXPR, TREE_TYPE (arg00), arg00,
7167                               build_int_cst (TREE_TYPE (arg00),
7168                                              int01 / int11));
7169           alt1 = arg10;
7170           same = maybe_same;
7171           if (swap)
7172             maybe_same = alt0, alt0 = alt1, alt1 = maybe_same;
7173         }
7174     }
7175
7176   if (same)
7177     return fold_build2_loc (loc, MULT_EXPR, type,
7178                         fold_build2_loc (loc, code, type,
7179                                      fold_convert_loc (loc, type, alt0),
7180                                      fold_convert_loc (loc, type, alt1)),
7181                         fold_convert_loc (loc, type, same));
7182
7183   return NULL_TREE;
7184 }
7185
7186 /* Subroutine of native_encode_expr.  Encode the INTEGER_CST
7187    specified by EXPR into the buffer PTR of length LEN bytes.
7188    Return the number of bytes placed in the buffer, or zero
7189    upon failure.  */
7190
7191 static int
7192 native_encode_int (const_tree expr, unsigned char *ptr, int len)
7193 {
7194   tree type = TREE_TYPE (expr);
7195   int total_bytes = GET_MODE_SIZE (TYPE_MODE (type));
7196   int byte, offset, word, words;
7197   unsigned char value;
7198
7199   if (total_bytes > len)
7200     return 0;
7201   words = total_bytes / UNITS_PER_WORD;
7202
7203   for (byte = 0; byte < total_bytes; byte++)
7204     {
7205       int bitpos = byte * BITS_PER_UNIT;
7206       if (bitpos < HOST_BITS_PER_WIDE_INT)
7207         value = (unsigned char) (TREE_INT_CST_LOW (expr) >> bitpos);
7208       else
7209         value = (unsigned char) (TREE_INT_CST_HIGH (expr)
7210                                  >> (bitpos - HOST_BITS_PER_WIDE_INT));
7211
7212       if (total_bytes > UNITS_PER_WORD)
7213         {
7214           word = byte / UNITS_PER_WORD;
7215           if (WORDS_BIG_ENDIAN)
7216             word = (words - 1) - word;
7217           offset = word * UNITS_PER_WORD;
7218           if (BYTES_BIG_ENDIAN)
7219             offset += (UNITS_PER_WORD - 1) - (byte % UNITS_PER_WORD);
7220           else
7221             offset += byte % UNITS_PER_WORD;
7222         }
7223       else
7224         offset = BYTES_BIG_ENDIAN ? (total_bytes - 1) - byte : byte;
7225       ptr[offset] = value;
7226     }
7227   return total_bytes;
7228 }
7229
7230
7231 /* Subroutine of native_encode_expr.  Encode the REAL_CST
7232    specified by EXPR into the buffer PTR of length LEN bytes.
7233    Return the number of bytes placed in the buffer, or zero
7234    upon failure.  */
7235
7236 static int
7237 native_encode_real (const_tree expr, unsigned char *ptr, int len)
7238 {
7239   tree type = TREE_TYPE (expr);
7240   int total_bytes = GET_MODE_SIZE (TYPE_MODE (type));
7241   int byte, offset, word, words, bitpos;
7242   unsigned char value;
7243
7244   /* There are always 32 bits in each long, no matter the size of
7245      the hosts long.  We handle floating point representations with
7246      up to 192 bits.  */
7247   long tmp[6];
7248
7249   if (total_bytes > len)
7250     return 0;
7251   words = (32 / BITS_PER_UNIT) / UNITS_PER_WORD;
7252
7253   real_to_target (tmp, TREE_REAL_CST_PTR (expr), TYPE_MODE (type));
7254
7255   for (bitpos = 0; bitpos < total_bytes * BITS_PER_UNIT;
7256        bitpos += BITS_PER_UNIT)
7257     {
7258       byte = (bitpos / BITS_PER_UNIT) & 3;
7259       value = (unsigned char) (tmp[bitpos / 32] >> (bitpos & 31));
7260
7261       if (UNITS_PER_WORD < 4)
7262         {
7263           word = byte / UNITS_PER_WORD;
7264           if (WORDS_BIG_ENDIAN)
7265             word = (words - 1) - word;
7266           offset = word * UNITS_PER_WORD;
7267           if (BYTES_BIG_ENDIAN)
7268             offset += (UNITS_PER_WORD - 1) - (byte % UNITS_PER_WORD);
7269           else
7270             offset += byte % UNITS_PER_WORD;
7271         }
7272       else
7273         offset = BYTES_BIG_ENDIAN ? 3 - byte : byte;
7274       ptr[offset + ((bitpos / BITS_PER_UNIT) & ~3)] = value;
7275     }
7276   return total_bytes;
7277 }
7278
7279 /* Subroutine of native_encode_expr.  Encode the COMPLEX_CST
7280    specified by EXPR into the buffer PTR of length LEN bytes.
7281    Return the number of bytes placed in the buffer, or zero
7282    upon failure.  */
7283
7284 static int
7285 native_encode_complex (const_tree expr, unsigned char *ptr, int len)
7286 {
7287   int rsize, isize;
7288   tree part;
7289
7290   part = TREE_REALPART (expr);
7291   rsize = native_encode_expr (part, ptr, len);
7292   if (rsize == 0)
7293     return 0;
7294   part = TREE_IMAGPART (expr);
7295   isize = native_encode_expr (part, ptr+rsize, len-rsize);
7296   if (isize != rsize)
7297     return 0;
7298   return rsize + isize;
7299 }
7300
7301
7302 /* Subroutine of native_encode_expr.  Encode the VECTOR_CST
7303    specified by EXPR into the buffer PTR of length LEN bytes.
7304    Return the number of bytes placed in the buffer, or zero
7305    upon failure.  */
7306
7307 static int
7308 native_encode_vector (const_tree expr, unsigned char *ptr, int len)
7309 {
7310   int i, size, offset, count;
7311   tree itype, elem, elements;
7312
7313   offset = 0;
7314   elements = TREE_VECTOR_CST_ELTS (expr);
7315   count = TYPE_VECTOR_SUBPARTS (TREE_TYPE (expr));
7316   itype = TREE_TYPE (TREE_TYPE (expr));
7317   size = GET_MODE_SIZE (TYPE_MODE (itype));
7318   for (i = 0; i < count; i++)
7319     {
7320       if (elements)
7321         {
7322           elem = TREE_VALUE (elements);
7323           elements = TREE_CHAIN (elements);
7324         }
7325       else
7326         elem = NULL_TREE;
7327
7328       if (elem)
7329         {
7330           if (native_encode_expr (elem, ptr+offset, len-offset) != size)
7331             return 0;
7332         }
7333       else
7334         {
7335           if (offset + size > len)
7336             return 0;
7337           memset (ptr+offset, 0, size);
7338         }
7339       offset += size;
7340     }
7341   return offset;
7342 }
7343
7344
7345 /* Subroutine of native_encode_expr.  Encode the STRING_CST
7346    specified by EXPR into the buffer PTR of length LEN bytes.
7347    Return the number of bytes placed in the buffer, or zero
7348    upon failure.  */
7349
7350 static int
7351 native_encode_string (const_tree expr, unsigned char *ptr, int len)
7352 {
7353   tree type = TREE_TYPE (expr);
7354   HOST_WIDE_INT total_bytes;
7355
7356   if (TREE_CODE (type) != ARRAY_TYPE
7357       || TREE_CODE (TREE_TYPE (type)) != INTEGER_TYPE
7358       || GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (type))) != BITS_PER_UNIT
7359       || !host_integerp (TYPE_SIZE_UNIT (type), 0))
7360     return 0;
7361   total_bytes = tree_low_cst (TYPE_SIZE_UNIT (type), 0);
7362   if (total_bytes > len)
7363     return 0;
7364   if (TREE_STRING_LENGTH (expr) < total_bytes)
7365     {
7366       memcpy (ptr, TREE_STRING_POINTER (expr), TREE_STRING_LENGTH (expr));
7367       memset (ptr + TREE_STRING_LENGTH (expr), 0,
7368               total_bytes - TREE_STRING_LENGTH (expr));
7369     }
7370   else
7371     memcpy (ptr, TREE_STRING_POINTER (expr), total_bytes);
7372   return total_bytes;
7373 }
7374
7375
7376 /* Subroutine of fold_view_convert_expr.  Encode the INTEGER_CST,
7377    REAL_CST, COMPLEX_CST or VECTOR_CST specified by EXPR into the
7378    buffer PTR of length LEN bytes.  Return the number of bytes
7379    placed in the buffer, or zero upon failure.  */
7380
7381 int
7382 native_encode_expr (const_tree expr, unsigned char *ptr, int len)
7383 {
7384   switch (TREE_CODE (expr))
7385     {
7386     case INTEGER_CST:
7387       return native_encode_int (expr, ptr, len);
7388
7389     case REAL_CST:
7390       return native_encode_real (expr, ptr, len);
7391
7392     case COMPLEX_CST:
7393       return native_encode_complex (expr, ptr, len);
7394
7395     case VECTOR_CST:
7396       return native_encode_vector (expr, ptr, len);
7397
7398     case STRING_CST:
7399       return native_encode_string (expr, ptr, len);
7400
7401     default:
7402       return 0;
7403     }
7404 }
7405
7406
7407 /* Subroutine of native_interpret_expr.  Interpret the contents of
7408    the buffer PTR of length LEN as an INTEGER_CST of type TYPE.
7409    If the buffer cannot be interpreted, return NULL_TREE.  */
7410
7411 static tree
7412 native_interpret_int (tree type, const unsigned char *ptr, int len)
7413 {
7414   int total_bytes = GET_MODE_SIZE (TYPE_MODE (type));
7415   int byte, offset, word, words;
7416   unsigned char value;
7417   double_int result;
7418
7419   if (total_bytes > len)
7420     return NULL_TREE;
7421   if (total_bytes * BITS_PER_UNIT > 2 * HOST_BITS_PER_WIDE_INT)
7422     return NULL_TREE;
7423
7424   result = double_int_zero;
7425   words = total_bytes / UNITS_PER_WORD;
7426
7427   for (byte = 0; byte < total_bytes; byte++)
7428     {
7429       int bitpos = byte * BITS_PER_UNIT;
7430       if (total_bytes > UNITS_PER_WORD)
7431         {
7432           word = byte / UNITS_PER_WORD;
7433           if (WORDS_BIG_ENDIAN)
7434             word = (words - 1) - word;
7435           offset = word * UNITS_PER_WORD;
7436           if (BYTES_BIG_ENDIAN)
7437             offset += (UNITS_PER_WORD - 1) - (byte % UNITS_PER_WORD);
7438           else
7439             offset += byte % UNITS_PER_WORD;
7440         }
7441       else
7442         offset = BYTES_BIG_ENDIAN ? (total_bytes - 1) - byte : byte;
7443       value = ptr[offset];
7444
7445       if (bitpos < HOST_BITS_PER_WIDE_INT)
7446         result.low |= (unsigned HOST_WIDE_INT) value << bitpos;
7447       else
7448         result.high |= (unsigned HOST_WIDE_INT) value
7449                        << (bitpos - HOST_BITS_PER_WIDE_INT);
7450     }
7451
7452   return double_int_to_tree (type, result);
7453 }
7454
7455
7456 /* Subroutine of native_interpret_expr.  Interpret the contents of
7457    the buffer PTR of length LEN as a REAL_CST of type TYPE.
7458    If the buffer cannot be interpreted, return NULL_TREE.  */
7459
7460 static tree
7461 native_interpret_real (tree type, const unsigned char *ptr, int len)
7462 {
7463   enum machine_mode mode = TYPE_MODE (type);
7464   int total_bytes = GET_MODE_SIZE (mode);
7465   int byte, offset, word, words, bitpos;
7466   unsigned char value;
7467   /* There are always 32 bits in each long, no matter the size of
7468      the hosts long.  We handle floating point representations with
7469      up to 192 bits.  */
7470   REAL_VALUE_TYPE r;
7471   long tmp[6];
7472
7473   total_bytes = GET_MODE_SIZE (TYPE_MODE (type));
7474   if (total_bytes > len || total_bytes > 24)
7475     return NULL_TREE;
7476   words = (32 / BITS_PER_UNIT) / UNITS_PER_WORD;
7477
7478   memset (tmp, 0, sizeof (tmp));
7479   for (bitpos = 0; bitpos < total_bytes * BITS_PER_UNIT;
7480        bitpos += BITS_PER_UNIT)
7481     {
7482       byte = (bitpos / BITS_PER_UNIT) & 3;
7483       if (UNITS_PER_WORD < 4)
7484         {
7485           word = byte / UNITS_PER_WORD;
7486           if (WORDS_BIG_ENDIAN)
7487             word = (words - 1) - word;
7488           offset = word * UNITS_PER_WORD;
7489           if (BYTES_BIG_ENDIAN)
7490             offset += (UNITS_PER_WORD - 1) - (byte % UNITS_PER_WORD);
7491           else
7492             offset += byte % UNITS_PER_WORD;
7493         }
7494       else
7495         offset = BYTES_BIG_ENDIAN ? 3 - byte : byte;
7496       value = ptr[offset + ((bitpos / BITS_PER_UNIT) & ~3)];
7497
7498       tmp[bitpos / 32] |= (unsigned long)value << (bitpos & 31);
7499     }
7500
7501   real_from_target (&r, tmp, mode);
7502   return build_real (type, r);
7503 }
7504
7505
7506 /* Subroutine of native_interpret_expr.  Interpret the contents of
7507    the buffer PTR of length LEN as a COMPLEX_CST of type TYPE.
7508    If the buffer cannot be interpreted, return NULL_TREE.  */
7509
7510 static tree
7511 native_interpret_complex (tree type, const unsigned char *ptr, int len)
7512 {
7513   tree etype, rpart, ipart;
7514   int size;
7515
7516   etype = TREE_TYPE (type);
7517   size = GET_MODE_SIZE (TYPE_MODE (etype));
7518   if (size * 2 > len)
7519     return NULL_TREE;
7520   rpart = native_interpret_expr (etype, ptr, size);
7521   if (!rpart)
7522     return NULL_TREE;
7523   ipart = native_interpret_expr (etype, ptr+size, size);
7524   if (!ipart)
7525     return NULL_TREE;
7526   return build_complex (type, rpart, ipart);
7527 }
7528
7529
7530 /* Subroutine of native_interpret_expr.  Interpret the contents of
7531    the buffer PTR of length LEN as a VECTOR_CST of type TYPE.
7532    If the buffer cannot be interpreted, return NULL_TREE.  */
7533
7534 static tree
7535 native_interpret_vector (tree type, const unsigned char *ptr, int len)
7536 {
7537   tree etype, elem, elements;
7538   int i, size, count;
7539
7540   etype = TREE_TYPE (type);
7541   size = GET_MODE_SIZE (TYPE_MODE (etype));
7542   count = TYPE_VECTOR_SUBPARTS (type);
7543   if (size * count > len)
7544     return NULL_TREE;
7545
7546   elements = NULL_TREE;
7547   for (i = count - 1; i >= 0; i--)
7548     {
7549       elem = native_interpret_expr (etype, ptr+(i*size), size);
7550       if (!elem)
7551         return NULL_TREE;
7552       elements = tree_cons (NULL_TREE, elem, elements);
7553     }
7554   return build_vector (type, elements);
7555 }
7556
7557
7558 /* Subroutine of fold_view_convert_expr.  Interpret the contents of
7559    the buffer PTR of length LEN as a constant of type TYPE.  For
7560    INTEGRAL_TYPE_P we return an INTEGER_CST, for SCALAR_FLOAT_TYPE_P
7561    we return a REAL_CST, etc...  If the buffer cannot be interpreted,
7562    return NULL_TREE.  */
7563
7564 tree
7565 native_interpret_expr (tree type, const unsigned char *ptr, int len)
7566 {
7567   switch (TREE_CODE (type))
7568     {
7569     case INTEGER_TYPE:
7570     case ENUMERAL_TYPE:
7571     case BOOLEAN_TYPE:
7572       return native_interpret_int (type, ptr, len);
7573
7574     case REAL_TYPE:
7575       return native_interpret_real (type, ptr, len);
7576
7577     case COMPLEX_TYPE:
7578       return native_interpret_complex (type, ptr, len);
7579
7580     case VECTOR_TYPE:
7581       return native_interpret_vector (type, ptr, len);
7582
7583     default:
7584       return NULL_TREE;
7585     }
7586 }
7587
7588
7589 /* Fold a VIEW_CONVERT_EXPR of a constant expression EXPR to type
7590    TYPE at compile-time.  If we're unable to perform the conversion
7591    return NULL_TREE.  */
7592
7593 static tree
7594 fold_view_convert_expr (tree type, tree expr)
7595 {
7596   /* We support up to 512-bit values (for V8DFmode).  */
7597   unsigned char buffer[64];
7598   int len;
7599
7600   /* Check that the host and target are sane.  */
7601   if (CHAR_BIT != 8 || BITS_PER_UNIT != 8)
7602     return NULL_TREE;
7603
7604   len = native_encode_expr (expr, buffer, sizeof (buffer));
7605   if (len == 0)
7606     return NULL_TREE;
7607
7608   return native_interpret_expr (type, buffer, len);
7609 }
7610
7611 /* Build an expression for the address of T.  Folds away INDIRECT_REF
7612    to avoid confusing the gimplify process.  */
7613
7614 tree
7615 build_fold_addr_expr_with_type_loc (location_t loc, tree t, tree ptrtype)
7616 {
7617   /* The size of the object is not relevant when talking about its address.  */
7618   if (TREE_CODE (t) == WITH_SIZE_EXPR)
7619     t = TREE_OPERAND (t, 0);
7620
7621   if (TREE_CODE (t) == INDIRECT_REF)
7622     {
7623       t = TREE_OPERAND (t, 0);
7624
7625       if (TREE_TYPE (t) != ptrtype)
7626         t = build1_loc (loc, NOP_EXPR, ptrtype, t);
7627     }
7628   else if (TREE_CODE (t) == MEM_REF
7629       && integer_zerop (TREE_OPERAND (t, 1)))
7630     return TREE_OPERAND (t, 0);
7631   else if (TREE_CODE (t) == VIEW_CONVERT_EXPR)
7632     {
7633       t = build_fold_addr_expr_loc (loc, TREE_OPERAND (t, 0));
7634
7635       if (TREE_TYPE (t) != ptrtype)
7636         t = fold_convert_loc (loc, ptrtype, t);
7637     }
7638   else
7639     t = build1_loc (loc, ADDR_EXPR, ptrtype, t);
7640
7641   return t;
7642 }
7643
7644 /* Build an expression for the address of T.  */
7645
7646 tree
7647 build_fold_addr_expr_loc (location_t loc, tree t)
7648 {
7649   tree ptrtype = build_pointer_type (TREE_TYPE (t));
7650
7651   return build_fold_addr_expr_with_type_loc (loc, t, ptrtype);
7652 }
7653
7654 static bool vec_cst_ctor_to_array (tree, tree *);
7655
7656 /* Fold a unary expression of code CODE and type TYPE with operand
7657    OP0.  Return the folded expression if folding is successful.
7658    Otherwise, return NULL_TREE.  */
7659
7660 tree
7661 fold_unary_loc (location_t loc, enum tree_code code, tree type, tree op0)
7662 {
7663   tree tem;
7664   tree arg0;
7665   enum tree_code_class kind = TREE_CODE_CLASS (code);
7666
7667   gcc_assert (IS_EXPR_CODE_CLASS (kind)
7668               && TREE_CODE_LENGTH (code) == 1);
7669
7670   arg0 = op0;
7671   if (arg0)
7672     {
7673       if (CONVERT_EXPR_CODE_P (code)
7674           || code == FLOAT_EXPR || code == ABS_EXPR || code == NEGATE_EXPR)
7675         {
7676           /* Don't use STRIP_NOPS, because signedness of argument type
7677              matters.  */
7678           STRIP_SIGN_NOPS (arg0);
7679         }
7680       else
7681         {
7682           /* Strip any conversions that don't change the mode.  This
7683              is safe for every expression, except for a comparison
7684              expression because its signedness is derived from its
7685              operands.
7686
7687              Note that this is done as an internal manipulation within
7688              the constant folder, in order to find the simplest
7689              representation of the arguments so that their form can be
7690              studied.  In any cases, the appropriate type conversions
7691              should be put back in the tree that will get out of the
7692              constant folder.  */
7693           STRIP_NOPS (arg0);
7694         }
7695     }
7696
7697   if (TREE_CODE_CLASS (code) == tcc_unary)
7698     {
7699       if (TREE_CODE (arg0) == COMPOUND_EXPR)
7700         return build2 (COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
7701                        fold_build1_loc (loc, code, type,
7702                                     fold_convert_loc (loc, TREE_TYPE (op0),
7703                                                       TREE_OPERAND (arg0, 1))));
7704       else if (TREE_CODE (arg0) == COND_EXPR)
7705         {
7706           tree arg01 = TREE_OPERAND (arg0, 1);
7707           tree arg02 = TREE_OPERAND (arg0, 2);
7708           if (! VOID_TYPE_P (TREE_TYPE (arg01)))
7709             arg01 = fold_build1_loc (loc, code, type,
7710                                  fold_convert_loc (loc,
7711                                                    TREE_TYPE (op0), arg01));
7712           if (! VOID_TYPE_P (TREE_TYPE (arg02)))
7713             arg02 = fold_build1_loc (loc, code, type,
7714                                  fold_convert_loc (loc,
7715                                                    TREE_TYPE (op0), arg02));
7716           tem = fold_build3_loc (loc, COND_EXPR, type, TREE_OPERAND (arg0, 0),
7717                              arg01, arg02);
7718
7719           /* If this was a conversion, and all we did was to move into
7720              inside the COND_EXPR, bring it back out.  But leave it if
7721              it is a conversion from integer to integer and the
7722              result precision is no wider than a word since such a
7723              conversion is cheap and may be optimized away by combine,
7724              while it couldn't if it were outside the COND_EXPR.  Then return
7725              so we don't get into an infinite recursion loop taking the
7726              conversion out and then back in.  */
7727
7728           if ((CONVERT_EXPR_CODE_P (code)
7729                || code == NON_LVALUE_EXPR)
7730               && TREE_CODE (tem) == COND_EXPR
7731               && TREE_CODE (TREE_OPERAND (tem, 1)) == code
7732               && TREE_CODE (TREE_OPERAND (tem, 2)) == code
7733               && ! VOID_TYPE_P (TREE_OPERAND (tem, 1))
7734               && ! VOID_TYPE_P (TREE_OPERAND (tem, 2))
7735               && (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (tem, 1), 0))
7736                   == TREE_TYPE (TREE_OPERAND (TREE_OPERAND (tem, 2), 0)))
7737               && (! (INTEGRAL_TYPE_P (TREE_TYPE (tem))
7738                      && (INTEGRAL_TYPE_P
7739                          (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (tem, 1), 0))))
7740                      && TYPE_PRECISION (TREE_TYPE (tem)) <= BITS_PER_WORD)
7741                   || flag_syntax_only))
7742             tem = build1_loc (loc, code, type,
7743                               build3 (COND_EXPR,
7744                                       TREE_TYPE (TREE_OPERAND
7745                                                  (TREE_OPERAND (tem, 1), 0)),
7746                                       TREE_OPERAND (tem, 0),
7747                                       TREE_OPERAND (TREE_OPERAND (tem, 1), 0),
7748                                       TREE_OPERAND (TREE_OPERAND (tem, 2),
7749                                                     0)));
7750           return tem;
7751         }
7752    }
7753
7754   switch (code)
7755     {
7756     case PAREN_EXPR:
7757       /* Re-association barriers around constants and other re-association
7758          barriers can be removed.  */
7759       if (CONSTANT_CLASS_P (op0)
7760           || TREE_CODE (op0) == PAREN_EXPR)
7761         return fold_convert_loc (loc, type, op0);
7762       return NULL_TREE;
7763
7764     CASE_CONVERT:
7765     case FLOAT_EXPR:
7766     case FIX_TRUNC_EXPR:
7767       if (TREE_TYPE (op0) == type)
7768         return op0;
7769
7770       if (COMPARISON_CLASS_P (op0))
7771         {
7772           /* If we have (type) (a CMP b) and type is an integral type, return
7773              new expression involving the new type.  Canonicalize
7774              (type) (a CMP b) to (a CMP b) ? (type) true : (type) false for
7775              non-integral type.
7776              Do not fold the result as that would not simplify further, also
7777              folding again results in recursions.  */
7778           if (TREE_CODE (type) == BOOLEAN_TYPE)
7779             return build2_loc (loc, TREE_CODE (op0), type,
7780                                TREE_OPERAND (op0, 0),
7781                                TREE_OPERAND (op0, 1));
7782           else if (!INTEGRAL_TYPE_P (type))
7783             return build3_loc (loc, COND_EXPR, type, op0,
7784                                constant_boolean_node (true, type),
7785                                constant_boolean_node (false, type));
7786         }
7787
7788       /* Handle cases of two conversions in a row.  */
7789       if (CONVERT_EXPR_P (op0))
7790         {
7791           tree inside_type = TREE_TYPE (TREE_OPERAND (op0, 0));
7792           tree inter_type = TREE_TYPE (op0);
7793           int inside_int = INTEGRAL_TYPE_P (inside_type);
7794           int inside_ptr = POINTER_TYPE_P (inside_type);
7795           int inside_float = FLOAT_TYPE_P (inside_type);
7796           int inside_vec = TREE_CODE (inside_type) == VECTOR_TYPE;
7797           unsigned int inside_prec = TYPE_PRECISION (inside_type);
7798           int inside_unsignedp = TYPE_UNSIGNED (inside_type);
7799           int inter_int = INTEGRAL_TYPE_P (inter_type);
7800           int inter_ptr = POINTER_TYPE_P (inter_type);
7801           int inter_float = FLOAT_TYPE_P (inter_type);
7802           int inter_vec = TREE_CODE (inter_type) == VECTOR_TYPE;
7803           unsigned int inter_prec = TYPE_PRECISION (inter_type);
7804           int inter_unsignedp = TYPE_UNSIGNED (inter_type);
7805           int final_int = INTEGRAL_TYPE_P (type);
7806           int final_ptr = POINTER_TYPE_P (type);
7807           int final_float = FLOAT_TYPE_P (type);
7808           int final_vec = TREE_CODE (type) == VECTOR_TYPE;
7809           unsigned int final_prec = TYPE_PRECISION (type);
7810           int final_unsignedp = TYPE_UNSIGNED (type);
7811
7812           /* In addition to the cases of two conversions in a row
7813              handled below, if we are converting something to its own
7814              type via an object of identical or wider precision, neither
7815              conversion is needed.  */
7816           if (TYPE_MAIN_VARIANT (inside_type) == TYPE_MAIN_VARIANT (type)
7817               && (((inter_int || inter_ptr) && final_int)
7818                   || (inter_float && final_float))
7819               && inter_prec >= final_prec)
7820             return fold_build1_loc (loc, code, type, TREE_OPERAND (op0, 0));
7821
7822           /* Likewise, if the intermediate and initial types are either both
7823              float or both integer, we don't need the middle conversion if the
7824              former is wider than the latter and doesn't change the signedness
7825              (for integers).  Avoid this if the final type is a pointer since
7826              then we sometimes need the middle conversion.  Likewise if the
7827              final type has a precision not equal to the size of its mode.  */
7828           if (((inter_int && inside_int)
7829                || (inter_float && inside_float)
7830                || (inter_vec && inside_vec))
7831               && inter_prec >= inside_prec
7832               && (inter_float || inter_vec
7833                   || inter_unsignedp == inside_unsignedp)
7834               && ! (final_prec != GET_MODE_BITSIZE (TYPE_MODE (type))
7835                     && TYPE_MODE (type) == TYPE_MODE (inter_type))
7836               && ! final_ptr
7837               && (! final_vec || inter_prec == inside_prec))
7838             return fold_build1_loc (loc, code, type, TREE_OPERAND (op0, 0));
7839
7840           /* If we have a sign-extension of a zero-extended value, we can
7841              replace that by a single zero-extension.  */
7842           if (inside_int && inter_int && final_int
7843               && inside_prec < inter_prec && inter_prec < final_prec
7844               && inside_unsignedp && !inter_unsignedp)
7845             return fold_build1_loc (loc, code, type, TREE_OPERAND (op0, 0));
7846
7847           /* Two conversions in a row are not needed unless:
7848              - some conversion is floating-point (overstrict for now), or
7849              - some conversion is a vector (overstrict for now), or
7850              - the intermediate type is narrower than both initial and
7851                final, or
7852              - the intermediate type and innermost type differ in signedness,
7853                and the outermost type is wider than the intermediate, or
7854              - the initial type is a pointer type and the precisions of the
7855                intermediate and final types differ, or
7856              - the final type is a pointer type and the precisions of the
7857                initial and intermediate types differ.  */
7858           if (! inside_float && ! inter_float && ! final_float
7859               && ! inside_vec && ! inter_vec && ! final_vec
7860               && (inter_prec >= inside_prec || inter_prec >= final_prec)
7861               && ! (inside_int && inter_int
7862                     && inter_unsignedp != inside_unsignedp
7863                     && inter_prec < final_prec)
7864               && ((inter_unsignedp && inter_prec > inside_prec)
7865                   == (final_unsignedp && final_prec > inter_prec))
7866               && ! (inside_ptr && inter_prec != final_prec)
7867               && ! (final_ptr && inside_prec != inter_prec)
7868               && ! (final_prec != GET_MODE_BITSIZE (TYPE_MODE (type))
7869                     && TYPE_MODE (type) == TYPE_MODE (inter_type)))
7870             return fold_build1_loc (loc, code, type, TREE_OPERAND (op0, 0));
7871         }
7872
7873       /* Handle (T *)&A.B.C for A being of type T and B and C
7874          living at offset zero.  This occurs frequently in
7875          C++ upcasting and then accessing the base.  */
7876       if (TREE_CODE (op0) == ADDR_EXPR
7877           && POINTER_TYPE_P (type)
7878           && handled_component_p (TREE_OPERAND (op0, 0)))
7879         {
7880           HOST_WIDE_INT bitsize, bitpos;
7881           tree offset;
7882           enum machine_mode mode;
7883           int unsignedp, volatilep;
7884           tree base = TREE_OPERAND (op0, 0);
7885           base = get_inner_reference (base, &bitsize, &bitpos, &offset,
7886                                       &mode, &unsignedp, &volatilep, false);
7887           /* If the reference was to a (constant) zero offset, we can use
7888              the address of the base if it has the same base type
7889              as the result type and the pointer type is unqualified.  */
7890           if (! offset && bitpos == 0
7891               && (TYPE_MAIN_VARIANT (TREE_TYPE (type))
7892                   == TYPE_MAIN_VARIANT (TREE_TYPE (base)))
7893               && TYPE_QUALS (type) == TYPE_UNQUALIFIED)
7894             return fold_convert_loc (loc, type,
7895                                      build_fold_addr_expr_loc (loc, base));
7896         }
7897
7898       if (TREE_CODE (op0) == MODIFY_EXPR
7899           && TREE_CONSTANT (TREE_OPERAND (op0, 1))
7900           /* Detect assigning a bitfield.  */
7901           && !(TREE_CODE (TREE_OPERAND (op0, 0)) == COMPONENT_REF
7902                && DECL_BIT_FIELD
7903                (TREE_OPERAND (TREE_OPERAND (op0, 0), 1))))
7904         {
7905           /* Don't leave an assignment inside a conversion
7906              unless assigning a bitfield.  */
7907           tem = fold_build1_loc (loc, code, type, TREE_OPERAND (op0, 1));
7908           /* First do the assignment, then return converted constant.  */
7909           tem = build2_loc (loc, COMPOUND_EXPR, TREE_TYPE (tem), op0, tem);
7910           TREE_NO_WARNING (tem) = 1;
7911           TREE_USED (tem) = 1;
7912           return tem;
7913         }
7914
7915       /* Convert (T)(x & c) into (T)x & (T)c, if c is an integer
7916          constants (if x has signed type, the sign bit cannot be set
7917          in c).  This folds extension into the BIT_AND_EXPR.
7918          ??? We don't do it for BOOLEAN_TYPE or ENUMERAL_TYPE because they
7919          very likely don't have maximal range for their precision and this
7920          transformation effectively doesn't preserve non-maximal ranges.  */
7921       if (TREE_CODE (type) == INTEGER_TYPE
7922           && TREE_CODE (op0) == BIT_AND_EXPR
7923           && TREE_CODE (TREE_OPERAND (op0, 1)) == INTEGER_CST)
7924         {
7925           tree and_expr = op0;
7926           tree and0 = TREE_OPERAND (and_expr, 0);
7927           tree and1 = TREE_OPERAND (and_expr, 1);
7928           int change = 0;
7929
7930           if (TYPE_UNSIGNED (TREE_TYPE (and_expr))
7931               || (TYPE_PRECISION (type)
7932                   <= TYPE_PRECISION (TREE_TYPE (and_expr))))
7933             change = 1;
7934           else if (TYPE_PRECISION (TREE_TYPE (and1))
7935                    <= HOST_BITS_PER_WIDE_INT
7936                    && host_integerp (and1, 1))
7937             {
7938               unsigned HOST_WIDE_INT cst;
7939
7940               cst = tree_low_cst (and1, 1);
7941               cst &= (HOST_WIDE_INT) -1
7942                      << (TYPE_PRECISION (TREE_TYPE (and1)) - 1);
7943               change = (cst == 0);
7944 #ifdef LOAD_EXTEND_OP
7945               if (change
7946                   && !flag_syntax_only
7947                   && (LOAD_EXTEND_OP (TYPE_MODE (TREE_TYPE (and0)))
7948                       == ZERO_EXTEND))
7949                 {
7950                   tree uns = unsigned_type_for (TREE_TYPE (and0));
7951                   and0 = fold_convert_loc (loc, uns, and0);
7952                   and1 = fold_convert_loc (loc, uns, and1);
7953                 }
7954 #endif
7955             }
7956           if (change)
7957             {
7958               tem = force_fit_type_double (type, tree_to_double_int (and1),
7959                                            0, TREE_OVERFLOW (and1));
7960               return fold_build2_loc (loc, BIT_AND_EXPR, type,
7961                                   fold_convert_loc (loc, type, and0), tem);
7962             }
7963         }
7964
7965       /* Convert (T1)(X p+ Y) into ((T1)X p+ Y), for pointer type,
7966          when one of the new casts will fold away. Conservatively we assume
7967          that this happens when X or Y is NOP_EXPR or Y is INTEGER_CST. */
7968       if (POINTER_TYPE_P (type)
7969           && TREE_CODE (arg0) == POINTER_PLUS_EXPR
7970           && (!TYPE_RESTRICT (type) || TYPE_RESTRICT (TREE_TYPE (arg0)))
7971           && (TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
7972               || TREE_CODE (TREE_OPERAND (arg0, 0)) == NOP_EXPR
7973               || TREE_CODE (TREE_OPERAND (arg0, 1)) == NOP_EXPR))
7974         {
7975           tree arg00 = TREE_OPERAND (arg0, 0);
7976           tree arg01 = TREE_OPERAND (arg0, 1);
7977
7978           return fold_build_pointer_plus_loc
7979                    (loc, fold_convert_loc (loc, type, arg00), arg01);
7980         }
7981
7982       /* Convert (T1)(~(T2)X) into ~(T1)X if T1 and T2 are integral types
7983          of the same precision, and X is an integer type not narrower than
7984          types T1 or T2, i.e. the cast (T2)X isn't an extension.  */
7985       if (INTEGRAL_TYPE_P (type)
7986           && TREE_CODE (op0) == BIT_NOT_EXPR
7987           && INTEGRAL_TYPE_P (TREE_TYPE (op0))
7988           && CONVERT_EXPR_P (TREE_OPERAND (op0, 0))
7989           && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (op0)))
7990         {
7991           tem = TREE_OPERAND (TREE_OPERAND (op0, 0), 0);
7992           if (INTEGRAL_TYPE_P (TREE_TYPE (tem))
7993               && TYPE_PRECISION (type) <= TYPE_PRECISION (TREE_TYPE (tem)))
7994             return fold_build1_loc (loc, BIT_NOT_EXPR, type,
7995                                 fold_convert_loc (loc, type, tem));
7996         }
7997
7998       /* Convert (T1)(X * Y) into (T1)X * (T1)Y if T1 is narrower than the
7999          type of X and Y (integer types only).  */
8000       if (INTEGRAL_TYPE_P (type)
8001           && TREE_CODE (op0) == MULT_EXPR
8002           && INTEGRAL_TYPE_P (TREE_TYPE (op0))
8003           && TYPE_PRECISION (type) < TYPE_PRECISION (TREE_TYPE (op0)))
8004         {
8005           /* Be careful not to introduce new overflows.  */
8006           tree mult_type;
8007           if (TYPE_OVERFLOW_WRAPS (type))
8008             mult_type = type;
8009           else
8010             mult_type = unsigned_type_for (type);
8011
8012           if (TYPE_PRECISION (mult_type) < TYPE_PRECISION (TREE_TYPE (op0)))
8013             {
8014               tem = fold_build2_loc (loc, MULT_EXPR, mult_type,
8015                                  fold_convert_loc (loc, mult_type,
8016                                                    TREE_OPERAND (op0, 0)),
8017                                  fold_convert_loc (loc, mult_type,
8018                                                    TREE_OPERAND (op0, 1)));
8019               return fold_convert_loc (loc, type, tem);
8020             }
8021         }
8022
8023       tem = fold_convert_const (code, type, op0);
8024       return tem ? tem : NULL_TREE;
8025
8026     case ADDR_SPACE_CONVERT_EXPR:
8027       if (integer_zerop (arg0))
8028         return fold_convert_const (code, type, arg0);
8029       return NULL_TREE;
8030
8031     case FIXED_CONVERT_EXPR:
8032       tem = fold_convert_const (code, type, arg0);
8033       return tem ? tem : NULL_TREE;
8034
8035     case VIEW_CONVERT_EXPR:
8036       if (TREE_TYPE (op0) == type)
8037         return op0;
8038       if (TREE_CODE (op0) == VIEW_CONVERT_EXPR)
8039         return fold_build1_loc (loc, VIEW_CONVERT_EXPR,
8040                             type, TREE_OPERAND (op0, 0));
8041       if (TREE_CODE (op0) == MEM_REF)
8042         return fold_build2_loc (loc, MEM_REF, type,
8043                                 TREE_OPERAND (op0, 0), TREE_OPERAND (op0, 1));
8044
8045       /* For integral conversions with the same precision or pointer
8046          conversions use a NOP_EXPR instead.  */
8047       if ((INTEGRAL_TYPE_P (type)
8048            || POINTER_TYPE_P (type))
8049           && (INTEGRAL_TYPE_P (TREE_TYPE (op0))
8050               || POINTER_TYPE_P (TREE_TYPE (op0)))
8051           && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (op0)))
8052         return fold_convert_loc (loc, type, op0);
8053
8054       /* Strip inner integral conversions that do not change the precision.  */
8055       if (CONVERT_EXPR_P (op0)
8056           && (INTEGRAL_TYPE_P (TREE_TYPE (op0))
8057               || POINTER_TYPE_P (TREE_TYPE (op0)))
8058           && (INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (op0, 0)))
8059               || POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (op0, 0))))
8060           && (TYPE_PRECISION (TREE_TYPE (op0))
8061               == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op0, 0)))))
8062         return fold_build1_loc (loc, VIEW_CONVERT_EXPR,
8063                             type, TREE_OPERAND (op0, 0));
8064
8065       return fold_view_convert_expr (type, op0);
8066
8067     case NEGATE_EXPR:
8068       tem = fold_negate_expr (loc, arg0);
8069       if (tem)
8070         return fold_convert_loc (loc, type, tem);
8071       return NULL_TREE;
8072
8073     case ABS_EXPR:
8074       if (TREE_CODE (arg0) == INTEGER_CST || TREE_CODE (arg0) == REAL_CST)
8075         return fold_abs_const (arg0, type);
8076       else if (TREE_CODE (arg0) == NEGATE_EXPR)
8077         return fold_build1_loc (loc, ABS_EXPR, type, TREE_OPERAND (arg0, 0));
8078       /* Convert fabs((double)float) into (double)fabsf(float).  */
8079       else if (TREE_CODE (arg0) == NOP_EXPR
8080                && TREE_CODE (type) == REAL_TYPE)
8081         {
8082           tree targ0 = strip_float_extensions (arg0);
8083           if (targ0 != arg0)
8084             return fold_convert_loc (loc, type,
8085                                      fold_build1_loc (loc, ABS_EXPR,
8086                                                   TREE_TYPE (targ0),
8087                                                   targ0));
8088         }
8089       /* ABS_EXPR<ABS_EXPR<x>> = ABS_EXPR<x> even if flag_wrapv is on.  */
8090       else if (TREE_CODE (arg0) == ABS_EXPR)
8091         return arg0;
8092       else if (tree_expr_nonnegative_p (arg0))
8093         return arg0;
8094
8095       /* Strip sign ops from argument.  */
8096       if (TREE_CODE (type) == REAL_TYPE)
8097         {
8098           tem = fold_strip_sign_ops (arg0);
8099           if (tem)
8100             return fold_build1_loc (loc, ABS_EXPR, type,
8101                                 fold_convert_loc (loc, type, tem));
8102         }
8103       return NULL_TREE;
8104
8105     case CONJ_EXPR:
8106       if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
8107         return fold_convert_loc (loc, type, arg0);
8108       if (TREE_CODE (arg0) == COMPLEX_EXPR)
8109         {
8110           tree itype = TREE_TYPE (type);
8111           tree rpart = fold_convert_loc (loc, itype, TREE_OPERAND (arg0, 0));
8112           tree ipart = fold_convert_loc (loc, itype, TREE_OPERAND (arg0, 1));
8113           return fold_build2_loc (loc, COMPLEX_EXPR, type, rpart,
8114                               negate_expr (ipart));
8115         }
8116       if (TREE_CODE (arg0) == COMPLEX_CST)
8117         {
8118           tree itype = TREE_TYPE (type);
8119           tree rpart = fold_convert_loc (loc, itype, TREE_REALPART (arg0));
8120           tree ipart = fold_convert_loc (loc, itype, TREE_IMAGPART (arg0));
8121           return build_complex (type, rpart, negate_expr (ipart));
8122         }
8123       if (TREE_CODE (arg0) == CONJ_EXPR)
8124         return fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
8125       return NULL_TREE;
8126
8127     case BIT_NOT_EXPR:
8128       if (TREE_CODE (arg0) == INTEGER_CST)
8129         return fold_not_const (arg0, type);
8130       else if (TREE_CODE (arg0) == BIT_NOT_EXPR)
8131         return fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
8132       /* Convert ~ (-A) to A - 1.  */
8133       else if (INTEGRAL_TYPE_P (type) && TREE_CODE (arg0) == NEGATE_EXPR)
8134         return fold_build2_loc (loc, MINUS_EXPR, type,
8135                             fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0)),
8136                             build_int_cst (type, 1));
8137       /* Convert ~ (A - 1) or ~ (A + -1) to -A.  */
8138       else if (INTEGRAL_TYPE_P (type)
8139                && ((TREE_CODE (arg0) == MINUS_EXPR
8140                     && integer_onep (TREE_OPERAND (arg0, 1)))
8141                    || (TREE_CODE (arg0) == PLUS_EXPR
8142                        && integer_all_onesp (TREE_OPERAND (arg0, 1)))))
8143         return fold_build1_loc (loc, NEGATE_EXPR, type,
8144                             fold_convert_loc (loc, type,
8145                                               TREE_OPERAND (arg0, 0)));
8146       /* Convert ~(X ^ Y) to ~X ^ Y or X ^ ~Y if ~X or ~Y simplify.  */
8147       else if (TREE_CODE (arg0) == BIT_XOR_EXPR
8148                && (tem = fold_unary_loc (loc, BIT_NOT_EXPR, type,
8149                                      fold_convert_loc (loc, type,
8150                                                        TREE_OPERAND (arg0, 0)))))
8151         return fold_build2_loc (loc, BIT_XOR_EXPR, type, tem,
8152                             fold_convert_loc (loc, type,
8153                                               TREE_OPERAND (arg0, 1)));
8154       else if (TREE_CODE (arg0) == BIT_XOR_EXPR
8155                && (tem = fold_unary_loc (loc, BIT_NOT_EXPR, type,
8156                                      fold_convert_loc (loc, type,
8157                                                        TREE_OPERAND (arg0, 1)))))
8158         return fold_build2_loc (loc, BIT_XOR_EXPR, type,
8159                             fold_convert_loc (loc, type,
8160                                               TREE_OPERAND (arg0, 0)), tem);
8161       /* Perform BIT_NOT_EXPR on each element individually.  */
8162       else if (TREE_CODE (arg0) == VECTOR_CST)
8163         {
8164           tree elements = TREE_VECTOR_CST_ELTS (arg0), elem, list = NULL_TREE;
8165           int count = TYPE_VECTOR_SUBPARTS (type), i;
8166
8167           for (i = 0; i < count; i++)
8168             {
8169               if (elements)
8170                 {
8171                   elem = TREE_VALUE (elements);
8172                   elem = fold_unary_loc (loc, BIT_NOT_EXPR, TREE_TYPE (type), elem);
8173                   if (elem == NULL_TREE)
8174                     break;
8175                   elements = TREE_CHAIN (elements);
8176                 }
8177               else
8178                 elem = build_int_cst (TREE_TYPE (type), -1);
8179               list = tree_cons (NULL_TREE, elem, list);
8180             }
8181           if (i == count)
8182             return build_vector (type, nreverse (list));
8183         }
8184
8185       return NULL_TREE;
8186
8187     case TRUTH_NOT_EXPR:
8188       /* The argument to invert_truthvalue must have Boolean type.  */
8189       if (TREE_CODE (TREE_TYPE (arg0)) != BOOLEAN_TYPE)
8190           arg0 = fold_convert_loc (loc, boolean_type_node, arg0);
8191
8192       /* Note that the operand of this must be an int
8193          and its values must be 0 or 1.
8194          ("true" is a fixed value perhaps depending on the language,
8195          but we don't handle values other than 1 correctly yet.)  */
8196       tem = fold_truth_not_expr (loc, arg0);
8197       if (!tem)
8198         return NULL_TREE;
8199       return fold_convert_loc (loc, type, tem);
8200
8201     case REALPART_EXPR:
8202       if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
8203         return fold_convert_loc (loc, type, arg0);
8204       if (TREE_CODE (arg0) == COMPLEX_EXPR)
8205         return omit_one_operand_loc (loc, type, TREE_OPERAND (arg0, 0),
8206                                  TREE_OPERAND (arg0, 1));
8207       if (TREE_CODE (arg0) == COMPLEX_CST)
8208         return fold_convert_loc (loc, type, TREE_REALPART (arg0));
8209       if (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
8210         {
8211           tree itype = TREE_TYPE (TREE_TYPE (arg0));
8212           tem = fold_build2_loc (loc, TREE_CODE (arg0), itype,
8213                              fold_build1_loc (loc, REALPART_EXPR, itype,
8214                                           TREE_OPERAND (arg0, 0)),
8215                              fold_build1_loc (loc, REALPART_EXPR, itype,
8216                                           TREE_OPERAND (arg0, 1)));
8217           return fold_convert_loc (loc, type, tem);
8218         }
8219       if (TREE_CODE (arg0) == CONJ_EXPR)
8220         {
8221           tree itype = TREE_TYPE (TREE_TYPE (arg0));
8222           tem = fold_build1_loc (loc, REALPART_EXPR, itype,
8223                              TREE_OPERAND (arg0, 0));
8224           return fold_convert_loc (loc, type, tem);
8225         }
8226       if (TREE_CODE (arg0) == CALL_EXPR)
8227         {
8228           tree fn = get_callee_fndecl (arg0);
8229           if (fn && DECL_BUILT_IN_CLASS (fn) == BUILT_IN_NORMAL)
8230             switch (DECL_FUNCTION_CODE (fn))
8231               {
8232               CASE_FLT_FN (BUILT_IN_CEXPI):
8233                 fn = mathfn_built_in (type, BUILT_IN_COS);
8234                 if (fn)
8235                   return build_call_expr_loc (loc, fn, 1, CALL_EXPR_ARG (arg0, 0));
8236                 break;
8237
8238               default:
8239                 break;
8240               }
8241         }
8242       return NULL_TREE;
8243
8244     case IMAGPART_EXPR:
8245       if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
8246         return build_zero_cst (type);
8247       if (TREE_CODE (arg0) == COMPLEX_EXPR)
8248         return omit_one_operand_loc (loc, type, TREE_OPERAND (arg0, 1),
8249                                  TREE_OPERAND (arg0, 0));
8250       if (TREE_CODE (arg0) == COMPLEX_CST)
8251         return fold_convert_loc (loc, type, TREE_IMAGPART (arg0));
8252       if (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
8253         {
8254           tree itype = TREE_TYPE (TREE_TYPE (arg0));
8255           tem = fold_build2_loc (loc, TREE_CODE (arg0), itype,
8256                              fold_build1_loc (loc, IMAGPART_EXPR, itype,
8257                                           TREE_OPERAND (arg0, 0)),
8258                              fold_build1_loc (loc, IMAGPART_EXPR, itype,
8259                                           TREE_OPERAND (arg0, 1)));
8260           return fold_convert_loc (loc, type, tem);
8261         }
8262       if (TREE_CODE (arg0) == CONJ_EXPR)
8263         {
8264           tree itype = TREE_TYPE (TREE_TYPE (arg0));
8265           tem = fold_build1_loc (loc, IMAGPART_EXPR, itype, TREE_OPERAND (arg0, 0));
8266           return fold_convert_loc (loc, type, negate_expr (tem));
8267         }
8268       if (TREE_CODE (arg0) == CALL_EXPR)
8269         {
8270           tree fn = get_callee_fndecl (arg0);
8271           if (fn && DECL_BUILT_IN_CLASS (fn) == BUILT_IN_NORMAL)
8272             switch (DECL_FUNCTION_CODE (fn))
8273               {
8274               CASE_FLT_FN (BUILT_IN_CEXPI):
8275                 fn = mathfn_built_in (type, BUILT_IN_SIN);
8276                 if (fn)
8277                   return build_call_expr_loc (loc, fn, 1, CALL_EXPR_ARG (arg0, 0));
8278                 break;
8279
8280               default:
8281                 break;
8282               }
8283         }
8284       return NULL_TREE;
8285
8286     case INDIRECT_REF:
8287       /* Fold *&X to X if X is an lvalue.  */
8288       if (TREE_CODE (op0) == ADDR_EXPR)
8289         {
8290           tree op00 = TREE_OPERAND (op0, 0);
8291           if ((TREE_CODE (op00) == VAR_DECL
8292                || TREE_CODE (op00) == PARM_DECL
8293                || TREE_CODE (op00) == RESULT_DECL)
8294               && !TREE_READONLY (op00))
8295             return op00;
8296         }
8297       return NULL_TREE;
8298
8299     case VEC_UNPACK_LO_EXPR:
8300     case VEC_UNPACK_HI_EXPR:
8301     case VEC_UNPACK_FLOAT_LO_EXPR:
8302     case VEC_UNPACK_FLOAT_HI_EXPR:
8303       {
8304         unsigned int nelts = TYPE_VECTOR_SUBPARTS (type), i;
8305         tree *elts, vals = NULL_TREE;
8306         enum tree_code subcode;
8307
8308         gcc_assert (TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0)) == nelts * 2);
8309         if (TREE_CODE (arg0) != VECTOR_CST)
8310           return NULL_TREE;
8311
8312         elts = XALLOCAVEC (tree, nelts * 2);
8313         if (!vec_cst_ctor_to_array (arg0, elts))
8314           return NULL_TREE;
8315
8316         if ((!BYTES_BIG_ENDIAN) ^ (code == VEC_UNPACK_LO_EXPR
8317                                    || code == VEC_UNPACK_FLOAT_LO_EXPR))
8318           elts += nelts;
8319
8320         if (code == VEC_UNPACK_LO_EXPR || code == VEC_UNPACK_HI_EXPR)
8321           subcode = NOP_EXPR;
8322         else
8323           subcode = FLOAT_EXPR;
8324
8325         for (i = 0; i < nelts; i++)
8326           {
8327             elts[i] = fold_convert_const (subcode, TREE_TYPE (type), elts[i]);
8328             if (elts[i] == NULL_TREE || !CONSTANT_CLASS_P (elts[i]))
8329               return NULL_TREE;
8330           }
8331
8332         for (i = 0; i < nelts; i++)
8333           vals = tree_cons (NULL_TREE, elts[nelts - i - 1], vals);
8334         return build_vector (type, vals);
8335       }
8336
8337     default:
8338       return NULL_TREE;
8339     } /* switch (code) */
8340 }
8341
8342
8343 /* If the operation was a conversion do _not_ mark a resulting constant
8344    with TREE_OVERFLOW if the original constant was not.  These conversions
8345    have implementation defined behavior and retaining the TREE_OVERFLOW
8346    flag here would confuse later passes such as VRP.  */
8347 tree
8348 fold_unary_ignore_overflow_loc (location_t loc, enum tree_code code,
8349                                 tree type, tree op0)
8350 {
8351   tree res = fold_unary_loc (loc, code, type, op0);
8352   if (res
8353       && TREE_CODE (res) == INTEGER_CST
8354       && TREE_CODE (op0) == INTEGER_CST
8355       && CONVERT_EXPR_CODE_P (code))
8356     TREE_OVERFLOW (res) = TREE_OVERFLOW (op0);
8357
8358   return res;
8359 }
8360
8361 /* Fold a binary bitwise/truth expression of code CODE and type TYPE with
8362    operands OP0 and OP1.  LOC is the location of the resulting expression.
8363    ARG0 and ARG1 are the NOP_STRIPed results of OP0 and OP1.
8364    Return the folded expression if folding is successful.  Otherwise,
8365    return NULL_TREE.  */
8366 static tree
8367 fold_truth_andor (location_t loc, enum tree_code code, tree type,
8368                   tree arg0, tree arg1, tree op0, tree op1)
8369 {
8370   tree tem;
8371
8372   /* We only do these simplifications if we are optimizing.  */
8373   if (!optimize)
8374     return NULL_TREE;
8375
8376   /* Check for things like (A || B) && (A || C).  We can convert this
8377      to A || (B && C).  Note that either operator can be any of the four
8378      truth and/or operations and the transformation will still be
8379      valid.   Also note that we only care about order for the
8380      ANDIF and ORIF operators.  If B contains side effects, this
8381      might change the truth-value of A.  */
8382   if (TREE_CODE (arg0) == TREE_CODE (arg1)
8383       && (TREE_CODE (arg0) == TRUTH_ANDIF_EXPR
8384           || TREE_CODE (arg0) == TRUTH_ORIF_EXPR
8385           || TREE_CODE (arg0) == TRUTH_AND_EXPR
8386           || TREE_CODE (arg0) == TRUTH_OR_EXPR)
8387       && ! TREE_SIDE_EFFECTS (TREE_OPERAND (arg0, 1)))
8388     {
8389       tree a00 = TREE_OPERAND (arg0, 0);
8390       tree a01 = TREE_OPERAND (arg0, 1);
8391       tree a10 = TREE_OPERAND (arg1, 0);
8392       tree a11 = TREE_OPERAND (arg1, 1);
8393       int commutative = ((TREE_CODE (arg0) == TRUTH_OR_EXPR
8394                           || TREE_CODE (arg0) == TRUTH_AND_EXPR)
8395                          && (code == TRUTH_AND_EXPR
8396                              || code == TRUTH_OR_EXPR));
8397
8398       if (operand_equal_p (a00, a10, 0))
8399         return fold_build2_loc (loc, TREE_CODE (arg0), type, a00,
8400                             fold_build2_loc (loc, code, type, a01, a11));
8401       else if (commutative && operand_equal_p (a00, a11, 0))
8402         return fold_build2_loc (loc, TREE_CODE (arg0), type, a00,
8403                             fold_build2_loc (loc, code, type, a01, a10));
8404       else if (commutative && operand_equal_p (a01, a10, 0))
8405         return fold_build2_loc (loc, TREE_CODE (arg0), type, a01,
8406                             fold_build2_loc (loc, code, type, a00, a11));
8407
8408       /* This case if tricky because we must either have commutative
8409          operators or else A10 must not have side-effects.  */
8410
8411       else if ((commutative || ! TREE_SIDE_EFFECTS (a10))
8412                && operand_equal_p (a01, a11, 0))
8413         return fold_build2_loc (loc, TREE_CODE (arg0), type,
8414                             fold_build2_loc (loc, code, type, a00, a10),
8415                             a01);
8416     }
8417
8418   /* See if we can build a range comparison.  */
8419   if (0 != (tem = fold_range_test (loc, code, type, op0, op1)))
8420     return tem;
8421
8422   if ((code == TRUTH_ANDIF_EXPR && TREE_CODE (arg0) == TRUTH_ORIF_EXPR)
8423       || (code == TRUTH_ORIF_EXPR && TREE_CODE (arg0) == TRUTH_ANDIF_EXPR))
8424     {
8425       tem = merge_truthop_with_opposite_arm (loc, arg0, arg1, true);
8426       if (tem)
8427         return fold_build2_loc (loc, code, type, tem, arg1);
8428     }
8429
8430   if ((code == TRUTH_ANDIF_EXPR && TREE_CODE (arg1) == TRUTH_ORIF_EXPR)
8431       || (code == TRUTH_ORIF_EXPR && TREE_CODE (arg1) == TRUTH_ANDIF_EXPR))
8432     {
8433       tem = merge_truthop_with_opposite_arm (loc, arg1, arg0, false);
8434       if (tem)
8435         return fold_build2_loc (loc, code, type, arg0, tem);
8436     }
8437
8438   /* Check for the possibility of merging component references.  If our
8439      lhs is another similar operation, try to merge its rhs with our
8440      rhs.  Then try to merge our lhs and rhs.  */
8441   if (TREE_CODE (arg0) == code
8442       && 0 != (tem = fold_truth_andor_1 (loc, code, type,
8443                                          TREE_OPERAND (arg0, 1), arg1)))
8444     return fold_build2_loc (loc, code, type, TREE_OPERAND (arg0, 0), tem);
8445
8446   if ((tem = fold_truth_andor_1 (loc, code, type, arg0, arg1)) != 0)
8447     return tem;
8448
8449   if ((BRANCH_COST (optimize_function_for_speed_p (cfun),
8450                     false) >= 2)
8451       && LOGICAL_OP_NON_SHORT_CIRCUIT
8452       && (code == TRUTH_AND_EXPR
8453           || code == TRUTH_ANDIF_EXPR
8454           || code == TRUTH_OR_EXPR
8455           || code == TRUTH_ORIF_EXPR))
8456     {
8457       enum tree_code ncode, icode;
8458
8459       ncode = (code == TRUTH_ANDIF_EXPR || code == TRUTH_AND_EXPR)
8460               ? TRUTH_AND_EXPR : TRUTH_OR_EXPR;
8461       icode = ncode == TRUTH_AND_EXPR ? TRUTH_ANDIF_EXPR : TRUTH_ORIF_EXPR;
8462
8463       /* Transform ((A AND-IF B) AND[-IF] C) into (A AND-IF (B AND C)),
8464          or ((A OR-IF B) OR[-IF] C) into (A OR-IF (B OR C))
8465          We don't want to pack more than two leafs to a non-IF AND/OR
8466          expression.
8467          If tree-code of left-hand operand isn't an AND/OR-IF code and not
8468          equal to IF-CODE, then we don't want to add right-hand operand.
8469          If the inner right-hand side of left-hand operand has
8470          side-effects, or isn't simple, then we can't add to it,
8471          as otherwise we might destroy if-sequence.  */
8472       if (TREE_CODE (arg0) == icode
8473           && simple_operand_p_2 (arg1)
8474           /* Needed for sequence points to handle trappings, and
8475              side-effects.  */
8476           && simple_operand_p_2 (TREE_OPERAND (arg0, 1)))
8477         {
8478           tem = fold_build2_loc (loc, ncode, type, TREE_OPERAND (arg0, 1),
8479                                  arg1);
8480           return fold_build2_loc (loc, icode, type, TREE_OPERAND (arg0, 0),
8481                                   tem);
8482         }
8483         /* Same as abouve but for (A AND[-IF] (B AND-IF C)) -> ((A AND B) AND-IF C),
8484            or (A OR[-IF] (B OR-IF C) -> ((A OR B) OR-IF C).  */
8485       else if (TREE_CODE (arg1) == icode
8486           && simple_operand_p_2 (arg0)
8487           /* Needed for sequence points to handle trappings, and
8488              side-effects.  */
8489           && simple_operand_p_2 (TREE_OPERAND (arg1, 0)))
8490         {
8491           tem = fold_build2_loc (loc, ncode, type,
8492                                  arg0, TREE_OPERAND (arg1, 0));
8493           return fold_build2_loc (loc, icode, type, tem,
8494                                   TREE_OPERAND (arg1, 1));
8495         }
8496       /* Transform (A AND-IF B) into (A AND B), or (A OR-IF B)
8497          into (A OR B).
8498          For sequence point consistancy, we need to check for trapping,
8499          and side-effects.  */
8500       else if (code == icode && simple_operand_p_2 (arg0)
8501                && simple_operand_p_2 (arg1))
8502         return fold_build2_loc (loc, ncode, type, arg0, arg1);
8503     }
8504
8505   return NULL_TREE;
8506 }
8507
8508 /* Fold a binary expression of code CODE and type TYPE with operands
8509    OP0 and OP1, containing either a MIN-MAX or a MAX-MIN combination.
8510    Return the folded expression if folding is successful.  Otherwise,
8511    return NULL_TREE.  */
8512
8513 static tree
8514 fold_minmax (location_t loc, enum tree_code code, tree type, tree op0, tree op1)
8515 {
8516   enum tree_code compl_code;
8517
8518   if (code == MIN_EXPR)
8519     compl_code = MAX_EXPR;
8520   else if (code == MAX_EXPR)
8521     compl_code = MIN_EXPR;
8522   else
8523     gcc_unreachable ();
8524
8525   /* MIN (MAX (a, b), b) == b.  */
8526   if (TREE_CODE (op0) == compl_code
8527       && operand_equal_p (TREE_OPERAND (op0, 1), op1, 0))
8528     return omit_one_operand_loc (loc, type, op1, TREE_OPERAND (op0, 0));
8529
8530   /* MIN (MAX (b, a), b) == b.  */
8531   if (TREE_CODE (op0) == compl_code
8532       && operand_equal_p (TREE_OPERAND (op0, 0), op1, 0)
8533       && reorder_operands_p (TREE_OPERAND (op0, 1), op1))
8534     return omit_one_operand_loc (loc, type, op1, TREE_OPERAND (op0, 1));
8535
8536   /* MIN (a, MAX (a, b)) == a.  */
8537   if (TREE_CODE (op1) == compl_code
8538       && operand_equal_p (op0, TREE_OPERAND (op1, 0), 0)
8539       && reorder_operands_p (op0, TREE_OPERAND (op1, 1)))
8540     return omit_one_operand_loc (loc, type, op0, TREE_OPERAND (op1, 1));
8541
8542   /* MIN (a, MAX (b, a)) == a.  */
8543   if (TREE_CODE (op1) == compl_code
8544       && operand_equal_p (op0, TREE_OPERAND (op1, 1), 0)
8545       && reorder_operands_p (op0, TREE_OPERAND (op1, 0)))
8546     return omit_one_operand_loc (loc, type, op0, TREE_OPERAND (op1, 0));
8547
8548   return NULL_TREE;
8549 }
8550
8551 /* Helper that tries to canonicalize the comparison ARG0 CODE ARG1
8552    by changing CODE to reduce the magnitude of constants involved in
8553    ARG0 of the comparison.
8554    Returns a canonicalized comparison tree if a simplification was
8555    possible, otherwise returns NULL_TREE.
8556    Set *STRICT_OVERFLOW_P to true if the canonicalization is only
8557    valid if signed overflow is undefined.  */
8558
8559 static tree
8560 maybe_canonicalize_comparison_1 (location_t loc, enum tree_code code, tree type,
8561                                  tree arg0, tree arg1,
8562                                  bool *strict_overflow_p)
8563 {
8564   enum tree_code code0 = TREE_CODE (arg0);
8565   tree t, cst0 = NULL_TREE;
8566   int sgn0;
8567   bool swap = false;
8568
8569   /* Match A +- CST code arg1 and CST code arg1.  We can change the
8570      first form only if overflow is undefined.  */
8571   if (!((TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg0))
8572          /* In principle pointers also have undefined overflow behavior,
8573             but that causes problems elsewhere.  */
8574          && !POINTER_TYPE_P (TREE_TYPE (arg0))
8575          && (code0 == MINUS_EXPR
8576              || code0 == PLUS_EXPR)
8577          && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
8578         || code0 == INTEGER_CST))
8579     return NULL_TREE;
8580
8581   /* Identify the constant in arg0 and its sign.  */
8582   if (code0 == INTEGER_CST)
8583     cst0 = arg0;
8584   else
8585     cst0 = TREE_OPERAND (arg0, 1);
8586   sgn0 = tree_int_cst_sgn (cst0);
8587
8588   /* Overflowed constants and zero will cause problems.  */
8589   if (integer_zerop (cst0)
8590       || TREE_OVERFLOW (cst0))
8591     return NULL_TREE;
8592
8593   /* See if we can reduce the magnitude of the constant in
8594      arg0 by changing the comparison code.  */
8595   if (code0 == INTEGER_CST)
8596     {
8597       /* CST <= arg1  ->  CST-1 < arg1.  */
8598       if (code == LE_EXPR && sgn0 == 1)
8599         code = LT_EXPR;
8600       /* -CST < arg1  ->  -CST-1 <= arg1.  */
8601       else if (code == LT_EXPR && sgn0 == -1)
8602         code = LE_EXPR;
8603       /* CST > arg1  ->  CST-1 >= arg1.  */
8604       else if (code == GT_EXPR && sgn0 == 1)
8605         code = GE_EXPR;
8606       /* -CST >= arg1  ->  -CST-1 > arg1.  */
8607       else if (code == GE_EXPR && sgn0 == -1)
8608         code = GT_EXPR;
8609       else
8610         return NULL_TREE;
8611       /* arg1 code' CST' might be more canonical.  */
8612       swap = true;
8613     }
8614   else
8615     {
8616       /* A - CST < arg1  ->  A - CST-1 <= arg1.  */
8617       if (code == LT_EXPR
8618           && code0 == ((sgn0 == -1) ? PLUS_EXPR : MINUS_EXPR))
8619         code = LE_EXPR;
8620       /* A + CST > arg1  ->  A + CST-1 >= arg1.  */
8621       else if (code == GT_EXPR
8622                && code0 == ((sgn0 == -1) ? MINUS_EXPR : PLUS_EXPR))
8623         code = GE_EXPR;
8624       /* A + CST <= arg1  ->  A + CST-1 < arg1.  */
8625       else if (code == LE_EXPR
8626                && code0 == ((sgn0 == -1) ? MINUS_EXPR : PLUS_EXPR))
8627         code = LT_EXPR;
8628       /* A - CST >= arg1  ->  A - CST-1 > arg1.  */
8629       else if (code == GE_EXPR
8630                && code0 == ((sgn0 == -1) ? PLUS_EXPR : MINUS_EXPR))
8631         code = GT_EXPR;
8632       else
8633         return NULL_TREE;
8634       *strict_overflow_p = true;
8635     }
8636
8637   /* Now build the constant reduced in magnitude.  But not if that
8638      would produce one outside of its types range.  */
8639   if (INTEGRAL_TYPE_P (TREE_TYPE (cst0))
8640       && ((sgn0 == 1
8641            && TYPE_MIN_VALUE (TREE_TYPE (cst0))
8642            && tree_int_cst_equal (cst0, TYPE_MIN_VALUE (TREE_TYPE (cst0))))
8643           || (sgn0 == -1
8644               && TYPE_MAX_VALUE (TREE_TYPE (cst0))
8645               && tree_int_cst_equal (cst0, TYPE_MAX_VALUE (TREE_TYPE (cst0))))))
8646     /* We cannot swap the comparison here as that would cause us to
8647        endlessly recurse.  */
8648     return NULL_TREE;
8649
8650   t = int_const_binop (sgn0 == -1 ? PLUS_EXPR : MINUS_EXPR,
8651                        cst0, build_int_cst (TREE_TYPE (cst0), 1));
8652   if (code0 != INTEGER_CST)
8653     t = fold_build2_loc (loc, code0, TREE_TYPE (arg0), TREE_OPERAND (arg0, 0), t);
8654   t = fold_convert (TREE_TYPE (arg1), t);
8655
8656   /* If swapping might yield to a more canonical form, do so.  */
8657   if (swap)
8658     return fold_build2_loc (loc, swap_tree_comparison (code), type, arg1, t);
8659   else
8660     return fold_build2_loc (loc, code, type, t, arg1);
8661 }
8662
8663 /* Canonicalize the comparison ARG0 CODE ARG1 with type TYPE with undefined
8664    overflow further.  Try to decrease the magnitude of constants involved
8665    by changing LE_EXPR and GE_EXPR to LT_EXPR and GT_EXPR or vice versa
8666    and put sole constants at the second argument position.
8667    Returns the canonicalized tree if changed, otherwise NULL_TREE.  */
8668
8669 static tree
8670 maybe_canonicalize_comparison (location_t loc, enum tree_code code, tree type,
8671                                tree arg0, tree arg1)
8672 {
8673   tree t;
8674   bool strict_overflow_p;
8675   const char * const warnmsg = G_("assuming signed overflow does not occur "
8676                                   "when reducing constant in comparison");
8677
8678   /* Try canonicalization by simplifying arg0.  */
8679   strict_overflow_p = false;
8680   t = maybe_canonicalize_comparison_1 (loc, code, type, arg0, arg1,
8681                                        &strict_overflow_p);
8682   if (t)
8683     {
8684       if (strict_overflow_p)
8685         fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_MAGNITUDE);
8686       return t;
8687     }
8688
8689   /* Try canonicalization by simplifying arg1 using the swapped
8690      comparison.  */
8691   code = swap_tree_comparison (code);
8692   strict_overflow_p = false;
8693   t = maybe_canonicalize_comparison_1 (loc, code, type, arg1, arg0,
8694                                        &strict_overflow_p);
8695   if (t && strict_overflow_p)
8696     fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_MAGNITUDE);
8697   return t;
8698 }
8699
8700 /* Return whether BASE + OFFSET + BITPOS may wrap around the address
8701    space.  This is used to avoid issuing overflow warnings for
8702    expressions like &p->x which can not wrap.  */
8703
8704 static bool
8705 pointer_may_wrap_p (tree base, tree offset, HOST_WIDE_INT bitpos)
8706 {
8707   unsigned HOST_WIDE_INT offset_low, total_low;
8708   HOST_WIDE_INT size, offset_high, total_high;
8709
8710   if (!POINTER_TYPE_P (TREE_TYPE (base)))
8711     return true;
8712
8713   if (bitpos < 0)
8714     return true;
8715
8716   if (offset == NULL_TREE)
8717     {
8718       offset_low = 0;
8719       offset_high = 0;
8720     }
8721   else if (TREE_CODE (offset) != INTEGER_CST || TREE_OVERFLOW (offset))
8722     return true;
8723   else
8724     {
8725       offset_low = TREE_INT_CST_LOW (offset);
8726       offset_high = TREE_INT_CST_HIGH (offset);
8727     }
8728
8729   if (add_double_with_sign (offset_low, offset_high,
8730                             bitpos / BITS_PER_UNIT, 0,
8731                             &total_low, &total_high,
8732                             true))
8733     return true;
8734
8735   if (total_high != 0)
8736     return true;
8737
8738   size = int_size_in_bytes (TREE_TYPE (TREE_TYPE (base)));
8739   if (size <= 0)
8740     return true;
8741
8742   /* We can do slightly better for SIZE if we have an ADDR_EXPR of an
8743      array.  */
8744   if (TREE_CODE (base) == ADDR_EXPR)
8745     {
8746       HOST_WIDE_INT base_size;
8747
8748       base_size = int_size_in_bytes (TREE_TYPE (TREE_OPERAND (base, 0)));
8749       if (base_size > 0 && size < base_size)
8750         size = base_size;
8751     }
8752
8753   return total_low > (unsigned HOST_WIDE_INT) size;
8754 }
8755
8756 /* Subroutine of fold_binary.  This routine performs all of the
8757    transformations that are common to the equality/inequality
8758    operators (EQ_EXPR and NE_EXPR) and the ordering operators
8759    (LT_EXPR, LE_EXPR, GE_EXPR and GT_EXPR).  Callers other than
8760    fold_binary should call fold_binary.  Fold a comparison with
8761    tree code CODE and type TYPE with operands OP0 and OP1.  Return
8762    the folded comparison or NULL_TREE.  */
8763
8764 static tree
8765 fold_comparison (location_t loc, enum tree_code code, tree type,
8766                  tree op0, tree op1)
8767 {
8768   tree arg0, arg1, tem;
8769
8770   arg0 = op0;
8771   arg1 = op1;
8772
8773   STRIP_SIGN_NOPS (arg0);
8774   STRIP_SIGN_NOPS (arg1);
8775
8776   tem = fold_relational_const (code, type, arg0, arg1);
8777   if (tem != NULL_TREE)
8778     return tem;
8779
8780   /* If one arg is a real or integer constant, put it last.  */
8781   if (tree_swap_operands_p (arg0, arg1, true))
8782     return fold_build2_loc (loc, swap_tree_comparison (code), type, op1, op0);
8783
8784   /* Transform comparisons of the form X +- C1 CMP C2 to X CMP C2 +- C1.  */
8785   if ((TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
8786       && (TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
8787           && !TREE_OVERFLOW (TREE_OPERAND (arg0, 1))
8788           && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
8789       && (TREE_CODE (arg1) == INTEGER_CST
8790           && !TREE_OVERFLOW (arg1)))
8791     {
8792       tree const1 = TREE_OPERAND (arg0, 1);
8793       tree const2 = arg1;
8794       tree variable = TREE_OPERAND (arg0, 0);
8795       tree lhs;
8796       int lhs_add;
8797       lhs_add = TREE_CODE (arg0) != PLUS_EXPR;
8798
8799       lhs = fold_build2_loc (loc, lhs_add ? PLUS_EXPR : MINUS_EXPR,
8800                          TREE_TYPE (arg1), const2, const1);
8801
8802       /* If the constant operation overflowed this can be
8803          simplified as a comparison against INT_MAX/INT_MIN.  */
8804       if (TREE_CODE (lhs) == INTEGER_CST
8805           && TREE_OVERFLOW (lhs))
8806         {
8807           int const1_sgn = tree_int_cst_sgn (const1);
8808           enum tree_code code2 = code;
8809
8810           /* Get the sign of the constant on the lhs if the
8811              operation were VARIABLE + CONST1.  */
8812           if (TREE_CODE (arg0) == MINUS_EXPR)
8813             const1_sgn = -const1_sgn;
8814
8815           /* The sign of the constant determines if we overflowed
8816              INT_MAX (const1_sgn == -1) or INT_MIN (const1_sgn == 1).
8817              Canonicalize to the INT_MIN overflow by swapping the comparison
8818              if necessary.  */
8819           if (const1_sgn == -1)
8820             code2 = swap_tree_comparison (code);
8821
8822           /* We now can look at the canonicalized case
8823                VARIABLE + 1  CODE2  INT_MIN
8824              and decide on the result.  */
8825           if (code2 == LT_EXPR
8826               || code2 == LE_EXPR
8827               || code2 == EQ_EXPR)
8828             return omit_one_operand_loc (loc, type, boolean_false_node, variable);
8829           else if (code2 == NE_EXPR
8830                    || code2 == GE_EXPR
8831                    || code2 == GT_EXPR)
8832             return omit_one_operand_loc (loc, type, boolean_true_node, variable);
8833         }
8834
8835       if (TREE_CODE (lhs) == TREE_CODE (arg1)
8836           && (TREE_CODE (lhs) != INTEGER_CST
8837               || !TREE_OVERFLOW (lhs)))
8838         {
8839           if (code != EQ_EXPR && code != NE_EXPR)
8840             fold_overflow_warning ("assuming signed overflow does not occur "
8841                                    "when changing X +- C1 cmp C2 to "
8842                                    "X cmp C1 +- C2",
8843                                    WARN_STRICT_OVERFLOW_COMPARISON);
8844           return fold_build2_loc (loc, code, type, variable, lhs);
8845         }
8846     }
8847
8848   /* For comparisons of pointers we can decompose it to a compile time
8849      comparison of the base objects and the offsets into the object.
8850      This requires at least one operand being an ADDR_EXPR or a
8851      POINTER_PLUS_EXPR to do more than the operand_equal_p test below.  */
8852   if (POINTER_TYPE_P (TREE_TYPE (arg0))
8853       && (TREE_CODE (arg0) == ADDR_EXPR
8854           || TREE_CODE (arg1) == ADDR_EXPR
8855           || TREE_CODE (arg0) == POINTER_PLUS_EXPR
8856           || TREE_CODE (arg1) == POINTER_PLUS_EXPR))
8857     {
8858       tree base0, base1, offset0 = NULL_TREE, offset1 = NULL_TREE;
8859       HOST_WIDE_INT bitsize, bitpos0 = 0, bitpos1 = 0;
8860       enum machine_mode mode;
8861       int volatilep, unsignedp;
8862       bool indirect_base0 = false, indirect_base1 = false;
8863
8864       /* Get base and offset for the access.  Strip ADDR_EXPR for
8865          get_inner_reference, but put it back by stripping INDIRECT_REF
8866          off the base object if possible.  indirect_baseN will be true
8867          if baseN is not an address but refers to the object itself.  */
8868       base0 = arg0;
8869       if (TREE_CODE (arg0) == ADDR_EXPR)
8870         {
8871           base0 = get_inner_reference (TREE_OPERAND (arg0, 0),
8872                                        &bitsize, &bitpos0, &offset0, &mode,
8873                                        &unsignedp, &volatilep, false);
8874           if (TREE_CODE (base0) == INDIRECT_REF)
8875             base0 = TREE_OPERAND (base0, 0);
8876           else
8877             indirect_base0 = true;
8878         }
8879       else if (TREE_CODE (arg0) == POINTER_PLUS_EXPR)
8880         {
8881           base0 = TREE_OPERAND (arg0, 0);
8882           STRIP_SIGN_NOPS (base0);
8883           if (TREE_CODE (base0) == ADDR_EXPR)
8884             {
8885               base0 = TREE_OPERAND (base0, 0);
8886               indirect_base0 = true;
8887             }
8888           offset0 = TREE_OPERAND (arg0, 1);
8889           if (host_integerp (offset0, 0))
8890             {
8891               HOST_WIDE_INT off = size_low_cst (offset0);
8892               if ((HOST_WIDE_INT) (((unsigned HOST_WIDE_INT) off)
8893                                    * BITS_PER_UNIT)
8894                   / BITS_PER_UNIT == (HOST_WIDE_INT) off)
8895                 {
8896                   bitpos0 = off * BITS_PER_UNIT;
8897                   offset0 = NULL_TREE;
8898                 }
8899             }
8900         }
8901
8902       base1 = arg1;
8903       if (TREE_CODE (arg1) == ADDR_EXPR)
8904         {
8905           base1 = get_inner_reference (TREE_OPERAND (arg1, 0),
8906                                        &bitsize, &bitpos1, &offset1, &mode,
8907                                        &unsignedp, &volatilep, false);
8908           if (TREE_CODE (base1) == INDIRECT_REF)
8909             base1 = TREE_OPERAND (base1, 0);
8910           else
8911             indirect_base1 = true;
8912         }
8913       else if (TREE_CODE (arg1) == POINTER_PLUS_EXPR)
8914         {
8915           base1 = TREE_OPERAND (arg1, 0);
8916           STRIP_SIGN_NOPS (base1);
8917           if (TREE_CODE (base1) == ADDR_EXPR)
8918             {
8919               base1 = TREE_OPERAND (base1, 0);
8920               indirect_base1 = true;
8921             }
8922           offset1 = TREE_OPERAND (arg1, 1);
8923           if (host_integerp (offset1, 0))
8924             {
8925               HOST_WIDE_INT off = size_low_cst (offset1);
8926               if ((HOST_WIDE_INT) (((unsigned HOST_WIDE_INT) off)
8927                                    * BITS_PER_UNIT)
8928                   / BITS_PER_UNIT == (HOST_WIDE_INT) off)
8929                 {
8930                   bitpos1 = off * BITS_PER_UNIT;
8931                   offset1 = NULL_TREE;
8932                 }
8933             }
8934         }
8935
8936       /* A local variable can never be pointed to by
8937          the default SSA name of an incoming parameter.  */
8938       if ((TREE_CODE (arg0) == ADDR_EXPR
8939            && indirect_base0
8940            && TREE_CODE (base0) == VAR_DECL
8941            && auto_var_in_fn_p (base0, current_function_decl)
8942            && !indirect_base1
8943            && TREE_CODE (base1) == SSA_NAME
8944            && TREE_CODE (SSA_NAME_VAR (base1)) == PARM_DECL
8945            && SSA_NAME_IS_DEFAULT_DEF (base1))
8946           || (TREE_CODE (arg1) == ADDR_EXPR
8947               && indirect_base1
8948               && TREE_CODE (base1) == VAR_DECL
8949               && auto_var_in_fn_p (base1, current_function_decl)
8950               && !indirect_base0
8951               && TREE_CODE (base0) == SSA_NAME
8952               && TREE_CODE (SSA_NAME_VAR (base0)) == PARM_DECL
8953               && SSA_NAME_IS_DEFAULT_DEF (base0)))
8954         {
8955           if (code == NE_EXPR)
8956             return constant_boolean_node (1, type);
8957           else if (code == EQ_EXPR)
8958             return constant_boolean_node (0, type);
8959         }
8960       /* If we have equivalent bases we might be able to simplify.  */
8961       else if (indirect_base0 == indirect_base1
8962                && operand_equal_p (base0, base1, 0))
8963         {
8964           /* We can fold this expression to a constant if the non-constant
8965              offset parts are equal.  */
8966           if ((offset0 == offset1
8967                || (offset0 && offset1
8968                    && operand_equal_p (offset0, offset1, 0)))
8969               && (code == EQ_EXPR
8970                   || code == NE_EXPR
8971                   || (indirect_base0 && DECL_P (base0))
8972                   || POINTER_TYPE_OVERFLOW_UNDEFINED))
8973
8974             {
8975               if (code != EQ_EXPR
8976                   && code != NE_EXPR
8977                   && bitpos0 != bitpos1
8978                   && (pointer_may_wrap_p (base0, offset0, bitpos0)
8979                       || pointer_may_wrap_p (base1, offset1, bitpos1)))
8980                 fold_overflow_warning (("assuming pointer wraparound does not "
8981                                         "occur when comparing P +- C1 with "
8982                                         "P +- C2"),
8983                                        WARN_STRICT_OVERFLOW_CONDITIONAL);
8984
8985               switch (code)
8986                 {
8987                 case EQ_EXPR:
8988                   return constant_boolean_node (bitpos0 == bitpos1, type);
8989                 case NE_EXPR:
8990                   return constant_boolean_node (bitpos0 != bitpos1, type);
8991                 case LT_EXPR:
8992                   return constant_boolean_node (bitpos0 < bitpos1, type);
8993                 case LE_EXPR:
8994                   return constant_boolean_node (bitpos0 <= bitpos1, type);
8995                 case GE_EXPR:
8996                   return constant_boolean_node (bitpos0 >= bitpos1, type);
8997                 case GT_EXPR:
8998                   return constant_boolean_node (bitpos0 > bitpos1, type);
8999                 default:;
9000                 }
9001             }
9002           /* We can simplify the comparison to a comparison of the variable
9003              offset parts if the constant offset parts are equal.
9004              Be careful to use signed size type here because otherwise we
9005              mess with array offsets in the wrong way.  This is possible
9006              because pointer arithmetic is restricted to retain within an
9007              object and overflow on pointer differences is undefined as of
9008              6.5.6/8 and /9 with respect to the signed ptrdiff_t.  */
9009           else if (bitpos0 == bitpos1
9010                    && ((code == EQ_EXPR || code == NE_EXPR)
9011                        || (indirect_base0 && DECL_P (base0))
9012                        || POINTER_TYPE_OVERFLOW_UNDEFINED))
9013             {
9014               /* By converting to signed size type we cover middle-end pointer
9015                  arithmetic which operates on unsigned pointer types of size
9016                  type size and ARRAY_REF offsets which are properly sign or
9017                  zero extended from their type in case it is narrower than
9018                  size type.  */
9019               if (offset0 == NULL_TREE)
9020                 offset0 = build_int_cst (ssizetype, 0);
9021               else
9022                 offset0 = fold_convert_loc (loc, ssizetype, offset0);
9023               if (offset1 == NULL_TREE)
9024                 offset1 = build_int_cst (ssizetype, 0);
9025               else
9026                 offset1 = fold_convert_loc (loc, ssizetype, offset1);
9027
9028               if (code != EQ_EXPR
9029                   && code != NE_EXPR
9030                   && (pointer_may_wrap_p (base0, offset0, bitpos0)
9031                       || pointer_may_wrap_p (base1, offset1, bitpos1)))
9032                 fold_overflow_warning (("assuming pointer wraparound does not "
9033                                         "occur when comparing P +- C1 with "
9034                                         "P +- C2"),
9035                                        WARN_STRICT_OVERFLOW_COMPARISON);
9036
9037               return fold_build2_loc (loc, code, type, offset0, offset1);
9038             }
9039         }
9040       /* For non-equal bases we can simplify if they are addresses
9041          of local binding decls or constants.  */
9042       else if (indirect_base0 && indirect_base1
9043                /* We know that !operand_equal_p (base0, base1, 0)
9044                   because the if condition was false.  But make
9045                   sure two decls are not the same.  */
9046                && base0 != base1
9047                && TREE_CODE (arg0) == ADDR_EXPR
9048                && TREE_CODE (arg1) == ADDR_EXPR
9049                && (((TREE_CODE (base0) == VAR_DECL
9050                      || TREE_CODE (base0) == PARM_DECL)
9051                     && (targetm.binds_local_p (base0)
9052                         || CONSTANT_CLASS_P (base1)))
9053                    || CONSTANT_CLASS_P (base0))
9054                && (((TREE_CODE (base1) == VAR_DECL
9055                      || TREE_CODE (base1) == PARM_DECL)
9056                     && (targetm.binds_local_p (base1)
9057                         || CONSTANT_CLASS_P (base0)))
9058                    || CONSTANT_CLASS_P (base1)))
9059         {
9060           if (code == EQ_EXPR)
9061             return omit_two_operands_loc (loc, type, boolean_false_node,
9062                                       arg0, arg1);
9063           else if (code == NE_EXPR)
9064             return omit_two_operands_loc (loc, type, boolean_true_node,
9065                                       arg0, arg1);
9066         }
9067       /* For equal offsets we can simplify to a comparison of the
9068          base addresses.  */
9069       else if (bitpos0 == bitpos1
9070                && (indirect_base0
9071                    ? base0 != TREE_OPERAND (arg0, 0) : base0 != arg0)
9072                && (indirect_base1
9073                    ? base1 != TREE_OPERAND (arg1, 0) : base1 != arg1)
9074                && ((offset0 == offset1)
9075                    || (offset0 && offset1
9076                        && operand_equal_p (offset0, offset1, 0))))
9077         {
9078           if (indirect_base0)
9079             base0 = build_fold_addr_expr_loc (loc, base0);
9080           if (indirect_base1)
9081             base1 = build_fold_addr_expr_loc (loc, base1);
9082           return fold_build2_loc (loc, code, type, base0, base1);
9083         }
9084     }
9085
9086   /* Transform comparisons of the form X +- C1 CMP Y +- C2 to
9087      X CMP Y +- C2 +- C1 for signed X, Y.  This is valid if
9088      the resulting offset is smaller in absolute value than the
9089      original one.  */
9090   if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg0))
9091       && (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
9092       && (TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
9093           && !TREE_OVERFLOW (TREE_OPERAND (arg0, 1)))
9094       && (TREE_CODE (arg1) == PLUS_EXPR || TREE_CODE (arg1) == MINUS_EXPR)
9095       && (TREE_CODE (TREE_OPERAND (arg1, 1)) == INTEGER_CST
9096           && !TREE_OVERFLOW (TREE_OPERAND (arg1, 1))))
9097     {
9098       tree const1 = TREE_OPERAND (arg0, 1);
9099       tree const2 = TREE_OPERAND (arg1, 1);
9100       tree variable1 = TREE_OPERAND (arg0, 0);
9101       tree variable2 = TREE_OPERAND (arg1, 0);
9102       tree cst;
9103       const char * const warnmsg = G_("assuming signed overflow does not "
9104                                       "occur when combining constants around "
9105                                       "a comparison");
9106
9107       /* Put the constant on the side where it doesn't overflow and is
9108          of lower absolute value than before.  */
9109       cst = int_const_binop (TREE_CODE (arg0) == TREE_CODE (arg1)
9110                              ? MINUS_EXPR : PLUS_EXPR,
9111                              const2, const1);
9112       if (!TREE_OVERFLOW (cst)
9113           && tree_int_cst_compare (const2, cst) == tree_int_cst_sgn (const2))
9114         {
9115           fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_COMPARISON);
9116           return fold_build2_loc (loc, code, type,
9117                               variable1,
9118                               fold_build2_loc (loc,
9119                                            TREE_CODE (arg1), TREE_TYPE (arg1),
9120                                            variable2, cst));
9121         }
9122
9123       cst = int_const_binop (TREE_CODE (arg0) == TREE_CODE (arg1)
9124                              ? MINUS_EXPR : PLUS_EXPR,
9125                              const1, const2);
9126       if (!TREE_OVERFLOW (cst)
9127           && tree_int_cst_compare (const1, cst) == tree_int_cst_sgn (const1))
9128         {
9129           fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_COMPARISON);
9130           return fold_build2_loc (loc, code, type,
9131                               fold_build2_loc (loc, TREE_CODE (arg0), TREE_TYPE (arg0),
9132                                            variable1, cst),
9133                               variable2);
9134         }
9135     }
9136
9137   /* Transform comparisons of the form X * C1 CMP 0 to X CMP 0 in the
9138      signed arithmetic case.  That form is created by the compiler
9139      often enough for folding it to be of value.  One example is in
9140      computing loop trip counts after Operator Strength Reduction.  */
9141   if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg0))
9142       && TREE_CODE (arg0) == MULT_EXPR
9143       && (TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
9144           && !TREE_OVERFLOW (TREE_OPERAND (arg0, 1)))
9145       && integer_zerop (arg1))
9146     {
9147       tree const1 = TREE_OPERAND (arg0, 1);
9148       tree const2 = arg1;                       /* zero */
9149       tree variable1 = TREE_OPERAND (arg0, 0);
9150       enum tree_code cmp_code = code;
9151
9152       /* Handle unfolded multiplication by zero.  */
9153       if (integer_zerop (const1))
9154         return fold_build2_loc (loc, cmp_code, type, const1, const2);
9155
9156       fold_overflow_warning (("assuming signed overflow does not occur when "
9157                               "eliminating multiplication in comparison "
9158                               "with zero"),
9159                              WARN_STRICT_OVERFLOW_COMPARISON);
9160
9161       /* If const1 is negative we swap the sense of the comparison.  */
9162       if (tree_int_cst_sgn (const1) < 0)
9163         cmp_code = swap_tree_comparison (cmp_code);
9164
9165       return fold_build2_loc (loc, cmp_code, type, variable1, const2);
9166     }
9167
9168   tem = maybe_canonicalize_comparison (loc, code, type, arg0, arg1);
9169   if (tem)
9170     return tem;
9171
9172   if (FLOAT_TYPE_P (TREE_TYPE (arg0)))
9173     {
9174       tree targ0 = strip_float_extensions (arg0);
9175       tree targ1 = strip_float_extensions (arg1);
9176       tree newtype = TREE_TYPE (targ0);
9177
9178       if (TYPE_PRECISION (TREE_TYPE (targ1)) > TYPE_PRECISION (newtype))
9179         newtype = TREE_TYPE (targ1);
9180
9181       /* Fold (double)float1 CMP (double)float2 into float1 CMP float2.  */
9182       if (TYPE_PRECISION (newtype) < TYPE_PRECISION (TREE_TYPE (arg0)))
9183         return fold_build2_loc (loc, code, type,
9184                             fold_convert_loc (loc, newtype, targ0),
9185                             fold_convert_loc (loc, newtype, targ1));
9186
9187       /* (-a) CMP (-b) -> b CMP a  */
9188       if (TREE_CODE (arg0) == NEGATE_EXPR
9189           && TREE_CODE (arg1) == NEGATE_EXPR)
9190         return fold_build2_loc (loc, code, type, TREE_OPERAND (arg1, 0),
9191                             TREE_OPERAND (arg0, 0));
9192
9193       if (TREE_CODE (arg1) == REAL_CST)
9194         {
9195           REAL_VALUE_TYPE cst;
9196           cst = TREE_REAL_CST (arg1);
9197
9198           /* (-a) CMP CST -> a swap(CMP) (-CST)  */
9199           if (TREE_CODE (arg0) == NEGATE_EXPR)
9200             return fold_build2_loc (loc, swap_tree_comparison (code), type,
9201                                 TREE_OPERAND (arg0, 0),
9202                                 build_real (TREE_TYPE (arg1),
9203                                             real_value_negate (&cst)));
9204
9205           /* IEEE doesn't distinguish +0 and -0 in comparisons.  */
9206           /* a CMP (-0) -> a CMP 0  */
9207           if (REAL_VALUE_MINUS_ZERO (cst))
9208             return fold_build2_loc (loc, code, type, arg0,
9209                                 build_real (TREE_TYPE (arg1), dconst0));
9210
9211           /* x != NaN is always true, other ops are always false.  */
9212           if (REAL_VALUE_ISNAN (cst)
9213               && ! HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg1))))
9214             {
9215               tem = (code == NE_EXPR) ? integer_one_node : integer_zero_node;
9216               return omit_one_operand_loc (loc, type, tem, arg0);
9217             }
9218
9219           /* Fold comparisons against infinity.  */
9220           if (REAL_VALUE_ISINF (cst)
9221               && MODE_HAS_INFINITIES (TYPE_MODE (TREE_TYPE (arg1))))
9222             {
9223               tem = fold_inf_compare (loc, code, type, arg0, arg1);
9224               if (tem != NULL_TREE)
9225                 return tem;
9226             }
9227         }
9228
9229       /* If this is a comparison of a real constant with a PLUS_EXPR
9230          or a MINUS_EXPR of a real constant, we can convert it into a
9231          comparison with a revised real constant as long as no overflow
9232          occurs when unsafe_math_optimizations are enabled.  */
9233       if (flag_unsafe_math_optimizations
9234           && TREE_CODE (arg1) == REAL_CST
9235           && (TREE_CODE (arg0) == PLUS_EXPR
9236               || TREE_CODE (arg0) == MINUS_EXPR)
9237           && TREE_CODE (TREE_OPERAND (arg0, 1)) == REAL_CST
9238           && 0 != (tem = const_binop (TREE_CODE (arg0) == PLUS_EXPR
9239                                       ? MINUS_EXPR : PLUS_EXPR,
9240                                       arg1, TREE_OPERAND (arg0, 1)))
9241           && !TREE_OVERFLOW (tem))
9242         return fold_build2_loc (loc, code, type, TREE_OPERAND (arg0, 0), tem);
9243
9244       /* Likewise, we can simplify a comparison of a real constant with
9245          a MINUS_EXPR whose first operand is also a real constant, i.e.
9246          (c1 - x) < c2 becomes x > c1-c2.  Reordering is allowed on
9247          floating-point types only if -fassociative-math is set.  */
9248       if (flag_associative_math
9249           && TREE_CODE (arg1) == REAL_CST
9250           && TREE_CODE (arg0) == MINUS_EXPR
9251           && TREE_CODE (TREE_OPERAND (arg0, 0)) == REAL_CST
9252           && 0 != (tem = const_binop (MINUS_EXPR, TREE_OPERAND (arg0, 0),
9253                                       arg1))
9254           && !TREE_OVERFLOW (tem))
9255         return fold_build2_loc (loc, swap_tree_comparison (code), type,
9256                             TREE_OPERAND (arg0, 1), tem);
9257
9258       /* Fold comparisons against built-in math functions.  */
9259       if (TREE_CODE (arg1) == REAL_CST
9260           && flag_unsafe_math_optimizations
9261           && ! flag_errno_math)
9262         {
9263           enum built_in_function fcode = builtin_mathfn_code (arg0);
9264
9265           if (fcode != END_BUILTINS)
9266             {
9267               tem = fold_mathfn_compare (loc, fcode, code, type, arg0, arg1);
9268               if (tem != NULL_TREE)
9269                 return tem;
9270             }
9271         }
9272     }
9273
9274   if (TREE_CODE (TREE_TYPE (arg0)) == INTEGER_TYPE
9275       && CONVERT_EXPR_P (arg0))
9276     {
9277       /* If we are widening one operand of an integer comparison,
9278          see if the other operand is similarly being widened.  Perhaps we
9279          can do the comparison in the narrower type.  */
9280       tem = fold_widened_comparison (loc, code, type, arg0, arg1);
9281       if (tem)
9282         return tem;
9283
9284       /* Or if we are changing signedness.  */
9285       tem = fold_sign_changed_comparison (loc, code, type, arg0, arg1);
9286       if (tem)
9287         return tem;
9288     }
9289
9290   /* If this is comparing a constant with a MIN_EXPR or a MAX_EXPR of a
9291      constant, we can simplify it.  */
9292   if (TREE_CODE (arg1) == INTEGER_CST
9293       && (TREE_CODE (arg0) == MIN_EXPR
9294           || TREE_CODE (arg0) == MAX_EXPR)
9295       && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
9296     {
9297       tem = optimize_minmax_comparison (loc, code, type, op0, op1);
9298       if (tem)
9299         return tem;
9300     }
9301
9302   /* Simplify comparison of something with itself.  (For IEEE
9303      floating-point, we can only do some of these simplifications.)  */
9304   if (operand_equal_p (arg0, arg1, 0))
9305     {
9306       switch (code)
9307         {
9308         case EQ_EXPR:
9309           if (! FLOAT_TYPE_P (TREE_TYPE (arg0))
9310               || ! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))))
9311             return constant_boolean_node (1, type);
9312           break;
9313
9314         case GE_EXPR:
9315         case LE_EXPR:
9316           if (! FLOAT_TYPE_P (TREE_TYPE (arg0))
9317               || ! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))))
9318             return constant_boolean_node (1, type);
9319           return fold_build2_loc (loc, EQ_EXPR, type, arg0, arg1);
9320
9321         case NE_EXPR:
9322           /* For NE, we can only do this simplification if integer
9323              or we don't honor IEEE floating point NaNs.  */
9324           if (FLOAT_TYPE_P (TREE_TYPE (arg0))
9325               && HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))))
9326             break;
9327           /* ... fall through ...  */
9328         case GT_EXPR:
9329         case LT_EXPR:
9330           return constant_boolean_node (0, type);
9331         default:
9332           gcc_unreachable ();
9333         }
9334     }
9335
9336   /* If we are comparing an expression that just has comparisons
9337      of two integer values, arithmetic expressions of those comparisons,
9338      and constants, we can simplify it.  There are only three cases
9339      to check: the two values can either be equal, the first can be
9340      greater, or the second can be greater.  Fold the expression for
9341      those three values.  Since each value must be 0 or 1, we have
9342      eight possibilities, each of which corresponds to the constant 0
9343      or 1 or one of the six possible comparisons.
9344
9345      This handles common cases like (a > b) == 0 but also handles
9346      expressions like  ((x > y) - (y > x)) > 0, which supposedly
9347      occur in macroized code.  */
9348
9349   if (TREE_CODE (arg1) == INTEGER_CST && TREE_CODE (arg0) != INTEGER_CST)
9350     {
9351       tree cval1 = 0, cval2 = 0;
9352       int save_p = 0;
9353
9354       if (twoval_comparison_p (arg0, &cval1, &cval2, &save_p)
9355           /* Don't handle degenerate cases here; they should already
9356              have been handled anyway.  */
9357           && cval1 != 0 && cval2 != 0
9358           && ! (TREE_CONSTANT (cval1) && TREE_CONSTANT (cval2))
9359           && TREE_TYPE (cval1) == TREE_TYPE (cval2)
9360           && INTEGRAL_TYPE_P (TREE_TYPE (cval1))
9361           && TYPE_MAX_VALUE (TREE_TYPE (cval1))
9362           && TYPE_MAX_VALUE (TREE_TYPE (cval2))
9363           && ! operand_equal_p (TYPE_MIN_VALUE (TREE_TYPE (cval1)),
9364                                 TYPE_MAX_VALUE (TREE_TYPE (cval2)), 0))
9365         {
9366           tree maxval = TYPE_MAX_VALUE (TREE_TYPE (cval1));
9367           tree minval = TYPE_MIN_VALUE (TREE_TYPE (cval1));
9368
9369           /* We can't just pass T to eval_subst in case cval1 or cval2
9370              was the same as ARG1.  */
9371
9372           tree high_result
9373                 = fold_build2_loc (loc, code, type,
9374                                eval_subst (loc, arg0, cval1, maxval,
9375                                            cval2, minval),
9376                                arg1);
9377           tree equal_result
9378                 = fold_build2_loc (loc, code, type,
9379                                eval_subst (loc, arg0, cval1, maxval,
9380                                            cval2, maxval),
9381                                arg1);
9382           tree low_result
9383                 = fold_build2_loc (loc, code, type,
9384                                eval_subst (loc, arg0, cval1, minval,
9385                                            cval2, maxval),
9386                                arg1);
9387
9388           /* All three of these results should be 0 or 1.  Confirm they are.
9389              Then use those values to select the proper code to use.  */
9390
9391           if (TREE_CODE (high_result) == INTEGER_CST
9392               && TREE_CODE (equal_result) == INTEGER_CST
9393               && TREE_CODE (low_result) == INTEGER_CST)
9394             {
9395               /* Make a 3-bit mask with the high-order bit being the
9396                  value for `>', the next for '=', and the low for '<'.  */
9397               switch ((integer_onep (high_result) * 4)
9398                       + (integer_onep (equal_result) * 2)
9399                       + integer_onep (low_result))
9400                 {
9401                 case 0:
9402                   /* Always false.  */
9403                   return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
9404                 case 1:
9405                   code = LT_EXPR;
9406                   break;
9407                 case 2:
9408                   code = EQ_EXPR;
9409                   break;
9410                 case 3:
9411                   code = LE_EXPR;
9412                   break;
9413                 case 4:
9414                   code = GT_EXPR;
9415                   break;
9416                 case 5:
9417                   code = NE_EXPR;
9418                   break;
9419                 case 6:
9420                   code = GE_EXPR;
9421                   break;
9422                 case 7:
9423                   /* Always true.  */
9424                   return omit_one_operand_loc (loc, type, integer_one_node, arg0);
9425                 }
9426
9427               if (save_p)
9428                 {
9429                   tem = save_expr (build2 (code, type, cval1, cval2));
9430                   SET_EXPR_LOCATION (tem, loc);
9431                   return tem;
9432                 }
9433               return fold_build2_loc (loc, code, type, cval1, cval2);
9434             }
9435         }
9436     }
9437
9438   /* We can fold X/C1 op C2 where C1 and C2 are integer constants
9439      into a single range test.  */
9440   if ((TREE_CODE (arg0) == TRUNC_DIV_EXPR
9441        || TREE_CODE (arg0) == EXACT_DIV_EXPR)
9442       && TREE_CODE (arg1) == INTEGER_CST
9443       && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
9444       && !integer_zerop (TREE_OPERAND (arg0, 1))
9445       && !TREE_OVERFLOW (TREE_OPERAND (arg0, 1))
9446       && !TREE_OVERFLOW (arg1))
9447     {
9448       tem = fold_div_compare (loc, code, type, arg0, arg1);
9449       if (tem != NULL_TREE)
9450         return tem;
9451     }
9452
9453   /* Fold ~X op ~Y as Y op X.  */
9454   if (TREE_CODE (arg0) == BIT_NOT_EXPR
9455       && TREE_CODE (arg1) == BIT_NOT_EXPR)
9456     {
9457       tree cmp_type = TREE_TYPE (TREE_OPERAND (arg0, 0));
9458       return fold_build2_loc (loc, code, type,
9459                           fold_convert_loc (loc, cmp_type,
9460                                             TREE_OPERAND (arg1, 0)),
9461                           TREE_OPERAND (arg0, 0));
9462     }
9463
9464   /* Fold ~X op C as X op' ~C, where op' is the swapped comparison.  */
9465   if (TREE_CODE (arg0) == BIT_NOT_EXPR
9466       && TREE_CODE (arg1) == INTEGER_CST)
9467     {
9468       tree cmp_type = TREE_TYPE (TREE_OPERAND (arg0, 0));
9469       return fold_build2_loc (loc, swap_tree_comparison (code), type,
9470                           TREE_OPERAND (arg0, 0),
9471                           fold_build1_loc (loc, BIT_NOT_EXPR, cmp_type,
9472                                        fold_convert_loc (loc, cmp_type, arg1)));
9473     }
9474
9475   return NULL_TREE;
9476 }
9477
9478
9479 /* Subroutine of fold_binary.  Optimize complex multiplications of the
9480    form z * conj(z), as pow(realpart(z),2) + pow(imagpart(z),2).  The
9481    argument EXPR represents the expression "z" of type TYPE.  */
9482
9483 static tree
9484 fold_mult_zconjz (location_t loc, tree type, tree expr)
9485 {
9486   tree itype = TREE_TYPE (type);
9487   tree rpart, ipart, tem;
9488
9489   if (TREE_CODE (expr) == COMPLEX_EXPR)
9490     {
9491       rpart = TREE_OPERAND (expr, 0);
9492       ipart = TREE_OPERAND (expr, 1);
9493     }
9494   else if (TREE_CODE (expr) == COMPLEX_CST)
9495     {
9496       rpart = TREE_REALPART (expr);
9497       ipart = TREE_IMAGPART (expr);
9498     }
9499   else
9500     {
9501       expr = save_expr (expr);
9502       rpart = fold_build1_loc (loc, REALPART_EXPR, itype, expr);
9503       ipart = fold_build1_loc (loc, IMAGPART_EXPR, itype, expr);
9504     }
9505
9506   rpart = save_expr (rpart);
9507   ipart = save_expr (ipart);
9508   tem = fold_build2_loc (loc, PLUS_EXPR, itype,
9509                      fold_build2_loc (loc, MULT_EXPR, itype, rpart, rpart),
9510                      fold_build2_loc (loc, MULT_EXPR, itype, ipart, ipart));
9511   return fold_build2_loc (loc, COMPLEX_EXPR, type, tem,
9512                           build_zero_cst (itype));
9513 }
9514
9515
9516 /* Subroutine of fold_binary.  If P is the value of EXPR, computes
9517    power-of-two M and (arbitrary) N such that M divides (P-N).  This condition
9518    guarantees that P and N have the same least significant log2(M) bits.
9519    N is not otherwise constrained.  In particular, N is not normalized to
9520    0 <= N < M as is common.  In general, the precise value of P is unknown.
9521    M is chosen as large as possible such that constant N can be determined.
9522
9523    Returns M and sets *RESIDUE to N.
9524
9525    If ALLOW_FUNC_ALIGN is true, do take functions' DECL_ALIGN_UNIT into
9526    account.  This is not always possible due to PR 35705.
9527  */
9528
9529 static unsigned HOST_WIDE_INT
9530 get_pointer_modulus_and_residue (tree expr, unsigned HOST_WIDE_INT *residue,
9531                                  bool allow_func_align)
9532 {
9533   enum tree_code code;
9534
9535   *residue = 0;
9536
9537   code = TREE_CODE (expr);
9538   if (code == ADDR_EXPR)
9539     {
9540       unsigned int bitalign;
9541       bitalign = get_object_alignment_1 (TREE_OPERAND (expr, 0), residue);
9542       *residue /= BITS_PER_UNIT;
9543       return bitalign / BITS_PER_UNIT;
9544     }
9545   else if (code == POINTER_PLUS_EXPR)
9546     {
9547       tree op0, op1;
9548       unsigned HOST_WIDE_INT modulus;
9549       enum tree_code inner_code;
9550
9551       op0 = TREE_OPERAND (expr, 0);
9552       STRIP_NOPS (op0);
9553       modulus = get_pointer_modulus_and_residue (op0, residue,
9554                                                  allow_func_align);
9555
9556       op1 = TREE_OPERAND (expr, 1);
9557       STRIP_NOPS (op1);
9558       inner_code = TREE_CODE (op1);
9559       if (inner_code == INTEGER_CST)
9560         {
9561           *residue += TREE_INT_CST_LOW (op1);
9562           return modulus;
9563         }
9564       else if (inner_code == MULT_EXPR)
9565         {
9566           op1 = TREE_OPERAND (op1, 1);
9567           if (TREE_CODE (op1) == INTEGER_CST)
9568             {
9569               unsigned HOST_WIDE_INT align;
9570
9571               /* Compute the greatest power-of-2 divisor of op1.  */
9572               align = TREE_INT_CST_LOW (op1);
9573               align &= -align;
9574
9575               /* If align is non-zero and less than *modulus, replace
9576                  *modulus with align., If align is 0, then either op1 is 0
9577                  or the greatest power-of-2 divisor of op1 doesn't fit in an
9578                  unsigned HOST_WIDE_INT.  In either case, no additional
9579                  constraint is imposed.  */
9580               if (align)
9581                 modulus = MIN (modulus, align);
9582
9583               return modulus;
9584             }
9585         }
9586     }
9587
9588   /* If we get here, we were unable to determine anything useful about the
9589      expression.  */
9590   return 1;
9591 }
9592
9593 /* Helper function for fold_vec_perm.  Store elements of VECTOR_CST or
9594    CONSTRUCTOR ARG into array ELTS and return true if successful.  */
9595
9596 static bool
9597 vec_cst_ctor_to_array (tree arg, tree *elts)
9598 {
9599   unsigned int nelts = TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg)), i;
9600
9601   if (TREE_CODE (arg) == VECTOR_CST)
9602     {
9603       tree t;
9604
9605       for (i = 0, t = TREE_VECTOR_CST_ELTS (arg);
9606            i < nelts && t; i++, t = TREE_CHAIN (t))
9607         elts[i] = TREE_VALUE (t);
9608       if (t)
9609         return false;
9610     }
9611   else if (TREE_CODE (arg) == CONSTRUCTOR)
9612     {
9613       constructor_elt *elt;
9614
9615       FOR_EACH_VEC_ELT (constructor_elt, CONSTRUCTOR_ELTS (arg), i, elt)
9616         if (i >= nelts)
9617           return false;
9618         else
9619           elts[i] = elt->value;
9620     }
9621   else
9622     return false;
9623   for (; i < nelts; i++)
9624     elts[i]
9625       = fold_convert (TREE_TYPE (TREE_TYPE (arg)), integer_zero_node);
9626   return true;
9627 }
9628
9629 /* Attempt to fold vector permutation of ARG0 and ARG1 vectors using SEL
9630    selector.  Return the folded VECTOR_CST or CONSTRUCTOR if successful,
9631    NULL_TREE otherwise.  */
9632
9633 static tree
9634 fold_vec_perm (tree type, tree arg0, tree arg1, const unsigned char *sel)
9635 {
9636   unsigned int nelts = TYPE_VECTOR_SUBPARTS (type), i;
9637   tree *elts;
9638   bool need_ctor = false;
9639
9640   gcc_assert (TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0)) == nelts
9641               && TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg1)) == nelts);
9642   if (TREE_TYPE (TREE_TYPE (arg0)) != TREE_TYPE (type)
9643       || TREE_TYPE (TREE_TYPE (arg1)) != TREE_TYPE (type))
9644     return NULL_TREE;
9645
9646   elts = XALLOCAVEC (tree, nelts * 3);
9647   if (!vec_cst_ctor_to_array (arg0, elts)
9648       || !vec_cst_ctor_to_array (arg1, elts + nelts))
9649     return NULL_TREE;
9650
9651   for (i = 0; i < nelts; i++)
9652     {
9653       if (!CONSTANT_CLASS_P (elts[sel[i]]))
9654         need_ctor = true;
9655       elts[i + 2 * nelts] = unshare_expr (elts[sel[i]]);
9656     }
9657
9658   if (need_ctor)
9659     {
9660       VEC(constructor_elt,gc) *v = VEC_alloc (constructor_elt, gc, nelts);
9661       for (i = 0; i < nelts; i++)
9662         CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, elts[2 * nelts + i]);
9663       return build_constructor (type, v);
9664     }
9665   else
9666     {
9667       tree vals = NULL_TREE;
9668       for (i = 0; i < nelts; i++)
9669         vals = tree_cons (NULL_TREE, elts[3 * nelts - i - 1], vals);
9670       return build_vector (type, vals);
9671     }
9672 }
9673
9674 /* Try to fold a pointer difference of type TYPE two address expressions of
9675    array references AREF0 and AREF1 using location LOC.  Return a
9676    simplified expression for the difference or NULL_TREE.  */
9677
9678 static tree
9679 fold_addr_of_array_ref_difference (location_t loc, tree type,
9680                                    tree aref0, tree aref1)
9681 {
9682   tree base0 = TREE_OPERAND (aref0, 0);
9683   tree base1 = TREE_OPERAND (aref1, 0);
9684   tree base_offset = build_int_cst (type, 0);
9685
9686   /* If the bases are array references as well, recurse.  If the bases
9687      are pointer indirections compute the difference of the pointers.
9688      If the bases are equal, we are set.  */
9689   if ((TREE_CODE (base0) == ARRAY_REF
9690        && TREE_CODE (base1) == ARRAY_REF
9691        && (base_offset
9692            = fold_addr_of_array_ref_difference (loc, type, base0, base1)))
9693       || (INDIRECT_REF_P (base0)
9694           && INDIRECT_REF_P (base1)
9695           && (base_offset = fold_binary_loc (loc, MINUS_EXPR, type,
9696                                              TREE_OPERAND (base0, 0),
9697                                              TREE_OPERAND (base1, 0))))
9698       || operand_equal_p (base0, base1, 0))
9699     {
9700       tree op0 = fold_convert_loc (loc, type, TREE_OPERAND (aref0, 1));
9701       tree op1 = fold_convert_loc (loc, type, TREE_OPERAND (aref1, 1));
9702       tree esz = fold_convert_loc (loc, type, array_ref_element_size (aref0));
9703       tree diff = build2 (MINUS_EXPR, type, op0, op1);
9704       return fold_build2_loc (loc, PLUS_EXPR, type,
9705                               base_offset,
9706                               fold_build2_loc (loc, MULT_EXPR, type,
9707                                                diff, esz));
9708     }
9709   return NULL_TREE;
9710 }
9711
9712 /* Fold a binary expression of code CODE and type TYPE with operands
9713    OP0 and OP1.  LOC is the location of the resulting expression.
9714    Return the folded expression if folding is successful.  Otherwise,
9715    return NULL_TREE.  */
9716
9717 tree
9718 fold_binary_loc (location_t loc,
9719              enum tree_code code, tree type, tree op0, tree op1)
9720 {
9721   enum tree_code_class kind = TREE_CODE_CLASS (code);
9722   tree arg0, arg1, tem;
9723   tree t1 = NULL_TREE;
9724   bool strict_overflow_p;
9725
9726   gcc_assert (IS_EXPR_CODE_CLASS (kind)
9727               && TREE_CODE_LENGTH (code) == 2
9728               && op0 != NULL_TREE
9729               && op1 != NULL_TREE);
9730
9731   arg0 = op0;
9732   arg1 = op1;
9733
9734   /* Strip any conversions that don't change the mode.  This is
9735      safe for every expression, except for a comparison expression
9736      because its signedness is derived from its operands.  So, in
9737      the latter case, only strip conversions that don't change the
9738      signedness.  MIN_EXPR/MAX_EXPR also need signedness of arguments
9739      preserved.
9740
9741      Note that this is done as an internal manipulation within the
9742      constant folder, in order to find the simplest representation
9743      of the arguments so that their form can be studied.  In any
9744      cases, the appropriate type conversions should be put back in
9745      the tree that will get out of the constant folder.  */
9746
9747   if (kind == tcc_comparison || code == MIN_EXPR || code == MAX_EXPR)
9748     {
9749       STRIP_SIGN_NOPS (arg0);
9750       STRIP_SIGN_NOPS (arg1);
9751     }
9752   else
9753     {
9754       STRIP_NOPS (arg0);
9755       STRIP_NOPS (arg1);
9756     }
9757
9758   /* Note that TREE_CONSTANT isn't enough: static var addresses are
9759      constant but we can't do arithmetic on them.  */
9760   if ((TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
9761       || (TREE_CODE (arg0) == REAL_CST && TREE_CODE (arg1) == REAL_CST)
9762       || (TREE_CODE (arg0) == FIXED_CST && TREE_CODE (arg1) == FIXED_CST)
9763       || (TREE_CODE (arg0) == FIXED_CST && TREE_CODE (arg1) == INTEGER_CST)
9764       || (TREE_CODE (arg0) == COMPLEX_CST && TREE_CODE (arg1) == COMPLEX_CST)
9765       || (TREE_CODE (arg0) == VECTOR_CST && TREE_CODE (arg1) == VECTOR_CST))
9766     {
9767       if (kind == tcc_binary)
9768         {
9769           /* Make sure type and arg0 have the same saturating flag.  */
9770           gcc_assert (TYPE_SATURATING (type)
9771                       == TYPE_SATURATING (TREE_TYPE (arg0)));
9772           tem = const_binop (code, arg0, arg1);
9773         }
9774       else if (kind == tcc_comparison)
9775         tem = fold_relational_const (code, type, arg0, arg1);
9776       else
9777         tem = NULL_TREE;
9778
9779       if (tem != NULL_TREE)
9780         {
9781           if (TREE_TYPE (tem) != type)
9782             tem = fold_convert_loc (loc, type, tem);
9783           return tem;
9784         }
9785     }
9786
9787   /* If this is a commutative operation, and ARG0 is a constant, move it
9788      to ARG1 to reduce the number of tests below.  */
9789   if (commutative_tree_code (code)
9790       && tree_swap_operands_p (arg0, arg1, true))
9791     return fold_build2_loc (loc, code, type, op1, op0);
9792
9793   /* ARG0 is the first operand of EXPR, and ARG1 is the second operand.
9794
9795      First check for cases where an arithmetic operation is applied to a
9796      compound, conditional, or comparison operation.  Push the arithmetic
9797      operation inside the compound or conditional to see if any folding
9798      can then be done.  Convert comparison to conditional for this purpose.
9799      The also optimizes non-constant cases that used to be done in
9800      expand_expr.
9801
9802      Before we do that, see if this is a BIT_AND_EXPR or a BIT_IOR_EXPR,
9803      one of the operands is a comparison and the other is a comparison, a
9804      BIT_AND_EXPR with the constant 1, or a truth value.  In that case, the
9805      code below would make the expression more complex.  Change it to a
9806      TRUTH_{AND,OR}_EXPR.  Likewise, convert a similar NE_EXPR to
9807      TRUTH_XOR_EXPR and an EQ_EXPR to the inversion of a TRUTH_XOR_EXPR.  */
9808
9809   if ((code == BIT_AND_EXPR || code == BIT_IOR_EXPR
9810        || code == EQ_EXPR || code == NE_EXPR)
9811       && ((truth_value_p (TREE_CODE (arg0))
9812            && (truth_value_p (TREE_CODE (arg1))
9813                || (TREE_CODE (arg1) == BIT_AND_EXPR
9814                    && integer_onep (TREE_OPERAND (arg1, 1)))))
9815           || (truth_value_p (TREE_CODE (arg1))
9816               && (truth_value_p (TREE_CODE (arg0))
9817                   || (TREE_CODE (arg0) == BIT_AND_EXPR
9818                       && integer_onep (TREE_OPERAND (arg0, 1)))))))
9819     {
9820       tem = fold_build2_loc (loc, code == BIT_AND_EXPR ? TRUTH_AND_EXPR
9821                          : code == BIT_IOR_EXPR ? TRUTH_OR_EXPR
9822                          : TRUTH_XOR_EXPR,
9823                          boolean_type_node,
9824                          fold_convert_loc (loc, boolean_type_node, arg0),
9825                          fold_convert_loc (loc, boolean_type_node, arg1));
9826
9827       if (code == EQ_EXPR)
9828         tem = invert_truthvalue_loc (loc, tem);
9829
9830       return fold_convert_loc (loc, type, tem);
9831     }
9832
9833   if (TREE_CODE_CLASS (code) == tcc_binary
9834       || TREE_CODE_CLASS (code) == tcc_comparison)
9835     {
9836       if (TREE_CODE (arg0) == COMPOUND_EXPR)
9837         {
9838           tem = fold_build2_loc (loc, code, type,
9839                              fold_convert_loc (loc, TREE_TYPE (op0),
9840                                                TREE_OPERAND (arg0, 1)), op1);
9841           return build2_loc (loc, COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
9842                              tem);
9843         }
9844       if (TREE_CODE (arg1) == COMPOUND_EXPR
9845           && reorder_operands_p (arg0, TREE_OPERAND (arg1, 0)))
9846         {
9847           tem = fold_build2_loc (loc, code, type, op0,
9848                              fold_convert_loc (loc, TREE_TYPE (op1),
9849                                                TREE_OPERAND (arg1, 1)));
9850           return build2_loc (loc, COMPOUND_EXPR, type, TREE_OPERAND (arg1, 0),
9851                              tem);
9852         }
9853
9854       if (TREE_CODE (arg0) == COND_EXPR || COMPARISON_CLASS_P (arg0))
9855         {
9856           tem = fold_binary_op_with_conditional_arg (loc, code, type, op0, op1,
9857                                                      arg0, arg1,
9858                                                      /*cond_first_p=*/1);
9859           if (tem != NULL_TREE)
9860             return tem;
9861         }
9862
9863       if (TREE_CODE (arg1) == COND_EXPR || COMPARISON_CLASS_P (arg1))
9864         {
9865           tem = fold_binary_op_with_conditional_arg (loc, code, type, op0, op1,
9866                                                      arg1, arg0,
9867                                                      /*cond_first_p=*/0);
9868           if (tem != NULL_TREE)
9869             return tem;
9870         }
9871     }
9872
9873   switch (code)
9874     {
9875     case MEM_REF:
9876       /* MEM[&MEM[p, CST1], CST2] -> MEM[p, CST1 + CST2].  */
9877       if (TREE_CODE (arg0) == ADDR_EXPR
9878           && TREE_CODE (TREE_OPERAND (arg0, 0)) == MEM_REF)
9879         {
9880           tree iref = TREE_OPERAND (arg0, 0);
9881           return fold_build2 (MEM_REF, type,
9882                               TREE_OPERAND (iref, 0),
9883                               int_const_binop (PLUS_EXPR, arg1,
9884                                                TREE_OPERAND (iref, 1)));
9885         }
9886
9887       /* MEM[&a.b, CST2] -> MEM[&a, offsetof (a, b) + CST2].  */
9888       if (TREE_CODE (arg0) == ADDR_EXPR
9889           && handled_component_p (TREE_OPERAND (arg0, 0)))
9890         {
9891           tree base;
9892           HOST_WIDE_INT coffset;
9893           base = get_addr_base_and_unit_offset (TREE_OPERAND (arg0, 0),
9894                                                 &coffset);
9895           if (!base)
9896             return NULL_TREE;
9897           return fold_build2 (MEM_REF, type,
9898                               build_fold_addr_expr (base),
9899                               int_const_binop (PLUS_EXPR, arg1,
9900                                                size_int (coffset)));
9901         }
9902
9903       return NULL_TREE;
9904
9905     case POINTER_PLUS_EXPR:
9906       /* 0 +p index -> (type)index */
9907       if (integer_zerop (arg0))
9908         return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg1));
9909
9910       /* PTR +p 0 -> PTR */
9911       if (integer_zerop (arg1))
9912         return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
9913
9914       /* INT +p INT -> (PTR)(INT + INT).  Stripping types allows for this. */
9915       if (INTEGRAL_TYPE_P (TREE_TYPE (arg1))
9916            && INTEGRAL_TYPE_P (TREE_TYPE (arg0)))
9917         return fold_convert_loc (loc, type,
9918                                  fold_build2_loc (loc, PLUS_EXPR, sizetype,
9919                                               fold_convert_loc (loc, sizetype,
9920                                                                 arg1),
9921                                               fold_convert_loc (loc, sizetype,
9922                                                                 arg0)));
9923
9924       /* (PTR +p B) +p A -> PTR +p (B + A) */
9925       if (TREE_CODE (arg0) == POINTER_PLUS_EXPR)
9926         {
9927           tree inner;
9928           tree arg01 = fold_convert_loc (loc, sizetype, TREE_OPERAND (arg0, 1));
9929           tree arg00 = TREE_OPERAND (arg0, 0);
9930           inner = fold_build2_loc (loc, PLUS_EXPR, sizetype,
9931                                arg01, fold_convert_loc (loc, sizetype, arg1));
9932           return fold_convert_loc (loc, type,
9933                                    fold_build_pointer_plus_loc (loc,
9934                                                                 arg00, inner));
9935         }
9936
9937       /* PTR_CST +p CST -> CST1 */
9938       if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
9939         return fold_build2_loc (loc, PLUS_EXPR, type, arg0,
9940                             fold_convert_loc (loc, type, arg1));
9941
9942      /* Try replacing &a[i1] +p c * i2 with &a[i1 + i2], if c is step
9943         of the array.  Loop optimizer sometimes produce this type of
9944         expressions.  */
9945       if (TREE_CODE (arg0) == ADDR_EXPR)
9946         {
9947           tem = try_move_mult_to_index (loc, arg0,
9948                                         fold_convert_loc (loc, sizetype, arg1));
9949           if (tem)
9950             return fold_convert_loc (loc, type, tem);
9951         }
9952
9953       return NULL_TREE;
9954
9955     case PLUS_EXPR:
9956       /* A + (-B) -> A - B */
9957       if (TREE_CODE (arg1) == NEGATE_EXPR)
9958         return fold_build2_loc (loc, MINUS_EXPR, type,
9959                             fold_convert_loc (loc, type, arg0),
9960                             fold_convert_loc (loc, type,
9961                                               TREE_OPERAND (arg1, 0)));
9962       /* (-A) + B -> B - A */
9963       if (TREE_CODE (arg0) == NEGATE_EXPR
9964           && reorder_operands_p (TREE_OPERAND (arg0, 0), arg1))
9965         return fold_build2_loc (loc, MINUS_EXPR, type,
9966                             fold_convert_loc (loc, type, arg1),
9967                             fold_convert_loc (loc, type,
9968                                               TREE_OPERAND (arg0, 0)));
9969
9970       if (INTEGRAL_TYPE_P (type))
9971         {
9972           /* Convert ~A + 1 to -A.  */
9973           if (TREE_CODE (arg0) == BIT_NOT_EXPR
9974               && integer_onep (arg1))
9975             return fold_build1_loc (loc, NEGATE_EXPR, type,
9976                                 fold_convert_loc (loc, type,
9977                                                   TREE_OPERAND (arg0, 0)));
9978
9979           /* ~X + X is -1.  */
9980           if (TREE_CODE (arg0) == BIT_NOT_EXPR
9981               && !TYPE_OVERFLOW_TRAPS (type))
9982             {
9983               tree tem = TREE_OPERAND (arg0, 0);
9984
9985               STRIP_NOPS (tem);
9986               if (operand_equal_p (tem, arg1, 0))
9987                 {
9988                   t1 = build_int_cst_type (type, -1);
9989                   return omit_one_operand_loc (loc, type, t1, arg1);
9990                 }
9991             }
9992
9993           /* X + ~X is -1.  */
9994           if (TREE_CODE (arg1) == BIT_NOT_EXPR
9995               && !TYPE_OVERFLOW_TRAPS (type))
9996             {
9997               tree tem = TREE_OPERAND (arg1, 0);
9998
9999               STRIP_NOPS (tem);
10000               if (operand_equal_p (arg0, tem, 0))
10001                 {
10002                   t1 = build_int_cst_type (type, -1);
10003                   return omit_one_operand_loc (loc, type, t1, arg0);
10004                 }
10005             }
10006
10007           /* X + (X / CST) * -CST is X % CST.  */
10008           if (TREE_CODE (arg1) == MULT_EXPR
10009               && TREE_CODE (TREE_OPERAND (arg1, 0)) == TRUNC_DIV_EXPR
10010               && operand_equal_p (arg0,
10011                                   TREE_OPERAND (TREE_OPERAND (arg1, 0), 0), 0))
10012             {
10013               tree cst0 = TREE_OPERAND (TREE_OPERAND (arg1, 0), 1);
10014               tree cst1 = TREE_OPERAND (arg1, 1);
10015               tree sum = fold_binary_loc (loc, PLUS_EXPR, TREE_TYPE (cst1),
10016                                       cst1, cst0);
10017               if (sum && integer_zerop (sum))
10018                 return fold_convert_loc (loc, type,
10019                                          fold_build2_loc (loc, TRUNC_MOD_EXPR,
10020                                                       TREE_TYPE (arg0), arg0,
10021                                                       cst0));
10022             }
10023         }
10024
10025       /* Handle (A1 * C1) + (A2 * C2) with A1, A2 or C1, C2 being the same or
10026          one.  Make sure the type is not saturating and has the signedness of
10027          the stripped operands, as fold_plusminus_mult_expr will re-associate.
10028          ??? The latter condition should use TYPE_OVERFLOW_* flags instead.  */
10029       if ((TREE_CODE (arg0) == MULT_EXPR
10030            || TREE_CODE (arg1) == MULT_EXPR)
10031           && !TYPE_SATURATING (type)
10032           && TYPE_UNSIGNED (type) == TYPE_UNSIGNED (TREE_TYPE (arg0))
10033           && TYPE_UNSIGNED (type) == TYPE_UNSIGNED (TREE_TYPE (arg1))
10034           && (!FLOAT_TYPE_P (type) || flag_associative_math))
10035         {
10036           tree tem = fold_plusminus_mult_expr (loc, code, type, arg0, arg1);
10037           if (tem)
10038             return tem;
10039         }
10040
10041       if (! FLOAT_TYPE_P (type))
10042         {
10043           if (integer_zerop (arg1))
10044             return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
10045
10046           /* If we are adding two BIT_AND_EXPR's, both of which are and'ing
10047              with a constant, and the two constants have no bits in common,
10048              we should treat this as a BIT_IOR_EXPR since this may produce more
10049              simplifications.  */
10050           if (TREE_CODE (arg0) == BIT_AND_EXPR
10051               && TREE_CODE (arg1) == BIT_AND_EXPR
10052               && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
10053               && TREE_CODE (TREE_OPERAND (arg1, 1)) == INTEGER_CST
10054               && integer_zerop (const_binop (BIT_AND_EXPR,
10055                                              TREE_OPERAND (arg0, 1),
10056                                              TREE_OPERAND (arg1, 1))))
10057             {
10058               code = BIT_IOR_EXPR;
10059               goto bit_ior;
10060             }
10061
10062           /* Reassociate (plus (plus (mult) (foo)) (mult)) as
10063              (plus (plus (mult) (mult)) (foo)) so that we can
10064              take advantage of the factoring cases below.  */
10065           if (TYPE_OVERFLOW_WRAPS (type)
10066               && (((TREE_CODE (arg0) == PLUS_EXPR
10067                     || TREE_CODE (arg0) == MINUS_EXPR)
10068                    && TREE_CODE (arg1) == MULT_EXPR)
10069                   || ((TREE_CODE (arg1) == PLUS_EXPR
10070                        || TREE_CODE (arg1) == MINUS_EXPR)
10071                       && TREE_CODE (arg0) == MULT_EXPR)))
10072             {
10073               tree parg0, parg1, parg, marg;
10074               enum tree_code pcode;
10075
10076               if (TREE_CODE (arg1) == MULT_EXPR)
10077                 parg = arg0, marg = arg1;
10078               else
10079                 parg = arg1, marg = arg0;
10080               pcode = TREE_CODE (parg);
10081               parg0 = TREE_OPERAND (parg, 0);
10082               parg1 = TREE_OPERAND (parg, 1);
10083               STRIP_NOPS (parg0);
10084               STRIP_NOPS (parg1);
10085
10086               if (TREE_CODE (parg0) == MULT_EXPR
10087                   && TREE_CODE (parg1) != MULT_EXPR)
10088                 return fold_build2_loc (loc, pcode, type,
10089                                     fold_build2_loc (loc, PLUS_EXPR, type,
10090                                                  fold_convert_loc (loc, type,
10091                                                                    parg0),
10092                                                  fold_convert_loc (loc, type,
10093                                                                    marg)),
10094                                     fold_convert_loc (loc, type, parg1));
10095               if (TREE_CODE (parg0) != MULT_EXPR
10096                   && TREE_CODE (parg1) == MULT_EXPR)
10097                 return
10098                   fold_build2_loc (loc, PLUS_EXPR, type,
10099                                fold_convert_loc (loc, type, parg0),
10100                                fold_build2_loc (loc, pcode, type,
10101                                             fold_convert_loc (loc, type, marg),
10102                                             fold_convert_loc (loc, type,
10103                                                               parg1)));
10104             }
10105         }
10106       else
10107         {
10108           /* See if ARG1 is zero and X + ARG1 reduces to X.  */
10109           if (fold_real_zero_addition_p (TREE_TYPE (arg0), arg1, 0))
10110             return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
10111
10112           /* Likewise if the operands are reversed.  */
10113           if (fold_real_zero_addition_p (TREE_TYPE (arg1), arg0, 0))
10114             return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg1));
10115
10116           /* Convert X + -C into X - C.  */
10117           if (TREE_CODE (arg1) == REAL_CST
10118               && REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg1)))
10119             {
10120               tem = fold_negate_const (arg1, type);
10121               if (!TREE_OVERFLOW (arg1) || !flag_trapping_math)
10122                 return fold_build2_loc (loc, MINUS_EXPR, type,
10123                                     fold_convert_loc (loc, type, arg0),
10124                                     fold_convert_loc (loc, type, tem));
10125             }
10126
10127           /* Fold __complex__ ( x, 0 ) + __complex__ ( 0, y )
10128              to __complex__ ( x, y ).  This is not the same for SNaNs or
10129              if signed zeros are involved.  */
10130           if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
10131               && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0)))
10132               && COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0)))
10133             {
10134               tree rtype = TREE_TYPE (TREE_TYPE (arg0));
10135               tree arg0r = fold_unary_loc (loc, REALPART_EXPR, rtype, arg0);
10136               tree arg0i = fold_unary_loc (loc, IMAGPART_EXPR, rtype, arg0);
10137               bool arg0rz = false, arg0iz = false;
10138               if ((arg0r && (arg0rz = real_zerop (arg0r)))
10139                   || (arg0i && (arg0iz = real_zerop (arg0i))))
10140                 {
10141                   tree arg1r = fold_unary_loc (loc, REALPART_EXPR, rtype, arg1);
10142                   tree arg1i = fold_unary_loc (loc, IMAGPART_EXPR, rtype, arg1);
10143                   if (arg0rz && arg1i && real_zerop (arg1i))
10144                     {
10145                       tree rp = arg1r ? arg1r
10146                                   : build1 (REALPART_EXPR, rtype, arg1);
10147                       tree ip = arg0i ? arg0i
10148                                   : build1 (IMAGPART_EXPR, rtype, arg0);
10149                       return fold_build2_loc (loc, COMPLEX_EXPR, type, rp, ip);
10150                     }
10151                   else if (arg0iz && arg1r && real_zerop (arg1r))
10152                     {
10153                       tree rp = arg0r ? arg0r
10154                                   : build1 (REALPART_EXPR, rtype, arg0);
10155                       tree ip = arg1i ? arg1i
10156                                   : build1 (IMAGPART_EXPR, rtype, arg1);
10157                       return fold_build2_loc (loc, COMPLEX_EXPR, type, rp, ip);
10158                     }
10159                 }
10160             }
10161
10162           if (flag_unsafe_math_optimizations
10163               && (TREE_CODE (arg0) == RDIV_EXPR || TREE_CODE (arg0) == MULT_EXPR)
10164               && (TREE_CODE (arg1) == RDIV_EXPR || TREE_CODE (arg1) == MULT_EXPR)
10165               && (tem = distribute_real_division (loc, code, type, arg0, arg1)))
10166             return tem;
10167
10168           /* Convert x+x into x*2.0.  */
10169           if (operand_equal_p (arg0, arg1, 0)
10170               && SCALAR_FLOAT_TYPE_P (type))
10171             return fold_build2_loc (loc, MULT_EXPR, type, arg0,
10172                                 build_real (type, dconst2));
10173
10174           /* Convert a + (b*c + d*e) into (a + b*c) + d*e.
10175              We associate floats only if the user has specified
10176              -fassociative-math.  */
10177           if (flag_associative_math
10178               && TREE_CODE (arg1) == PLUS_EXPR
10179               && TREE_CODE (arg0) != MULT_EXPR)
10180             {
10181               tree tree10 = TREE_OPERAND (arg1, 0);
10182               tree tree11 = TREE_OPERAND (arg1, 1);
10183               if (TREE_CODE (tree11) == MULT_EXPR
10184                   && TREE_CODE (tree10) == MULT_EXPR)
10185                 {
10186                   tree tree0;
10187                   tree0 = fold_build2_loc (loc, PLUS_EXPR, type, arg0, tree10);
10188                   return fold_build2_loc (loc, PLUS_EXPR, type, tree0, tree11);
10189                 }
10190             }
10191           /* Convert (b*c + d*e) + a into b*c + (d*e +a).
10192              We associate floats only if the user has specified
10193              -fassociative-math.  */
10194           if (flag_associative_math
10195               && TREE_CODE (arg0) == PLUS_EXPR
10196               && TREE_CODE (arg1) != MULT_EXPR)
10197             {
10198               tree tree00 = TREE_OPERAND (arg0, 0);
10199               tree tree01 = TREE_OPERAND (arg0, 1);
10200               if (TREE_CODE (tree01) == MULT_EXPR
10201                   && TREE_CODE (tree00) == MULT_EXPR)
10202                 {
10203                   tree tree0;
10204                   tree0 = fold_build2_loc (loc, PLUS_EXPR, type, tree01, arg1);
10205                   return fold_build2_loc (loc, PLUS_EXPR, type, tree00, tree0);
10206                 }
10207             }
10208         }
10209
10210      bit_rotate:
10211       /* (A << C1) + (A >> C2) if A is unsigned and C1+C2 is the size of A
10212          is a rotate of A by C1 bits.  */
10213       /* (A << B) + (A >> (Z - B)) if A is unsigned and Z is the size of A
10214          is a rotate of A by B bits.  */
10215       {
10216         enum tree_code code0, code1;
10217         tree rtype;
10218         code0 = TREE_CODE (arg0);
10219         code1 = TREE_CODE (arg1);
10220         if (((code0 == RSHIFT_EXPR && code1 == LSHIFT_EXPR)
10221              || (code1 == RSHIFT_EXPR && code0 == LSHIFT_EXPR))
10222             && operand_equal_p (TREE_OPERAND (arg0, 0),
10223                                 TREE_OPERAND (arg1, 0), 0)
10224             && (rtype = TREE_TYPE (TREE_OPERAND (arg0, 0)),
10225                 TYPE_UNSIGNED (rtype))
10226             /* Only create rotates in complete modes.  Other cases are not
10227                expanded properly.  */
10228             && TYPE_PRECISION (rtype) == GET_MODE_PRECISION (TYPE_MODE (rtype)))
10229           {
10230             tree tree01, tree11;
10231             enum tree_code code01, code11;
10232
10233             tree01 = TREE_OPERAND (arg0, 1);
10234             tree11 = TREE_OPERAND (arg1, 1);
10235             STRIP_NOPS (tree01);
10236             STRIP_NOPS (tree11);
10237             code01 = TREE_CODE (tree01);
10238             code11 = TREE_CODE (tree11);
10239             if (code01 == INTEGER_CST
10240                 && code11 == INTEGER_CST
10241                 && TREE_INT_CST_HIGH (tree01) == 0
10242                 && TREE_INT_CST_HIGH (tree11) == 0
10243                 && ((TREE_INT_CST_LOW (tree01) + TREE_INT_CST_LOW (tree11))
10244                     == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0)))))
10245               {
10246                 tem = build2_loc (loc, LROTATE_EXPR,
10247                                   TREE_TYPE (TREE_OPERAND (arg0, 0)),
10248                                   TREE_OPERAND (arg0, 0),
10249                                   code0 == LSHIFT_EXPR ? tree01 : tree11);
10250                 return fold_convert_loc (loc, type, tem);
10251               }
10252             else if (code11 == MINUS_EXPR)
10253               {
10254                 tree tree110, tree111;
10255                 tree110 = TREE_OPERAND (tree11, 0);
10256                 tree111 = TREE_OPERAND (tree11, 1);
10257                 STRIP_NOPS (tree110);
10258                 STRIP_NOPS (tree111);
10259                 if (TREE_CODE (tree110) == INTEGER_CST
10260                     && 0 == compare_tree_int (tree110,
10261                                               TYPE_PRECISION
10262                                               (TREE_TYPE (TREE_OPERAND
10263                                                           (arg0, 0))))
10264                     && operand_equal_p (tree01, tree111, 0))
10265                   return
10266                     fold_convert_loc (loc, type,
10267                                       build2 ((code0 == LSHIFT_EXPR
10268                                                ? LROTATE_EXPR
10269                                                : RROTATE_EXPR),
10270                                               TREE_TYPE (TREE_OPERAND (arg0, 0)),
10271                                               TREE_OPERAND (arg0, 0), tree01));
10272               }
10273             else if (code01 == MINUS_EXPR)
10274               {
10275                 tree tree010, tree011;
10276                 tree010 = TREE_OPERAND (tree01, 0);
10277                 tree011 = TREE_OPERAND (tree01, 1);
10278                 STRIP_NOPS (tree010);
10279                 STRIP_NOPS (tree011);
10280                 if (TREE_CODE (tree010) == INTEGER_CST
10281                     && 0 == compare_tree_int (tree010,
10282                                               TYPE_PRECISION
10283                                               (TREE_TYPE (TREE_OPERAND
10284                                                           (arg0, 0))))
10285                     && operand_equal_p (tree11, tree011, 0))
10286                     return fold_convert_loc
10287                       (loc, type,
10288                        build2 ((code0 != LSHIFT_EXPR
10289                                 ? LROTATE_EXPR
10290                                 : RROTATE_EXPR),
10291                                TREE_TYPE (TREE_OPERAND (arg0, 0)),
10292                                TREE_OPERAND (arg0, 0), tree11));
10293               }
10294           }
10295       }
10296
10297     associate:
10298       /* In most languages, can't associate operations on floats through
10299          parentheses.  Rather than remember where the parentheses were, we
10300          don't associate floats at all, unless the user has specified
10301          -fassociative-math.
10302          And, we need to make sure type is not saturating.  */
10303
10304       if ((! FLOAT_TYPE_P (type) || flag_associative_math)
10305           && !TYPE_SATURATING (type))
10306         {
10307           tree var0, con0, lit0, minus_lit0;
10308           tree var1, con1, lit1, minus_lit1;
10309           bool ok = true;
10310
10311           /* Split both trees into variables, constants, and literals.  Then
10312              associate each group together, the constants with literals,
10313              then the result with variables.  This increases the chances of
10314              literals being recombined later and of generating relocatable
10315              expressions for the sum of a constant and literal.  */
10316           var0 = split_tree (arg0, code, &con0, &lit0, &minus_lit0, 0);
10317           var1 = split_tree (arg1, code, &con1, &lit1, &minus_lit1,
10318                              code == MINUS_EXPR);
10319
10320           /* Recombine MINUS_EXPR operands by using PLUS_EXPR.  */
10321           if (code == MINUS_EXPR)
10322             code = PLUS_EXPR;
10323
10324           /* With undefined overflow we can only associate constants with one
10325              variable, and constants whose association doesn't overflow.  */
10326           if ((POINTER_TYPE_P (type) && POINTER_TYPE_OVERFLOW_UNDEFINED)
10327               || (INTEGRAL_TYPE_P (type) && !TYPE_OVERFLOW_WRAPS (type)))
10328             {
10329               if (var0 && var1)
10330                 {
10331                   tree tmp0 = var0;
10332                   tree tmp1 = var1;
10333
10334                   if (TREE_CODE (tmp0) == NEGATE_EXPR)
10335                     tmp0 = TREE_OPERAND (tmp0, 0);
10336                   if (TREE_CODE (tmp1) == NEGATE_EXPR)
10337                     tmp1 = TREE_OPERAND (tmp1, 0);
10338                   /* The only case we can still associate with two variables
10339                      is if they are the same, modulo negation.  */
10340                   if (!operand_equal_p (tmp0, tmp1, 0))
10341                     ok = false;
10342                 }
10343
10344               if (ok && lit0 && lit1)
10345                 {
10346                   tree tmp0 = fold_convert (type, lit0);
10347                   tree tmp1 = fold_convert (type, lit1);
10348
10349                   if (!TREE_OVERFLOW (tmp0) && !TREE_OVERFLOW (tmp1)
10350                       && TREE_OVERFLOW (fold_build2 (code, type, tmp0, tmp1)))
10351                     ok = false;
10352                 }
10353             }
10354
10355           /* Only do something if we found more than two objects.  Otherwise,
10356              nothing has changed and we risk infinite recursion.  */
10357           if (ok
10358               && (2 < ((var0 != 0) + (var1 != 0)
10359                        + (con0 != 0) + (con1 != 0)
10360                        + (lit0 != 0) + (lit1 != 0)
10361                        + (minus_lit0 != 0) + (minus_lit1 != 0))))
10362             {
10363               var0 = associate_trees (loc, var0, var1, code, type);
10364               con0 = associate_trees (loc, con0, con1, code, type);
10365               lit0 = associate_trees (loc, lit0, lit1, code, type);
10366               minus_lit0 = associate_trees (loc, minus_lit0, minus_lit1, code, type);
10367
10368               /* Preserve the MINUS_EXPR if the negative part of the literal is
10369                  greater than the positive part.  Otherwise, the multiplicative
10370                  folding code (i.e extract_muldiv) may be fooled in case
10371                  unsigned constants are subtracted, like in the following
10372                  example: ((X*2 + 4) - 8U)/2.  */
10373               if (minus_lit0 && lit0)
10374                 {
10375                   if (TREE_CODE (lit0) == INTEGER_CST
10376                       && TREE_CODE (minus_lit0) == INTEGER_CST
10377                       && tree_int_cst_lt (lit0, minus_lit0))
10378                     {
10379                       minus_lit0 = associate_trees (loc, minus_lit0, lit0,
10380                                                     MINUS_EXPR, type);
10381                       lit0 = 0;
10382                     }
10383                   else
10384                     {
10385                       lit0 = associate_trees (loc, lit0, minus_lit0,
10386                                               MINUS_EXPR, type);
10387                       minus_lit0 = 0;
10388                     }
10389                 }
10390               if (minus_lit0)
10391                 {
10392                   if (con0 == 0)
10393                     return
10394                       fold_convert_loc (loc, type,
10395                                         associate_trees (loc, var0, minus_lit0,
10396                                                          MINUS_EXPR, type));
10397                   else
10398                     {
10399                       con0 = associate_trees (loc, con0, minus_lit0,
10400                                               MINUS_EXPR, type);
10401                       return
10402                         fold_convert_loc (loc, type,
10403                                           associate_trees (loc, var0, con0,
10404                                                            PLUS_EXPR, type));
10405                     }
10406                 }
10407
10408               con0 = associate_trees (loc, con0, lit0, code, type);
10409               return
10410                 fold_convert_loc (loc, type, associate_trees (loc, var0, con0,
10411                                                               code, type));
10412             }
10413         }
10414
10415       return NULL_TREE;
10416
10417     case MINUS_EXPR:
10418       /* Pointer simplifications for subtraction, simple reassociations. */
10419       if (POINTER_TYPE_P (TREE_TYPE (arg1)) && POINTER_TYPE_P (TREE_TYPE (arg0)))
10420         {
10421           /* (PTR0 p+ A) - (PTR1 p+ B) -> (PTR0 - PTR1) + (A - B) */
10422           if (TREE_CODE (arg0) == POINTER_PLUS_EXPR
10423               && TREE_CODE (arg1) == POINTER_PLUS_EXPR)
10424             {
10425               tree arg00 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
10426               tree arg01 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 1));
10427               tree arg10 = fold_convert_loc (loc, type, TREE_OPERAND (arg1, 0));
10428               tree arg11 = fold_convert_loc (loc, type, TREE_OPERAND (arg1, 1));
10429               return fold_build2_loc (loc, PLUS_EXPR, type,
10430                                   fold_build2_loc (loc, MINUS_EXPR, type,
10431                                                arg00, arg10),
10432                                   fold_build2_loc (loc, MINUS_EXPR, type,
10433                                                arg01, arg11));
10434             }
10435           /* (PTR0 p+ A) - PTR1 -> (PTR0 - PTR1) + A, assuming PTR0 - PTR1 simplifies. */
10436           else if (TREE_CODE (arg0) == POINTER_PLUS_EXPR)
10437             {
10438               tree arg00 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
10439               tree arg01 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 1));
10440               tree tmp = fold_binary_loc (loc, MINUS_EXPR, type, arg00,
10441                                       fold_convert_loc (loc, type, arg1));
10442               if (tmp)
10443                 return fold_build2_loc (loc, PLUS_EXPR, type, tmp, arg01);
10444             }
10445         }
10446       /* A - (-B) -> A + B */
10447       if (TREE_CODE (arg1) == NEGATE_EXPR)
10448         return fold_build2_loc (loc, PLUS_EXPR, type, op0,
10449                             fold_convert_loc (loc, type,
10450                                               TREE_OPERAND (arg1, 0)));
10451       /* (-A) - B -> (-B) - A  where B is easily negated and we can swap.  */
10452       if (TREE_CODE (arg0) == NEGATE_EXPR
10453           && (FLOAT_TYPE_P (type)
10454               || INTEGRAL_TYPE_P (type))
10455           && negate_expr_p (arg1)
10456           && reorder_operands_p (arg0, arg1))
10457         return fold_build2_loc (loc, MINUS_EXPR, type,
10458                             fold_convert_loc (loc, type,
10459                                               negate_expr (arg1)),
10460                             fold_convert_loc (loc, type,
10461                                               TREE_OPERAND (arg0, 0)));
10462       /* Convert -A - 1 to ~A.  */
10463       if (INTEGRAL_TYPE_P (type)
10464           && TREE_CODE (arg0) == NEGATE_EXPR
10465           && integer_onep (arg1)
10466           && !TYPE_OVERFLOW_TRAPS (type))
10467         return fold_build1_loc (loc, BIT_NOT_EXPR, type,
10468                             fold_convert_loc (loc, type,
10469                                               TREE_OPERAND (arg0, 0)));
10470
10471       /* Convert -1 - A to ~A.  */
10472       if (INTEGRAL_TYPE_P (type)
10473           && integer_all_onesp (arg0))
10474         return fold_build1_loc (loc, BIT_NOT_EXPR, type, op1);
10475
10476
10477       /* X - (X / CST) * CST is X % CST.  */
10478       if (INTEGRAL_TYPE_P (type)
10479           && TREE_CODE (arg1) == MULT_EXPR
10480           && TREE_CODE (TREE_OPERAND (arg1, 0)) == TRUNC_DIV_EXPR
10481           && operand_equal_p (arg0,
10482                               TREE_OPERAND (TREE_OPERAND (arg1, 0), 0), 0)
10483           && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg1, 0), 1),
10484                               TREE_OPERAND (arg1, 1), 0))
10485         return
10486           fold_convert_loc (loc, type,
10487                             fold_build2_loc (loc, TRUNC_MOD_EXPR, TREE_TYPE (arg0),
10488                                          arg0, TREE_OPERAND (arg1, 1)));
10489
10490       if (! FLOAT_TYPE_P (type))
10491         {
10492           if (integer_zerop (arg0))
10493             return negate_expr (fold_convert_loc (loc, type, arg1));
10494           if (integer_zerop (arg1))
10495             return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
10496
10497           /* Fold A - (A & B) into ~B & A.  */
10498           if (!TREE_SIDE_EFFECTS (arg0)
10499               && TREE_CODE (arg1) == BIT_AND_EXPR)
10500             {
10501               if (operand_equal_p (arg0, TREE_OPERAND (arg1, 1), 0))
10502                 {
10503                   tree arg10 = fold_convert_loc (loc, type,
10504                                                  TREE_OPERAND (arg1, 0));
10505                   return fold_build2_loc (loc, BIT_AND_EXPR, type,
10506                                       fold_build1_loc (loc, BIT_NOT_EXPR,
10507                                                    type, arg10),
10508                                       fold_convert_loc (loc, type, arg0));
10509                 }
10510               if (operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
10511                 {
10512                   tree arg11 = fold_convert_loc (loc,
10513                                                  type, TREE_OPERAND (arg1, 1));
10514                   return fold_build2_loc (loc, BIT_AND_EXPR, type,
10515                                       fold_build1_loc (loc, BIT_NOT_EXPR,
10516                                                    type, arg11),
10517                                       fold_convert_loc (loc, type, arg0));
10518                 }
10519             }
10520
10521           /* Fold (A & ~B) - (A & B) into (A ^ B) - B, where B is
10522              any power of 2 minus 1.  */
10523           if (TREE_CODE (arg0) == BIT_AND_EXPR
10524               && TREE_CODE (arg1) == BIT_AND_EXPR
10525               && operand_equal_p (TREE_OPERAND (arg0, 0),
10526                                   TREE_OPERAND (arg1, 0), 0))
10527             {
10528               tree mask0 = TREE_OPERAND (arg0, 1);
10529               tree mask1 = TREE_OPERAND (arg1, 1);
10530               tree tem = fold_build1_loc (loc, BIT_NOT_EXPR, type, mask0);
10531
10532               if (operand_equal_p (tem, mask1, 0))
10533                 {
10534                   tem = fold_build2_loc (loc, BIT_XOR_EXPR, type,
10535                                      TREE_OPERAND (arg0, 0), mask1);
10536                   return fold_build2_loc (loc, MINUS_EXPR, type, tem, mask1);
10537                 }
10538             }
10539         }
10540
10541       /* See if ARG1 is zero and X - ARG1 reduces to X.  */
10542       else if (fold_real_zero_addition_p (TREE_TYPE (arg0), arg1, 1))
10543         return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
10544
10545       /* (ARG0 - ARG1) is the same as (-ARG1 + ARG0).  So check whether
10546          ARG0 is zero and X + ARG0 reduces to X, since that would mean
10547          (-ARG1 + ARG0) reduces to -ARG1.  */
10548       else if (fold_real_zero_addition_p (TREE_TYPE (arg1), arg0, 0))
10549         return negate_expr (fold_convert_loc (loc, type, arg1));
10550
10551       /* Fold __complex__ ( x, 0 ) - __complex__ ( 0, y ) to
10552          __complex__ ( x, -y ).  This is not the same for SNaNs or if
10553          signed zeros are involved.  */
10554       if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
10555           && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0)))
10556           && COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0)))
10557         {
10558           tree rtype = TREE_TYPE (TREE_TYPE (arg0));
10559           tree arg0r = fold_unary_loc (loc, REALPART_EXPR, rtype, arg0);
10560           tree arg0i = fold_unary_loc (loc, IMAGPART_EXPR, rtype, arg0);
10561           bool arg0rz = false, arg0iz = false;
10562           if ((arg0r && (arg0rz = real_zerop (arg0r)))
10563               || (arg0i && (arg0iz = real_zerop (arg0i))))
10564             {
10565               tree arg1r = fold_unary_loc (loc, REALPART_EXPR, rtype, arg1);
10566               tree arg1i = fold_unary_loc (loc, IMAGPART_EXPR, rtype, arg1);
10567               if (arg0rz && arg1i && real_zerop (arg1i))
10568                 {
10569                   tree rp = fold_build1_loc (loc, NEGATE_EXPR, rtype,
10570                                          arg1r ? arg1r
10571                                          : build1 (REALPART_EXPR, rtype, arg1));
10572                   tree ip = arg0i ? arg0i
10573                     : build1 (IMAGPART_EXPR, rtype, arg0);
10574                   return fold_build2_loc (loc, COMPLEX_EXPR, type, rp, ip);
10575                 }
10576               else if (arg0iz && arg1r && real_zerop (arg1r))
10577                 {
10578                   tree rp = arg0r ? arg0r
10579                     : build1 (REALPART_EXPR, rtype, arg0);
10580                   tree ip = fold_build1_loc (loc, NEGATE_EXPR, rtype,
10581                                          arg1i ? arg1i
10582                                          : build1 (IMAGPART_EXPR, rtype, arg1));
10583                   return fold_build2_loc (loc, COMPLEX_EXPR, type, rp, ip);
10584                 }
10585             }
10586         }
10587
10588       /* Fold &x - &x.  This can happen from &x.foo - &x.
10589          This is unsafe for certain floats even in non-IEEE formats.
10590          In IEEE, it is unsafe because it does wrong for NaNs.
10591          Also note that operand_equal_p is always false if an operand
10592          is volatile.  */
10593
10594       if ((!FLOAT_TYPE_P (type) || !HONOR_NANS (TYPE_MODE (type)))
10595           && operand_equal_p (arg0, arg1, 0))
10596         return build_zero_cst (type);
10597
10598       /* A - B -> A + (-B) if B is easily negatable.  */
10599       if (negate_expr_p (arg1)
10600           && ((FLOAT_TYPE_P (type)
10601                /* Avoid this transformation if B is a positive REAL_CST.  */
10602                && (TREE_CODE (arg1) != REAL_CST
10603                    ||  REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg1))))
10604               || INTEGRAL_TYPE_P (type)))
10605         return fold_build2_loc (loc, PLUS_EXPR, type,
10606                             fold_convert_loc (loc, type, arg0),
10607                             fold_convert_loc (loc, type,
10608                                               negate_expr (arg1)));
10609
10610       /* Try folding difference of addresses.  */
10611       {
10612         HOST_WIDE_INT diff;
10613
10614         if ((TREE_CODE (arg0) == ADDR_EXPR
10615              || TREE_CODE (arg1) == ADDR_EXPR)
10616             && ptr_difference_const (arg0, arg1, &diff))
10617           return build_int_cst_type (type, diff);
10618       }
10619
10620       /* Fold &a[i] - &a[j] to i-j.  */
10621       if (TREE_CODE (arg0) == ADDR_EXPR
10622           && TREE_CODE (TREE_OPERAND (arg0, 0)) == ARRAY_REF
10623           && TREE_CODE (arg1) == ADDR_EXPR
10624           && TREE_CODE (TREE_OPERAND (arg1, 0)) == ARRAY_REF)
10625         {
10626           tree tem = fold_addr_of_array_ref_difference (loc, type,
10627                                                         TREE_OPERAND (arg0, 0),
10628                                                         TREE_OPERAND (arg1, 0));
10629           if (tem)
10630             return tem;
10631         }
10632
10633       if (FLOAT_TYPE_P (type)
10634           && flag_unsafe_math_optimizations
10635           && (TREE_CODE (arg0) == RDIV_EXPR || TREE_CODE (arg0) == MULT_EXPR)
10636           && (TREE_CODE (arg1) == RDIV_EXPR || TREE_CODE (arg1) == MULT_EXPR)
10637           && (tem = distribute_real_division (loc, code, type, arg0, arg1)))
10638         return tem;
10639
10640       /* Handle (A1 * C1) - (A2 * C2) with A1, A2 or C1, C2 being the same or
10641          one.  Make sure the type is not saturating and has the signedness of
10642          the stripped operands, as fold_plusminus_mult_expr will re-associate.
10643          ??? The latter condition should use TYPE_OVERFLOW_* flags instead.  */
10644       if ((TREE_CODE (arg0) == MULT_EXPR
10645            || TREE_CODE (arg1) == MULT_EXPR)
10646           && !TYPE_SATURATING (type)
10647           && TYPE_UNSIGNED (type) == TYPE_UNSIGNED (TREE_TYPE (arg0))
10648           && TYPE_UNSIGNED (type) == TYPE_UNSIGNED (TREE_TYPE (arg1))
10649           && (!FLOAT_TYPE_P (type) || flag_associative_math))
10650         {
10651           tree tem = fold_plusminus_mult_expr (loc, code, type, arg0, arg1);
10652           if (tem)
10653             return tem;
10654         }
10655
10656       goto associate;
10657
10658     case MULT_EXPR:
10659       /* (-A) * (-B) -> A * B  */
10660       if (TREE_CODE (arg0) == NEGATE_EXPR && negate_expr_p (arg1))
10661         return fold_build2_loc (loc, MULT_EXPR, type,
10662                             fold_convert_loc (loc, type,
10663                                               TREE_OPERAND (arg0, 0)),
10664                             fold_convert_loc (loc, type,
10665                                               negate_expr (arg1)));
10666       if (TREE_CODE (arg1) == NEGATE_EXPR && negate_expr_p (arg0))
10667         return fold_build2_loc (loc, MULT_EXPR, type,
10668                             fold_convert_loc (loc, type,
10669                                               negate_expr (arg0)),
10670                             fold_convert_loc (loc, type,
10671                                               TREE_OPERAND (arg1, 0)));
10672
10673       if (! FLOAT_TYPE_P (type))
10674         {
10675           if (integer_zerop (arg1))
10676             return omit_one_operand_loc (loc, type, arg1, arg0);
10677           if (integer_onep (arg1))
10678             return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
10679           /* Transform x * -1 into -x.  Make sure to do the negation
10680              on the original operand with conversions not stripped
10681              because we can only strip non-sign-changing conversions.  */
10682           if (integer_all_onesp (arg1))
10683             return fold_convert_loc (loc, type, negate_expr (op0));
10684           /* Transform x * -C into -x * C if x is easily negatable.  */
10685           if (TREE_CODE (arg1) == INTEGER_CST
10686               && tree_int_cst_sgn (arg1) == -1
10687               && negate_expr_p (arg0)
10688               && (tem = negate_expr (arg1)) != arg1
10689               && !TREE_OVERFLOW (tem))
10690             return fold_build2_loc (loc, MULT_EXPR, type,
10691                                 fold_convert_loc (loc, type,
10692                                                   negate_expr (arg0)),
10693                                 tem);
10694
10695           /* (a * (1 << b)) is (a << b)  */
10696           if (TREE_CODE (arg1) == LSHIFT_EXPR
10697               && integer_onep (TREE_OPERAND (arg1, 0)))
10698             return fold_build2_loc (loc, LSHIFT_EXPR, type, op0,
10699                                 TREE_OPERAND (arg1, 1));
10700           if (TREE_CODE (arg0) == LSHIFT_EXPR
10701               && integer_onep (TREE_OPERAND (arg0, 0)))
10702             return fold_build2_loc (loc, LSHIFT_EXPR, type, op1,
10703                                 TREE_OPERAND (arg0, 1));
10704
10705           /* (A + A) * C -> A * 2 * C  */
10706           if (TREE_CODE (arg0) == PLUS_EXPR
10707               && TREE_CODE (arg1) == INTEGER_CST
10708               && operand_equal_p (TREE_OPERAND (arg0, 0),
10709                                   TREE_OPERAND (arg0, 1), 0))
10710             return fold_build2_loc (loc, MULT_EXPR, type,
10711                                 omit_one_operand_loc (loc, type,
10712                                                   TREE_OPERAND (arg0, 0),
10713                                                   TREE_OPERAND (arg0, 1)),
10714                                 fold_build2_loc (loc, MULT_EXPR, type,
10715                                              build_int_cst (type, 2) , arg1));
10716
10717           strict_overflow_p = false;
10718           if (TREE_CODE (arg1) == INTEGER_CST
10719               && 0 != (tem = extract_muldiv (op0, arg1, code, NULL_TREE,
10720                                              &strict_overflow_p)))
10721             {
10722               if (strict_overflow_p)
10723                 fold_overflow_warning (("assuming signed overflow does not "
10724                                         "occur when simplifying "
10725                                         "multiplication"),
10726                                        WARN_STRICT_OVERFLOW_MISC);
10727               return fold_convert_loc (loc, type, tem);
10728             }
10729
10730           /* Optimize z * conj(z) for integer complex numbers.  */
10731           if (TREE_CODE (arg0) == CONJ_EXPR
10732               && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
10733             return fold_mult_zconjz (loc, type, arg1);
10734           if (TREE_CODE (arg1) == CONJ_EXPR
10735               && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
10736             return fold_mult_zconjz (loc, type, arg0);
10737         }
10738       else
10739         {
10740           /* Maybe fold x * 0 to 0.  The expressions aren't the same
10741              when x is NaN, since x * 0 is also NaN.  Nor are they the
10742              same in modes with signed zeros, since multiplying a
10743              negative value by 0 gives -0, not +0.  */
10744           if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0)))
10745               && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0)))
10746               && real_zerop (arg1))
10747             return omit_one_operand_loc (loc, type, arg1, arg0);
10748           /* In IEEE floating point, x*1 is not equivalent to x for snans.
10749              Likewise for complex arithmetic with signed zeros.  */
10750           if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
10751               && (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0)))
10752                   || !COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0)))
10753               && real_onep (arg1))
10754             return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
10755
10756           /* Transform x * -1.0 into -x.  */
10757           if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
10758               && (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0)))
10759                   || !COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0)))
10760               && real_minus_onep (arg1))
10761             return fold_convert_loc (loc, type, negate_expr (arg0));
10762
10763           /* Convert (C1/X)*C2 into (C1*C2)/X.  This transformation may change
10764              the result for floating point types due to rounding so it is applied
10765              only if -fassociative-math was specify.  */
10766           if (flag_associative_math
10767               && TREE_CODE (arg0) == RDIV_EXPR
10768               && TREE_CODE (arg1) == REAL_CST
10769               && TREE_CODE (TREE_OPERAND (arg0, 0)) == REAL_CST)
10770             {
10771               tree tem = const_binop (MULT_EXPR, TREE_OPERAND (arg0, 0),
10772                                       arg1);
10773               if (tem)
10774                 return fold_build2_loc (loc, RDIV_EXPR, type, tem,
10775                                     TREE_OPERAND (arg0, 1));
10776             }
10777
10778           /* Strip sign operations from X in X*X, i.e. -Y*-Y -> Y*Y.  */
10779           if (operand_equal_p (arg0, arg1, 0))
10780             {
10781               tree tem = fold_strip_sign_ops (arg0);
10782               if (tem != NULL_TREE)
10783                 {
10784                   tem = fold_convert_loc (loc, type, tem);
10785                   return fold_build2_loc (loc, MULT_EXPR, type, tem, tem);
10786                 }
10787             }
10788
10789           /* Fold z * +-I to __complex__ (-+__imag z, +-__real z).
10790              This is not the same for NaNs or if signed zeros are
10791              involved.  */
10792           if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0)))
10793               && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0)))
10794               && COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0))
10795               && TREE_CODE (arg1) == COMPLEX_CST
10796               && real_zerop (TREE_REALPART (arg1)))
10797             {
10798               tree rtype = TREE_TYPE (TREE_TYPE (arg0));
10799               if (real_onep (TREE_IMAGPART (arg1)))
10800                 return
10801                   fold_build2_loc (loc, COMPLEX_EXPR, type,
10802                                negate_expr (fold_build1_loc (loc, IMAGPART_EXPR,
10803                                                              rtype, arg0)),
10804                                fold_build1_loc (loc, REALPART_EXPR, rtype, arg0));
10805               else if (real_minus_onep (TREE_IMAGPART (arg1)))
10806                 return
10807                   fold_build2_loc (loc, COMPLEX_EXPR, type,
10808                                fold_build1_loc (loc, IMAGPART_EXPR, rtype, arg0),
10809                                negate_expr (fold_build1_loc (loc, REALPART_EXPR,
10810                                                              rtype, arg0)));
10811             }
10812
10813           /* Optimize z * conj(z) for floating point complex numbers.
10814              Guarded by flag_unsafe_math_optimizations as non-finite
10815              imaginary components don't produce scalar results.  */
10816           if (flag_unsafe_math_optimizations
10817               && TREE_CODE (arg0) == CONJ_EXPR
10818               && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
10819             return fold_mult_zconjz (loc, type, arg1);
10820           if (flag_unsafe_math_optimizations
10821               && TREE_CODE (arg1) == CONJ_EXPR
10822               && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
10823             return fold_mult_zconjz (loc, type, arg0);
10824
10825           if (flag_unsafe_math_optimizations)
10826             {
10827               enum built_in_function fcode0 = builtin_mathfn_code (arg0);
10828               enum built_in_function fcode1 = builtin_mathfn_code (arg1);
10829
10830               /* Optimizations of root(...)*root(...).  */
10831               if (fcode0 == fcode1 && BUILTIN_ROOT_P (fcode0))
10832                 {
10833                   tree rootfn, arg;
10834                   tree arg00 = CALL_EXPR_ARG (arg0, 0);
10835                   tree arg10 = CALL_EXPR_ARG (arg1, 0);
10836
10837                   /* Optimize sqrt(x)*sqrt(x) as x.  */
10838                   if (BUILTIN_SQRT_P (fcode0)
10839                       && operand_equal_p (arg00, arg10, 0)
10840                       && ! HONOR_SNANS (TYPE_MODE (type)))
10841                     return arg00;
10842
10843                   /* Optimize root(x)*root(y) as root(x*y).  */
10844                   rootfn = TREE_OPERAND (CALL_EXPR_FN (arg0), 0);
10845                   arg = fold_build2_loc (loc, MULT_EXPR, type, arg00, arg10);
10846                   return build_call_expr_loc (loc, rootfn, 1, arg);
10847                 }
10848
10849               /* Optimize expN(x)*expN(y) as expN(x+y).  */
10850               if (fcode0 == fcode1 && BUILTIN_EXPONENT_P (fcode0))
10851                 {
10852                   tree expfn = TREE_OPERAND (CALL_EXPR_FN (arg0), 0);
10853                   tree arg = fold_build2_loc (loc, PLUS_EXPR, type,
10854                                           CALL_EXPR_ARG (arg0, 0),
10855                                           CALL_EXPR_ARG (arg1, 0));
10856                   return build_call_expr_loc (loc, expfn, 1, arg);
10857                 }
10858
10859               /* Optimizations of pow(...)*pow(...).  */
10860               if ((fcode0 == BUILT_IN_POW && fcode1 == BUILT_IN_POW)
10861                   || (fcode0 == BUILT_IN_POWF && fcode1 == BUILT_IN_POWF)
10862                   || (fcode0 == BUILT_IN_POWL && fcode1 == BUILT_IN_POWL))
10863                 {
10864                   tree arg00 = CALL_EXPR_ARG (arg0, 0);
10865                   tree arg01 = CALL_EXPR_ARG (arg0, 1);
10866                   tree arg10 = CALL_EXPR_ARG (arg1, 0);
10867                   tree arg11 = CALL_EXPR_ARG (arg1, 1);
10868
10869                   /* Optimize pow(x,y)*pow(z,y) as pow(x*z,y).  */
10870                   if (operand_equal_p (arg01, arg11, 0))
10871                     {
10872                       tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg0), 0);
10873                       tree arg = fold_build2_loc (loc, MULT_EXPR, type,
10874                                               arg00, arg10);
10875                       return build_call_expr_loc (loc, powfn, 2, arg, arg01);
10876                     }
10877
10878                   /* Optimize pow(x,y)*pow(x,z) as pow(x,y+z).  */
10879                   if (operand_equal_p (arg00, arg10, 0))
10880                     {
10881                       tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg0), 0);
10882                       tree arg = fold_build2_loc (loc, PLUS_EXPR, type,
10883                                               arg01, arg11);
10884                       return build_call_expr_loc (loc, powfn, 2, arg00, arg);
10885                     }
10886                 }
10887
10888               /* Optimize tan(x)*cos(x) as sin(x).  */
10889               if (((fcode0 == BUILT_IN_TAN && fcode1 == BUILT_IN_COS)
10890                    || (fcode0 == BUILT_IN_TANF && fcode1 == BUILT_IN_COSF)
10891                    || (fcode0 == BUILT_IN_TANL && fcode1 == BUILT_IN_COSL)
10892                    || (fcode0 == BUILT_IN_COS && fcode1 == BUILT_IN_TAN)
10893                    || (fcode0 == BUILT_IN_COSF && fcode1 == BUILT_IN_TANF)
10894                    || (fcode0 == BUILT_IN_COSL && fcode1 == BUILT_IN_TANL))
10895                   && operand_equal_p (CALL_EXPR_ARG (arg0, 0),
10896                                       CALL_EXPR_ARG (arg1, 0), 0))
10897                 {
10898                   tree sinfn = mathfn_built_in (type, BUILT_IN_SIN);
10899
10900                   if (sinfn != NULL_TREE)
10901                     return build_call_expr_loc (loc, sinfn, 1,
10902                                             CALL_EXPR_ARG (arg0, 0));
10903                 }
10904
10905               /* Optimize x*pow(x,c) as pow(x,c+1).  */
10906               if (fcode1 == BUILT_IN_POW
10907                   || fcode1 == BUILT_IN_POWF
10908                   || fcode1 == BUILT_IN_POWL)
10909                 {
10910                   tree arg10 = CALL_EXPR_ARG (arg1, 0);
10911                   tree arg11 = CALL_EXPR_ARG (arg1, 1);
10912                   if (TREE_CODE (arg11) == REAL_CST
10913                       && !TREE_OVERFLOW (arg11)
10914                       && operand_equal_p (arg0, arg10, 0))
10915                     {
10916                       tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg1), 0);
10917                       REAL_VALUE_TYPE c;
10918                       tree arg;
10919
10920                       c = TREE_REAL_CST (arg11);
10921                       real_arithmetic (&c, PLUS_EXPR, &c, &dconst1);
10922                       arg = build_real (type, c);
10923                       return build_call_expr_loc (loc, powfn, 2, arg0, arg);
10924                     }
10925                 }
10926
10927               /* Optimize pow(x,c)*x as pow(x,c+1).  */
10928               if (fcode0 == BUILT_IN_POW
10929                   || fcode0 == BUILT_IN_POWF
10930                   || fcode0 == BUILT_IN_POWL)
10931                 {
10932                   tree arg00 = CALL_EXPR_ARG (arg0, 0);
10933                   tree arg01 = CALL_EXPR_ARG (arg0, 1);
10934                   if (TREE_CODE (arg01) == REAL_CST
10935                       && !TREE_OVERFLOW (arg01)
10936                       && operand_equal_p (arg1, arg00, 0))
10937                     {
10938                       tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg0), 0);
10939                       REAL_VALUE_TYPE c;
10940                       tree arg;
10941
10942                       c = TREE_REAL_CST (arg01);
10943                       real_arithmetic (&c, PLUS_EXPR, &c, &dconst1);
10944                       arg = build_real (type, c);
10945                       return build_call_expr_loc (loc, powfn, 2, arg1, arg);
10946                     }
10947                 }
10948
10949               /* Canonicalize x*x as pow(x,2.0), which is expanded as x*x.  */
10950               if (!in_gimple_form
10951                   && optimize
10952                   && operand_equal_p (arg0, arg1, 0))
10953                 {
10954                   tree powfn = mathfn_built_in (type, BUILT_IN_POW);
10955
10956                   if (powfn)
10957                     {
10958                       tree arg = build_real (type, dconst2);
10959                       return build_call_expr_loc (loc, powfn, 2, arg0, arg);
10960                     }
10961                 }
10962             }
10963         }
10964       goto associate;
10965
10966     case BIT_IOR_EXPR:
10967     bit_ior:
10968       if (integer_all_onesp (arg1))
10969         return omit_one_operand_loc (loc, type, arg1, arg0);
10970       if (integer_zerop (arg1))
10971         return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
10972       if (operand_equal_p (arg0, arg1, 0))
10973         return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
10974
10975       /* ~X | X is -1.  */
10976       if (TREE_CODE (arg0) == BIT_NOT_EXPR
10977           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
10978         {
10979           t1 = build_zero_cst (type);
10980           t1 = fold_unary_loc (loc, BIT_NOT_EXPR, type, t1);
10981           return omit_one_operand_loc (loc, type, t1, arg1);
10982         }
10983
10984       /* X | ~X is -1.  */
10985       if (TREE_CODE (arg1) == BIT_NOT_EXPR
10986           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
10987         {
10988           t1 = build_zero_cst (type);
10989           t1 = fold_unary_loc (loc, BIT_NOT_EXPR, type, t1);
10990           return omit_one_operand_loc (loc, type, t1, arg0);
10991         }
10992
10993       /* Canonicalize (X & C1) | C2.  */
10994       if (TREE_CODE (arg0) == BIT_AND_EXPR
10995           && TREE_CODE (arg1) == INTEGER_CST
10996           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
10997         {
10998           double_int c1, c2, c3, msk;
10999           int width = TYPE_PRECISION (type), w;
11000           c1 = tree_to_double_int (TREE_OPERAND (arg0, 1));
11001           c2 = tree_to_double_int (arg1);
11002
11003           /* If (C1&C2) == C1, then (X&C1)|C2 becomes (X,C2).  */
11004           if (double_int_equal_p (double_int_and (c1, c2), c1))
11005             return omit_one_operand_loc (loc, type, arg1,
11006                                          TREE_OPERAND (arg0, 0));
11007
11008           msk = double_int_mask (width);
11009
11010           /* If (C1|C2) == ~0 then (X&C1)|C2 becomes X|C2.  */
11011           if (double_int_zero_p (double_int_and_not (msk,
11012                                                      double_int_ior (c1, c2))))
11013             return fold_build2_loc (loc, BIT_IOR_EXPR, type,
11014                                     TREE_OPERAND (arg0, 0), arg1);
11015
11016           /* Minimize the number of bits set in C1, i.e. C1 := C1 & ~C2,
11017              unless (C1 & ~C2) | (C2 & C3) for some C3 is a mask of some
11018              mode which allows further optimizations.  */
11019           c1 = double_int_and (c1, msk);
11020           c2 = double_int_and (c2, msk);
11021           c3 = double_int_and_not (c1, c2);
11022           for (w = BITS_PER_UNIT;
11023                w <= width && w <= HOST_BITS_PER_WIDE_INT;
11024                w <<= 1)
11025             {
11026               unsigned HOST_WIDE_INT mask
11027                 = (unsigned HOST_WIDE_INT) -1 >> (HOST_BITS_PER_WIDE_INT - w);
11028               if (((c1.low | c2.low) & mask) == mask
11029                   && (c1.low & ~mask) == 0 && c1.high == 0)
11030                 {
11031                   c3 = uhwi_to_double_int (mask);
11032                   break;
11033                 }
11034             }
11035           if (!double_int_equal_p (c3, c1))
11036             return fold_build2_loc (loc, BIT_IOR_EXPR, type,
11037                                     fold_build2_loc (loc, BIT_AND_EXPR, type,
11038                                                      TREE_OPERAND (arg0, 0),
11039                                                      double_int_to_tree (type,
11040                                                                          c3)),
11041                                     arg1);
11042         }
11043
11044       /* (X & Y) | Y is (X, Y).  */
11045       if (TREE_CODE (arg0) == BIT_AND_EXPR
11046           && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
11047         return omit_one_operand_loc (loc, type, arg1, TREE_OPERAND (arg0, 0));
11048       /* (X & Y) | X is (Y, X).  */
11049       if (TREE_CODE (arg0) == BIT_AND_EXPR
11050           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
11051           && reorder_operands_p (TREE_OPERAND (arg0, 1), arg1))
11052         return omit_one_operand_loc (loc, type, arg1, TREE_OPERAND (arg0, 1));
11053       /* X | (X & Y) is (Y, X).  */
11054       if (TREE_CODE (arg1) == BIT_AND_EXPR
11055           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0)
11056           && reorder_operands_p (arg0, TREE_OPERAND (arg1, 1)))
11057         return omit_one_operand_loc (loc, type, arg0, TREE_OPERAND (arg1, 1));
11058       /* X | (Y & X) is (Y, X).  */
11059       if (TREE_CODE (arg1) == BIT_AND_EXPR
11060           && operand_equal_p (arg0, TREE_OPERAND (arg1, 1), 0)
11061           && reorder_operands_p (arg0, TREE_OPERAND (arg1, 0)))
11062         return omit_one_operand_loc (loc, type, arg0, TREE_OPERAND (arg1, 0));
11063
11064       /* (X & ~Y) | (~X & Y) is X ^ Y */
11065       if (TREE_CODE (arg0) == BIT_AND_EXPR
11066           && TREE_CODE (arg1) == BIT_AND_EXPR)
11067         {
11068           tree a0, a1, l0, l1, n0, n1;
11069
11070           a0 = fold_convert_loc (loc, type, TREE_OPERAND (arg1, 0));
11071           a1 = fold_convert_loc (loc, type, TREE_OPERAND (arg1, 1));
11072
11073           l0 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
11074           l1 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 1));
11075
11076           n0 = fold_build1_loc (loc, BIT_NOT_EXPR, type, l0);
11077           n1 = fold_build1_loc (loc, BIT_NOT_EXPR, type, l1);
11078
11079           if ((operand_equal_p (n0, a0, 0)
11080                && operand_equal_p (n1, a1, 0))
11081               || (operand_equal_p (n0, a1, 0)
11082                   && operand_equal_p (n1, a0, 0)))
11083             return fold_build2_loc (loc, BIT_XOR_EXPR, type, l0, n1);
11084         }
11085
11086       t1 = distribute_bit_expr (loc, code, type, arg0, arg1);
11087       if (t1 != NULL_TREE)
11088         return t1;
11089
11090       /* Convert (or (not arg0) (not arg1)) to (not (and (arg0) (arg1))).
11091
11092          This results in more efficient code for machines without a NAND
11093          instruction.  Combine will canonicalize to the first form
11094          which will allow use of NAND instructions provided by the
11095          backend if they exist.  */
11096       if (TREE_CODE (arg0) == BIT_NOT_EXPR
11097           && TREE_CODE (arg1) == BIT_NOT_EXPR)
11098         {
11099           return
11100             fold_build1_loc (loc, BIT_NOT_EXPR, type,
11101                          build2 (BIT_AND_EXPR, type,
11102                                  fold_convert_loc (loc, type,
11103                                                    TREE_OPERAND (arg0, 0)),
11104                                  fold_convert_loc (loc, type,
11105                                                    TREE_OPERAND (arg1, 0))));
11106         }
11107
11108       /* See if this can be simplified into a rotate first.  If that
11109          is unsuccessful continue in the association code.  */
11110       goto bit_rotate;
11111
11112     case BIT_XOR_EXPR:
11113       if (integer_zerop (arg1))
11114         return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
11115       if (integer_all_onesp (arg1))
11116         return fold_build1_loc (loc, BIT_NOT_EXPR, type, op0);
11117       if (operand_equal_p (arg0, arg1, 0))
11118         return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
11119
11120       /* ~X ^ X is -1.  */
11121       if (TREE_CODE (arg0) == BIT_NOT_EXPR
11122           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
11123         {
11124           t1 = build_zero_cst (type);
11125           t1 = fold_unary_loc (loc, BIT_NOT_EXPR, type, t1);
11126           return omit_one_operand_loc (loc, type, t1, arg1);
11127         }
11128
11129       /* X ^ ~X is -1.  */
11130       if (TREE_CODE (arg1) == BIT_NOT_EXPR
11131           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
11132         {
11133           t1 = build_zero_cst (type);
11134           t1 = fold_unary_loc (loc, BIT_NOT_EXPR, type, t1);
11135           return omit_one_operand_loc (loc, type, t1, arg0);
11136         }
11137
11138       /* If we are XORing two BIT_AND_EXPR's, both of which are and'ing
11139          with a constant, and the two constants have no bits in common,
11140          we should treat this as a BIT_IOR_EXPR since this may produce more
11141          simplifications.  */
11142       if (TREE_CODE (arg0) == BIT_AND_EXPR
11143           && TREE_CODE (arg1) == BIT_AND_EXPR
11144           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
11145           && TREE_CODE (TREE_OPERAND (arg1, 1)) == INTEGER_CST
11146           && integer_zerop (const_binop (BIT_AND_EXPR,
11147                                          TREE_OPERAND (arg0, 1),
11148                                          TREE_OPERAND (arg1, 1))))
11149         {
11150           code = BIT_IOR_EXPR;
11151           goto bit_ior;
11152         }
11153
11154       /* (X | Y) ^ X -> Y & ~ X*/
11155       if (TREE_CODE (arg0) == BIT_IOR_EXPR
11156           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
11157         {
11158           tree t2 = TREE_OPERAND (arg0, 1);
11159           t1 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (arg1),
11160                             arg1);
11161           t1 = fold_build2_loc (loc, BIT_AND_EXPR, type,
11162                             fold_convert_loc (loc, type, t2),
11163                             fold_convert_loc (loc, type, t1));
11164           return t1;
11165         }
11166
11167       /* (Y | X) ^ X -> Y & ~ X*/
11168       if (TREE_CODE (arg0) == BIT_IOR_EXPR
11169           && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
11170         {
11171           tree t2 = TREE_OPERAND (arg0, 0);
11172           t1 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (arg1),
11173                             arg1);
11174           t1 = fold_build2_loc (loc, BIT_AND_EXPR, type,
11175                             fold_convert_loc (loc, type, t2),
11176                             fold_convert_loc (loc, type, t1));
11177           return t1;
11178         }
11179
11180       /* X ^ (X | Y) -> Y & ~ X*/
11181       if (TREE_CODE (arg1) == BIT_IOR_EXPR
11182           && operand_equal_p (TREE_OPERAND (arg1, 0), arg0, 0))
11183         {
11184           tree t2 = TREE_OPERAND (arg1, 1);
11185           t1 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (arg0),
11186                             arg0);
11187           t1 = fold_build2_loc (loc, BIT_AND_EXPR, type,
11188                             fold_convert_loc (loc, type, t2),
11189                             fold_convert_loc (loc, type, t1));
11190           return t1;
11191         }
11192
11193       /* X ^ (Y | X) -> Y & ~ X*/
11194       if (TREE_CODE (arg1) == BIT_IOR_EXPR
11195           && operand_equal_p (TREE_OPERAND (arg1, 1), arg0, 0))
11196         {
11197           tree t2 = TREE_OPERAND (arg1, 0);
11198           t1 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (arg0),
11199                             arg0);
11200           t1 = fold_build2_loc (loc, BIT_AND_EXPR, type,
11201                             fold_convert_loc (loc, type, t2),
11202                             fold_convert_loc (loc, type, t1));
11203           return t1;
11204         }
11205
11206       /* Convert ~X ^ ~Y to X ^ Y.  */
11207       if (TREE_CODE (arg0) == BIT_NOT_EXPR
11208           && TREE_CODE (arg1) == BIT_NOT_EXPR)
11209         return fold_build2_loc (loc, code, type,
11210                             fold_convert_loc (loc, type,
11211                                               TREE_OPERAND (arg0, 0)),
11212                             fold_convert_loc (loc, type,
11213                                               TREE_OPERAND (arg1, 0)));
11214
11215       /* Convert ~X ^ C to X ^ ~C.  */
11216       if (TREE_CODE (arg0) == BIT_NOT_EXPR
11217           && TREE_CODE (arg1) == INTEGER_CST)
11218         return fold_build2_loc (loc, code, type,
11219                             fold_convert_loc (loc, type,
11220                                               TREE_OPERAND (arg0, 0)),
11221                             fold_build1_loc (loc, BIT_NOT_EXPR, type, arg1));
11222
11223       /* Fold (X & 1) ^ 1 as (X & 1) == 0.  */
11224       if (TREE_CODE (arg0) == BIT_AND_EXPR
11225           && integer_onep (TREE_OPERAND (arg0, 1))
11226           && integer_onep (arg1))
11227         return fold_build2_loc (loc, EQ_EXPR, type, arg0,
11228                             build_int_cst (TREE_TYPE (arg0), 0));
11229
11230       /* Fold (X & Y) ^ Y as ~X & Y.  */
11231       if (TREE_CODE (arg0) == BIT_AND_EXPR
11232           && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
11233         {
11234           tem = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
11235           return fold_build2_loc (loc, BIT_AND_EXPR, type,
11236                               fold_build1_loc (loc, BIT_NOT_EXPR, type, tem),
11237                               fold_convert_loc (loc, type, arg1));
11238         }
11239       /* Fold (X & Y) ^ X as ~Y & X.  */
11240       if (TREE_CODE (arg0) == BIT_AND_EXPR
11241           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
11242           && reorder_operands_p (TREE_OPERAND (arg0, 1), arg1))
11243         {
11244           tem = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 1));
11245           return fold_build2_loc (loc, BIT_AND_EXPR, type,
11246                               fold_build1_loc (loc, BIT_NOT_EXPR, type, tem),
11247                               fold_convert_loc (loc, type, arg1));
11248         }
11249       /* Fold X ^ (X & Y) as X & ~Y.  */
11250       if (TREE_CODE (arg1) == BIT_AND_EXPR
11251           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
11252         {
11253           tem = fold_convert_loc (loc, type, TREE_OPERAND (arg1, 1));
11254           return fold_build2_loc (loc, BIT_AND_EXPR, type,
11255                               fold_convert_loc (loc, type, arg0),
11256                               fold_build1_loc (loc, BIT_NOT_EXPR, type, tem));
11257         }
11258       /* Fold X ^ (Y & X) as ~Y & X.  */
11259       if (TREE_CODE (arg1) == BIT_AND_EXPR
11260           && operand_equal_p (arg0, TREE_OPERAND (arg1, 1), 0)
11261           && reorder_operands_p (arg0, TREE_OPERAND (arg1, 0)))
11262         {
11263           tem = fold_convert_loc (loc, type, TREE_OPERAND (arg1, 0));
11264           return fold_build2_loc (loc, BIT_AND_EXPR, type,
11265                               fold_build1_loc (loc, BIT_NOT_EXPR, type, tem),
11266                               fold_convert_loc (loc, type, arg0));
11267         }
11268
11269       /* See if this can be simplified into a rotate first.  If that
11270          is unsuccessful continue in the association code.  */
11271       goto bit_rotate;
11272
11273     case BIT_AND_EXPR:
11274       if (integer_all_onesp (arg1))
11275         return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
11276       if (integer_zerop (arg1))
11277         return omit_one_operand_loc (loc, type, arg1, arg0);
11278       if (operand_equal_p (arg0, arg1, 0))
11279         return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
11280
11281       /* ~X & X, (X == 0) & X, and !X & X are always zero.  */
11282       if ((TREE_CODE (arg0) == BIT_NOT_EXPR
11283            || TREE_CODE (arg0) == TRUTH_NOT_EXPR
11284            || (TREE_CODE (arg0) == EQ_EXPR
11285                && integer_zerop (TREE_OPERAND (arg0, 1))))
11286           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
11287         return omit_one_operand_loc (loc, type, integer_zero_node, arg1);
11288
11289       /* X & ~X , X & (X == 0), and X & !X are always zero.  */
11290       if ((TREE_CODE (arg1) == BIT_NOT_EXPR
11291            || TREE_CODE (arg1) == TRUTH_NOT_EXPR
11292            || (TREE_CODE (arg1) == EQ_EXPR
11293                && integer_zerop (TREE_OPERAND (arg1, 1))))
11294           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
11295         return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
11296
11297       /* Canonicalize (X | C1) & C2 as (X & C2) | (C1 & C2).  */
11298       if (TREE_CODE (arg0) == BIT_IOR_EXPR
11299           && TREE_CODE (arg1) == INTEGER_CST
11300           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
11301         {
11302           tree tmp1 = fold_convert_loc (loc, type, arg1);
11303           tree tmp2 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
11304           tree tmp3 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 1));
11305           tmp2 = fold_build2_loc (loc, BIT_AND_EXPR, type, tmp2, tmp1);
11306           tmp3 = fold_build2_loc (loc, BIT_AND_EXPR, type, tmp3, tmp1);
11307           return
11308             fold_convert_loc (loc, type,
11309                               fold_build2_loc (loc, BIT_IOR_EXPR,
11310                                            type, tmp2, tmp3));
11311         }
11312
11313       /* (X | Y) & Y is (X, Y).  */
11314       if (TREE_CODE (arg0) == BIT_IOR_EXPR
11315           && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
11316         return omit_one_operand_loc (loc, type, arg1, TREE_OPERAND (arg0, 0));
11317       /* (X | Y) & X is (Y, X).  */
11318       if (TREE_CODE (arg0) == BIT_IOR_EXPR
11319           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
11320           && reorder_operands_p (TREE_OPERAND (arg0, 1), arg1))
11321         return omit_one_operand_loc (loc, type, arg1, TREE_OPERAND (arg0, 1));
11322       /* X & (X | Y) is (Y, X).  */
11323       if (TREE_CODE (arg1) == BIT_IOR_EXPR
11324           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0)
11325           && reorder_operands_p (arg0, TREE_OPERAND (arg1, 1)))
11326         return omit_one_operand_loc (loc, type, arg0, TREE_OPERAND (arg1, 1));
11327       /* X & (Y | X) is (Y, X).  */
11328       if (TREE_CODE (arg1) == BIT_IOR_EXPR
11329           && operand_equal_p (arg0, TREE_OPERAND (arg1, 1), 0)
11330           && reorder_operands_p (arg0, TREE_OPERAND (arg1, 0)))
11331         return omit_one_operand_loc (loc, type, arg0, TREE_OPERAND (arg1, 0));
11332
11333       /* Fold (X ^ 1) & 1 as (X & 1) == 0.  */
11334       if (TREE_CODE (arg0) == BIT_XOR_EXPR
11335           && integer_onep (TREE_OPERAND (arg0, 1))
11336           && integer_onep (arg1))
11337         {
11338           tem = TREE_OPERAND (arg0, 0);
11339           return fold_build2_loc (loc, EQ_EXPR, type,
11340                               fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (tem), tem,
11341                                            build_int_cst (TREE_TYPE (tem), 1)),
11342                               build_int_cst (TREE_TYPE (tem), 0));
11343         }
11344       /* Fold ~X & 1 as (X & 1) == 0.  */
11345       if (TREE_CODE (arg0) == BIT_NOT_EXPR
11346           && integer_onep (arg1))
11347         {
11348           tem = TREE_OPERAND (arg0, 0);
11349           return fold_build2_loc (loc, EQ_EXPR, type,
11350                               fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (tem), tem,
11351                                            build_int_cst (TREE_TYPE (tem), 1)),
11352                               build_int_cst (TREE_TYPE (tem), 0));
11353         }
11354       /* Fold !X & 1 as X == 0.  */
11355       if (TREE_CODE (arg0) == TRUTH_NOT_EXPR
11356           && integer_onep (arg1))
11357         {
11358           tem = TREE_OPERAND (arg0, 0);
11359           return fold_build2_loc (loc, EQ_EXPR, type, tem,
11360                                   build_int_cst (TREE_TYPE (tem), 0));
11361         }
11362
11363       /* Fold (X ^ Y) & Y as ~X & Y.  */
11364       if (TREE_CODE (arg0) == BIT_XOR_EXPR
11365           && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
11366         {
11367           tem = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
11368           return fold_build2_loc (loc, BIT_AND_EXPR, type,
11369                               fold_build1_loc (loc, BIT_NOT_EXPR, type, tem),
11370                               fold_convert_loc (loc, type, arg1));
11371         }
11372       /* Fold (X ^ Y) & X as ~Y & X.  */
11373       if (TREE_CODE (arg0) == BIT_XOR_EXPR
11374           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
11375           && reorder_operands_p (TREE_OPERAND (arg0, 1), arg1))
11376         {
11377           tem = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 1));
11378           return fold_build2_loc (loc, BIT_AND_EXPR, type,
11379                               fold_build1_loc (loc, BIT_NOT_EXPR, type, tem),
11380                               fold_convert_loc (loc, type, arg1));
11381         }
11382       /* Fold X & (X ^ Y) as X & ~Y.  */
11383       if (TREE_CODE (arg1) == BIT_XOR_EXPR
11384           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
11385         {
11386           tem = fold_convert_loc (loc, type, TREE_OPERAND (arg1, 1));
11387           return fold_build2_loc (loc, BIT_AND_EXPR, type,
11388                               fold_convert_loc (loc, type, arg0),
11389                               fold_build1_loc (loc, BIT_NOT_EXPR, type, tem));
11390         }
11391       /* Fold X & (Y ^ X) as ~Y & X.  */
11392       if (TREE_CODE (arg1) == BIT_XOR_EXPR
11393           && operand_equal_p (arg0, TREE_OPERAND (arg1, 1), 0)
11394           && reorder_operands_p (arg0, TREE_OPERAND (arg1, 0)))
11395         {
11396           tem = fold_convert_loc (loc, type, TREE_OPERAND (arg1, 0));
11397           return fold_build2_loc (loc, BIT_AND_EXPR, type,
11398                               fold_build1_loc (loc, BIT_NOT_EXPR, type, tem),
11399                               fold_convert_loc (loc, type, arg0));
11400         }
11401
11402       /* For constants M and N, if M == (1LL << cst) - 1 && (N & M) == M,
11403          ((A & N) + B) & M -> (A + B) & M
11404          Similarly if (N & M) == 0,
11405          ((A | N) + B) & M -> (A + B) & M
11406          and for - instead of + (or unary - instead of +)
11407          and/or ^ instead of |.
11408          If B is constant and (B & M) == 0, fold into A & M.  */
11409       if (host_integerp (arg1, 1))
11410         {
11411           unsigned HOST_WIDE_INT cst1 = tree_low_cst (arg1, 1);
11412           if (~cst1 && (cst1 & (cst1 + 1)) == 0
11413               && INTEGRAL_TYPE_P (TREE_TYPE (arg0))
11414               && (TREE_CODE (arg0) == PLUS_EXPR
11415                   || TREE_CODE (arg0) == MINUS_EXPR
11416                   || TREE_CODE (arg0) == NEGATE_EXPR)
11417               && (TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg0))
11418                   || TREE_CODE (TREE_TYPE (arg0)) == INTEGER_TYPE))
11419             {
11420               tree pmop[2];
11421               int which = 0;
11422               unsigned HOST_WIDE_INT cst0;
11423
11424               /* Now we know that arg0 is (C + D) or (C - D) or
11425                  -C and arg1 (M) is == (1LL << cst) - 1.
11426                  Store C into PMOP[0] and D into PMOP[1].  */
11427               pmop[0] = TREE_OPERAND (arg0, 0);
11428               pmop[1] = NULL;
11429               if (TREE_CODE (arg0) != NEGATE_EXPR)
11430                 {
11431                   pmop[1] = TREE_OPERAND (arg0, 1);
11432                   which = 1;
11433                 }
11434
11435               if (!host_integerp (TYPE_MAX_VALUE (TREE_TYPE (arg0)), 1)
11436                   || (tree_low_cst (TYPE_MAX_VALUE (TREE_TYPE (arg0)), 1)
11437                       & cst1) != cst1)
11438                 which = -1;
11439
11440               for (; which >= 0; which--)
11441                 switch (TREE_CODE (pmop[which]))
11442                   {
11443                   case BIT_AND_EXPR:
11444                   case BIT_IOR_EXPR:
11445                   case BIT_XOR_EXPR:
11446                     if (TREE_CODE (TREE_OPERAND (pmop[which], 1))
11447                         != INTEGER_CST)
11448                       break;
11449                     /* tree_low_cst not used, because we don't care about
11450                        the upper bits.  */
11451                     cst0 = TREE_INT_CST_LOW (TREE_OPERAND (pmop[which], 1));
11452                     cst0 &= cst1;
11453                     if (TREE_CODE (pmop[which]) == BIT_AND_EXPR)
11454                       {
11455                         if (cst0 != cst1)
11456                           break;
11457                       }
11458                     else if (cst0 != 0)
11459                       break;
11460                     /* If C or D is of the form (A & N) where
11461                        (N & M) == M, or of the form (A | N) or
11462                        (A ^ N) where (N & M) == 0, replace it with A.  */
11463                     pmop[which] = TREE_OPERAND (pmop[which], 0);
11464                     break;
11465                   case INTEGER_CST:
11466                     /* If C or D is a N where (N & M) == 0, it can be
11467                        omitted (assumed 0).  */
11468                     if ((TREE_CODE (arg0) == PLUS_EXPR
11469                          || (TREE_CODE (arg0) == MINUS_EXPR && which == 0))
11470                         && (TREE_INT_CST_LOW (pmop[which]) & cst1) == 0)
11471                       pmop[which] = NULL;
11472                     break;
11473                   default:
11474                     break;
11475                   }
11476
11477               /* Only build anything new if we optimized one or both arguments
11478                  above.  */
11479               if (pmop[0] != TREE_OPERAND (arg0, 0)
11480                   || (TREE_CODE (arg0) != NEGATE_EXPR
11481                       && pmop[1] != TREE_OPERAND (arg0, 1)))
11482                 {
11483                   tree utype = TREE_TYPE (arg0);
11484                   if (! TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg0)))
11485                     {
11486                       /* Perform the operations in a type that has defined
11487                          overflow behavior.  */
11488                       utype = unsigned_type_for (TREE_TYPE (arg0));
11489                       if (pmop[0] != NULL)
11490                         pmop[0] = fold_convert_loc (loc, utype, pmop[0]);
11491                       if (pmop[1] != NULL)
11492                         pmop[1] = fold_convert_loc (loc, utype, pmop[1]);
11493                     }
11494
11495                   if (TREE_CODE (arg0) == NEGATE_EXPR)
11496                     tem = fold_build1_loc (loc, NEGATE_EXPR, utype, pmop[0]);
11497                   else if (TREE_CODE (arg0) == PLUS_EXPR)
11498                     {
11499                       if (pmop[0] != NULL && pmop[1] != NULL)
11500                         tem = fold_build2_loc (loc, PLUS_EXPR, utype,
11501                                                pmop[0], pmop[1]);
11502                       else if (pmop[0] != NULL)
11503                         tem = pmop[0];
11504                       else if (pmop[1] != NULL)
11505                         tem = pmop[1];
11506                       else
11507                         return build_int_cst (type, 0);
11508                     }
11509                   else if (pmop[0] == NULL)
11510                     tem = fold_build1_loc (loc, NEGATE_EXPR, utype, pmop[1]);
11511                   else
11512                     tem = fold_build2_loc (loc, MINUS_EXPR, utype,
11513                                            pmop[0], pmop[1]);
11514                   /* TEM is now the new binary +, - or unary - replacement.  */
11515                   tem = fold_build2_loc (loc, BIT_AND_EXPR, utype, tem,
11516                                          fold_convert_loc (loc, utype, arg1));
11517                   return fold_convert_loc (loc, type, tem);
11518                 }
11519             }
11520         }
11521
11522       t1 = distribute_bit_expr (loc, code, type, arg0, arg1);
11523       if (t1 != NULL_TREE)
11524         return t1;
11525       /* Simplify ((int)c & 0377) into (int)c, if c is unsigned char.  */
11526       if (TREE_CODE (arg1) == INTEGER_CST && TREE_CODE (arg0) == NOP_EXPR
11527           && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg0, 0))))
11528         {
11529           unsigned int prec
11530             = TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0)));
11531
11532           if (prec < BITS_PER_WORD && prec < HOST_BITS_PER_WIDE_INT
11533               && (~TREE_INT_CST_LOW (arg1)
11534                   & (((HOST_WIDE_INT) 1 << prec) - 1)) == 0)
11535             return
11536               fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
11537         }
11538
11539       /* Convert (and (not arg0) (not arg1)) to (not (or (arg0) (arg1))).
11540
11541          This results in more efficient code for machines without a NOR
11542          instruction.  Combine will canonicalize to the first form
11543          which will allow use of NOR instructions provided by the
11544          backend if they exist.  */
11545       if (TREE_CODE (arg0) == BIT_NOT_EXPR
11546           && TREE_CODE (arg1) == BIT_NOT_EXPR)
11547         {
11548           return fold_build1_loc (loc, BIT_NOT_EXPR, type,
11549                               build2 (BIT_IOR_EXPR, type,
11550                                       fold_convert_loc (loc, type,
11551                                                         TREE_OPERAND (arg0, 0)),
11552                                       fold_convert_loc (loc, type,
11553                                                         TREE_OPERAND (arg1, 0))));
11554         }
11555
11556       /* If arg0 is derived from the address of an object or function, we may
11557          be able to fold this expression using the object or function's
11558          alignment.  */
11559       if (POINTER_TYPE_P (TREE_TYPE (arg0)) && host_integerp (arg1, 1))
11560         {
11561           unsigned HOST_WIDE_INT modulus, residue;
11562           unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (arg1);
11563
11564           modulus = get_pointer_modulus_and_residue (arg0, &residue,
11565                                                      integer_onep (arg1));
11566
11567           /* This works because modulus is a power of 2.  If this weren't the
11568              case, we'd have to replace it by its greatest power-of-2
11569              divisor: modulus & -modulus.  */
11570           if (low < modulus)
11571             return build_int_cst (type, residue & low);
11572         }
11573
11574       /* Fold (X << C1) & C2 into (X << C1) & (C2 | ((1 << C1) - 1))
11575               (X >> C1) & C2 into (X >> C1) & (C2 | ~((type) -1 >> C1))
11576          if the new mask might be further optimized.  */
11577       if ((TREE_CODE (arg0) == LSHIFT_EXPR
11578            || TREE_CODE (arg0) == RSHIFT_EXPR)
11579           && host_integerp (TREE_OPERAND (arg0, 1), 1)
11580           && host_integerp (arg1, TYPE_UNSIGNED (TREE_TYPE (arg1)))
11581           && tree_low_cst (TREE_OPERAND (arg0, 1), 1)
11582              < TYPE_PRECISION (TREE_TYPE (arg0))
11583           && TYPE_PRECISION (TREE_TYPE (arg0)) <= HOST_BITS_PER_WIDE_INT
11584           && tree_low_cst (TREE_OPERAND (arg0, 1), 1) > 0)
11585         {
11586           unsigned int shiftc = tree_low_cst (TREE_OPERAND (arg0, 1), 1);
11587           unsigned HOST_WIDE_INT mask
11588             = tree_low_cst (arg1, TYPE_UNSIGNED (TREE_TYPE (arg1)));
11589           unsigned HOST_WIDE_INT newmask, zerobits = 0;
11590           tree shift_type = TREE_TYPE (arg0);
11591
11592           if (TREE_CODE (arg0) == LSHIFT_EXPR)
11593             zerobits = ((((unsigned HOST_WIDE_INT) 1) << shiftc) - 1);
11594           else if (TREE_CODE (arg0) == RSHIFT_EXPR
11595                    && TYPE_PRECISION (TREE_TYPE (arg0))
11596                       == GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (arg0))))
11597             {
11598               unsigned int prec = TYPE_PRECISION (TREE_TYPE (arg0));
11599               tree arg00 = TREE_OPERAND (arg0, 0);
11600               /* See if more bits can be proven as zero because of
11601                  zero extension.  */
11602               if (TREE_CODE (arg00) == NOP_EXPR
11603                   && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg00, 0))))
11604                 {
11605                   tree inner_type = TREE_TYPE (TREE_OPERAND (arg00, 0));
11606                   if (TYPE_PRECISION (inner_type)
11607                       == GET_MODE_BITSIZE (TYPE_MODE (inner_type))
11608                       && TYPE_PRECISION (inner_type) < prec)
11609                     {
11610                       prec = TYPE_PRECISION (inner_type);
11611                       /* See if we can shorten the right shift.  */
11612                       if (shiftc < prec)
11613                         shift_type = inner_type;
11614                     }
11615                 }
11616               zerobits = ~(unsigned HOST_WIDE_INT) 0;
11617               zerobits >>= HOST_BITS_PER_WIDE_INT - shiftc;
11618               zerobits <<= prec - shiftc;
11619               /* For arithmetic shift if sign bit could be set, zerobits
11620                  can contain actually sign bits, so no transformation is
11621                  possible, unless MASK masks them all away.  In that
11622                  case the shift needs to be converted into logical shift.  */
11623               if (!TYPE_UNSIGNED (TREE_TYPE (arg0))
11624                   && prec == TYPE_PRECISION (TREE_TYPE (arg0)))
11625                 {
11626                   if ((mask & zerobits) == 0)
11627                     shift_type = unsigned_type_for (TREE_TYPE (arg0));
11628                   else
11629                     zerobits = 0;
11630                 }
11631             }
11632
11633           /* ((X << 16) & 0xff00) is (X, 0).  */
11634           if ((mask & zerobits) == mask)
11635             return omit_one_operand_loc (loc, type,
11636                                      build_int_cst (type, 0), arg0);
11637
11638           newmask = mask | zerobits;
11639           if (newmask != mask && (newmask & (newmask + 1)) == 0)
11640             {
11641               unsigned int prec;
11642
11643               /* Only do the transformation if NEWMASK is some integer
11644                  mode's mask.  */
11645               for (prec = BITS_PER_UNIT;
11646                    prec < HOST_BITS_PER_WIDE_INT; prec <<= 1)
11647                 if (newmask == (((unsigned HOST_WIDE_INT) 1) << prec) - 1)
11648                   break;
11649               if (prec < HOST_BITS_PER_WIDE_INT
11650                   || newmask == ~(unsigned HOST_WIDE_INT) 0)
11651                 {
11652                   tree newmaskt;
11653
11654                   if (shift_type != TREE_TYPE (arg0))
11655                     {
11656                       tem = fold_build2_loc (loc, TREE_CODE (arg0), shift_type,
11657                                          fold_convert_loc (loc, shift_type,
11658                                                            TREE_OPERAND (arg0, 0)),
11659                                          TREE_OPERAND (arg0, 1));
11660                       tem = fold_convert_loc (loc, type, tem);
11661                     }
11662                   else
11663                     tem = op0;
11664                   newmaskt = build_int_cst_type (TREE_TYPE (op1), newmask);
11665                   if (!tree_int_cst_equal (newmaskt, arg1))
11666                     return fold_build2_loc (loc, BIT_AND_EXPR, type, tem, newmaskt);
11667                 }
11668             }
11669         }
11670
11671       goto associate;
11672
11673     case RDIV_EXPR:
11674       /* Don't touch a floating-point divide by zero unless the mode
11675          of the constant can represent infinity.  */
11676       if (TREE_CODE (arg1) == REAL_CST
11677           && !MODE_HAS_INFINITIES (TYPE_MODE (TREE_TYPE (arg1)))
11678           && real_zerop (arg1))
11679         return NULL_TREE;
11680
11681       /* Optimize A / A to 1.0 if we don't care about
11682          NaNs or Infinities.  Skip the transformation
11683          for non-real operands.  */
11684       if (SCALAR_FLOAT_TYPE_P (TREE_TYPE (arg0))
11685           && ! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0)))
11686           && ! HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg0)))
11687           && operand_equal_p (arg0, arg1, 0))
11688         {
11689           tree r = build_real (TREE_TYPE (arg0), dconst1);
11690
11691           return omit_two_operands_loc (loc, type, r, arg0, arg1);
11692         }
11693
11694       /* The complex version of the above A / A optimization.  */
11695       if (COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0))
11696           && operand_equal_p (arg0, arg1, 0))
11697         {
11698           tree elem_type = TREE_TYPE (TREE_TYPE (arg0));
11699           if (! HONOR_NANS (TYPE_MODE (elem_type))
11700               && ! HONOR_INFINITIES (TYPE_MODE (elem_type)))
11701             {
11702               tree r = build_real (elem_type, dconst1);
11703               /* omit_two_operands will call fold_convert for us.  */
11704               return omit_two_operands_loc (loc, type, r, arg0, arg1);
11705             }
11706         }
11707
11708       /* (-A) / (-B) -> A / B  */
11709       if (TREE_CODE (arg0) == NEGATE_EXPR && negate_expr_p (arg1))
11710         return fold_build2_loc (loc, RDIV_EXPR, type,
11711                             TREE_OPERAND (arg0, 0),
11712                             negate_expr (arg1));
11713       if (TREE_CODE (arg1) == NEGATE_EXPR && negate_expr_p (arg0))
11714         return fold_build2_loc (loc, RDIV_EXPR, type,
11715                             negate_expr (arg0),
11716                             TREE_OPERAND (arg1, 0));
11717
11718       /* In IEEE floating point, x/1 is not equivalent to x for snans.  */
11719       if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
11720           && real_onep (arg1))
11721         return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
11722
11723       /* In IEEE floating point, x/-1 is not equivalent to -x for snans.  */
11724       if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
11725           && real_minus_onep (arg1))
11726         return non_lvalue_loc (loc, fold_convert_loc (loc, type,
11727                                                   negate_expr (arg0)));
11728
11729       /* If ARG1 is a constant, we can convert this to a multiply by the
11730          reciprocal.  This does not have the same rounding properties,
11731          so only do this if -freciprocal-math.  We can actually
11732          always safely do it if ARG1 is a power of two, but it's hard to
11733          tell if it is or not in a portable manner.  */
11734       if (TREE_CODE (arg1) == REAL_CST)
11735         {
11736           if (flag_reciprocal_math
11737               && 0 != (tem = const_binop (code, build_real (type, dconst1),
11738                                           arg1)))
11739             return fold_build2_loc (loc, MULT_EXPR, type, arg0, tem);
11740           /* Find the reciprocal if optimizing and the result is exact.  */
11741           if (optimize)
11742             {
11743               REAL_VALUE_TYPE r;
11744               r = TREE_REAL_CST (arg1);
11745               if (exact_real_inverse (TYPE_MODE(TREE_TYPE(arg0)), &r))
11746                 {
11747                   tem = build_real (type, r);
11748                   return fold_build2_loc (loc, MULT_EXPR, type,
11749                                       fold_convert_loc (loc, type, arg0), tem);
11750                 }
11751             }
11752         }
11753       /* Convert A/B/C to A/(B*C).  */
11754       if (flag_reciprocal_math
11755           && TREE_CODE (arg0) == RDIV_EXPR)
11756         return fold_build2_loc (loc, RDIV_EXPR, type, TREE_OPERAND (arg0, 0),
11757                             fold_build2_loc (loc, MULT_EXPR, type,
11758                                          TREE_OPERAND (arg0, 1), arg1));
11759
11760       /* Convert A/(B/C) to (A/B)*C.  */
11761       if (flag_reciprocal_math
11762           && TREE_CODE (arg1) == RDIV_EXPR)
11763         return fold_build2_loc (loc, MULT_EXPR, type,
11764                             fold_build2_loc (loc, RDIV_EXPR, type, arg0,
11765                                          TREE_OPERAND (arg1, 0)),
11766                             TREE_OPERAND (arg1, 1));
11767
11768       /* Convert C1/(X*C2) into (C1/C2)/X.  */
11769       if (flag_reciprocal_math
11770           && TREE_CODE (arg1) == MULT_EXPR
11771           && TREE_CODE (arg0) == REAL_CST
11772           && TREE_CODE (TREE_OPERAND (arg1, 1)) == REAL_CST)
11773         {
11774           tree tem = const_binop (RDIV_EXPR, arg0,
11775                                   TREE_OPERAND (arg1, 1));
11776           if (tem)
11777             return fold_build2_loc (loc, RDIV_EXPR, type, tem,
11778                                 TREE_OPERAND (arg1, 0));
11779         }
11780
11781       if (flag_unsafe_math_optimizations)
11782         {
11783           enum built_in_function fcode0 = builtin_mathfn_code (arg0);
11784           enum built_in_function fcode1 = builtin_mathfn_code (arg1);
11785
11786           /* Optimize sin(x)/cos(x) as tan(x).  */
11787           if (((fcode0 == BUILT_IN_SIN && fcode1 == BUILT_IN_COS)
11788                || (fcode0 == BUILT_IN_SINF && fcode1 == BUILT_IN_COSF)
11789                || (fcode0 == BUILT_IN_SINL && fcode1 == BUILT_IN_COSL))
11790               && operand_equal_p (CALL_EXPR_ARG (arg0, 0),
11791                                   CALL_EXPR_ARG (arg1, 0), 0))
11792             {
11793               tree tanfn = mathfn_built_in (type, BUILT_IN_TAN);
11794
11795               if (tanfn != NULL_TREE)
11796                 return build_call_expr_loc (loc, tanfn, 1, CALL_EXPR_ARG (arg0, 0));
11797             }
11798
11799           /* Optimize cos(x)/sin(x) as 1.0/tan(x).  */
11800           if (((fcode0 == BUILT_IN_COS && fcode1 == BUILT_IN_SIN)
11801                || (fcode0 == BUILT_IN_COSF && fcode1 == BUILT_IN_SINF)
11802                || (fcode0 == BUILT_IN_COSL && fcode1 == BUILT_IN_SINL))
11803               && operand_equal_p (CALL_EXPR_ARG (arg0, 0),
11804                                   CALL_EXPR_ARG (arg1, 0), 0))
11805             {
11806               tree tanfn = mathfn_built_in (type, BUILT_IN_TAN);
11807
11808               if (tanfn != NULL_TREE)
11809                 {
11810                   tree tmp = build_call_expr_loc (loc, tanfn, 1,
11811                                               CALL_EXPR_ARG (arg0, 0));
11812                   return fold_build2_loc (loc, RDIV_EXPR, type,
11813                                       build_real (type, dconst1), tmp);
11814                 }
11815             }
11816
11817           /* Optimize sin(x)/tan(x) as cos(x) if we don't care about
11818              NaNs or Infinities.  */
11819           if (((fcode0 == BUILT_IN_SIN && fcode1 == BUILT_IN_TAN)
11820                || (fcode0 == BUILT_IN_SINF && fcode1 == BUILT_IN_TANF)
11821                || (fcode0 == BUILT_IN_SINL && fcode1 == BUILT_IN_TANL)))
11822             {
11823               tree arg00 = CALL_EXPR_ARG (arg0, 0);
11824               tree arg01 = CALL_EXPR_ARG (arg1, 0);
11825
11826               if (! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg00)))
11827                   && ! HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg00)))
11828                   && operand_equal_p (arg00, arg01, 0))
11829                 {
11830                   tree cosfn = mathfn_built_in (type, BUILT_IN_COS);
11831
11832                   if (cosfn != NULL_TREE)
11833                     return build_call_expr_loc (loc, cosfn, 1, arg00);
11834                 }
11835             }
11836
11837           /* Optimize tan(x)/sin(x) as 1.0/cos(x) if we don't care about
11838              NaNs or Infinities.  */
11839           if (((fcode0 == BUILT_IN_TAN && fcode1 == BUILT_IN_SIN)
11840                || (fcode0 == BUILT_IN_TANF && fcode1 == BUILT_IN_SINF)
11841                || (fcode0 == BUILT_IN_TANL && fcode1 == BUILT_IN_SINL)))
11842             {
11843               tree arg00 = CALL_EXPR_ARG (arg0, 0);
11844               tree arg01 = CALL_EXPR_ARG (arg1, 0);
11845
11846               if (! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg00)))
11847                   && ! HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg00)))
11848                   && operand_equal_p (arg00, arg01, 0))
11849                 {
11850                   tree cosfn = mathfn_built_in (type, BUILT_IN_COS);
11851
11852                   if (cosfn != NULL_TREE)
11853                     {
11854                       tree tmp = build_call_expr_loc (loc, cosfn, 1, arg00);
11855                       return fold_build2_loc (loc, RDIV_EXPR, type,
11856                                           build_real (type, dconst1),
11857                                           tmp);
11858                     }
11859                 }
11860             }
11861
11862           /* Optimize pow(x,c)/x as pow(x,c-1).  */
11863           if (fcode0 == BUILT_IN_POW
11864               || fcode0 == BUILT_IN_POWF
11865               || fcode0 == BUILT_IN_POWL)
11866             {
11867               tree arg00 = CALL_EXPR_ARG (arg0, 0);
11868               tree arg01 = CALL_EXPR_ARG (arg0, 1);
11869               if (TREE_CODE (arg01) == REAL_CST
11870                   && !TREE_OVERFLOW (arg01)
11871                   && operand_equal_p (arg1, arg00, 0))
11872                 {
11873                   tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg0), 0);
11874                   REAL_VALUE_TYPE c;
11875                   tree arg;
11876
11877                   c = TREE_REAL_CST (arg01);
11878                   real_arithmetic (&c, MINUS_EXPR, &c, &dconst1);
11879                   arg = build_real (type, c);
11880                   return build_call_expr_loc (loc, powfn, 2, arg1, arg);
11881                 }
11882             }
11883
11884           /* Optimize a/root(b/c) into a*root(c/b).  */
11885           if (BUILTIN_ROOT_P (fcode1))
11886             {
11887               tree rootarg = CALL_EXPR_ARG (arg1, 0);
11888
11889               if (TREE_CODE (rootarg) == RDIV_EXPR)
11890                 {
11891                   tree rootfn = TREE_OPERAND (CALL_EXPR_FN (arg1), 0);
11892                   tree b = TREE_OPERAND (rootarg, 0);
11893                   tree c = TREE_OPERAND (rootarg, 1);
11894
11895                   tree tmp = fold_build2_loc (loc, RDIV_EXPR, type, c, b);
11896
11897                   tmp = build_call_expr_loc (loc, rootfn, 1, tmp);
11898                   return fold_build2_loc (loc, MULT_EXPR, type, arg0, tmp);
11899                 }
11900             }
11901
11902           /* Optimize x/expN(y) into x*expN(-y).  */
11903           if (BUILTIN_EXPONENT_P (fcode1))
11904             {
11905               tree expfn = TREE_OPERAND (CALL_EXPR_FN (arg1), 0);
11906               tree arg = negate_expr (CALL_EXPR_ARG (arg1, 0));
11907               arg1 = build_call_expr_loc (loc,
11908                                       expfn, 1,
11909                                       fold_convert_loc (loc, type, arg));
11910               return fold_build2_loc (loc, MULT_EXPR, type, arg0, arg1);
11911             }
11912
11913           /* Optimize x/pow(y,z) into x*pow(y,-z).  */
11914           if (fcode1 == BUILT_IN_POW
11915               || fcode1 == BUILT_IN_POWF
11916               || fcode1 == BUILT_IN_POWL)
11917             {
11918               tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg1), 0);
11919               tree arg10 = CALL_EXPR_ARG (arg1, 0);
11920               tree arg11 = CALL_EXPR_ARG (arg1, 1);
11921               tree neg11 = fold_convert_loc (loc, type,
11922                                              negate_expr (arg11));
11923               arg1 = build_call_expr_loc (loc, powfn, 2, arg10, neg11);
11924               return fold_build2_loc (loc, MULT_EXPR, type, arg0, arg1);
11925             }
11926         }
11927       return NULL_TREE;
11928
11929     case TRUNC_DIV_EXPR:
11930       /* Optimize (X & (-A)) / A where A is a power of 2,
11931          to X >> log2(A) */
11932       if (TREE_CODE (arg0) == BIT_AND_EXPR
11933           && !TYPE_UNSIGNED (type) && TREE_CODE (arg1) == INTEGER_CST
11934           && integer_pow2p (arg1) && tree_int_cst_sgn (arg1) > 0)
11935         {
11936           tree sum = fold_binary_loc (loc, PLUS_EXPR, TREE_TYPE (arg1),
11937                                       arg1, TREE_OPERAND (arg0, 1));
11938           if (sum && integer_zerop (sum)) {
11939             unsigned long pow2;
11940
11941             if (TREE_INT_CST_LOW (arg1))
11942               pow2 = exact_log2 (TREE_INT_CST_LOW (arg1));
11943             else
11944               pow2 = exact_log2 (TREE_INT_CST_HIGH (arg1))
11945                       + HOST_BITS_PER_WIDE_INT;
11946
11947             return fold_build2_loc (loc, RSHIFT_EXPR, type,
11948                           TREE_OPERAND (arg0, 0),
11949                           build_int_cst (integer_type_node, pow2));
11950           }
11951         }
11952
11953       /* Fall thru */
11954
11955     case FLOOR_DIV_EXPR:
11956       /* Simplify A / (B << N) where A and B are positive and B is
11957          a power of 2, to A >> (N + log2(B)).  */
11958       strict_overflow_p = false;
11959       if (TREE_CODE (arg1) == LSHIFT_EXPR
11960           && (TYPE_UNSIGNED (type)
11961               || tree_expr_nonnegative_warnv_p (op0, &strict_overflow_p)))
11962         {
11963           tree sval = TREE_OPERAND (arg1, 0);
11964           if (integer_pow2p (sval) && tree_int_cst_sgn (sval) > 0)
11965             {
11966               tree sh_cnt = TREE_OPERAND (arg1, 1);
11967               unsigned long pow2;
11968
11969               if (TREE_INT_CST_LOW (sval))
11970                 pow2 = exact_log2 (TREE_INT_CST_LOW (sval));
11971               else
11972                 pow2 = exact_log2 (TREE_INT_CST_HIGH (sval))
11973                        + HOST_BITS_PER_WIDE_INT;
11974
11975               if (strict_overflow_p)
11976                 fold_overflow_warning (("assuming signed overflow does not "
11977                                         "occur when simplifying A / (B << N)"),
11978                                        WARN_STRICT_OVERFLOW_MISC);
11979
11980               sh_cnt = fold_build2_loc (loc, PLUS_EXPR, TREE_TYPE (sh_cnt),
11981                                         sh_cnt,
11982                                         build_int_cst (TREE_TYPE (sh_cnt),
11983                                                        pow2));
11984               return fold_build2_loc (loc, RSHIFT_EXPR, type,
11985                                   fold_convert_loc (loc, type, arg0), sh_cnt);
11986             }
11987         }
11988
11989       /* For unsigned integral types, FLOOR_DIV_EXPR is the same as
11990          TRUNC_DIV_EXPR.  Rewrite into the latter in this case.  */
11991       if (INTEGRAL_TYPE_P (type)
11992           && TYPE_UNSIGNED (type)
11993           && code == FLOOR_DIV_EXPR)
11994         return fold_build2_loc (loc, TRUNC_DIV_EXPR, type, op0, op1);
11995
11996       /* Fall thru */
11997
11998     case ROUND_DIV_EXPR:
11999     case CEIL_DIV_EXPR:
12000     case EXACT_DIV_EXPR:
12001       if (integer_onep (arg1))
12002         return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
12003       if (integer_zerop (arg1))
12004         return NULL_TREE;
12005       /* X / -1 is -X.  */
12006       if (!TYPE_UNSIGNED (type)
12007           && TREE_CODE (arg1) == INTEGER_CST
12008           && TREE_INT_CST_LOW (arg1) == (unsigned HOST_WIDE_INT) -1
12009           && TREE_INT_CST_HIGH (arg1) == -1)
12010         return fold_convert_loc (loc, type, negate_expr (arg0));
12011
12012       /* Convert -A / -B to A / B when the type is signed and overflow is
12013          undefined.  */
12014       if ((!INTEGRAL_TYPE_P (type) || TYPE_OVERFLOW_UNDEFINED (type))
12015           && TREE_CODE (arg0) == NEGATE_EXPR
12016           && negate_expr_p (arg1))
12017         {
12018           if (INTEGRAL_TYPE_P (type))
12019             fold_overflow_warning (("assuming signed overflow does not occur "
12020                                     "when distributing negation across "
12021                                     "division"),
12022                                    WARN_STRICT_OVERFLOW_MISC);
12023           return fold_build2_loc (loc, code, type,
12024                               fold_convert_loc (loc, type,
12025                                                 TREE_OPERAND (arg0, 0)),
12026                               fold_convert_loc (loc, type,
12027                                                 negate_expr (arg1)));
12028         }
12029       if ((!INTEGRAL_TYPE_P (type) || TYPE_OVERFLOW_UNDEFINED (type))
12030           && TREE_CODE (arg1) == NEGATE_EXPR
12031           && negate_expr_p (arg0))
12032         {
12033           if (INTEGRAL_TYPE_P (type))
12034             fold_overflow_warning (("assuming signed overflow does not occur "
12035                                     "when distributing negation across "
12036                                     "division"),
12037                                    WARN_STRICT_OVERFLOW_MISC);
12038           return fold_build2_loc (loc, code, type,
12039                               fold_convert_loc (loc, type,
12040                                                 negate_expr (arg0)),
12041                               fold_convert_loc (loc, type,
12042                                                 TREE_OPERAND (arg1, 0)));
12043         }
12044
12045       /* If arg0 is a multiple of arg1, then rewrite to the fastest div
12046          operation, EXACT_DIV_EXPR.
12047
12048          Note that only CEIL_DIV_EXPR and FLOOR_DIV_EXPR are rewritten now.
12049          At one time others generated faster code, it's not clear if they do
12050          after the last round to changes to the DIV code in expmed.c.  */
12051       if ((code == CEIL_DIV_EXPR || code == FLOOR_DIV_EXPR)
12052           && multiple_of_p (type, arg0, arg1))
12053         return fold_build2_loc (loc, EXACT_DIV_EXPR, type, arg0, arg1);
12054
12055       strict_overflow_p = false;
12056       if (TREE_CODE (arg1) == INTEGER_CST
12057           && 0 != (tem = extract_muldiv (op0, arg1, code, NULL_TREE,
12058                                          &strict_overflow_p)))
12059         {
12060           if (strict_overflow_p)
12061             fold_overflow_warning (("assuming signed overflow does not occur "
12062                                     "when simplifying division"),
12063                                    WARN_STRICT_OVERFLOW_MISC);
12064           return fold_convert_loc (loc, type, tem);
12065         }
12066
12067       return NULL_TREE;
12068
12069     case CEIL_MOD_EXPR:
12070     case FLOOR_MOD_EXPR:
12071     case ROUND_MOD_EXPR:
12072     case TRUNC_MOD_EXPR:
12073       /* X % 1 is always zero, but be sure to preserve any side
12074          effects in X.  */
12075       if (integer_onep (arg1))
12076         return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
12077
12078       /* X % 0, return X % 0 unchanged so that we can get the
12079          proper warnings and errors.  */
12080       if (integer_zerop (arg1))
12081         return NULL_TREE;
12082
12083       /* 0 % X is always zero, but be sure to preserve any side
12084          effects in X.  Place this after checking for X == 0.  */
12085       if (integer_zerop (arg0))
12086         return omit_one_operand_loc (loc, type, integer_zero_node, arg1);
12087
12088       /* X % -1 is zero.  */
12089       if (!TYPE_UNSIGNED (type)
12090           && TREE_CODE (arg1) == INTEGER_CST
12091           && TREE_INT_CST_LOW (arg1) == (unsigned HOST_WIDE_INT) -1
12092           && TREE_INT_CST_HIGH (arg1) == -1)
12093         return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
12094
12095       /* X % -C is the same as X % C.  */
12096       if (code == TRUNC_MOD_EXPR
12097           && !TYPE_UNSIGNED (type)
12098           && TREE_CODE (arg1) == INTEGER_CST
12099           && !TREE_OVERFLOW (arg1)
12100           && TREE_INT_CST_HIGH (arg1) < 0
12101           && !TYPE_OVERFLOW_TRAPS (type)
12102           /* Avoid this transformation if C is INT_MIN, i.e. C == -C.  */
12103           && !sign_bit_p (arg1, arg1))
12104         return fold_build2_loc (loc, code, type,
12105                             fold_convert_loc (loc, type, arg0),
12106                             fold_convert_loc (loc, type,
12107                                               negate_expr (arg1)));
12108
12109       /* X % -Y is the same as X % Y.  */
12110       if (code == TRUNC_MOD_EXPR
12111           && !TYPE_UNSIGNED (type)
12112           && TREE_CODE (arg1) == NEGATE_EXPR
12113           && !TYPE_OVERFLOW_TRAPS (type))
12114         return fold_build2_loc (loc, code, type, fold_convert_loc (loc, type, arg0),
12115                             fold_convert_loc (loc, type,
12116                                               TREE_OPERAND (arg1, 0)));
12117
12118       strict_overflow_p = false;
12119       if (TREE_CODE (arg1) == INTEGER_CST
12120           && 0 != (tem = extract_muldiv (op0, arg1, code, NULL_TREE,
12121                                          &strict_overflow_p)))
12122         {
12123           if (strict_overflow_p)
12124             fold_overflow_warning (("assuming signed overflow does not occur "
12125                                     "when simplifying modulus"),
12126                                    WARN_STRICT_OVERFLOW_MISC);
12127           return fold_convert_loc (loc, type, tem);
12128         }
12129
12130       /* Optimize TRUNC_MOD_EXPR by a power of two into a BIT_AND_EXPR,
12131          i.e. "X % C" into "X & (C - 1)", if X and C are positive.  */
12132       if ((code == TRUNC_MOD_EXPR || code == FLOOR_MOD_EXPR)
12133           && (TYPE_UNSIGNED (type)
12134               || tree_expr_nonnegative_warnv_p (op0, &strict_overflow_p)))
12135         {
12136           tree c = arg1;
12137           /* Also optimize A % (C << N)  where C is a power of 2,
12138              to A & ((C << N) - 1).  */
12139           if (TREE_CODE (arg1) == LSHIFT_EXPR)
12140             c = TREE_OPERAND (arg1, 0);
12141
12142           if (integer_pow2p (c) && tree_int_cst_sgn (c) > 0)
12143             {
12144               tree mask
12145                 = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (arg1), arg1,
12146                                    build_int_cst (TREE_TYPE (arg1), 1));
12147               if (strict_overflow_p)
12148                 fold_overflow_warning (("assuming signed overflow does not "
12149                                         "occur when simplifying "
12150                                         "X % (power of two)"),
12151                                        WARN_STRICT_OVERFLOW_MISC);
12152               return fold_build2_loc (loc, BIT_AND_EXPR, type,
12153                                       fold_convert_loc (loc, type, arg0),
12154                                       fold_convert_loc (loc, type, mask));
12155             }
12156         }
12157
12158       return NULL_TREE;
12159
12160     case LROTATE_EXPR:
12161     case RROTATE_EXPR:
12162       if (integer_all_onesp (arg0))
12163         return omit_one_operand_loc (loc, type, arg0, arg1);
12164       goto shift;
12165
12166     case RSHIFT_EXPR:
12167       /* Optimize -1 >> x for arithmetic right shifts.  */
12168       if (integer_all_onesp (arg0) && !TYPE_UNSIGNED (type)
12169           && tree_expr_nonnegative_p (arg1))
12170         return omit_one_operand_loc (loc, type, arg0, arg1);
12171       /* ... fall through ...  */
12172
12173     case LSHIFT_EXPR:
12174     shift:
12175       if (integer_zerop (arg1))
12176         return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
12177       if (integer_zerop (arg0))
12178         return omit_one_operand_loc (loc, type, arg0, arg1);
12179
12180       /* Since negative shift count is not well-defined,
12181          don't try to compute it in the compiler.  */
12182       if (TREE_CODE (arg1) == INTEGER_CST && tree_int_cst_sgn (arg1) < 0)
12183         return NULL_TREE;
12184
12185       /* Turn (a OP c1) OP c2 into a OP (c1+c2).  */
12186       if (TREE_CODE (op0) == code && host_integerp (arg1, false)
12187           && TREE_INT_CST_LOW (arg1) < TYPE_PRECISION (type)
12188           && host_integerp (TREE_OPERAND (arg0, 1), false)
12189           && TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1)) < TYPE_PRECISION (type))
12190         {
12191           HOST_WIDE_INT low = (TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1))
12192                                + TREE_INT_CST_LOW (arg1));
12193
12194           /* Deal with a OP (c1 + c2) being undefined but (a OP c1) OP c2
12195              being well defined.  */
12196           if (low >= TYPE_PRECISION (type))
12197             {
12198               if (code == LROTATE_EXPR || code == RROTATE_EXPR)
12199                 low = low % TYPE_PRECISION (type);
12200               else if (TYPE_UNSIGNED (type) || code == LSHIFT_EXPR)
12201                 return omit_one_operand_loc (loc, type, build_int_cst (type, 0),
12202                                          TREE_OPERAND (arg0, 0));
12203               else
12204                 low = TYPE_PRECISION (type) - 1;
12205             }
12206
12207           return fold_build2_loc (loc, code, type, TREE_OPERAND (arg0, 0),
12208                               build_int_cst (type, low));
12209         }
12210
12211       /* Transform (x >> c) << c into x & (-1<<c), or transform (x << c) >> c
12212          into x & ((unsigned)-1 >> c) for unsigned types.  */
12213       if (((code == LSHIFT_EXPR && TREE_CODE (arg0) == RSHIFT_EXPR)
12214            || (TYPE_UNSIGNED (type)
12215                && code == RSHIFT_EXPR && TREE_CODE (arg0) == LSHIFT_EXPR))
12216           && host_integerp (arg1, false)
12217           && TREE_INT_CST_LOW (arg1) < TYPE_PRECISION (type)
12218           && host_integerp (TREE_OPERAND (arg0, 1), false)
12219           && TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1)) < TYPE_PRECISION (type))
12220         {
12221           HOST_WIDE_INT low0 = TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1));
12222           HOST_WIDE_INT low1 = TREE_INT_CST_LOW (arg1);
12223           tree lshift;
12224           tree arg00;
12225
12226           if (low0 == low1)
12227             {
12228               arg00 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
12229
12230               lshift = build_int_cst (type, -1);
12231               lshift = int_const_binop (code, lshift, arg1);
12232
12233               return fold_build2_loc (loc, BIT_AND_EXPR, type, arg00, lshift);
12234             }
12235         }
12236
12237       /* Rewrite an LROTATE_EXPR by a constant into an
12238          RROTATE_EXPR by a new constant.  */
12239       if (code == LROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST)
12240         {
12241           tree tem = build_int_cst (TREE_TYPE (arg1),
12242                                     TYPE_PRECISION (type));
12243           tem = const_binop (MINUS_EXPR, tem, arg1);
12244           return fold_build2_loc (loc, RROTATE_EXPR, type, op0, tem);
12245         }
12246
12247       /* If we have a rotate of a bit operation with the rotate count and
12248          the second operand of the bit operation both constant,
12249          permute the two operations.  */
12250       if (code == RROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST
12251           && (TREE_CODE (arg0) == BIT_AND_EXPR
12252               || TREE_CODE (arg0) == BIT_IOR_EXPR
12253               || TREE_CODE (arg0) == BIT_XOR_EXPR)
12254           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
12255         return fold_build2_loc (loc, TREE_CODE (arg0), type,
12256                             fold_build2_loc (loc, code, type,
12257                                          TREE_OPERAND (arg0, 0), arg1),
12258                             fold_build2_loc (loc, code, type,
12259                                          TREE_OPERAND (arg0, 1), arg1));
12260
12261       /* Two consecutive rotates adding up to the precision of the
12262          type can be ignored.  */
12263       if (code == RROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST
12264           && TREE_CODE (arg0) == RROTATE_EXPR
12265           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
12266           && TREE_INT_CST_HIGH (arg1) == 0
12267           && TREE_INT_CST_HIGH (TREE_OPERAND (arg0, 1)) == 0
12268           && ((TREE_INT_CST_LOW (arg1)
12269                + TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1)))
12270               == (unsigned int) TYPE_PRECISION (type)))
12271         return TREE_OPERAND (arg0, 0);
12272
12273       /* Fold (X & C2) << C1 into (X << C1) & (C2 << C1)
12274               (X & C2) >> C1 into (X >> C1) & (C2 >> C1)
12275          if the latter can be further optimized.  */
12276       if ((code == LSHIFT_EXPR || code == RSHIFT_EXPR)
12277           && TREE_CODE (arg0) == BIT_AND_EXPR
12278           && TREE_CODE (arg1) == INTEGER_CST
12279           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
12280         {
12281           tree mask = fold_build2_loc (loc, code, type,
12282                                    fold_convert_loc (loc, type,
12283                                                      TREE_OPERAND (arg0, 1)),
12284                                    arg1);
12285           tree shift = fold_build2_loc (loc, code, type,
12286                                     fold_convert_loc (loc, type,
12287                                                       TREE_OPERAND (arg0, 0)),
12288                                     arg1);
12289           tem = fold_binary_loc (loc, BIT_AND_EXPR, type, shift, mask);
12290           if (tem)
12291             return tem;
12292         }
12293
12294       return NULL_TREE;
12295
12296     case MIN_EXPR:
12297       if (operand_equal_p (arg0, arg1, 0))
12298         return omit_one_operand_loc (loc, type, arg0, arg1);
12299       if (INTEGRAL_TYPE_P (type)
12300           && operand_equal_p (arg1, TYPE_MIN_VALUE (type), OEP_ONLY_CONST))
12301         return omit_one_operand_loc (loc, type, arg1, arg0);
12302       tem = fold_minmax (loc, MIN_EXPR, type, arg0, arg1);
12303       if (tem)
12304         return tem;
12305       goto associate;
12306
12307     case MAX_EXPR:
12308       if (operand_equal_p (arg0, arg1, 0))
12309         return omit_one_operand_loc (loc, type, arg0, arg1);
12310       if (INTEGRAL_TYPE_P (type)
12311           && TYPE_MAX_VALUE (type)
12312           && operand_equal_p (arg1, TYPE_MAX_VALUE (type), OEP_ONLY_CONST))
12313         return omit_one_operand_loc (loc, type, arg1, arg0);
12314       tem = fold_minmax (loc, MAX_EXPR, type, arg0, arg1);
12315       if (tem)
12316         return tem;
12317       goto associate;
12318
12319     case TRUTH_ANDIF_EXPR:
12320       /* Note that the operands of this must be ints
12321          and their values must be 0 or 1.
12322          ("true" is a fixed value perhaps depending on the language.)  */
12323       /* If first arg is constant zero, return it.  */
12324       if (integer_zerop (arg0))
12325         return fold_convert_loc (loc, type, arg0);
12326     case TRUTH_AND_EXPR:
12327       /* If either arg is constant true, drop it.  */
12328       if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
12329         return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg1));
12330       if (TREE_CODE (arg1) == INTEGER_CST && ! integer_zerop (arg1)
12331           /* Preserve sequence points.  */
12332           && (code != TRUTH_ANDIF_EXPR || ! TREE_SIDE_EFFECTS (arg0)))
12333         return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
12334       /* If second arg is constant zero, result is zero, but first arg
12335          must be evaluated.  */
12336       if (integer_zerop (arg1))
12337         return omit_one_operand_loc (loc, type, arg1, arg0);
12338       /* Likewise for first arg, but note that only the TRUTH_AND_EXPR
12339          case will be handled here.  */
12340       if (integer_zerop (arg0))
12341         return omit_one_operand_loc (loc, type, arg0, arg1);
12342
12343       /* !X && X is always false.  */
12344       if (TREE_CODE (arg0) == TRUTH_NOT_EXPR
12345           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
12346         return omit_one_operand_loc (loc, type, integer_zero_node, arg1);
12347       /* X && !X is always false.  */
12348       if (TREE_CODE (arg1) == TRUTH_NOT_EXPR
12349           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
12350         return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
12351
12352       /* A < X && A + 1 > Y ==> A < X && A >= Y.  Normally A + 1 > Y
12353          means A >= Y && A != MAX, but in this case we know that
12354          A < X <= MAX.  */
12355
12356       if (!TREE_SIDE_EFFECTS (arg0)
12357           && !TREE_SIDE_EFFECTS (arg1))
12358         {
12359           tem = fold_to_nonsharp_ineq_using_bound (loc, arg0, arg1);
12360           if (tem && !operand_equal_p (tem, arg0, 0))
12361             return fold_build2_loc (loc, code, type, tem, arg1);
12362
12363           tem = fold_to_nonsharp_ineq_using_bound (loc, arg1, arg0);
12364           if (tem && !operand_equal_p (tem, arg1, 0))
12365             return fold_build2_loc (loc, code, type, arg0, tem);
12366         }
12367
12368       if ((tem = fold_truth_andor (loc, code, type, arg0, arg1, op0, op1))
12369           != NULL_TREE)
12370         return tem;
12371
12372       return NULL_TREE;
12373
12374     case TRUTH_ORIF_EXPR:
12375       /* Note that the operands of this must be ints
12376          and their values must be 0 or true.
12377          ("true" is a fixed value perhaps depending on the language.)  */
12378       /* If first arg is constant true, return it.  */
12379       if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
12380         return fold_convert_loc (loc, type, arg0);
12381     case TRUTH_OR_EXPR:
12382       /* If either arg is constant zero, drop it.  */
12383       if (TREE_CODE (arg0) == INTEGER_CST && integer_zerop (arg0))
12384         return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg1));
12385       if (TREE_CODE (arg1) == INTEGER_CST && integer_zerop (arg1)
12386           /* Preserve sequence points.  */
12387           && (code != TRUTH_ORIF_EXPR || ! TREE_SIDE_EFFECTS (arg0)))
12388         return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
12389       /* If second arg is constant true, result is true, but we must
12390          evaluate first arg.  */
12391       if (TREE_CODE (arg1) == INTEGER_CST && ! integer_zerop (arg1))
12392         return omit_one_operand_loc (loc, type, arg1, arg0);
12393       /* Likewise for first arg, but note this only occurs here for
12394          TRUTH_OR_EXPR.  */
12395       if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
12396         return omit_one_operand_loc (loc, type, arg0, arg1);
12397
12398       /* !X || X is always true.  */
12399       if (TREE_CODE (arg0) == TRUTH_NOT_EXPR
12400           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
12401         return omit_one_operand_loc (loc, type, integer_one_node, arg1);
12402       /* X || !X is always true.  */
12403       if (TREE_CODE (arg1) == TRUTH_NOT_EXPR
12404           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
12405         return omit_one_operand_loc (loc, type, integer_one_node, arg0);
12406
12407       /* (X && !Y) || (!X && Y) is X ^ Y */
12408       if (TREE_CODE (arg0) == TRUTH_AND_EXPR
12409           && TREE_CODE (arg1) == TRUTH_AND_EXPR)
12410         {
12411           tree a0, a1, l0, l1, n0, n1;
12412
12413           a0 = fold_convert_loc (loc, type, TREE_OPERAND (arg1, 0));
12414           a1 = fold_convert_loc (loc, type, TREE_OPERAND (arg1, 1));
12415
12416           l0 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
12417           l1 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 1));
12418
12419           n0 = fold_build1_loc (loc, TRUTH_NOT_EXPR, type, l0);
12420           n1 = fold_build1_loc (loc, TRUTH_NOT_EXPR, type, l1);
12421
12422           if ((operand_equal_p (n0, a0, 0)
12423                && operand_equal_p (n1, a1, 0))
12424               || (operand_equal_p (n0, a1, 0)
12425                   && operand_equal_p (n1, a0, 0)))
12426             return fold_build2_loc (loc, TRUTH_XOR_EXPR, type, l0, n1);
12427         }
12428
12429       if ((tem = fold_truth_andor (loc, code, type, arg0, arg1, op0, op1))
12430           != NULL_TREE)
12431         return tem;
12432
12433       return NULL_TREE;
12434
12435     case TRUTH_XOR_EXPR:
12436       /* If the second arg is constant zero, drop it.  */
12437       if (integer_zerop (arg1))
12438         return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
12439       /* If the second arg is constant true, this is a logical inversion.  */
12440       if (integer_onep (arg1))
12441         {
12442           /* Only call invert_truthvalue if operand is a truth value.  */
12443           if (TREE_CODE (TREE_TYPE (arg0)) != BOOLEAN_TYPE)
12444             tem = fold_build1_loc (loc, TRUTH_NOT_EXPR, TREE_TYPE (arg0), arg0);
12445           else
12446             tem = invert_truthvalue_loc (loc, arg0);
12447           return non_lvalue_loc (loc, fold_convert_loc (loc, type, tem));
12448         }
12449       /* Identical arguments cancel to zero.  */
12450       if (operand_equal_p (arg0, arg1, 0))
12451         return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
12452
12453       /* !X ^ X is always true.  */
12454       if (TREE_CODE (arg0) == TRUTH_NOT_EXPR
12455           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
12456         return omit_one_operand_loc (loc, type, integer_one_node, arg1);
12457
12458       /* X ^ !X is always true.  */
12459       if (TREE_CODE (arg1) == TRUTH_NOT_EXPR
12460           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
12461         return omit_one_operand_loc (loc, type, integer_one_node, arg0);
12462
12463       return NULL_TREE;
12464
12465     case EQ_EXPR:
12466     case NE_EXPR:
12467       STRIP_NOPS (arg0);
12468       STRIP_NOPS (arg1);
12469
12470       tem = fold_comparison (loc, code, type, op0, op1);
12471       if (tem != NULL_TREE)
12472         return tem;
12473
12474       /* bool_var != 0 becomes bool_var. */
12475       if (TREE_CODE (TREE_TYPE (arg0)) == BOOLEAN_TYPE && integer_zerop (arg1)
12476           && code == NE_EXPR)
12477         return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
12478
12479       /* bool_var == 1 becomes bool_var. */
12480       if (TREE_CODE (TREE_TYPE (arg0)) == BOOLEAN_TYPE && integer_onep (arg1)
12481           && code == EQ_EXPR)
12482         return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
12483
12484       /* bool_var != 1 becomes !bool_var. */
12485       if (TREE_CODE (TREE_TYPE (arg0)) == BOOLEAN_TYPE && integer_onep (arg1)
12486           && code == NE_EXPR)
12487         return fold_convert_loc (loc, type,
12488                                  fold_build1_loc (loc, TRUTH_NOT_EXPR,
12489                                                   TREE_TYPE (arg0), arg0));
12490
12491       /* bool_var == 0 becomes !bool_var. */
12492       if (TREE_CODE (TREE_TYPE (arg0)) == BOOLEAN_TYPE && integer_zerop (arg1)
12493           && code == EQ_EXPR)
12494         return fold_convert_loc (loc, type,
12495                                  fold_build1_loc (loc, TRUTH_NOT_EXPR,
12496                                                   TREE_TYPE (arg0), arg0));
12497
12498       /* !exp != 0 becomes !exp */
12499       if (TREE_CODE (arg0) == TRUTH_NOT_EXPR && integer_zerop (arg1)
12500           && code == NE_EXPR)
12501         return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
12502
12503       /* If this is an equality comparison of the address of two non-weak,
12504          unaliased symbols neither of which are extern (since we do not
12505          have access to attributes for externs), then we know the result.  */
12506       if (TREE_CODE (arg0) == ADDR_EXPR
12507           && VAR_OR_FUNCTION_DECL_P (TREE_OPERAND (arg0, 0))
12508           && ! DECL_WEAK (TREE_OPERAND (arg0, 0))
12509           && ! lookup_attribute ("alias",
12510                                  DECL_ATTRIBUTES (TREE_OPERAND (arg0, 0)))
12511           && ! DECL_EXTERNAL (TREE_OPERAND (arg0, 0))
12512           && TREE_CODE (arg1) == ADDR_EXPR
12513           && VAR_OR_FUNCTION_DECL_P (TREE_OPERAND (arg1, 0))
12514           && ! DECL_WEAK (TREE_OPERAND (arg1, 0))
12515           && ! lookup_attribute ("alias",
12516                                  DECL_ATTRIBUTES (TREE_OPERAND (arg1, 0)))
12517           && ! DECL_EXTERNAL (TREE_OPERAND (arg1, 0)))
12518         {
12519           /* We know that we're looking at the address of two
12520              non-weak, unaliased, static _DECL nodes.
12521
12522              It is both wasteful and incorrect to call operand_equal_p
12523              to compare the two ADDR_EXPR nodes.  It is wasteful in that
12524              all we need to do is test pointer equality for the arguments
12525              to the two ADDR_EXPR nodes.  It is incorrect to use
12526              operand_equal_p as that function is NOT equivalent to a
12527              C equality test.  It can in fact return false for two
12528              objects which would test as equal using the C equality
12529              operator.  */
12530           bool equal = TREE_OPERAND (arg0, 0) == TREE_OPERAND (arg1, 0);
12531           return constant_boolean_node (equal
12532                                         ? code == EQ_EXPR : code != EQ_EXPR,
12533                                         type);
12534         }
12535
12536       /* If this is an EQ or NE comparison of a constant with a PLUS_EXPR or
12537          a MINUS_EXPR of a constant, we can convert it into a comparison with
12538          a revised constant as long as no overflow occurs.  */
12539       if (TREE_CODE (arg1) == INTEGER_CST
12540           && (TREE_CODE (arg0) == PLUS_EXPR
12541               || TREE_CODE (arg0) == MINUS_EXPR)
12542           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
12543           && 0 != (tem = const_binop (TREE_CODE (arg0) == PLUS_EXPR
12544                                       ? MINUS_EXPR : PLUS_EXPR,
12545                                       fold_convert_loc (loc, TREE_TYPE (arg0),
12546                                                         arg1),
12547                                       TREE_OPERAND (arg0, 1)))
12548           && !TREE_OVERFLOW (tem))
12549         return fold_build2_loc (loc, code, type, TREE_OPERAND (arg0, 0), tem);
12550
12551       /* Similarly for a NEGATE_EXPR.  */
12552       if (TREE_CODE (arg0) == NEGATE_EXPR
12553           && TREE_CODE (arg1) == INTEGER_CST
12554           && 0 != (tem = negate_expr (fold_convert_loc (loc, TREE_TYPE (arg0),
12555                                                         arg1)))
12556           && TREE_CODE (tem) == INTEGER_CST
12557           && !TREE_OVERFLOW (tem))
12558         return fold_build2_loc (loc, code, type, TREE_OPERAND (arg0, 0), tem);
12559
12560       /* Similarly for a BIT_XOR_EXPR;  X ^ C1 == C2 is X == (C1 ^ C2).  */
12561       if (TREE_CODE (arg0) == BIT_XOR_EXPR
12562           && TREE_CODE (arg1) == INTEGER_CST
12563           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
12564         return fold_build2_loc (loc, code, type, TREE_OPERAND (arg0, 0),
12565                             fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (arg0),
12566                                          fold_convert_loc (loc,
12567                                                            TREE_TYPE (arg0),
12568                                                            arg1),
12569                                          TREE_OPERAND (arg0, 1)));
12570
12571       /* Transform comparisons of the form X +- Y CMP X to Y CMP 0.  */
12572       if ((TREE_CODE (arg0) == PLUS_EXPR
12573            || TREE_CODE (arg0) == POINTER_PLUS_EXPR
12574            || TREE_CODE (arg0) == MINUS_EXPR)
12575           && operand_equal_p (tree_strip_nop_conversions (TREE_OPERAND (arg0,
12576                                                                         0)),
12577                               arg1, 0)
12578           && (INTEGRAL_TYPE_P (TREE_TYPE (arg0))
12579               || POINTER_TYPE_P (TREE_TYPE (arg0))))
12580         {
12581           tree val = TREE_OPERAND (arg0, 1);
12582           return omit_two_operands_loc (loc, type,
12583                                     fold_build2_loc (loc, code, type,
12584                                                  val,
12585                                                  build_int_cst (TREE_TYPE (val),
12586                                                                 0)),
12587                                     TREE_OPERAND (arg0, 0), arg1);
12588         }
12589
12590       /* Transform comparisons of the form C - X CMP X if C % 2 == 1.  */
12591       if (TREE_CODE (arg0) == MINUS_EXPR
12592           && TREE_CODE (TREE_OPERAND (arg0, 0)) == INTEGER_CST
12593           && operand_equal_p (tree_strip_nop_conversions (TREE_OPERAND (arg0,
12594                                                                         1)),
12595                               arg1, 0)
12596           && (TREE_INT_CST_LOW (TREE_OPERAND (arg0, 0)) & 1) == 1)
12597         {
12598           return omit_two_operands_loc (loc, type,
12599                                     code == NE_EXPR
12600                                     ? boolean_true_node : boolean_false_node,
12601                                     TREE_OPERAND (arg0, 1), arg1);
12602         }
12603
12604       /* If we have X - Y == 0, we can convert that to X == Y and similarly
12605          for !=.  Don't do this for ordered comparisons due to overflow.  */
12606       if (TREE_CODE (arg0) == MINUS_EXPR
12607           && integer_zerop (arg1))
12608         return fold_build2_loc (loc, code, type,
12609                             TREE_OPERAND (arg0, 0), TREE_OPERAND (arg0, 1));
12610
12611       /* Convert ABS_EXPR<x> == 0 or ABS_EXPR<x> != 0 to x == 0 or x != 0.  */
12612       if (TREE_CODE (arg0) == ABS_EXPR
12613           && (integer_zerop (arg1) || real_zerop (arg1)))
12614         return fold_build2_loc (loc, code, type, TREE_OPERAND (arg0, 0), arg1);
12615
12616       /* If this is an EQ or NE comparison with zero and ARG0 is
12617          (1 << foo) & bar, convert it to (bar >> foo) & 1.  Both require
12618          two operations, but the latter can be done in one less insn
12619          on machines that have only two-operand insns or on which a
12620          constant cannot be the first operand.  */
12621       if (TREE_CODE (arg0) == BIT_AND_EXPR
12622           && integer_zerop (arg1))
12623         {
12624           tree arg00 = TREE_OPERAND (arg0, 0);
12625           tree arg01 = TREE_OPERAND (arg0, 1);
12626           if (TREE_CODE (arg00) == LSHIFT_EXPR
12627               && integer_onep (TREE_OPERAND (arg00, 0)))
12628             {
12629               tree tem = fold_build2_loc (loc, RSHIFT_EXPR, TREE_TYPE (arg00),
12630                                       arg01, TREE_OPERAND (arg00, 1));
12631               tem = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (arg0), tem,
12632                                  build_int_cst (TREE_TYPE (arg0), 1));
12633               return fold_build2_loc (loc, code, type,
12634                                   fold_convert_loc (loc, TREE_TYPE (arg1), tem),
12635                                   arg1);
12636             }
12637           else if (TREE_CODE (arg01) == LSHIFT_EXPR
12638                    && integer_onep (TREE_OPERAND (arg01, 0)))
12639             {
12640               tree tem = fold_build2_loc (loc, RSHIFT_EXPR, TREE_TYPE (arg01),
12641                                       arg00, TREE_OPERAND (arg01, 1));
12642               tem = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (arg0), tem,
12643                                  build_int_cst (TREE_TYPE (arg0), 1));
12644               return fold_build2_loc (loc, code, type,
12645                                   fold_convert_loc (loc, TREE_TYPE (arg1), tem),
12646                                   arg1);
12647             }
12648         }
12649
12650       /* If this is an NE or EQ comparison of zero against the result of a
12651          signed MOD operation whose second operand is a power of 2, make
12652          the MOD operation unsigned since it is simpler and equivalent.  */
12653       if (integer_zerop (arg1)
12654           && !TYPE_UNSIGNED (TREE_TYPE (arg0))
12655           && (TREE_CODE (arg0) == TRUNC_MOD_EXPR
12656               || TREE_CODE (arg0) == CEIL_MOD_EXPR
12657               || TREE_CODE (arg0) == FLOOR_MOD_EXPR
12658               || TREE_CODE (arg0) == ROUND_MOD_EXPR)
12659           && integer_pow2p (TREE_OPERAND (arg0, 1)))
12660         {
12661           tree newtype = unsigned_type_for (TREE_TYPE (arg0));
12662           tree newmod = fold_build2_loc (loc, TREE_CODE (arg0), newtype,
12663                                      fold_convert_loc (loc, newtype,
12664                                                        TREE_OPERAND (arg0, 0)),
12665                                      fold_convert_loc (loc, newtype,
12666                                                        TREE_OPERAND (arg0, 1)));
12667
12668           return fold_build2_loc (loc, code, type, newmod,
12669                               fold_convert_loc (loc, newtype, arg1));
12670         }
12671
12672       /* Fold ((X >> C1) & C2) == 0 and ((X >> C1) & C2) != 0 where
12673          C1 is a valid shift constant, and C2 is a power of two, i.e.
12674          a single bit.  */
12675       if (TREE_CODE (arg0) == BIT_AND_EXPR
12676           && TREE_CODE (TREE_OPERAND (arg0, 0)) == RSHIFT_EXPR
12677           && TREE_CODE (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1))
12678              == INTEGER_CST
12679           && integer_pow2p (TREE_OPERAND (arg0, 1))
12680           && integer_zerop (arg1))
12681         {
12682           tree itype = TREE_TYPE (arg0);
12683           unsigned HOST_WIDE_INT prec = TYPE_PRECISION (itype);
12684           tree arg001 = TREE_OPERAND (TREE_OPERAND (arg0, 0), 1);
12685
12686           /* Check for a valid shift count.  */
12687           if (TREE_INT_CST_HIGH (arg001) == 0
12688               && TREE_INT_CST_LOW (arg001) < prec)
12689             {
12690               tree arg01 = TREE_OPERAND (arg0, 1);
12691               tree arg000 = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
12692               unsigned HOST_WIDE_INT log2 = tree_log2 (arg01);
12693               /* If (C2 << C1) doesn't overflow, then ((X >> C1) & C2) != 0
12694                  can be rewritten as (X & (C2 << C1)) != 0.  */
12695               if ((log2 + TREE_INT_CST_LOW (arg001)) < prec)
12696                 {
12697                   tem = fold_build2_loc (loc, LSHIFT_EXPR, itype, arg01, arg001);
12698                   tem = fold_build2_loc (loc, BIT_AND_EXPR, itype, arg000, tem);
12699                   return fold_build2_loc (loc, code, type, tem,
12700                                           fold_convert_loc (loc, itype, arg1));
12701                 }
12702               /* Otherwise, for signed (arithmetic) shifts,
12703                  ((X >> C1) & C2) != 0 is rewritten as X < 0, and
12704                  ((X >> C1) & C2) == 0 is rewritten as X >= 0.  */
12705               else if (!TYPE_UNSIGNED (itype))
12706                 return fold_build2_loc (loc, code == EQ_EXPR ? GE_EXPR : LT_EXPR, type,
12707                                     arg000, build_int_cst (itype, 0));
12708               /* Otherwise, of unsigned (logical) shifts,
12709                  ((X >> C1) & C2) != 0 is rewritten as (X,false), and
12710                  ((X >> C1) & C2) == 0 is rewritten as (X,true).  */
12711               else
12712                 return omit_one_operand_loc (loc, type,
12713                                          code == EQ_EXPR ? integer_one_node
12714                                                          : integer_zero_node,
12715                                          arg000);
12716             }
12717         }
12718
12719       /* If we have (A & C) == C where C is a power of 2, convert this into
12720          (A & C) != 0.  Similarly for NE_EXPR.  */
12721       if (TREE_CODE (arg0) == BIT_AND_EXPR
12722           && integer_pow2p (TREE_OPERAND (arg0, 1))
12723           && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
12724         return fold_build2_loc (loc, code == EQ_EXPR ? NE_EXPR : EQ_EXPR, type,
12725                             arg0, fold_convert_loc (loc, TREE_TYPE (arg0),
12726                                                     integer_zero_node));
12727
12728       /* If we have (A & C) != 0 or (A & C) == 0 and C is the sign
12729          bit, then fold the expression into A < 0 or A >= 0.  */
12730       tem = fold_single_bit_test_into_sign_test (loc, code, arg0, arg1, type);
12731       if (tem)
12732         return tem;
12733
12734       /* If we have (A & C) == D where D & ~C != 0, convert this into 0.
12735          Similarly for NE_EXPR.  */
12736       if (TREE_CODE (arg0) == BIT_AND_EXPR
12737           && TREE_CODE (arg1) == INTEGER_CST
12738           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
12739         {
12740           tree notc = fold_build1_loc (loc, BIT_NOT_EXPR,
12741                                    TREE_TYPE (TREE_OPERAND (arg0, 1)),
12742                                    TREE_OPERAND (arg0, 1));
12743           tree dandnotc
12744             = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (arg0),
12745                                fold_convert_loc (loc, TREE_TYPE (arg0), arg1),
12746                                notc);
12747           tree rslt = code == EQ_EXPR ? integer_zero_node : integer_one_node;
12748           if (integer_nonzerop (dandnotc))
12749             return omit_one_operand_loc (loc, type, rslt, arg0);
12750         }
12751
12752       /* If we have (A | C) == D where C & ~D != 0, convert this into 0.
12753          Similarly for NE_EXPR.  */
12754       if (TREE_CODE (arg0) == BIT_IOR_EXPR
12755           && TREE_CODE (arg1) == INTEGER_CST
12756           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
12757         {
12758           tree notd = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (arg1), arg1);
12759           tree candnotd
12760             = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (arg0),
12761                                TREE_OPERAND (arg0, 1),
12762                                fold_convert_loc (loc, TREE_TYPE (arg0), notd));
12763           tree rslt = code == EQ_EXPR ? integer_zero_node : integer_one_node;
12764           if (integer_nonzerop (candnotd))
12765             return omit_one_operand_loc (loc, type, rslt, arg0);
12766         }
12767
12768       /* If this is a comparison of a field, we may be able to simplify it.  */
12769       if ((TREE_CODE (arg0) == COMPONENT_REF
12770            || TREE_CODE (arg0) == BIT_FIELD_REF)
12771           /* Handle the constant case even without -O
12772              to make sure the warnings are given.  */
12773           && (optimize || TREE_CODE (arg1) == INTEGER_CST))
12774         {
12775           t1 = optimize_bit_field_compare (loc, code, type, arg0, arg1);
12776           if (t1)
12777             return t1;
12778         }
12779
12780       /* Optimize comparisons of strlen vs zero to a compare of the
12781          first character of the string vs zero.  To wit,
12782                 strlen(ptr) == 0   =>  *ptr == 0
12783                 strlen(ptr) != 0   =>  *ptr != 0
12784          Other cases should reduce to one of these two (or a constant)
12785          due to the return value of strlen being unsigned.  */
12786       if (TREE_CODE (arg0) == CALL_EXPR
12787           && integer_zerop (arg1))
12788         {
12789           tree fndecl = get_callee_fndecl (arg0);
12790
12791           if (fndecl
12792               && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
12793               && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_STRLEN
12794               && call_expr_nargs (arg0) == 1
12795               && TREE_CODE (TREE_TYPE (CALL_EXPR_ARG (arg0, 0))) == POINTER_TYPE)
12796             {
12797               tree iref = build_fold_indirect_ref_loc (loc,
12798                                                    CALL_EXPR_ARG (arg0, 0));
12799               return fold_build2_loc (loc, code, type, iref,
12800                                   build_int_cst (TREE_TYPE (iref), 0));
12801             }
12802         }
12803
12804       /* Fold (X >> C) != 0 into X < 0 if C is one less than the width
12805          of X.  Similarly fold (X >> C) == 0 into X >= 0.  */
12806       if (TREE_CODE (arg0) == RSHIFT_EXPR
12807           && integer_zerop (arg1)
12808           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
12809         {
12810           tree arg00 = TREE_OPERAND (arg0, 0);
12811           tree arg01 = TREE_OPERAND (arg0, 1);
12812           tree itype = TREE_TYPE (arg00);
12813           if (TREE_INT_CST_HIGH (arg01) == 0
12814               && TREE_INT_CST_LOW (arg01)
12815                  == (unsigned HOST_WIDE_INT) (TYPE_PRECISION (itype) - 1))
12816             {
12817               if (TYPE_UNSIGNED (itype))
12818                 {
12819                   itype = signed_type_for (itype);
12820                   arg00 = fold_convert_loc (loc, itype, arg00);
12821                 }
12822               return fold_build2_loc (loc, code == EQ_EXPR ? GE_EXPR : LT_EXPR,
12823                                   type, arg00, build_int_cst (itype, 0));
12824             }
12825         }
12826
12827       /* (X ^ Y) == 0 becomes X == Y, and (X ^ Y) != 0 becomes X != Y.  */
12828       if (integer_zerop (arg1)
12829           && TREE_CODE (arg0) == BIT_XOR_EXPR)
12830         return fold_build2_loc (loc, code, type, TREE_OPERAND (arg0, 0),
12831                             TREE_OPERAND (arg0, 1));
12832
12833       /* (X ^ Y) == Y becomes X == 0.  We know that Y has no side-effects.  */
12834       if (TREE_CODE (arg0) == BIT_XOR_EXPR
12835           && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
12836         return fold_build2_loc (loc, code, type, TREE_OPERAND (arg0, 0),
12837                                 build_zero_cst (TREE_TYPE (arg0)));
12838       /* Likewise (X ^ Y) == X becomes Y == 0.  X has no side-effects.  */
12839       if (TREE_CODE (arg0) == BIT_XOR_EXPR
12840           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
12841           && reorder_operands_p (TREE_OPERAND (arg0, 1), arg1))
12842         return fold_build2_loc (loc, code, type, TREE_OPERAND (arg0, 1),
12843                                 build_zero_cst (TREE_TYPE (arg0)));
12844
12845       /* (X ^ C1) op C2 can be rewritten as X op (C1 ^ C2).  */
12846       if (TREE_CODE (arg0) == BIT_XOR_EXPR
12847           && TREE_CODE (arg1) == INTEGER_CST
12848           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
12849         return fold_build2_loc (loc, code, type, TREE_OPERAND (arg0, 0),
12850                             fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (arg1),
12851                                          TREE_OPERAND (arg0, 1), arg1));
12852
12853       /* Fold (~X & C) == 0 into (X & C) != 0 and (~X & C) != 0 into
12854          (X & C) == 0 when C is a single bit.  */
12855       if (TREE_CODE (arg0) == BIT_AND_EXPR
12856           && TREE_CODE (TREE_OPERAND (arg0, 0)) == BIT_NOT_EXPR
12857           && integer_zerop (arg1)
12858           && integer_pow2p (TREE_OPERAND (arg0, 1)))
12859         {
12860           tem = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (arg0),
12861                                  TREE_OPERAND (TREE_OPERAND (arg0, 0), 0),
12862                                  TREE_OPERAND (arg0, 1));
12863           return fold_build2_loc (loc, code == EQ_EXPR ? NE_EXPR : EQ_EXPR,
12864                                   type, tem,
12865                                   fold_convert_loc (loc, TREE_TYPE (arg0),
12866                                                     arg1));
12867         }
12868
12869       /* Fold ((X & C) ^ C) eq/ne 0 into (X & C) ne/eq 0, when the
12870          constant C is a power of two, i.e. a single bit.  */
12871       if (TREE_CODE (arg0) == BIT_XOR_EXPR
12872           && TREE_CODE (TREE_OPERAND (arg0, 0)) == BIT_AND_EXPR
12873           && integer_zerop (arg1)
12874           && integer_pow2p (TREE_OPERAND (arg0, 1))
12875           && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1),
12876                               TREE_OPERAND (arg0, 1), OEP_ONLY_CONST))
12877         {
12878           tree arg00 = TREE_OPERAND (arg0, 0);
12879           return fold_build2_loc (loc, code == EQ_EXPR ? NE_EXPR : EQ_EXPR, type,
12880                               arg00, build_int_cst (TREE_TYPE (arg00), 0));
12881         }
12882
12883       /* Likewise, fold ((X ^ C) & C) eq/ne 0 into (X & C) ne/eq 0,
12884          when is C is a power of two, i.e. a single bit.  */
12885       if (TREE_CODE (arg0) == BIT_AND_EXPR
12886           && TREE_CODE (TREE_OPERAND (arg0, 0)) == BIT_XOR_EXPR
12887           && integer_zerop (arg1)
12888           && integer_pow2p (TREE_OPERAND (arg0, 1))
12889           && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1),
12890                               TREE_OPERAND (arg0, 1), OEP_ONLY_CONST))
12891         {
12892           tree arg000 = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
12893           tem = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (arg000),
12894                              arg000, TREE_OPERAND (arg0, 1));
12895           return fold_build2_loc (loc, code == EQ_EXPR ? NE_EXPR : EQ_EXPR, type,
12896                               tem, build_int_cst (TREE_TYPE (tem), 0));
12897         }
12898
12899       if (integer_zerop (arg1)
12900           && tree_expr_nonzero_p (arg0))
12901         {
12902           tree res = constant_boolean_node (code==NE_EXPR, type);
12903           return omit_one_operand_loc (loc, type, res, arg0);
12904         }
12905
12906       /* Fold -X op -Y as X op Y, where op is eq/ne.  */
12907       if (TREE_CODE (arg0) == NEGATE_EXPR
12908           && TREE_CODE (arg1) == NEGATE_EXPR)
12909         return fold_build2_loc (loc, code, type,
12910                                 TREE_OPERAND (arg0, 0),
12911                                 fold_convert_loc (loc, TREE_TYPE (arg0),
12912                                                   TREE_OPERAND (arg1, 0)));
12913
12914       /* Fold (X & C) op (Y & C) as (X ^ Y) & C op 0", and symmetries.  */
12915       if (TREE_CODE (arg0) == BIT_AND_EXPR
12916           && TREE_CODE (arg1) == BIT_AND_EXPR)
12917         {
12918           tree arg00 = TREE_OPERAND (arg0, 0);
12919           tree arg01 = TREE_OPERAND (arg0, 1);
12920           tree arg10 = TREE_OPERAND (arg1, 0);
12921           tree arg11 = TREE_OPERAND (arg1, 1);
12922           tree itype = TREE_TYPE (arg0);
12923
12924           if (operand_equal_p (arg01, arg11, 0))
12925             return fold_build2_loc (loc, code, type,
12926                                 fold_build2_loc (loc, BIT_AND_EXPR, itype,
12927                                              fold_build2_loc (loc,
12928                                                           BIT_XOR_EXPR, itype,
12929                                                           arg00, arg10),
12930                                              arg01),
12931                                 build_zero_cst (itype));
12932
12933           if (operand_equal_p (arg01, arg10, 0))
12934             return fold_build2_loc (loc, code, type,
12935                                 fold_build2_loc (loc, BIT_AND_EXPR, itype,
12936                                              fold_build2_loc (loc,
12937                                                           BIT_XOR_EXPR, itype,
12938                                                           arg00, arg11),
12939                                              arg01),
12940                                 build_zero_cst (itype));
12941
12942           if (operand_equal_p (arg00, arg11, 0))
12943             return fold_build2_loc (loc, code, type,
12944                                 fold_build2_loc (loc, BIT_AND_EXPR, itype,
12945                                              fold_build2_loc (loc,
12946                                                           BIT_XOR_EXPR, itype,
12947                                                           arg01, arg10),
12948                                              arg00),
12949                                 build_zero_cst (itype));
12950
12951           if (operand_equal_p (arg00, arg10, 0))
12952             return fold_build2_loc (loc, code, type,
12953                                 fold_build2_loc (loc, BIT_AND_EXPR, itype,
12954                                              fold_build2_loc (loc,
12955                                                           BIT_XOR_EXPR, itype,
12956                                                           arg01, arg11),
12957                                              arg00),
12958                                 build_zero_cst (itype));
12959         }
12960
12961       if (TREE_CODE (arg0) == BIT_XOR_EXPR
12962           && TREE_CODE (arg1) == BIT_XOR_EXPR)
12963         {
12964           tree arg00 = TREE_OPERAND (arg0, 0);
12965           tree arg01 = TREE_OPERAND (arg0, 1);
12966           tree arg10 = TREE_OPERAND (arg1, 0);
12967           tree arg11 = TREE_OPERAND (arg1, 1);
12968           tree itype = TREE_TYPE (arg0);
12969
12970           /* Optimize (X ^ Z) op (Y ^ Z) as X op Y, and symmetries.
12971              operand_equal_p guarantees no side-effects so we don't need
12972              to use omit_one_operand on Z.  */
12973           if (operand_equal_p (arg01, arg11, 0))
12974             return fold_build2_loc (loc, code, type, arg00,
12975                                     fold_convert_loc (loc, TREE_TYPE (arg00),
12976                                                       arg10));
12977           if (operand_equal_p (arg01, arg10, 0))
12978             return fold_build2_loc (loc, code, type, arg00,
12979                                     fold_convert_loc (loc, TREE_TYPE (arg00),
12980                                                       arg11));
12981           if (operand_equal_p (arg00, arg11, 0))
12982             return fold_build2_loc (loc, code, type, arg01,
12983                                     fold_convert_loc (loc, TREE_TYPE (arg01),
12984                                                       arg10));
12985           if (operand_equal_p (arg00, arg10, 0))
12986             return fold_build2_loc (loc, code, type, arg01,
12987                                     fold_convert_loc (loc, TREE_TYPE (arg01),
12988                                                       arg11));
12989
12990           /* Optimize (X ^ C1) op (Y ^ C2) as (X ^ (C1 ^ C2)) op Y.  */
12991           if (TREE_CODE (arg01) == INTEGER_CST
12992               && TREE_CODE (arg11) == INTEGER_CST)
12993             {
12994               tem = fold_build2_loc (loc, BIT_XOR_EXPR, itype, arg01,
12995                                      fold_convert_loc (loc, itype, arg11));
12996               tem = fold_build2_loc (loc, BIT_XOR_EXPR, itype, arg00, tem);
12997               return fold_build2_loc (loc, code, type, tem,
12998                                       fold_convert_loc (loc, itype, arg10));
12999             }
13000         }
13001
13002       /* Attempt to simplify equality/inequality comparisons of complex
13003          values.  Only lower the comparison if the result is known or
13004          can be simplified to a single scalar comparison.  */
13005       if ((TREE_CODE (arg0) == COMPLEX_EXPR
13006            || TREE_CODE (arg0) == COMPLEX_CST)
13007           && (TREE_CODE (arg1) == COMPLEX_EXPR
13008               || TREE_CODE (arg1) == COMPLEX_CST))
13009         {
13010           tree real0, imag0, real1, imag1;
13011           tree rcond, icond;
13012
13013           if (TREE_CODE (arg0) == COMPLEX_EXPR)
13014             {
13015               real0 = TREE_OPERAND (arg0, 0);
13016               imag0 = TREE_OPERAND (arg0, 1);
13017             }
13018           else
13019             {
13020               real0 = TREE_REALPART (arg0);
13021               imag0 = TREE_IMAGPART (arg0);
13022             }
13023
13024           if (TREE_CODE (arg1) == COMPLEX_EXPR)
13025             {
13026               real1 = TREE_OPERAND (arg1, 0);
13027               imag1 = TREE_OPERAND (arg1, 1);
13028             }
13029           else
13030             {
13031               real1 = TREE_REALPART (arg1);
13032               imag1 = TREE_IMAGPART (arg1);
13033             }
13034
13035           rcond = fold_binary_loc (loc, code, type, real0, real1);
13036           if (rcond && TREE_CODE (rcond) == INTEGER_CST)
13037             {
13038               if (integer_zerop (rcond))
13039                 {
13040                   if (code == EQ_EXPR)
13041                     return omit_two_operands_loc (loc, type, boolean_false_node,
13042                                               imag0, imag1);
13043                   return fold_build2_loc (loc, NE_EXPR, type, imag0, imag1);
13044                 }
13045               else
13046                 {
13047                   if (code == NE_EXPR)
13048                     return omit_two_operands_loc (loc, type, boolean_true_node,
13049                                               imag0, imag1);
13050                   return fold_build2_loc (loc, EQ_EXPR, type, imag0, imag1);
13051                 }
13052             }
13053
13054           icond = fold_binary_loc (loc, code, type, imag0, imag1);
13055           if (icond && TREE_CODE (icond) == INTEGER_CST)
13056             {
13057               if (integer_zerop (icond))
13058                 {
13059                   if (code == EQ_EXPR)
13060                     return omit_two_operands_loc (loc, type, boolean_false_node,
13061                                               real0, real1);
13062                   return fold_build2_loc (loc, NE_EXPR, type, real0, real1);
13063                 }
13064               else
13065                 {
13066                   if (code == NE_EXPR)
13067                     return omit_two_operands_loc (loc, type, boolean_true_node,
13068                                               real0, real1);
13069                   return fold_build2_loc (loc, EQ_EXPR, type, real0, real1);
13070                 }
13071             }
13072         }
13073
13074       return NULL_TREE;
13075
13076     case LT_EXPR:
13077     case GT_EXPR:
13078     case LE_EXPR:
13079     case GE_EXPR:
13080       tem = fold_comparison (loc, code, type, op0, op1);
13081       if (tem != NULL_TREE)
13082         return tem;
13083
13084       /* Transform comparisons of the form X +- C CMP X.  */
13085       if ((TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
13086           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
13087           && ((TREE_CODE (TREE_OPERAND (arg0, 1)) == REAL_CST
13088                && !HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0))))
13089               || (TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
13090                   && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))))
13091         {
13092           tree arg01 = TREE_OPERAND (arg0, 1);
13093           enum tree_code code0 = TREE_CODE (arg0);
13094           int is_positive;
13095
13096           if (TREE_CODE (arg01) == REAL_CST)
13097             is_positive = REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg01)) ? -1 : 1;
13098           else
13099             is_positive = tree_int_cst_sgn (arg01);
13100
13101           /* (X - c) > X becomes false.  */
13102           if (code == GT_EXPR
13103               && ((code0 == MINUS_EXPR && is_positive >= 0)
13104                   || (code0 == PLUS_EXPR && is_positive <= 0)))
13105             {
13106               if (TREE_CODE (arg01) == INTEGER_CST
13107                   && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
13108                 fold_overflow_warning (("assuming signed overflow does not "
13109                                         "occur when assuming that (X - c) > X "
13110                                         "is always false"),
13111                                        WARN_STRICT_OVERFLOW_ALL);
13112               return constant_boolean_node (0, type);
13113             }
13114
13115           /* Likewise (X + c) < X becomes false.  */
13116           if (code == LT_EXPR
13117               && ((code0 == PLUS_EXPR && is_positive >= 0)
13118                   || (code0 == MINUS_EXPR && is_positive <= 0)))
13119             {
13120               if (TREE_CODE (arg01) == INTEGER_CST
13121                   && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
13122                 fold_overflow_warning (("assuming signed overflow does not "
13123                                         "occur when assuming that "
13124                                         "(X + c) < X is always false"),
13125                                        WARN_STRICT_OVERFLOW_ALL);
13126               return constant_boolean_node (0, type);
13127             }
13128
13129           /* Convert (X - c) <= X to true.  */
13130           if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1)))
13131               && code == LE_EXPR
13132               && ((code0 == MINUS_EXPR && is_positive >= 0)
13133                   || (code0 == PLUS_EXPR && is_positive <= 0)))
13134             {
13135               if (TREE_CODE (arg01) == INTEGER_CST
13136                   && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
13137                 fold_overflow_warning (("assuming signed overflow does not "
13138                                         "occur when assuming that "
13139                                         "(X - c) <= X is always true"),
13140                                        WARN_STRICT_OVERFLOW_ALL);
13141               return constant_boolean_node (1, type);
13142             }
13143
13144           /* Convert (X + c) >= X to true.  */
13145           if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1)))
13146               && code == GE_EXPR
13147               && ((code0 == PLUS_EXPR && is_positive >= 0)
13148                   || (code0 == MINUS_EXPR && is_positive <= 0)))
13149             {
13150               if (TREE_CODE (arg01) == INTEGER_CST
13151                   && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
13152                 fold_overflow_warning (("assuming signed overflow does not "
13153                                         "occur when assuming that "
13154                                         "(X + c) >= X is always true"),
13155                                        WARN_STRICT_OVERFLOW_ALL);
13156               return constant_boolean_node (1, type);
13157             }
13158
13159           if (TREE_CODE (arg01) == INTEGER_CST)
13160             {
13161               /* Convert X + c > X and X - c < X to true for integers.  */
13162               if (code == GT_EXPR
13163                   && ((code0 == PLUS_EXPR && is_positive > 0)
13164                       || (code0 == MINUS_EXPR && is_positive < 0)))
13165                 {
13166                   if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
13167                     fold_overflow_warning (("assuming signed overflow does "
13168                                             "not occur when assuming that "
13169                                             "(X + c) > X is always true"),
13170                                            WARN_STRICT_OVERFLOW_ALL);
13171                   return constant_boolean_node (1, type);
13172                 }
13173
13174               if (code == LT_EXPR
13175                   && ((code0 == MINUS_EXPR && is_positive > 0)
13176                       || (code0 == PLUS_EXPR && is_positive < 0)))
13177                 {
13178                   if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
13179                     fold_overflow_warning (("assuming signed overflow does "
13180                                             "not occur when assuming that "
13181                                             "(X - c) < X is always true"),
13182                                            WARN_STRICT_OVERFLOW_ALL);
13183                   return constant_boolean_node (1, type);
13184                 }
13185
13186               /* Convert X + c <= X and X - c >= X to false for integers.  */
13187               if (code == LE_EXPR
13188                   && ((code0 == PLUS_EXPR && is_positive > 0)
13189                       || (code0 == MINUS_EXPR && is_positive < 0)))
13190                 {
13191                   if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
13192                     fold_overflow_warning (("assuming signed overflow does "
13193                                             "not occur when assuming that "
13194                                             "(X + c) <= X is always false"),
13195                                            WARN_STRICT_OVERFLOW_ALL);
13196                   return constant_boolean_node (0, type);
13197                 }
13198
13199               if (code == GE_EXPR
13200                   && ((code0 == MINUS_EXPR && is_positive > 0)
13201                       || (code0 == PLUS_EXPR && is_positive < 0)))
13202                 {
13203                   if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
13204                     fold_overflow_warning (("assuming signed overflow does "
13205                                             "not occur when assuming that "
13206                                             "(X - c) >= X is always false"),
13207                                            WARN_STRICT_OVERFLOW_ALL);
13208                   return constant_boolean_node (0, type);
13209                 }
13210             }
13211         }
13212
13213       /* Comparisons with the highest or lowest possible integer of
13214          the specified precision will have known values.  */
13215       {
13216         tree arg1_type = TREE_TYPE (arg1);
13217         unsigned int width = TYPE_PRECISION (arg1_type);
13218
13219         if (TREE_CODE (arg1) == INTEGER_CST
13220             && width <= 2 * HOST_BITS_PER_WIDE_INT
13221             && (INTEGRAL_TYPE_P (arg1_type) || POINTER_TYPE_P (arg1_type)))
13222           {
13223             HOST_WIDE_INT signed_max_hi;
13224             unsigned HOST_WIDE_INT signed_max_lo;
13225             unsigned HOST_WIDE_INT max_hi, max_lo, min_hi, min_lo;
13226
13227             if (width <= HOST_BITS_PER_WIDE_INT)
13228               {
13229                 signed_max_lo = ((unsigned HOST_WIDE_INT) 1 << (width - 1))
13230                                 - 1;
13231                 signed_max_hi = 0;
13232                 max_hi = 0;
13233
13234                 if (TYPE_UNSIGNED (arg1_type))
13235                   {
13236                     max_lo = ((unsigned HOST_WIDE_INT) 2 << (width - 1)) - 1;
13237                     min_lo = 0;
13238                     min_hi = 0;
13239                   }
13240                 else
13241                   {
13242                     max_lo = signed_max_lo;
13243                     min_lo = ((unsigned HOST_WIDE_INT) -1 << (width - 1));
13244                     min_hi = -1;
13245                   }
13246               }
13247             else
13248               {
13249                 width -= HOST_BITS_PER_WIDE_INT;
13250                 signed_max_lo = -1;
13251                 signed_max_hi = ((unsigned HOST_WIDE_INT) 1 << (width - 1))
13252                                 - 1;
13253                 max_lo = -1;
13254                 min_lo = 0;
13255
13256                 if (TYPE_UNSIGNED (arg1_type))
13257                   {
13258                     max_hi = ((unsigned HOST_WIDE_INT) 2 << (width - 1)) - 1;
13259                     min_hi = 0;
13260                   }
13261                 else
13262                   {
13263                     max_hi = signed_max_hi;
13264                     min_hi = ((unsigned HOST_WIDE_INT) -1 << (width - 1));
13265                   }
13266               }
13267
13268             if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (arg1) == max_hi
13269                 && TREE_INT_CST_LOW (arg1) == max_lo)
13270               switch (code)
13271                 {
13272                 case GT_EXPR:
13273                   return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
13274
13275                 case GE_EXPR:
13276                   return fold_build2_loc (loc, EQ_EXPR, type, op0, op1);
13277
13278                 case LE_EXPR:
13279                   return omit_one_operand_loc (loc, type, integer_one_node, arg0);
13280
13281                 case LT_EXPR:
13282                   return fold_build2_loc (loc, NE_EXPR, type, op0, op1);
13283
13284                 /* The GE_EXPR and LT_EXPR cases above are not normally
13285                    reached because of previous transformations.  */
13286
13287                 default:
13288                   break;
13289                 }
13290             else if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (arg1)
13291                      == max_hi
13292                      && TREE_INT_CST_LOW (arg1) == max_lo - 1)
13293               switch (code)
13294                 {
13295                 case GT_EXPR:
13296                   arg1 = const_binop (PLUS_EXPR, arg1,
13297                                       build_int_cst (TREE_TYPE (arg1), 1));
13298                   return fold_build2_loc (loc, EQ_EXPR, type,
13299                                       fold_convert_loc (loc,
13300                                                         TREE_TYPE (arg1), arg0),
13301                                       arg1);
13302                 case LE_EXPR:
13303                   arg1 = const_binop (PLUS_EXPR, arg1,
13304                                       build_int_cst (TREE_TYPE (arg1), 1));
13305                   return fold_build2_loc (loc, NE_EXPR, type,
13306                                       fold_convert_loc (loc, TREE_TYPE (arg1),
13307                                                         arg0),
13308                                       arg1);
13309                 default:
13310                   break;
13311                 }
13312             else if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (arg1)
13313                      == min_hi
13314                      && TREE_INT_CST_LOW (arg1) == min_lo)
13315               switch (code)
13316                 {
13317                 case LT_EXPR:
13318                   return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
13319
13320                 case LE_EXPR:
13321                   return fold_build2_loc (loc, EQ_EXPR, type, op0, op1);
13322
13323                 case GE_EXPR:
13324                   return omit_one_operand_loc (loc, type, integer_one_node, arg0);
13325
13326                 case GT_EXPR:
13327                   return fold_build2_loc (loc, NE_EXPR, type, op0, op1);
13328
13329                 default:
13330                   break;
13331                 }
13332             else if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (arg1)
13333                      == min_hi
13334                      && TREE_INT_CST_LOW (arg1) == min_lo + 1)
13335               switch (code)
13336                 {
13337                 case GE_EXPR:
13338                   arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node);
13339                   return fold_build2_loc (loc, NE_EXPR, type,
13340                                       fold_convert_loc (loc,
13341                                                         TREE_TYPE (arg1), arg0),
13342                                       arg1);
13343                 case LT_EXPR:
13344                   arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node);
13345                   return fold_build2_loc (loc, EQ_EXPR, type,
13346                                       fold_convert_loc (loc, TREE_TYPE (arg1),
13347                                                         arg0),
13348                                       arg1);
13349                 default:
13350                   break;
13351                 }
13352
13353             else if (TREE_INT_CST_HIGH (arg1) == signed_max_hi
13354                      && TREE_INT_CST_LOW (arg1) == signed_max_lo
13355                      && TYPE_UNSIGNED (arg1_type)
13356                      /* We will flip the signedness of the comparison operator
13357                         associated with the mode of arg1, so the sign bit is
13358                         specified by this mode.  Check that arg1 is the signed
13359                         max associated with this sign bit.  */
13360                      && width == GET_MODE_BITSIZE (TYPE_MODE (arg1_type))
13361                      /* signed_type does not work on pointer types.  */
13362                      && INTEGRAL_TYPE_P (arg1_type))
13363               {
13364                 /* The following case also applies to X < signed_max+1
13365                    and X >= signed_max+1 because previous transformations.  */
13366                 if (code == LE_EXPR || code == GT_EXPR)
13367                   {
13368                     tree st;
13369                     st = signed_type_for (TREE_TYPE (arg1));
13370                     return fold_build2_loc (loc,
13371                                         code == LE_EXPR ? GE_EXPR : LT_EXPR,
13372                                         type, fold_convert_loc (loc, st, arg0),
13373                                         build_int_cst (st, 0));
13374                   }
13375               }
13376           }
13377       }
13378
13379       /* If we are comparing an ABS_EXPR with a constant, we can
13380          convert all the cases into explicit comparisons, but they may
13381          well not be faster than doing the ABS and one comparison.
13382          But ABS (X) <= C is a range comparison, which becomes a subtraction
13383          and a comparison, and is probably faster.  */
13384       if (code == LE_EXPR
13385           && TREE_CODE (arg1) == INTEGER_CST
13386           && TREE_CODE (arg0) == ABS_EXPR
13387           && ! TREE_SIDE_EFFECTS (arg0)
13388           && (0 != (tem = negate_expr (arg1)))
13389           && TREE_CODE (tem) == INTEGER_CST
13390           && !TREE_OVERFLOW (tem))
13391         return fold_build2_loc (loc, TRUTH_ANDIF_EXPR, type,
13392                             build2 (GE_EXPR, type,
13393                                     TREE_OPERAND (arg0, 0), tem),
13394                             build2 (LE_EXPR, type,
13395                                     TREE_OPERAND (arg0, 0), arg1));
13396
13397       /* Convert ABS_EXPR<x> >= 0 to true.  */
13398       strict_overflow_p = false;
13399       if (code == GE_EXPR
13400           && (integer_zerop (arg1)
13401               || (! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0)))
13402                   && real_zerop (arg1)))
13403           && tree_expr_nonnegative_warnv_p (arg0, &strict_overflow_p))
13404         {
13405           if (strict_overflow_p)
13406             fold_overflow_warning (("assuming signed overflow does not occur "
13407                                     "when simplifying comparison of "
13408                                     "absolute value and zero"),
13409                                    WARN_STRICT_OVERFLOW_CONDITIONAL);
13410           return omit_one_operand_loc (loc, type, integer_one_node, arg0);
13411         }
13412
13413       /* Convert ABS_EXPR<x> < 0 to false.  */
13414       strict_overflow_p = false;
13415       if (code == LT_EXPR
13416           && (integer_zerop (arg1) || real_zerop (arg1))
13417           && tree_expr_nonnegative_warnv_p (arg0, &strict_overflow_p))
13418         {
13419           if (strict_overflow_p)
13420             fold_overflow_warning (("assuming signed overflow does not occur "
13421                                     "when simplifying comparison of "
13422                                     "absolute value and zero"),
13423                                    WARN_STRICT_OVERFLOW_CONDITIONAL);
13424           return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
13425         }
13426
13427       /* If X is unsigned, convert X < (1 << Y) into X >> Y == 0
13428          and similarly for >= into !=.  */
13429       if ((code == LT_EXPR || code == GE_EXPR)
13430           && TYPE_UNSIGNED (TREE_TYPE (arg0))
13431           && TREE_CODE (arg1) == LSHIFT_EXPR
13432           && integer_onep (TREE_OPERAND (arg1, 0)))
13433         return build2_loc (loc, code == LT_EXPR ? EQ_EXPR : NE_EXPR, type,
13434                            build2 (RSHIFT_EXPR, TREE_TYPE (arg0), arg0,
13435                                    TREE_OPERAND (arg1, 1)),
13436                            build_int_cst (TREE_TYPE (arg0), 0));
13437
13438       if ((code == LT_EXPR || code == GE_EXPR)
13439           && TYPE_UNSIGNED (TREE_TYPE (arg0))
13440           && CONVERT_EXPR_P (arg1)
13441           && TREE_CODE (TREE_OPERAND (arg1, 0)) == LSHIFT_EXPR
13442           && integer_onep (TREE_OPERAND (TREE_OPERAND (arg1, 0), 0)))
13443         {
13444           tem = build2 (RSHIFT_EXPR, TREE_TYPE (arg0), arg0,
13445                         TREE_OPERAND (TREE_OPERAND (arg1, 0), 1));
13446           return build2_loc (loc, code == LT_EXPR ? EQ_EXPR : NE_EXPR, type,
13447                              fold_convert_loc (loc, TREE_TYPE (arg0), tem),
13448                              build_int_cst (TREE_TYPE (arg0), 0));
13449         }
13450
13451       return NULL_TREE;
13452
13453     case UNORDERED_EXPR:
13454     case ORDERED_EXPR:
13455     case UNLT_EXPR:
13456     case UNLE_EXPR:
13457     case UNGT_EXPR:
13458     case UNGE_EXPR:
13459     case UNEQ_EXPR:
13460     case LTGT_EXPR:
13461       if (TREE_CODE (arg0) == REAL_CST && TREE_CODE (arg1) == REAL_CST)
13462         {
13463           t1 = fold_relational_const (code, type, arg0, arg1);
13464           if (t1 != NULL_TREE)
13465             return t1;
13466         }
13467
13468       /* If the first operand is NaN, the result is constant.  */
13469       if (TREE_CODE (arg0) == REAL_CST
13470           && REAL_VALUE_ISNAN (TREE_REAL_CST (arg0))
13471           && (code != LTGT_EXPR || ! flag_trapping_math))
13472         {
13473           t1 = (code == ORDERED_EXPR || code == LTGT_EXPR)
13474                ? integer_zero_node
13475                : integer_one_node;
13476           return omit_one_operand_loc (loc, type, t1, arg1);
13477         }
13478
13479       /* If the second operand is NaN, the result is constant.  */
13480       if (TREE_CODE (arg1) == REAL_CST
13481           && REAL_VALUE_ISNAN (TREE_REAL_CST (arg1))
13482           && (code != LTGT_EXPR || ! flag_trapping_math))
13483         {
13484           t1 = (code == ORDERED_EXPR || code == LTGT_EXPR)
13485                ? integer_zero_node
13486                : integer_one_node;
13487           return omit_one_operand_loc (loc, type, t1, arg0);
13488         }
13489
13490       /* Simplify unordered comparison of something with itself.  */
13491       if ((code == UNLE_EXPR || code == UNGE_EXPR || code == UNEQ_EXPR)
13492           && operand_equal_p (arg0, arg1, 0))
13493         return constant_boolean_node (1, type);
13494
13495       if (code == LTGT_EXPR
13496           && !flag_trapping_math
13497           && operand_equal_p (arg0, arg1, 0))
13498         return constant_boolean_node (0, type);
13499
13500       /* Fold (double)float1 CMP (double)float2 into float1 CMP float2.  */
13501       {
13502         tree targ0 = strip_float_extensions (arg0);
13503         tree targ1 = strip_float_extensions (arg1);
13504         tree newtype = TREE_TYPE (targ0);
13505
13506         if (TYPE_PRECISION (TREE_TYPE (targ1)) > TYPE_PRECISION (newtype))
13507           newtype = TREE_TYPE (targ1);
13508
13509         if (TYPE_PRECISION (newtype) < TYPE_PRECISION (TREE_TYPE (arg0)))
13510           return fold_build2_loc (loc, code, type,
13511                               fold_convert_loc (loc, newtype, targ0),
13512                               fold_convert_loc (loc, newtype, targ1));
13513       }
13514
13515       return NULL_TREE;
13516
13517     case COMPOUND_EXPR:
13518       /* When pedantic, a compound expression can be neither an lvalue
13519          nor an integer constant expression.  */
13520       if (TREE_SIDE_EFFECTS (arg0) || TREE_CONSTANT (arg1))
13521         return NULL_TREE;
13522       /* Don't let (0, 0) be null pointer constant.  */
13523       tem = integer_zerop (arg1) ? build1 (NOP_EXPR, type, arg1)
13524                                  : fold_convert_loc (loc, type, arg1);
13525       return pedantic_non_lvalue_loc (loc, tem);
13526
13527     case COMPLEX_EXPR:
13528       if ((TREE_CODE (arg0) == REAL_CST
13529            && TREE_CODE (arg1) == REAL_CST)
13530           || (TREE_CODE (arg0) == INTEGER_CST
13531               && TREE_CODE (arg1) == INTEGER_CST))
13532         return build_complex (type, arg0, arg1);
13533       if (TREE_CODE (arg0) == REALPART_EXPR
13534           && TREE_CODE (arg1) == IMAGPART_EXPR
13535           && TREE_TYPE (TREE_OPERAND (arg0, 0)) == type
13536           && operand_equal_p (TREE_OPERAND (arg0, 0),
13537                               TREE_OPERAND (arg1, 0), 0))
13538         return omit_one_operand_loc (loc, type, TREE_OPERAND (arg0, 0),
13539                                      TREE_OPERAND (arg1, 0));
13540       return NULL_TREE;
13541
13542     case ASSERT_EXPR:
13543       /* An ASSERT_EXPR should never be passed to fold_binary.  */
13544       gcc_unreachable ();
13545
13546     case VEC_PACK_TRUNC_EXPR:
13547     case VEC_PACK_FIX_TRUNC_EXPR:
13548       {
13549         unsigned int nelts = TYPE_VECTOR_SUBPARTS (type), i;
13550         tree *elts, vals = NULL_TREE;
13551
13552         gcc_assert (TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0)) == nelts / 2
13553                     && TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg1)) == nelts / 2);
13554         if (TREE_CODE (arg0) != VECTOR_CST || TREE_CODE (arg1) != VECTOR_CST)
13555           return NULL_TREE;
13556
13557         elts = XALLOCAVEC (tree, nelts);
13558         if (!vec_cst_ctor_to_array (arg0, elts)
13559             || !vec_cst_ctor_to_array (arg1, elts + nelts / 2))
13560           return NULL_TREE;
13561
13562         for (i = 0; i < nelts; i++)
13563           {
13564             elts[i] = fold_convert_const (code == VEC_PACK_TRUNC_EXPR
13565                                           ? NOP_EXPR : FIX_TRUNC_EXPR,
13566                                           TREE_TYPE (type), elts[i]);
13567             if (elts[i] == NULL_TREE || !CONSTANT_CLASS_P (elts[i]))
13568               return NULL_TREE;
13569           }
13570
13571         for (i = 0; i < nelts; i++)
13572           vals = tree_cons (NULL_TREE, elts[nelts - i - 1], vals);
13573         return build_vector (type, vals);
13574       }
13575
13576     case VEC_WIDEN_MULT_LO_EXPR:
13577     case VEC_WIDEN_MULT_HI_EXPR:
13578       {
13579         unsigned int nelts = TYPE_VECTOR_SUBPARTS (type), i;
13580         tree *elts, vals = NULL_TREE;
13581
13582         gcc_assert (TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0)) == nelts * 2
13583                     && TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg1)) == nelts * 2);
13584         if (TREE_CODE (arg0) != VECTOR_CST || TREE_CODE (arg1) != VECTOR_CST)
13585           return NULL_TREE;
13586
13587         elts = XALLOCAVEC (tree, nelts * 4);
13588         if (!vec_cst_ctor_to_array (arg0, elts)
13589             || !vec_cst_ctor_to_array (arg1, elts + nelts * 2))
13590           return NULL_TREE;
13591
13592         if ((!BYTES_BIG_ENDIAN) ^ (code == VEC_WIDEN_MULT_LO_EXPR))
13593           elts += nelts;
13594
13595         for (i = 0; i < nelts; i++)
13596           {
13597             elts[i] = fold_convert_const (NOP_EXPR, TREE_TYPE (type), elts[i]);
13598             elts[i + nelts * 2]
13599               = fold_convert_const (NOP_EXPR, TREE_TYPE (type),
13600                                     elts[i + nelts * 2]);
13601             if (elts[i] == NULL_TREE || elts[i + nelts * 2] == NULL_TREE)
13602               return NULL_TREE;
13603             elts[i] = const_binop (MULT_EXPR, elts[i], elts[i + nelts * 2]);
13604             if (elts[i] == NULL_TREE || !CONSTANT_CLASS_P (elts[i]))
13605               return NULL_TREE;
13606           }
13607
13608         for (i = 0; i < nelts; i++)
13609           vals = tree_cons (NULL_TREE, elts[nelts - i - 1], vals);
13610         return build_vector (type, vals);
13611       }
13612
13613     default:
13614       return NULL_TREE;
13615     } /* switch (code) */
13616 }
13617
13618 /* Callback for walk_tree, looking for LABEL_EXPR.  Return *TP if it is
13619    a LABEL_EXPR; otherwise return NULL_TREE.  Do not check the subtrees
13620    of GOTO_EXPR.  */
13621
13622 static tree
13623 contains_label_1 (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
13624 {
13625   switch (TREE_CODE (*tp))
13626     {
13627     case LABEL_EXPR:
13628       return *tp;
13629
13630     case GOTO_EXPR:
13631       *walk_subtrees = 0;
13632
13633       /* ... fall through ...  */
13634
13635     default:
13636       return NULL_TREE;
13637     }
13638 }
13639
13640 /* Return whether the sub-tree ST contains a label which is accessible from
13641    outside the sub-tree.  */
13642
13643 static bool
13644 contains_label_p (tree st)
13645 {
13646   return
13647    (walk_tree_without_duplicates (&st, contains_label_1 , NULL) != NULL_TREE);
13648 }
13649
13650 /* Fold a ternary expression of code CODE and type TYPE with operands
13651    OP0, OP1, and OP2.  Return the folded expression if folding is
13652    successful.  Otherwise, return NULL_TREE.  */
13653
13654 tree
13655 fold_ternary_loc (location_t loc, enum tree_code code, tree type,
13656                   tree op0, tree op1, tree op2)
13657 {
13658   tree tem;
13659   tree arg0 = NULL_TREE, arg1 = NULL_TREE, arg2 = NULL_TREE;
13660   enum tree_code_class kind = TREE_CODE_CLASS (code);
13661
13662   gcc_assert (IS_EXPR_CODE_CLASS (kind)
13663               && TREE_CODE_LENGTH (code) == 3);
13664
13665   /* Strip any conversions that don't change the mode.  This is safe
13666      for every expression, except for a comparison expression because
13667      its signedness is derived from its operands.  So, in the latter
13668      case, only strip conversions that don't change the signedness.
13669
13670      Note that this is done as an internal manipulation within the
13671      constant folder, in order to find the simplest representation of
13672      the arguments so that their form can be studied.  In any cases,
13673      the appropriate type conversions should be put back in the tree
13674      that will get out of the constant folder.  */
13675   if (op0)
13676     {
13677       arg0 = op0;
13678       STRIP_NOPS (arg0);
13679     }
13680
13681   if (op1)
13682     {
13683       arg1 = op1;
13684       STRIP_NOPS (arg1);
13685     }
13686
13687   if (op2)
13688     {
13689       arg2 = op2;
13690       STRIP_NOPS (arg2);
13691     }
13692
13693   switch (code)
13694     {
13695     case COMPONENT_REF:
13696       if (TREE_CODE (arg0) == CONSTRUCTOR
13697           && ! type_contains_placeholder_p (TREE_TYPE (arg0)))
13698         {
13699           unsigned HOST_WIDE_INT idx;
13700           tree field, value;
13701           FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (arg0), idx, field, value)
13702             if (field == arg1)
13703               return value;
13704         }
13705       return NULL_TREE;
13706
13707     case COND_EXPR:
13708       /* Pedantic ANSI C says that a conditional expression is never an lvalue,
13709          so all simple results must be passed through pedantic_non_lvalue.  */
13710       if (TREE_CODE (arg0) == INTEGER_CST)
13711         {
13712           tree unused_op = integer_zerop (arg0) ? op1 : op2;
13713           tem = integer_zerop (arg0) ? op2 : op1;
13714           /* Only optimize constant conditions when the selected branch
13715              has the same type as the COND_EXPR.  This avoids optimizing
13716              away "c ? x : throw", where the throw has a void type.
13717              Avoid throwing away that operand which contains label.  */
13718           if ((!TREE_SIDE_EFFECTS (unused_op)
13719                || !contains_label_p (unused_op))
13720               && (! VOID_TYPE_P (TREE_TYPE (tem))
13721                   || VOID_TYPE_P (type)))
13722             return pedantic_non_lvalue_loc (loc, tem);
13723           return NULL_TREE;
13724         }
13725       if (operand_equal_p (arg1, op2, 0))
13726         return pedantic_omit_one_operand_loc (loc, type, arg1, arg0);
13727
13728       /* If we have A op B ? A : C, we may be able to convert this to a
13729          simpler expression, depending on the operation and the values
13730          of B and C.  Signed zeros prevent all of these transformations,
13731          for reasons given above each one.
13732
13733          Also try swapping the arguments and inverting the conditional.  */
13734       if (COMPARISON_CLASS_P (arg0)
13735           && operand_equal_for_comparison_p (TREE_OPERAND (arg0, 0),
13736                                              arg1, TREE_OPERAND (arg0, 1))
13737           && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg1))))
13738         {
13739           tem = fold_cond_expr_with_comparison (loc, type, arg0, op1, op2);
13740           if (tem)
13741             return tem;
13742         }
13743
13744       if (COMPARISON_CLASS_P (arg0)
13745           && operand_equal_for_comparison_p (TREE_OPERAND (arg0, 0),
13746                                              op2,
13747                                              TREE_OPERAND (arg0, 1))
13748           && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (op2))))
13749         {
13750           location_t loc0 = expr_location_or (arg0, loc);
13751           tem = fold_truth_not_expr (loc0, arg0);
13752           if (tem && COMPARISON_CLASS_P (tem))
13753             {
13754               tem = fold_cond_expr_with_comparison (loc, type, tem, op2, op1);
13755               if (tem)
13756                 return tem;
13757             }
13758         }
13759
13760       /* If the second operand is simpler than the third, swap them
13761          since that produces better jump optimization results.  */
13762       if (truth_value_p (TREE_CODE (arg0))
13763           && tree_swap_operands_p (op1, op2, false))
13764         {
13765           location_t loc0 = expr_location_or (arg0, loc);
13766           /* See if this can be inverted.  If it can't, possibly because
13767              it was a floating-point inequality comparison, don't do
13768              anything.  */
13769           tem = fold_truth_not_expr (loc0, arg0);
13770           if (tem)
13771             return fold_build3_loc (loc, code, type, tem, op2, op1);
13772         }
13773
13774       /* Convert A ? 1 : 0 to simply A.  */
13775       if (integer_onep (op1)
13776           && integer_zerop (op2)
13777           /* If we try to convert OP0 to our type, the
13778              call to fold will try to move the conversion inside
13779              a COND, which will recurse.  In that case, the COND_EXPR
13780              is probably the best choice, so leave it alone.  */
13781           && type == TREE_TYPE (arg0))
13782         return pedantic_non_lvalue_loc (loc, arg0);
13783
13784       /* Convert A ? 0 : 1 to !A.  This prefers the use of NOT_EXPR
13785          over COND_EXPR in cases such as floating point comparisons.  */
13786       if (integer_zerop (op1)
13787           && integer_onep (op2)
13788           && truth_value_p (TREE_CODE (arg0)))
13789         return pedantic_non_lvalue_loc (loc,
13790                                     fold_convert_loc (loc, type,
13791                                               invert_truthvalue_loc (loc,
13792                                                                      arg0)));
13793
13794       /* A < 0 ? <sign bit of A> : 0 is simply (A & <sign bit of A>).  */
13795       if (TREE_CODE (arg0) == LT_EXPR
13796           && integer_zerop (TREE_OPERAND (arg0, 1))
13797           && integer_zerop (op2)
13798           && (tem = sign_bit_p (TREE_OPERAND (arg0, 0), arg1)))
13799         {
13800           /* sign_bit_p only checks ARG1 bits within A's precision.
13801              If <sign bit of A> has wider type than A, bits outside
13802              of A's precision in <sign bit of A> need to be checked.
13803              If they are all 0, this optimization needs to be done
13804              in unsigned A's type, if they are all 1 in signed A's type,
13805              otherwise this can't be done.  */
13806           if (TYPE_PRECISION (TREE_TYPE (tem))
13807               < TYPE_PRECISION (TREE_TYPE (arg1))
13808               && TYPE_PRECISION (TREE_TYPE (tem))
13809                  < TYPE_PRECISION (type))
13810             {
13811               unsigned HOST_WIDE_INT mask_lo;
13812               HOST_WIDE_INT mask_hi;
13813               int inner_width, outer_width;
13814               tree tem_type;
13815
13816               inner_width = TYPE_PRECISION (TREE_TYPE (tem));
13817               outer_width = TYPE_PRECISION (TREE_TYPE (arg1));
13818               if (outer_width > TYPE_PRECISION (type))
13819                 outer_width = TYPE_PRECISION (type);
13820
13821               if (outer_width > HOST_BITS_PER_WIDE_INT)
13822                 {
13823                   mask_hi = ((unsigned HOST_WIDE_INT) -1
13824                              >> (2 * HOST_BITS_PER_WIDE_INT - outer_width));
13825                   mask_lo = -1;
13826                 }
13827               else
13828                 {
13829                   mask_hi = 0;
13830                   mask_lo = ((unsigned HOST_WIDE_INT) -1
13831                              >> (HOST_BITS_PER_WIDE_INT - outer_width));
13832                 }
13833               if (inner_width > HOST_BITS_PER_WIDE_INT)
13834                 {
13835                   mask_hi &= ~((unsigned HOST_WIDE_INT) -1
13836                                >> (HOST_BITS_PER_WIDE_INT - inner_width));
13837                   mask_lo = 0;
13838                 }
13839               else
13840                 mask_lo &= ~((unsigned HOST_WIDE_INT) -1
13841                              >> (HOST_BITS_PER_WIDE_INT - inner_width));
13842
13843               if ((TREE_INT_CST_HIGH (arg1) & mask_hi) == mask_hi
13844                   && (TREE_INT_CST_LOW (arg1) & mask_lo) == mask_lo)
13845                 {
13846                   tem_type = signed_type_for (TREE_TYPE (tem));
13847                   tem = fold_convert_loc (loc, tem_type, tem);
13848                 }
13849               else if ((TREE_INT_CST_HIGH (arg1) & mask_hi) == 0
13850                        && (TREE_INT_CST_LOW (arg1) & mask_lo) == 0)
13851                 {
13852                   tem_type = unsigned_type_for (TREE_TYPE (tem));
13853                   tem = fold_convert_loc (loc, tem_type, tem);
13854                 }
13855               else
13856                 tem = NULL;
13857             }
13858
13859           if (tem)
13860             return
13861               fold_convert_loc (loc, type,
13862                                 fold_build2_loc (loc, BIT_AND_EXPR,
13863                                              TREE_TYPE (tem), tem,
13864                                              fold_convert_loc (loc,
13865                                                                TREE_TYPE (tem),
13866                                                                arg1)));
13867         }
13868
13869       /* (A >> N) & 1 ? (1 << N) : 0 is simply A & (1 << N).  A & 1 was
13870          already handled above.  */
13871       if (TREE_CODE (arg0) == BIT_AND_EXPR
13872           && integer_onep (TREE_OPERAND (arg0, 1))
13873           && integer_zerop (op2)
13874           && integer_pow2p (arg1))
13875         {
13876           tree tem = TREE_OPERAND (arg0, 0);
13877           STRIP_NOPS (tem);
13878           if (TREE_CODE (tem) == RSHIFT_EXPR
13879               && TREE_CODE (TREE_OPERAND (tem, 1)) == INTEGER_CST
13880               && (unsigned HOST_WIDE_INT) tree_log2 (arg1) ==
13881                  TREE_INT_CST_LOW (TREE_OPERAND (tem, 1)))
13882             return fold_build2_loc (loc, BIT_AND_EXPR, type,
13883                                 TREE_OPERAND (tem, 0), arg1);
13884         }
13885
13886       /* A & N ? N : 0 is simply A & N if N is a power of two.  This
13887          is probably obsolete because the first operand should be a
13888          truth value (that's why we have the two cases above), but let's
13889          leave it in until we can confirm this for all front-ends.  */
13890       if (integer_zerop (op2)
13891           && TREE_CODE (arg0) == NE_EXPR
13892           && integer_zerop (TREE_OPERAND (arg0, 1))
13893           && integer_pow2p (arg1)
13894           && TREE_CODE (TREE_OPERAND (arg0, 0)) == BIT_AND_EXPR
13895           && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1),
13896                               arg1, OEP_ONLY_CONST))
13897         return pedantic_non_lvalue_loc (loc,
13898                                     fold_convert_loc (loc, type,
13899                                                       TREE_OPERAND (arg0, 0)));
13900
13901       /* Convert A ? B : 0 into A && B if A and B are truth values.  */
13902       if (integer_zerop (op2)
13903           && truth_value_p (TREE_CODE (arg0))
13904           && truth_value_p (TREE_CODE (arg1)))
13905         return fold_build2_loc (loc, TRUTH_ANDIF_EXPR, type,
13906                             fold_convert_loc (loc, type, arg0),
13907                             arg1);
13908
13909       /* Convert A ? B : 1 into !A || B if A and B are truth values.  */
13910       if (integer_onep (op2)
13911           && truth_value_p (TREE_CODE (arg0))
13912           && truth_value_p (TREE_CODE (arg1)))
13913         {
13914           location_t loc0 = expr_location_or (arg0, loc);
13915           /* Only perform transformation if ARG0 is easily inverted.  */
13916           tem = fold_truth_not_expr (loc0, arg0);
13917           if (tem)
13918             return fold_build2_loc (loc, TRUTH_ORIF_EXPR, type,
13919                                 fold_convert_loc (loc, type, tem),
13920                                 arg1);
13921         }
13922
13923       /* Convert A ? 0 : B into !A && B if A and B are truth values.  */
13924       if (integer_zerop (arg1)
13925           && truth_value_p (TREE_CODE (arg0))
13926           && truth_value_p (TREE_CODE (op2)))
13927         {
13928           location_t loc0 = expr_location_or (arg0, loc);
13929           /* Only perform transformation if ARG0 is easily inverted.  */
13930           tem = fold_truth_not_expr (loc0, arg0);
13931           if (tem)
13932             return fold_build2_loc (loc, TRUTH_ANDIF_EXPR, type,
13933                                 fold_convert_loc (loc, type, tem),
13934                                 op2);
13935         }
13936
13937       /* Convert A ? 1 : B into A || B if A and B are truth values.  */
13938       if (integer_onep (arg1)
13939           && truth_value_p (TREE_CODE (arg0))
13940           && truth_value_p (TREE_CODE (op2)))
13941         return fold_build2_loc (loc, TRUTH_ORIF_EXPR, type,
13942                             fold_convert_loc (loc, type, arg0),
13943                             op2);
13944
13945       return NULL_TREE;
13946
13947     case CALL_EXPR:
13948       /* CALL_EXPRs used to be ternary exprs.  Catch any mistaken uses
13949          of fold_ternary on them.  */
13950       gcc_unreachable ();
13951
13952     case BIT_FIELD_REF:
13953       if ((TREE_CODE (arg0) == VECTOR_CST
13954            || TREE_CODE (arg0) == CONSTRUCTOR)
13955           && type == TREE_TYPE (TREE_TYPE (arg0)))
13956         {
13957           unsigned HOST_WIDE_INT width = tree_low_cst (arg1, 1);
13958           unsigned HOST_WIDE_INT idx = tree_low_cst (op2, 1);
13959
13960           if (width != 0
13961               && simple_cst_equal (arg1, TYPE_SIZE (type)) == 1
13962               && (idx % width) == 0
13963               && (idx = idx / width)
13964                  < TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0)))
13965             {
13966               if (TREE_CODE (arg0) == VECTOR_CST)
13967                 {
13968                   tree elements = TREE_VECTOR_CST_ELTS (arg0);
13969                   while (idx-- > 0 && elements)
13970                     elements = TREE_CHAIN (elements);
13971                   if (elements)
13972                     return TREE_VALUE (elements);
13973                 }
13974               else if (idx < CONSTRUCTOR_NELTS (arg0))
13975                 return CONSTRUCTOR_ELT (arg0, idx)->value;
13976               return build_zero_cst (type);
13977             }
13978         }
13979
13980       /* A bit-field-ref that referenced the full argument can be stripped.  */
13981       if (INTEGRAL_TYPE_P (TREE_TYPE (arg0))
13982           && TYPE_PRECISION (TREE_TYPE (arg0)) == tree_low_cst (arg1, 1)
13983           && integer_zerop (op2))
13984         return fold_convert_loc (loc, type, arg0);
13985
13986       return NULL_TREE;
13987
13988     case FMA_EXPR:
13989       /* For integers we can decompose the FMA if possible.  */
13990       if (TREE_CODE (arg0) == INTEGER_CST
13991           && TREE_CODE (arg1) == INTEGER_CST)
13992         return fold_build2_loc (loc, PLUS_EXPR, type,
13993                                 const_binop (MULT_EXPR, arg0, arg1), arg2);
13994       if (integer_zerop (arg2))
13995         return fold_build2_loc (loc, MULT_EXPR, type, arg0, arg1);
13996
13997       return fold_fma (loc, type, arg0, arg1, arg2);
13998
13999     case VEC_PERM_EXPR:
14000       if (TREE_CODE (arg2) == VECTOR_CST)
14001         {
14002           unsigned int nelts = TYPE_VECTOR_SUBPARTS (type), i;
14003           unsigned char *sel = XALLOCAVEC (unsigned char, nelts);
14004           tree t;
14005           bool need_mask_canon = false;
14006
14007           gcc_assert (nelts == TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg2)));
14008           for (i = 0, t = TREE_VECTOR_CST_ELTS (arg2);
14009                i < nelts && t; i++, t = TREE_CHAIN (t))
14010             {
14011               if (TREE_CODE (TREE_VALUE (t)) != INTEGER_CST)
14012                 return NULL_TREE;
14013
14014               sel[i] = TREE_INT_CST_LOW (TREE_VALUE (t)) & (2 * nelts - 1);
14015               if (TREE_INT_CST_HIGH (TREE_VALUE (t))
14016                   || ((unsigned HOST_WIDE_INT)
14017                       TREE_INT_CST_LOW (TREE_VALUE (t)) != sel[i]))
14018                 need_mask_canon = true;
14019             }
14020           if (t)
14021             return NULL_TREE;
14022           for (; i < nelts; i++)
14023             sel[i] = 0;
14024
14025           if ((TREE_CODE (arg0) == VECTOR_CST
14026                || TREE_CODE (arg0) == CONSTRUCTOR)
14027               && (TREE_CODE (arg1) == VECTOR_CST
14028                   || TREE_CODE (arg1) == CONSTRUCTOR))
14029             {
14030               t = fold_vec_perm (type, arg0, arg1, sel);
14031               if (t != NULL_TREE)
14032                 return t;
14033             }
14034
14035           if (need_mask_canon && arg2 == op2)
14036             {
14037               tree list = NULL_TREE, eltype = TREE_TYPE (TREE_TYPE (arg2));
14038               for (i = 0; i < nelts; i++)
14039                 list = tree_cons (NULL_TREE,
14040                                   build_int_cst (eltype, sel[nelts - i - 1]),
14041                                   list);
14042               t = build_vector (TREE_TYPE (arg2), list);
14043               return build3_loc (loc, VEC_PERM_EXPR, type, op0, op1, t);
14044             }
14045         }
14046       return NULL_TREE;
14047
14048     default:
14049       return NULL_TREE;
14050     } /* switch (code) */
14051 }
14052
14053 /* Perform constant folding and related simplification of EXPR.
14054    The related simplifications include x*1 => x, x*0 => 0, etc.,
14055    and application of the associative law.
14056    NOP_EXPR conversions may be removed freely (as long as we
14057    are careful not to change the type of the overall expression).
14058    We cannot simplify through a CONVERT_EXPR, FIX_EXPR or FLOAT_EXPR,
14059    but we can constant-fold them if they have constant operands.  */
14060
14061 #ifdef ENABLE_FOLD_CHECKING
14062 # define fold(x) fold_1 (x)
14063 static tree fold_1 (tree);
14064 static
14065 #endif
14066 tree
14067 fold (tree expr)
14068 {
14069   const tree t = expr;
14070   enum tree_code code = TREE_CODE (t);
14071   enum tree_code_class kind = TREE_CODE_CLASS (code);
14072   tree tem;
14073   location_t loc = EXPR_LOCATION (expr);
14074
14075   /* Return right away if a constant.  */
14076   if (kind == tcc_constant)
14077     return t;
14078
14079   /* CALL_EXPR-like objects with variable numbers of operands are
14080      treated specially.  */
14081   if (kind == tcc_vl_exp)
14082     {
14083       if (code == CALL_EXPR)
14084         {
14085           tem = fold_call_expr (loc, expr, false);
14086           return tem ? tem : expr;
14087         }
14088       return expr;
14089     }
14090
14091   if (IS_EXPR_CODE_CLASS (kind))
14092     {
14093       tree type = TREE_TYPE (t);
14094       tree op0, op1, op2;
14095
14096       switch (TREE_CODE_LENGTH (code))
14097         {
14098         case 1:
14099           op0 = TREE_OPERAND (t, 0);
14100           tem = fold_unary_loc (loc, code, type, op0);
14101           return tem ? tem : expr;
14102         case 2:
14103           op0 = TREE_OPERAND (t, 0);
14104           op1 = TREE_OPERAND (t, 1);
14105           tem = fold_binary_loc (loc, code, type, op0, op1);
14106           return tem ? tem : expr;
14107         case 3:
14108           op0 = TREE_OPERAND (t, 0);
14109           op1 = TREE_OPERAND (t, 1);
14110           op2 = TREE_OPERAND (t, 2);
14111           tem = fold_ternary_loc (loc, code, type, op0, op1, op2);
14112           return tem ? tem : expr;
14113         default:
14114           break;
14115         }
14116     }
14117
14118   switch (code)
14119     {
14120     case ARRAY_REF:
14121       {
14122         tree op0 = TREE_OPERAND (t, 0);
14123         tree op1 = TREE_OPERAND (t, 1);
14124
14125         if (TREE_CODE (op1) == INTEGER_CST
14126             && TREE_CODE (op0) == CONSTRUCTOR
14127             && ! type_contains_placeholder_p (TREE_TYPE (op0)))
14128           {
14129             VEC(constructor_elt,gc) *elts = CONSTRUCTOR_ELTS (op0);
14130             unsigned HOST_WIDE_INT end = VEC_length (constructor_elt, elts);
14131             unsigned HOST_WIDE_INT begin = 0;
14132
14133             /* Find a matching index by means of a binary search.  */
14134             while (begin != end)
14135               {
14136                 unsigned HOST_WIDE_INT middle = (begin + end) / 2;
14137                 tree index = VEC_index (constructor_elt, elts, middle)->index;
14138
14139                 if (TREE_CODE (index) == INTEGER_CST
14140                     && tree_int_cst_lt (index, op1))
14141                   begin = middle + 1;
14142                 else if (TREE_CODE (index) == INTEGER_CST
14143                          && tree_int_cst_lt (op1, index))
14144                   end = middle;
14145                 else if (TREE_CODE (index) == RANGE_EXPR
14146                          && tree_int_cst_lt (TREE_OPERAND (index, 1), op1))
14147                   begin = middle + 1;
14148                 else if (TREE_CODE (index) == RANGE_EXPR
14149                          && tree_int_cst_lt (op1, TREE_OPERAND (index, 0)))
14150                   end = middle;
14151                 else
14152                   return VEC_index (constructor_elt, elts, middle)->value;
14153               }
14154           }
14155
14156         return t;
14157       }
14158
14159     case CONST_DECL:
14160       return fold (DECL_INITIAL (t));
14161
14162     default:
14163       return t;
14164     } /* switch (code) */
14165 }
14166
14167 #ifdef ENABLE_FOLD_CHECKING
14168 #undef fold
14169
14170 static void fold_checksum_tree (const_tree, struct md5_ctx *, htab_t);
14171 static void fold_check_failed (const_tree, const_tree);
14172 void print_fold_checksum (const_tree);
14173
14174 /* When --enable-checking=fold, compute a digest of expr before
14175    and after actual fold call to see if fold did not accidentally
14176    change original expr.  */
14177
14178 tree
14179 fold (tree expr)
14180 {
14181   tree ret;
14182   struct md5_ctx ctx;
14183   unsigned char checksum_before[16], checksum_after[16];
14184   htab_t ht;
14185
14186   ht = htab_create (32, htab_hash_pointer, htab_eq_pointer, NULL);
14187   md5_init_ctx (&ctx);
14188   fold_checksum_tree (expr, &ctx, ht);
14189   md5_finish_ctx (&ctx, checksum_before);
14190   htab_empty (ht);
14191
14192   ret = fold_1 (expr);
14193
14194   md5_init_ctx (&ctx);
14195   fold_checksum_tree (expr, &ctx, ht);
14196   md5_finish_ctx (&ctx, checksum_after);
14197   htab_delete (ht);
14198
14199   if (memcmp (checksum_before, checksum_after, 16))
14200     fold_check_failed (expr, ret);
14201
14202   return ret;
14203 }
14204
14205 void
14206 print_fold_checksum (const_tree expr)
14207 {
14208   struct md5_ctx ctx;
14209   unsigned char checksum[16], cnt;
14210   htab_t ht;
14211
14212   ht = htab_create (32, htab_hash_pointer, htab_eq_pointer, NULL);
14213   md5_init_ctx (&ctx);
14214   fold_checksum_tree (expr, &ctx, ht);
14215   md5_finish_ctx (&ctx, checksum);
14216   htab_delete (ht);
14217   for (cnt = 0; cnt < 16; ++cnt)
14218     fprintf (stderr, "%02x", checksum[cnt]);
14219   putc ('\n', stderr);
14220 }
14221
14222 static void
14223 fold_check_failed (const_tree expr ATTRIBUTE_UNUSED, const_tree ret ATTRIBUTE_UNUSED)
14224 {
14225   internal_error ("fold check: original tree changed by fold");
14226 }
14227
14228 static void
14229 fold_checksum_tree (const_tree expr, struct md5_ctx *ctx, htab_t ht)
14230 {
14231   void **slot;
14232   enum tree_code code;
14233   union tree_node buf;
14234   int i, len;
14235
14236  recursive_label:
14237   if (expr == NULL)
14238     return;
14239   slot = (void **) htab_find_slot (ht, expr, INSERT);
14240   if (*slot != NULL)
14241     return;
14242   *slot = CONST_CAST_TREE (expr);
14243   code = TREE_CODE (expr);
14244   if (TREE_CODE_CLASS (code) == tcc_declaration
14245       && DECL_ASSEMBLER_NAME_SET_P (expr))
14246     {
14247       /* Allow DECL_ASSEMBLER_NAME to be modified.  */
14248       memcpy ((char *) &buf, expr, tree_size (expr));
14249       SET_DECL_ASSEMBLER_NAME ((tree)&buf, NULL);
14250       expr = (tree) &buf;
14251     }
14252   else if (TREE_CODE_CLASS (code) == tcc_type
14253            && (TYPE_POINTER_TO (expr)
14254                || TYPE_REFERENCE_TO (expr)
14255                || TYPE_CACHED_VALUES_P (expr)
14256                || TYPE_CONTAINS_PLACEHOLDER_INTERNAL (expr)
14257                || TYPE_NEXT_VARIANT (expr)))
14258     {
14259       /* Allow these fields to be modified.  */
14260       tree tmp;
14261       memcpy ((char *) &buf, expr, tree_size (expr));
14262       expr = tmp = (tree) &buf;
14263       TYPE_CONTAINS_PLACEHOLDER_INTERNAL (tmp) = 0;
14264       TYPE_POINTER_TO (tmp) = NULL;
14265       TYPE_REFERENCE_TO (tmp) = NULL;
14266       TYPE_NEXT_VARIANT (tmp) = NULL;
14267       if (TYPE_CACHED_VALUES_P (tmp))
14268         {
14269           TYPE_CACHED_VALUES_P (tmp) = 0;
14270           TYPE_CACHED_VALUES (tmp) = NULL;
14271         }
14272     }
14273   md5_process_bytes (expr, tree_size (expr), ctx);
14274   if (CODE_CONTAINS_STRUCT (code, TS_TYPED))
14275     fold_checksum_tree (TREE_TYPE (expr), ctx, ht);
14276   if (TREE_CODE_CLASS (code) != tcc_type
14277       && TREE_CODE_CLASS (code) != tcc_declaration
14278       && code != TREE_LIST
14279       && code != SSA_NAME
14280       && CODE_CONTAINS_STRUCT (code, TS_COMMON))
14281     fold_checksum_tree (TREE_CHAIN (expr), ctx, ht);
14282   switch (TREE_CODE_CLASS (code))
14283     {
14284     case tcc_constant:
14285       switch (code)
14286         {
14287         case STRING_CST:
14288           md5_process_bytes (TREE_STRING_POINTER (expr),
14289                              TREE_STRING_LENGTH (expr), ctx);
14290           break;
14291         case COMPLEX_CST:
14292           fold_checksum_tree (TREE_REALPART (expr), ctx, ht);
14293           fold_checksum_tree (TREE_IMAGPART (expr), ctx, ht);
14294           break;
14295         case VECTOR_CST:
14296           fold_checksum_tree (TREE_VECTOR_CST_ELTS (expr), ctx, ht);
14297           break;
14298         default:
14299           break;
14300         }
14301       break;
14302     case tcc_exceptional:
14303       switch (code)
14304         {
14305         case TREE_LIST:
14306           fold_checksum_tree (TREE_PURPOSE (expr), ctx, ht);
14307           fold_checksum_tree (TREE_VALUE (expr), ctx, ht);
14308           expr = TREE_CHAIN (expr);
14309           goto recursive_label;
14310           break;
14311         case TREE_VEC:
14312           for (i = 0; i < TREE_VEC_LENGTH (expr); ++i)
14313             fold_checksum_tree (TREE_VEC_ELT (expr, i), ctx, ht);
14314           break;
14315         default:
14316           break;
14317         }
14318       break;
14319     case tcc_expression:
14320     case tcc_reference:
14321     case tcc_comparison:
14322     case tcc_unary:
14323     case tcc_binary:
14324     case tcc_statement:
14325     case tcc_vl_exp:
14326       len = TREE_OPERAND_LENGTH (expr);
14327       for (i = 0; i < len; ++i)
14328         fold_checksum_tree (TREE_OPERAND (expr, i), ctx, ht);
14329       break;
14330     case tcc_declaration:
14331       fold_checksum_tree (DECL_NAME (expr), ctx, ht);
14332       fold_checksum_tree (DECL_CONTEXT (expr), ctx, ht);
14333       if (CODE_CONTAINS_STRUCT (TREE_CODE (expr), TS_DECL_COMMON))
14334         {
14335           fold_checksum_tree (DECL_SIZE (expr), ctx, ht);
14336           fold_checksum_tree (DECL_SIZE_UNIT (expr), ctx, ht);
14337           fold_checksum_tree (DECL_INITIAL (expr), ctx, ht);
14338           fold_checksum_tree (DECL_ABSTRACT_ORIGIN (expr), ctx, ht);
14339           fold_checksum_tree (DECL_ATTRIBUTES (expr), ctx, ht);
14340         }
14341       if (CODE_CONTAINS_STRUCT (TREE_CODE (expr), TS_DECL_WITH_VIS))
14342         fold_checksum_tree (DECL_SECTION_NAME (expr), ctx, ht);
14343
14344       if (CODE_CONTAINS_STRUCT (TREE_CODE (expr), TS_DECL_NON_COMMON))
14345         {
14346           fold_checksum_tree (DECL_VINDEX (expr), ctx, ht);
14347           fold_checksum_tree (DECL_RESULT_FLD (expr), ctx, ht);
14348           fold_checksum_tree (DECL_ARGUMENT_FLD (expr), ctx, ht);
14349         }
14350       break;
14351     case tcc_type:
14352       if (TREE_CODE (expr) == ENUMERAL_TYPE)
14353         fold_checksum_tree (TYPE_VALUES (expr), ctx, ht);
14354       fold_checksum_tree (TYPE_SIZE (expr), ctx, ht);
14355       fold_checksum_tree (TYPE_SIZE_UNIT (expr), ctx, ht);
14356       fold_checksum_tree (TYPE_ATTRIBUTES (expr), ctx, ht);
14357       fold_checksum_tree (TYPE_NAME (expr), ctx, ht);
14358       if (INTEGRAL_TYPE_P (expr)
14359           || SCALAR_FLOAT_TYPE_P (expr))
14360         {
14361           fold_checksum_tree (TYPE_MIN_VALUE (expr), ctx, ht);
14362           fold_checksum_tree (TYPE_MAX_VALUE (expr), ctx, ht);
14363         }
14364       fold_checksum_tree (TYPE_MAIN_VARIANT (expr), ctx, ht);
14365       if (TREE_CODE (expr) == RECORD_TYPE
14366           || TREE_CODE (expr) == UNION_TYPE
14367           || TREE_CODE (expr) == QUAL_UNION_TYPE)
14368         fold_checksum_tree (TYPE_BINFO (expr), ctx, ht);
14369       fold_checksum_tree (TYPE_CONTEXT (expr), ctx, ht);
14370       break;
14371     default:
14372       break;
14373     }
14374 }
14375
14376 /* Helper function for outputting the checksum of a tree T.  When
14377    debugging with gdb, you can "define mynext" to be "next" followed
14378    by "call debug_fold_checksum (op0)", then just trace down till the
14379    outputs differ.  */
14380
14381 DEBUG_FUNCTION void
14382 debug_fold_checksum (const_tree t)
14383 {
14384   int i;
14385   unsigned char checksum[16];
14386   struct md5_ctx ctx;
14387   htab_t ht = htab_create (32, htab_hash_pointer, htab_eq_pointer, NULL);
14388
14389   md5_init_ctx (&ctx);
14390   fold_checksum_tree (t, &ctx, ht);
14391   md5_finish_ctx (&ctx, checksum);
14392   htab_empty (ht);
14393
14394   for (i = 0; i < 16; i++)
14395     fprintf (stderr, "%d ", checksum[i]);
14396
14397   fprintf (stderr, "\n");
14398 }
14399
14400 #endif
14401
14402 /* Fold a unary tree expression with code CODE of type TYPE with an
14403    operand OP0.  LOC is the location of the resulting expression.
14404    Return a folded expression if successful.  Otherwise, return a tree
14405    expression with code CODE of type TYPE with an operand OP0.  */
14406
14407 tree
14408 fold_build1_stat_loc (location_t loc,
14409                       enum tree_code code, tree type, tree op0 MEM_STAT_DECL)
14410 {
14411   tree tem;
14412 #ifdef ENABLE_FOLD_CHECKING
14413   unsigned char checksum_before[16], checksum_after[16];
14414   struct md5_ctx ctx;
14415   htab_t ht;
14416
14417   ht = htab_create (32, htab_hash_pointer, htab_eq_pointer, NULL);
14418   md5_init_ctx (&ctx);
14419   fold_checksum_tree (op0, &ctx, ht);
14420   md5_finish_ctx (&ctx, checksum_before);
14421   htab_empty (ht);
14422 #endif
14423
14424   tem = fold_unary_loc (loc, code, type, op0);
14425   if (!tem)
14426     tem = build1_stat_loc (loc, code, type, op0 PASS_MEM_STAT);
14427
14428 #ifdef ENABLE_FOLD_CHECKING
14429   md5_init_ctx (&ctx);
14430   fold_checksum_tree (op0, &ctx, ht);
14431   md5_finish_ctx (&ctx, checksum_after);
14432   htab_delete (ht);
14433
14434   if (memcmp (checksum_before, checksum_after, 16))
14435     fold_check_failed (op0, tem);
14436 #endif
14437   return tem;
14438 }
14439
14440 /* Fold a binary tree expression with code CODE of type TYPE with
14441    operands OP0 and OP1.  LOC is the location of the resulting
14442    expression.  Return a folded expression if successful.  Otherwise,
14443    return a tree expression with code CODE of type TYPE with operands
14444    OP0 and OP1.  */
14445
14446 tree
14447 fold_build2_stat_loc (location_t loc,
14448                       enum tree_code code, tree type, tree op0, tree op1
14449                       MEM_STAT_DECL)
14450 {
14451   tree tem;
14452 #ifdef ENABLE_FOLD_CHECKING
14453   unsigned char checksum_before_op0[16],
14454                 checksum_before_op1[16],
14455                 checksum_after_op0[16],
14456                 checksum_after_op1[16];
14457   struct md5_ctx ctx;
14458   htab_t ht;
14459
14460   ht = htab_create (32, htab_hash_pointer, htab_eq_pointer, NULL);
14461   md5_init_ctx (&ctx);
14462   fold_checksum_tree (op0, &ctx, ht);
14463   md5_finish_ctx (&ctx, checksum_before_op0);
14464   htab_empty (ht);
14465
14466   md5_init_ctx (&ctx);
14467   fold_checksum_tree (op1, &ctx, ht);
14468   md5_finish_ctx (&ctx, checksum_before_op1);
14469   htab_empty (ht);
14470 #endif
14471
14472   tem = fold_binary_loc (loc, code, type, op0, op1);
14473   if (!tem)
14474     tem = build2_stat_loc (loc, code, type, op0, op1 PASS_MEM_STAT);
14475
14476 #ifdef ENABLE_FOLD_CHECKING
14477   md5_init_ctx (&ctx);
14478   fold_checksum_tree (op0, &ctx, ht);
14479   md5_finish_ctx (&ctx, checksum_after_op0);
14480   htab_empty (ht);
14481
14482   if (memcmp (checksum_before_op0, checksum_after_op0, 16))
14483     fold_check_failed (op0, tem);
14484
14485   md5_init_ctx (&ctx);
14486   fold_checksum_tree (op1, &ctx, ht);
14487   md5_finish_ctx (&ctx, checksum_after_op1);
14488   htab_delete (ht);
14489
14490   if (memcmp (checksum_before_op1, checksum_after_op1, 16))
14491     fold_check_failed (op1, tem);
14492 #endif
14493   return tem;
14494 }
14495
14496 /* Fold a ternary tree expression with code CODE of type TYPE with
14497    operands OP0, OP1, and OP2.  Return a folded expression if
14498    successful.  Otherwise, return a tree expression with code CODE of
14499    type TYPE with operands OP0, OP1, and OP2.  */
14500
14501 tree
14502 fold_build3_stat_loc (location_t loc, enum tree_code code, tree type,
14503                       tree op0, tree op1, tree op2 MEM_STAT_DECL)
14504 {
14505   tree tem;
14506 #ifdef ENABLE_FOLD_CHECKING
14507   unsigned char checksum_before_op0[16],
14508                 checksum_before_op1[16],
14509                 checksum_before_op2[16],
14510                 checksum_after_op0[16],
14511                 checksum_after_op1[16],
14512                 checksum_after_op2[16];
14513   struct md5_ctx ctx;
14514   htab_t ht;
14515
14516   ht = htab_create (32, htab_hash_pointer, htab_eq_pointer, NULL);
14517   md5_init_ctx (&ctx);
14518   fold_checksum_tree (op0, &ctx, ht);
14519   md5_finish_ctx (&ctx, checksum_before_op0);
14520   htab_empty (ht);
14521
14522   md5_init_ctx (&ctx);
14523   fold_checksum_tree (op1, &ctx, ht);
14524   md5_finish_ctx (&ctx, checksum_before_op1);
14525   htab_empty (ht);
14526
14527   md5_init_ctx (&ctx);
14528   fold_checksum_tree (op2, &ctx, ht);
14529   md5_finish_ctx (&ctx, checksum_before_op2);
14530   htab_empty (ht);
14531 #endif
14532
14533   gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
14534   tem = fold_ternary_loc (loc, code, type, op0, op1, op2);
14535   if (!tem)
14536     tem = build3_stat_loc (loc, code, type, op0, op1, op2 PASS_MEM_STAT);
14537
14538 #ifdef ENABLE_FOLD_CHECKING
14539   md5_init_ctx (&ctx);
14540   fold_checksum_tree (op0, &ctx, ht);
14541   md5_finish_ctx (&ctx, checksum_after_op0);
14542   htab_empty (ht);
14543
14544   if (memcmp (checksum_before_op0, checksum_after_op0, 16))
14545     fold_check_failed (op0, tem);
14546
14547   md5_init_ctx (&ctx);
14548   fold_checksum_tree (op1, &ctx, ht);
14549   md5_finish_ctx (&ctx, checksum_after_op1);
14550   htab_empty (ht);
14551
14552   if (memcmp (checksum_before_op1, checksum_after_op1, 16))
14553     fold_check_failed (op1, tem);
14554
14555   md5_init_ctx (&ctx);
14556   fold_checksum_tree (op2, &ctx, ht);
14557   md5_finish_ctx (&ctx, checksum_after_op2);
14558   htab_delete (ht);
14559
14560   if (memcmp (checksum_before_op2, checksum_after_op2, 16))
14561     fold_check_failed (op2, tem);
14562 #endif
14563   return tem;
14564 }
14565
14566 /* Fold a CALL_EXPR expression of type TYPE with operands FN and NARGS
14567    arguments in ARGARRAY, and a null static chain.
14568    Return a folded expression if successful.  Otherwise, return a CALL_EXPR
14569    of type TYPE from the given operands as constructed by build_call_array.  */
14570
14571 tree
14572 fold_build_call_array_loc (location_t loc, tree type, tree fn,
14573                            int nargs, tree *argarray)
14574 {
14575   tree tem;
14576 #ifdef ENABLE_FOLD_CHECKING
14577   unsigned char checksum_before_fn[16],
14578                 checksum_before_arglist[16],
14579                 checksum_after_fn[16],
14580                 checksum_after_arglist[16];
14581   struct md5_ctx ctx;
14582   htab_t ht;
14583   int i;
14584
14585   ht = htab_create (32, htab_hash_pointer, htab_eq_pointer, NULL);
14586   md5_init_ctx (&ctx);
14587   fold_checksum_tree (fn, &ctx, ht);
14588   md5_finish_ctx (&ctx, checksum_before_fn);
14589   htab_empty (ht);
14590
14591   md5_init_ctx (&ctx);
14592   for (i = 0; i < nargs; i++)
14593     fold_checksum_tree (argarray[i], &ctx, ht);
14594   md5_finish_ctx (&ctx, checksum_before_arglist);
14595   htab_empty (ht);
14596 #endif
14597
14598   tem = fold_builtin_call_array (loc, type, fn, nargs, argarray);
14599
14600 #ifdef ENABLE_FOLD_CHECKING
14601   md5_init_ctx (&ctx);
14602   fold_checksum_tree (fn, &ctx, ht);
14603   md5_finish_ctx (&ctx, checksum_after_fn);
14604   htab_empty (ht);
14605
14606   if (memcmp (checksum_before_fn, checksum_after_fn, 16))
14607     fold_check_failed (fn, tem);
14608
14609   md5_init_ctx (&ctx);
14610   for (i = 0; i < nargs; i++)
14611     fold_checksum_tree (argarray[i], &ctx, ht);
14612   md5_finish_ctx (&ctx, checksum_after_arglist);
14613   htab_delete (ht);
14614
14615   if (memcmp (checksum_before_arglist, checksum_after_arglist, 16))
14616     fold_check_failed (NULL_TREE, tem);
14617 #endif
14618   return tem;
14619 }
14620
14621 /* Perform constant folding and related simplification of initializer
14622    expression EXPR.  These behave identically to "fold_buildN" but ignore
14623    potential run-time traps and exceptions that fold must preserve.  */
14624
14625 #define START_FOLD_INIT \
14626   int saved_signaling_nans = flag_signaling_nans;\
14627   int saved_trapping_math = flag_trapping_math;\
14628   int saved_rounding_math = flag_rounding_math;\
14629   int saved_trapv = flag_trapv;\
14630   int saved_folding_initializer = folding_initializer;\
14631   flag_signaling_nans = 0;\
14632   flag_trapping_math = 0;\
14633   flag_rounding_math = 0;\
14634   flag_trapv = 0;\
14635   folding_initializer = 1;
14636
14637 #define END_FOLD_INIT \
14638   flag_signaling_nans = saved_signaling_nans;\
14639   flag_trapping_math = saved_trapping_math;\
14640   flag_rounding_math = saved_rounding_math;\
14641   flag_trapv = saved_trapv;\
14642   folding_initializer = saved_folding_initializer;
14643
14644 tree
14645 fold_build1_initializer_loc (location_t loc, enum tree_code code,
14646                              tree type, tree op)
14647 {
14648   tree result;
14649   START_FOLD_INIT;
14650
14651   result = fold_build1_loc (loc, code, type, op);
14652
14653   END_FOLD_INIT;
14654   return result;
14655 }
14656
14657 tree
14658 fold_build2_initializer_loc (location_t loc, enum tree_code code,
14659                              tree type, tree op0, tree op1)
14660 {
14661   tree result;
14662   START_FOLD_INIT;
14663
14664   result = fold_build2_loc (loc, code, type, op0, op1);
14665
14666   END_FOLD_INIT;
14667   return result;
14668 }
14669
14670 tree
14671 fold_build3_initializer_loc (location_t loc, enum tree_code code,
14672                              tree type, tree op0, tree op1, tree op2)
14673 {
14674   tree result;
14675   START_FOLD_INIT;
14676
14677   result = fold_build3_loc (loc, code, type, op0, op1, op2);
14678
14679   END_FOLD_INIT;
14680   return result;
14681 }
14682
14683 tree
14684 fold_build_call_array_initializer_loc (location_t loc, tree type, tree fn,
14685                                        int nargs, tree *argarray)
14686 {
14687   tree result;
14688   START_FOLD_INIT;
14689
14690   result = fold_build_call_array_loc (loc, type, fn, nargs, argarray);
14691
14692   END_FOLD_INIT;
14693   return result;
14694 }
14695
14696 #undef START_FOLD_INIT
14697 #undef END_FOLD_INIT
14698
14699 /* Determine if first argument is a multiple of second argument.  Return 0 if
14700    it is not, or we cannot easily determined it to be.
14701
14702    An example of the sort of thing we care about (at this point; this routine
14703    could surely be made more general, and expanded to do what the *_DIV_EXPR's
14704    fold cases do now) is discovering that
14705
14706      SAVE_EXPR (I) * SAVE_EXPR (J * 8)
14707
14708    is a multiple of
14709
14710      SAVE_EXPR (J * 8)
14711
14712    when we know that the two SAVE_EXPR (J * 8) nodes are the same node.
14713
14714    This code also handles discovering that
14715
14716      SAVE_EXPR (I) * SAVE_EXPR (J * 8)
14717
14718    is a multiple of 8 so we don't have to worry about dealing with a
14719    possible remainder.
14720
14721    Note that we *look* inside a SAVE_EXPR only to determine how it was
14722    calculated; it is not safe for fold to do much of anything else with the
14723    internals of a SAVE_EXPR, since it cannot know when it will be evaluated
14724    at run time.  For example, the latter example above *cannot* be implemented
14725    as SAVE_EXPR (I) * J or any variant thereof, since the value of J at
14726    evaluation time of the original SAVE_EXPR is not necessarily the same at
14727    the time the new expression is evaluated.  The only optimization of this
14728    sort that would be valid is changing
14729
14730      SAVE_EXPR (I) * SAVE_EXPR (SAVE_EXPR (J) * 8)
14731
14732    divided by 8 to
14733
14734      SAVE_EXPR (I) * SAVE_EXPR (J)
14735
14736    (where the same SAVE_EXPR (J) is used in the original and the
14737    transformed version).  */
14738
14739 int
14740 multiple_of_p (tree type, const_tree top, const_tree bottom)
14741 {
14742   if (operand_equal_p (top, bottom, 0))
14743     return 1;
14744
14745   if (TREE_CODE (type) != INTEGER_TYPE)
14746     return 0;
14747
14748   switch (TREE_CODE (top))
14749     {
14750     case BIT_AND_EXPR:
14751       /* Bitwise and provides a power of two multiple.  If the mask is
14752          a multiple of BOTTOM then TOP is a multiple of BOTTOM.  */
14753       if (!integer_pow2p (bottom))
14754         return 0;
14755       /* FALLTHRU */
14756
14757     case MULT_EXPR:
14758       return (multiple_of_p (type, TREE_OPERAND (top, 0), bottom)
14759               || multiple_of_p (type, TREE_OPERAND (top, 1), bottom));
14760
14761     case PLUS_EXPR:
14762     case MINUS_EXPR:
14763       return (multiple_of_p (type, TREE_OPERAND (top, 0), bottom)
14764               && multiple_of_p (type, TREE_OPERAND (top, 1), bottom));
14765
14766     case LSHIFT_EXPR:
14767       if (TREE_CODE (TREE_OPERAND (top, 1)) == INTEGER_CST)
14768         {
14769           tree op1, t1;
14770
14771           op1 = TREE_OPERAND (top, 1);
14772           /* const_binop may not detect overflow correctly,
14773              so check for it explicitly here.  */
14774           if (TYPE_PRECISION (TREE_TYPE (size_one_node))
14775               > TREE_INT_CST_LOW (op1)
14776               && TREE_INT_CST_HIGH (op1) == 0
14777               && 0 != (t1 = fold_convert (type,
14778                                           const_binop (LSHIFT_EXPR,
14779                                                        size_one_node,
14780                                                        op1)))
14781               && !TREE_OVERFLOW (t1))
14782             return multiple_of_p (type, t1, bottom);
14783         }
14784       return 0;
14785
14786     case NOP_EXPR:
14787       /* Can't handle conversions from non-integral or wider integral type.  */
14788       if ((TREE_CODE (TREE_TYPE (TREE_OPERAND (top, 0))) != INTEGER_TYPE)
14789           || (TYPE_PRECISION (type)
14790               < TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (top, 0)))))
14791         return 0;
14792
14793       /* .. fall through ...  */
14794
14795     case SAVE_EXPR:
14796       return multiple_of_p (type, TREE_OPERAND (top, 0), bottom);
14797
14798     case COND_EXPR:
14799       return (multiple_of_p (type, TREE_OPERAND (top, 1), bottom)
14800               && multiple_of_p (type, TREE_OPERAND (top, 2), bottom));
14801
14802     case INTEGER_CST:
14803       if (TREE_CODE (bottom) != INTEGER_CST
14804           || integer_zerop (bottom)
14805           || (TYPE_UNSIGNED (type)
14806               && (tree_int_cst_sgn (top) < 0
14807                   || tree_int_cst_sgn (bottom) < 0)))
14808         return 0;
14809       return integer_zerop (int_const_binop (TRUNC_MOD_EXPR,
14810                                              top, bottom));
14811
14812     default:
14813       return 0;
14814     }
14815 }
14816
14817 /* Return true if CODE or TYPE is known to be non-negative. */
14818
14819 static bool
14820 tree_simple_nonnegative_warnv_p (enum tree_code code, tree type)
14821 {
14822   if ((TYPE_PRECISION (type) != 1 || TYPE_UNSIGNED (type))
14823       && truth_value_p (code))
14824     /* Truth values evaluate to 0 or 1, which is nonnegative unless we
14825        have a signed:1 type (where the value is -1 and 0).  */
14826     return true;
14827   return false;
14828 }
14829
14830 /* Return true if (CODE OP0) is known to be non-negative.  If the return
14831    value is based on the assumption that signed overflow is undefined,
14832    set *STRICT_OVERFLOW_P to true; otherwise, don't change
14833    *STRICT_OVERFLOW_P.  */
14834
14835 bool
14836 tree_unary_nonnegative_warnv_p (enum tree_code code, tree type, tree op0,
14837                                 bool *strict_overflow_p)
14838 {
14839   if (TYPE_UNSIGNED (type))
14840     return true;
14841
14842   switch (code)
14843     {
14844     case ABS_EXPR:
14845       /* We can't return 1 if flag_wrapv is set because
14846          ABS_EXPR<INT_MIN> = INT_MIN.  */
14847       if (!INTEGRAL_TYPE_P (type))
14848         return true;
14849       if (TYPE_OVERFLOW_UNDEFINED (type))
14850         {
14851           *strict_overflow_p = true;
14852           return true;
14853         }
14854       break;
14855
14856     case NON_LVALUE_EXPR:
14857     case FLOAT_EXPR:
14858     case FIX_TRUNC_EXPR:
14859       return tree_expr_nonnegative_warnv_p (op0,
14860                                             strict_overflow_p);
14861
14862     case NOP_EXPR:
14863       {
14864         tree inner_type = TREE_TYPE (op0);
14865         tree outer_type = type;
14866
14867         if (TREE_CODE (outer_type) == REAL_TYPE)
14868           {
14869             if (TREE_CODE (inner_type) == REAL_TYPE)
14870               return tree_expr_nonnegative_warnv_p (op0,
14871                                                     strict_overflow_p);
14872             if (TREE_CODE (inner_type) == INTEGER_TYPE)
14873               {
14874                 if (TYPE_UNSIGNED (inner_type))
14875                   return true;
14876                 return tree_expr_nonnegative_warnv_p (op0,
14877                                                       strict_overflow_p);
14878               }
14879           }
14880         else if (TREE_CODE (outer_type) == INTEGER_TYPE)
14881           {
14882             if (TREE_CODE (inner_type) == REAL_TYPE)
14883               return tree_expr_nonnegative_warnv_p (op0,
14884                                                     strict_overflow_p);
14885             if (TREE_CODE (inner_type) == INTEGER_TYPE)
14886               return TYPE_PRECISION (inner_type) < TYPE_PRECISION (outer_type)
14887                       && TYPE_UNSIGNED (inner_type);
14888           }
14889       }
14890       break;
14891
14892     default:
14893       return tree_simple_nonnegative_warnv_p (code, type);
14894     }
14895
14896   /* We don't know sign of `t', so be conservative and return false.  */
14897   return false;
14898 }
14899
14900 /* Return true if (CODE OP0 OP1) is known to be non-negative.  If the return
14901    value is based on the assumption that signed overflow is undefined,
14902    set *STRICT_OVERFLOW_P to true; otherwise, don't change
14903    *STRICT_OVERFLOW_P.  */
14904
14905 bool
14906 tree_binary_nonnegative_warnv_p (enum tree_code code, tree type, tree op0,
14907                                       tree op1, bool *strict_overflow_p)
14908 {
14909   if (TYPE_UNSIGNED (type))
14910     return true;
14911
14912   switch (code)
14913     {
14914     case POINTER_PLUS_EXPR:
14915     case PLUS_EXPR:
14916       if (FLOAT_TYPE_P (type))
14917         return (tree_expr_nonnegative_warnv_p (op0,
14918                                                strict_overflow_p)
14919                 && tree_expr_nonnegative_warnv_p (op1,
14920                                                   strict_overflow_p));
14921
14922       /* zero_extend(x) + zero_extend(y) is non-negative if x and y are
14923          both unsigned and at least 2 bits shorter than the result.  */
14924       if (TREE_CODE (type) == INTEGER_TYPE
14925           && TREE_CODE (op0) == NOP_EXPR
14926           && TREE_CODE (op1) == NOP_EXPR)
14927         {
14928           tree inner1 = TREE_TYPE (TREE_OPERAND (op0, 0));
14929           tree inner2 = TREE_TYPE (TREE_OPERAND (op1, 0));
14930           if (TREE_CODE (inner1) == INTEGER_TYPE && TYPE_UNSIGNED (inner1)
14931               && TREE_CODE (inner2) == INTEGER_TYPE && TYPE_UNSIGNED (inner2))
14932             {
14933               unsigned int prec = MAX (TYPE_PRECISION (inner1),
14934                                        TYPE_PRECISION (inner2)) + 1;
14935               return prec < TYPE_PRECISION (type);
14936             }
14937         }
14938       break;
14939
14940     case MULT_EXPR:
14941       if (FLOAT_TYPE_P (type))
14942         {
14943           /* x * x for floating point x is always non-negative.  */
14944           if (operand_equal_p (op0, op1, 0))
14945             return true;
14946           return (tree_expr_nonnegative_warnv_p (op0,
14947                                                  strict_overflow_p)
14948                   && tree_expr_nonnegative_warnv_p (op1,
14949                                                     strict_overflow_p));
14950         }
14951
14952       /* zero_extend(x) * zero_extend(y) is non-negative if x and y are
14953          both unsigned and their total bits is shorter than the result.  */
14954       if (TREE_CODE (type) == INTEGER_TYPE
14955           && (TREE_CODE (op0) == NOP_EXPR || TREE_CODE (op0) == INTEGER_CST)
14956           && (TREE_CODE (op1) == NOP_EXPR || TREE_CODE (op1) == INTEGER_CST))
14957         {
14958           tree inner0 = (TREE_CODE (op0) == NOP_EXPR)
14959             ? TREE_TYPE (TREE_OPERAND (op0, 0))
14960             : TREE_TYPE (op0);
14961           tree inner1 = (TREE_CODE (op1) == NOP_EXPR)
14962             ? TREE_TYPE (TREE_OPERAND (op1, 0))
14963             : TREE_TYPE (op1);
14964
14965           bool unsigned0 = TYPE_UNSIGNED (inner0);
14966           bool unsigned1 = TYPE_UNSIGNED (inner1);
14967
14968           if (TREE_CODE (op0) == INTEGER_CST)
14969             unsigned0 = unsigned0 || tree_int_cst_sgn (op0) >= 0;
14970
14971           if (TREE_CODE (op1) == INTEGER_CST)
14972             unsigned1 = unsigned1 || tree_int_cst_sgn (op1) >= 0;
14973
14974           if (TREE_CODE (inner0) == INTEGER_TYPE && unsigned0
14975               && TREE_CODE (inner1) == INTEGER_TYPE && unsigned1)
14976             {
14977               unsigned int precision0 = (TREE_CODE (op0) == INTEGER_CST)
14978                 ? tree_int_cst_min_precision (op0, /*unsignedp=*/true)
14979                 : TYPE_PRECISION (inner0);
14980
14981               unsigned int precision1 = (TREE_CODE (op1) == INTEGER_CST)
14982                 ? tree_int_cst_min_precision (op1, /*unsignedp=*/true)
14983                 : TYPE_PRECISION (inner1);
14984
14985               return precision0 + precision1 < TYPE_PRECISION (type);
14986             }
14987         }
14988       return false;
14989
14990     case BIT_AND_EXPR:
14991     case MAX_EXPR:
14992       return (tree_expr_nonnegative_warnv_p (op0,
14993                                              strict_overflow_p)
14994               || tree_expr_nonnegative_warnv_p (op1,
14995                                                 strict_overflow_p));
14996
14997     case BIT_IOR_EXPR:
14998     case BIT_XOR_EXPR:
14999     case MIN_EXPR:
15000     case RDIV_EXPR:
15001     case TRUNC_DIV_EXPR:
15002     case CEIL_DIV_EXPR:
15003     case FLOOR_DIV_EXPR:
15004     case ROUND_DIV_EXPR:
15005       return (tree_expr_nonnegative_warnv_p (op0,
15006                                              strict_overflow_p)
15007               && tree_expr_nonnegative_warnv_p (op1,
15008                                                 strict_overflow_p));
15009
15010     case TRUNC_MOD_EXPR:
15011     case CEIL_MOD_EXPR:
15012     case FLOOR_MOD_EXPR:
15013     case ROUND_MOD_EXPR:
15014       return tree_expr_nonnegative_warnv_p (op0,
15015                                             strict_overflow_p);
15016     default:
15017       return tree_simple_nonnegative_warnv_p (code, type);
15018     }
15019
15020   /* We don't know sign of `t', so be conservative and return false.  */
15021   return false;
15022 }
15023
15024 /* Return true if T is known to be non-negative.  If the return
15025    value is based on the assumption that signed overflow is undefined,
15026    set *STRICT_OVERFLOW_P to true; otherwise, don't change
15027    *STRICT_OVERFLOW_P.  */
15028
15029 bool
15030 tree_single_nonnegative_warnv_p (tree t, bool *strict_overflow_p)
15031 {
15032   if (TYPE_UNSIGNED (TREE_TYPE (t)))
15033     return true;
15034
15035   switch (TREE_CODE (t))
15036     {
15037     case INTEGER_CST:
15038       return tree_int_cst_sgn (t) >= 0;
15039
15040     case REAL_CST:
15041       return ! REAL_VALUE_NEGATIVE (TREE_REAL_CST (t));
15042
15043     case FIXED_CST:
15044       return ! FIXED_VALUE_NEGATIVE (TREE_FIXED_CST (t));
15045
15046     case COND_EXPR:
15047       return (tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 1),
15048                                              strict_overflow_p)
15049               && tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 2),
15050                                                 strict_overflow_p));
15051     default:
15052       return tree_simple_nonnegative_warnv_p (TREE_CODE (t),
15053                                                    TREE_TYPE (t));
15054     }
15055   /* We don't know sign of `t', so be conservative and return false.  */
15056   return false;
15057 }
15058
15059 /* Return true if T is known to be non-negative.  If the return
15060    value is based on the assumption that signed overflow is undefined,
15061    set *STRICT_OVERFLOW_P to true; otherwise, don't change
15062    *STRICT_OVERFLOW_P.  */
15063
15064 bool
15065 tree_call_nonnegative_warnv_p (tree type, tree fndecl,
15066                                tree arg0, tree arg1, bool *strict_overflow_p)
15067 {
15068   if (fndecl && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL)
15069     switch (DECL_FUNCTION_CODE (fndecl))
15070       {
15071         CASE_FLT_FN (BUILT_IN_ACOS):
15072         CASE_FLT_FN (BUILT_IN_ACOSH):
15073         CASE_FLT_FN (BUILT_IN_CABS):
15074         CASE_FLT_FN (BUILT_IN_COSH):
15075         CASE_FLT_FN (BUILT_IN_ERFC):
15076         CASE_FLT_FN (BUILT_IN_EXP):
15077         CASE_FLT_FN (BUILT_IN_EXP10):
15078         CASE_FLT_FN (BUILT_IN_EXP2):
15079         CASE_FLT_FN (BUILT_IN_FABS):
15080         CASE_FLT_FN (BUILT_IN_FDIM):
15081         CASE_FLT_FN (BUILT_IN_HYPOT):
15082         CASE_FLT_FN (BUILT_IN_POW10):
15083         CASE_INT_FN (BUILT_IN_FFS):
15084         CASE_INT_FN (BUILT_IN_PARITY):
15085         CASE_INT_FN (BUILT_IN_POPCOUNT):
15086       case BUILT_IN_BSWAP32:
15087       case BUILT_IN_BSWAP64:
15088         /* Always true.  */
15089         return true;
15090
15091         CASE_FLT_FN (BUILT_IN_SQRT):
15092         /* sqrt(-0.0) is -0.0.  */
15093         if (!HONOR_SIGNED_ZEROS (TYPE_MODE (type)))
15094           return true;
15095         return tree_expr_nonnegative_warnv_p (arg0,
15096                                               strict_overflow_p);
15097
15098         CASE_FLT_FN (BUILT_IN_ASINH):
15099         CASE_FLT_FN (BUILT_IN_ATAN):
15100         CASE_FLT_FN (BUILT_IN_ATANH):
15101         CASE_FLT_FN (BUILT_IN_CBRT):
15102         CASE_FLT_FN (BUILT_IN_CEIL):
15103         CASE_FLT_FN (BUILT_IN_ERF):
15104         CASE_FLT_FN (BUILT_IN_EXPM1):
15105         CASE_FLT_FN (BUILT_IN_FLOOR):
15106         CASE_FLT_FN (BUILT_IN_FMOD):
15107         CASE_FLT_FN (BUILT_IN_FREXP):
15108         CASE_FLT_FN (BUILT_IN_ICEIL):
15109         CASE_FLT_FN (BUILT_IN_IFLOOR):
15110         CASE_FLT_FN (BUILT_IN_IRINT):
15111         CASE_FLT_FN (BUILT_IN_IROUND):
15112         CASE_FLT_FN (BUILT_IN_LCEIL):
15113         CASE_FLT_FN (BUILT_IN_LDEXP):
15114         CASE_FLT_FN (BUILT_IN_LFLOOR):
15115         CASE_FLT_FN (BUILT_IN_LLCEIL):
15116         CASE_FLT_FN (BUILT_IN_LLFLOOR):
15117         CASE_FLT_FN (BUILT_IN_LLRINT):
15118         CASE_FLT_FN (BUILT_IN_LLROUND):
15119         CASE_FLT_FN (BUILT_IN_LRINT):
15120         CASE_FLT_FN (BUILT_IN_LROUND):
15121         CASE_FLT_FN (BUILT_IN_MODF):
15122         CASE_FLT_FN (BUILT_IN_NEARBYINT):
15123         CASE_FLT_FN (BUILT_IN_RINT):
15124         CASE_FLT_FN (BUILT_IN_ROUND):
15125         CASE_FLT_FN (BUILT_IN_SCALB):
15126         CASE_FLT_FN (BUILT_IN_SCALBLN):
15127         CASE_FLT_FN (BUILT_IN_SCALBN):
15128         CASE_FLT_FN (BUILT_IN_SIGNBIT):
15129         CASE_FLT_FN (BUILT_IN_SIGNIFICAND):
15130         CASE_FLT_FN (BUILT_IN_SINH):
15131         CASE_FLT_FN (BUILT_IN_TANH):
15132         CASE_FLT_FN (BUILT_IN_TRUNC):
15133         /* True if the 1st argument is nonnegative.  */
15134         return tree_expr_nonnegative_warnv_p (arg0,
15135                                               strict_overflow_p);
15136
15137         CASE_FLT_FN (BUILT_IN_FMAX):
15138         /* True if the 1st OR 2nd arguments are nonnegative.  */
15139         return (tree_expr_nonnegative_warnv_p (arg0,
15140                                                strict_overflow_p)
15141                 || (tree_expr_nonnegative_warnv_p (arg1,
15142                                                    strict_overflow_p)));
15143
15144         CASE_FLT_FN (BUILT_IN_FMIN):
15145         /* True if the 1st AND 2nd arguments are nonnegative.  */
15146         return (tree_expr_nonnegative_warnv_p (arg0,
15147                                                strict_overflow_p)
15148                 && (tree_expr_nonnegative_warnv_p (arg1,
15149                                                    strict_overflow_p)));
15150
15151         CASE_FLT_FN (BUILT_IN_COPYSIGN):
15152         /* True if the 2nd argument is nonnegative.  */
15153         return tree_expr_nonnegative_warnv_p (arg1,
15154                                               strict_overflow_p);
15155
15156         CASE_FLT_FN (BUILT_IN_POWI):
15157         /* True if the 1st argument is nonnegative or the second
15158            argument is an even integer.  */
15159         if (TREE_CODE (arg1) == INTEGER_CST
15160             && (TREE_INT_CST_LOW (arg1) & 1) == 0)
15161           return true;
15162         return tree_expr_nonnegative_warnv_p (arg0,
15163                                               strict_overflow_p);
15164
15165         CASE_FLT_FN (BUILT_IN_POW):
15166         /* True if the 1st argument is nonnegative or the second
15167            argument is an even integer valued real.  */
15168         if (TREE_CODE (arg1) == REAL_CST)
15169           {
15170             REAL_VALUE_TYPE c;
15171             HOST_WIDE_INT n;
15172
15173             c = TREE_REAL_CST (arg1);
15174             n = real_to_integer (&c);
15175             if ((n & 1) == 0)
15176               {
15177                 REAL_VALUE_TYPE cint;
15178                 real_from_integer (&cint, VOIDmode, n,
15179                                    n < 0 ? -1 : 0, 0);
15180                 if (real_identical (&c, &cint))
15181                   return true;
15182               }
15183           }
15184         return tree_expr_nonnegative_warnv_p (arg0,
15185                                               strict_overflow_p);
15186
15187       default:
15188         break;
15189       }
15190   return tree_simple_nonnegative_warnv_p (CALL_EXPR,
15191                                           type);
15192 }
15193
15194 /* Return true if T is known to be non-negative.  If the return
15195    value is based on the assumption that signed overflow is undefined,
15196    set *STRICT_OVERFLOW_P to true; otherwise, don't change
15197    *STRICT_OVERFLOW_P.  */
15198
15199 bool
15200 tree_invalid_nonnegative_warnv_p (tree t, bool *strict_overflow_p)
15201 {
15202   enum tree_code code = TREE_CODE (t);
15203   if (TYPE_UNSIGNED (TREE_TYPE (t)))
15204     return true;
15205
15206   switch (code)
15207     {
15208     case TARGET_EXPR:
15209       {
15210         tree temp = TARGET_EXPR_SLOT (t);
15211         t = TARGET_EXPR_INITIAL (t);
15212
15213         /* If the initializer is non-void, then it's a normal expression
15214            that will be assigned to the slot.  */
15215         if (!VOID_TYPE_P (t))
15216           return tree_expr_nonnegative_warnv_p (t, strict_overflow_p);
15217
15218         /* Otherwise, the initializer sets the slot in some way.  One common
15219            way is an assignment statement at the end of the initializer.  */
15220         while (1)
15221           {
15222             if (TREE_CODE (t) == BIND_EXPR)
15223               t = expr_last (BIND_EXPR_BODY (t));
15224             else if (TREE_CODE (t) == TRY_FINALLY_EXPR
15225                      || TREE_CODE (t) == TRY_CATCH_EXPR)
15226               t = expr_last (TREE_OPERAND (t, 0));
15227             else if (TREE_CODE (t) == STATEMENT_LIST)
15228               t = expr_last (t);
15229             else
15230               break;
15231           }
15232         if (TREE_CODE (t) == MODIFY_EXPR
15233             && TREE_OPERAND (t, 0) == temp)
15234           return tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 1),
15235                                                 strict_overflow_p);
15236
15237         return false;
15238       }
15239
15240     case CALL_EXPR:
15241       {
15242         tree arg0 = call_expr_nargs (t) > 0 ?  CALL_EXPR_ARG (t, 0) : NULL_TREE;
15243         tree arg1 = call_expr_nargs (t) > 1 ?  CALL_EXPR_ARG (t, 1) : NULL_TREE;
15244
15245         return tree_call_nonnegative_warnv_p (TREE_TYPE (t),
15246                                               get_callee_fndecl (t),
15247                                               arg0,
15248                                               arg1,
15249                                               strict_overflow_p);
15250       }
15251     case COMPOUND_EXPR:
15252     case MODIFY_EXPR:
15253       return tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 1),
15254                                             strict_overflow_p);
15255     case BIND_EXPR:
15256       return tree_expr_nonnegative_warnv_p (expr_last (TREE_OPERAND (t, 1)),
15257                                             strict_overflow_p);
15258     case SAVE_EXPR:
15259       return tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 0),
15260                                             strict_overflow_p);
15261
15262     default:
15263       return tree_simple_nonnegative_warnv_p (TREE_CODE (t),
15264                                                    TREE_TYPE (t));
15265     }
15266
15267   /* We don't know sign of `t', so be conservative and return false.  */
15268   return false;
15269 }
15270
15271 /* Return true if T is known to be non-negative.  If the return
15272    value is based on the assumption that signed overflow is undefined,
15273    set *STRICT_OVERFLOW_P to true; otherwise, don't change
15274    *STRICT_OVERFLOW_P.  */
15275
15276 bool
15277 tree_expr_nonnegative_warnv_p (tree t, bool *strict_overflow_p)
15278 {
15279   enum tree_code code;
15280   if (t == error_mark_node)
15281     return false;
15282
15283   code = TREE_CODE (t);
15284   switch (TREE_CODE_CLASS (code))
15285     {
15286     case tcc_binary:
15287     case tcc_comparison:
15288       return tree_binary_nonnegative_warnv_p (TREE_CODE (t),
15289                                               TREE_TYPE (t),
15290                                               TREE_OPERAND (t, 0),
15291                                               TREE_OPERAND (t, 1),
15292                                               strict_overflow_p);
15293
15294     case tcc_unary:
15295       return tree_unary_nonnegative_warnv_p (TREE_CODE (t),
15296                                              TREE_TYPE (t),
15297                                              TREE_OPERAND (t, 0),
15298                                              strict_overflow_p);
15299
15300     case tcc_constant:
15301     case tcc_declaration:
15302     case tcc_reference:
15303       return tree_single_nonnegative_warnv_p (t, strict_overflow_p);
15304
15305     default:
15306       break;
15307     }
15308
15309   switch (code)
15310     {
15311     case TRUTH_AND_EXPR:
15312     case TRUTH_OR_EXPR:
15313     case TRUTH_XOR_EXPR:
15314       return tree_binary_nonnegative_warnv_p (TREE_CODE (t),
15315                                               TREE_TYPE (t),
15316                                               TREE_OPERAND (t, 0),
15317                                               TREE_OPERAND (t, 1),
15318                                               strict_overflow_p);
15319     case TRUTH_NOT_EXPR:
15320       return tree_unary_nonnegative_warnv_p (TREE_CODE (t),
15321                                              TREE_TYPE (t),
15322                                              TREE_OPERAND (t, 0),
15323                                              strict_overflow_p);
15324
15325     case COND_EXPR:
15326     case CONSTRUCTOR:
15327     case OBJ_TYPE_REF:
15328     case ASSERT_EXPR:
15329     case ADDR_EXPR:
15330     case WITH_SIZE_EXPR:
15331     case SSA_NAME:
15332       return tree_single_nonnegative_warnv_p (t, strict_overflow_p);
15333
15334     default:
15335       return tree_invalid_nonnegative_warnv_p (t, strict_overflow_p);
15336     }
15337 }
15338
15339 /* Return true if `t' is known to be non-negative.  Handle warnings
15340    about undefined signed overflow.  */
15341
15342 bool
15343 tree_expr_nonnegative_p (tree t)
15344 {
15345   bool ret, strict_overflow_p;
15346
15347   strict_overflow_p = false;
15348   ret = tree_expr_nonnegative_warnv_p (t, &strict_overflow_p);
15349   if (strict_overflow_p)
15350     fold_overflow_warning (("assuming signed overflow does not occur when "
15351                             "determining that expression is always "
15352                             "non-negative"),
15353                            WARN_STRICT_OVERFLOW_MISC);
15354   return ret;
15355 }
15356
15357
15358 /* Return true when (CODE OP0) is an address and is known to be nonzero.
15359    For floating point we further ensure that T is not denormal.
15360    Similar logic is present in nonzero_address in rtlanal.h.
15361
15362    If the return value is based on the assumption that signed overflow
15363    is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
15364    change *STRICT_OVERFLOW_P.  */
15365
15366 bool
15367 tree_unary_nonzero_warnv_p (enum tree_code code, tree type, tree op0,
15368                                  bool *strict_overflow_p)
15369 {
15370   switch (code)
15371     {
15372     case ABS_EXPR:
15373       return tree_expr_nonzero_warnv_p (op0,
15374                                         strict_overflow_p);
15375
15376     case NOP_EXPR:
15377       {
15378         tree inner_type = TREE_TYPE (op0);
15379         tree outer_type = type;
15380
15381         return (TYPE_PRECISION (outer_type) >= TYPE_PRECISION (inner_type)
15382                 && tree_expr_nonzero_warnv_p (op0,
15383                                               strict_overflow_p));
15384       }
15385       break;
15386
15387     case NON_LVALUE_EXPR:
15388       return tree_expr_nonzero_warnv_p (op0,
15389                                         strict_overflow_p);
15390
15391     default:
15392       break;
15393   }
15394
15395   return false;
15396 }
15397
15398 /* Return true when (CODE OP0 OP1) is an address and is known to be nonzero.
15399    For floating point we further ensure that T is not denormal.
15400    Similar logic is present in nonzero_address in rtlanal.h.
15401
15402    If the return value is based on the assumption that signed overflow
15403    is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
15404    change *STRICT_OVERFLOW_P.  */
15405
15406 bool
15407 tree_binary_nonzero_warnv_p (enum tree_code code,
15408                              tree type,
15409                              tree op0,
15410                              tree op1, bool *strict_overflow_p)
15411 {
15412   bool sub_strict_overflow_p;
15413   switch (code)
15414     {
15415     case POINTER_PLUS_EXPR:
15416     case PLUS_EXPR:
15417       if (TYPE_OVERFLOW_UNDEFINED (type))
15418         {
15419           /* With the presence of negative values it is hard
15420              to say something.  */
15421           sub_strict_overflow_p = false;
15422           if (!tree_expr_nonnegative_warnv_p (op0,
15423                                               &sub_strict_overflow_p)
15424               || !tree_expr_nonnegative_warnv_p (op1,
15425                                                  &sub_strict_overflow_p))
15426             return false;
15427           /* One of operands must be positive and the other non-negative.  */
15428           /* We don't set *STRICT_OVERFLOW_P here: even if this value
15429              overflows, on a twos-complement machine the sum of two
15430              nonnegative numbers can never be zero.  */
15431           return (tree_expr_nonzero_warnv_p (op0,
15432                                              strict_overflow_p)
15433                   || tree_expr_nonzero_warnv_p (op1,
15434                                                 strict_overflow_p));
15435         }
15436       break;
15437
15438     case MULT_EXPR:
15439       if (TYPE_OVERFLOW_UNDEFINED (type))
15440         {
15441           if (tree_expr_nonzero_warnv_p (op0,
15442                                          strict_overflow_p)
15443               && tree_expr_nonzero_warnv_p (op1,
15444                                             strict_overflow_p))
15445             {
15446               *strict_overflow_p = true;
15447               return true;
15448             }
15449         }
15450       break;
15451
15452     case MIN_EXPR:
15453       sub_strict_overflow_p = false;
15454       if (tree_expr_nonzero_warnv_p (op0,
15455                                      &sub_strict_overflow_p)
15456           && tree_expr_nonzero_warnv_p (op1,
15457                                         &sub_strict_overflow_p))
15458         {
15459           if (sub_strict_overflow_p)
15460             *strict_overflow_p = true;
15461         }
15462       break;
15463
15464     case MAX_EXPR:
15465       sub_strict_overflow_p = false;
15466       if (tree_expr_nonzero_warnv_p (op0,
15467                                      &sub_strict_overflow_p))
15468         {
15469           if (sub_strict_overflow_p)
15470             *strict_overflow_p = true;
15471
15472           /* When both operands are nonzero, then MAX must be too.  */
15473           if (tree_expr_nonzero_warnv_p (op1,
15474                                          strict_overflow_p))
15475             return true;
15476
15477           /* MAX where operand 0 is positive is positive.  */
15478           return tree_expr_nonnegative_warnv_p (op0,
15479                                                strict_overflow_p);
15480         }
15481       /* MAX where operand 1 is positive is positive.  */
15482       else if (tree_expr_nonzero_warnv_p (op1,
15483                                           &sub_strict_overflow_p)
15484                && tree_expr_nonnegative_warnv_p (op1,
15485                                                  &sub_strict_overflow_p))
15486         {
15487           if (sub_strict_overflow_p)
15488             *strict_overflow_p = true;
15489           return true;
15490         }
15491       break;
15492
15493     case BIT_IOR_EXPR:
15494       return (tree_expr_nonzero_warnv_p (op1,
15495                                          strict_overflow_p)
15496               || tree_expr_nonzero_warnv_p (op0,
15497                                             strict_overflow_p));
15498
15499     default:
15500       break;
15501   }
15502
15503   return false;
15504 }
15505
15506 /* Return true when T is an address and is known to be nonzero.
15507    For floating point we further ensure that T is not denormal.
15508    Similar logic is present in nonzero_address in rtlanal.h.
15509
15510    If the return value is based on the assumption that signed overflow
15511    is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
15512    change *STRICT_OVERFLOW_P.  */
15513
15514 bool
15515 tree_single_nonzero_warnv_p (tree t, bool *strict_overflow_p)
15516 {
15517   bool sub_strict_overflow_p;
15518   switch (TREE_CODE (t))
15519     {
15520     case INTEGER_CST:
15521       return !integer_zerop (t);
15522
15523     case ADDR_EXPR:
15524       {
15525         tree base = TREE_OPERAND (t, 0);
15526         if (!DECL_P (base))
15527           base = get_base_address (base);
15528
15529         if (!base)
15530           return false;
15531
15532         /* Weak declarations may link to NULL.  Other things may also be NULL
15533            so protect with -fdelete-null-pointer-checks; but not variables
15534            allocated on the stack.  */
15535         if (DECL_P (base)
15536             && (flag_delete_null_pointer_checks
15537                 || (DECL_CONTEXT (base)
15538                     && TREE_CODE (DECL_CONTEXT (base)) == FUNCTION_DECL
15539                     && auto_var_in_fn_p (base, DECL_CONTEXT (base)))))
15540           return !VAR_OR_FUNCTION_DECL_P (base) || !DECL_WEAK (base);
15541
15542         /* Constants are never weak.  */
15543         if (CONSTANT_CLASS_P (base))
15544           return true;
15545
15546         return false;
15547       }
15548
15549     case COND_EXPR:
15550       sub_strict_overflow_p = false;
15551       if (tree_expr_nonzero_warnv_p (TREE_OPERAND (t, 1),
15552                                      &sub_strict_overflow_p)
15553           && tree_expr_nonzero_warnv_p (TREE_OPERAND (t, 2),
15554                                         &sub_strict_overflow_p))
15555         {
15556           if (sub_strict_overflow_p)
15557             *strict_overflow_p = true;
15558           return true;
15559         }
15560       break;
15561
15562     default:
15563       break;
15564     }
15565   return false;
15566 }
15567
15568 /* Return true when T is an address and is known to be nonzero.
15569    For floating point we further ensure that T is not denormal.
15570    Similar logic is present in nonzero_address in rtlanal.h.
15571
15572    If the return value is based on the assumption that signed overflow
15573    is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
15574    change *STRICT_OVERFLOW_P.  */
15575
15576 bool
15577 tree_expr_nonzero_warnv_p (tree t, bool *strict_overflow_p)
15578 {
15579   tree type = TREE_TYPE (t);
15580   enum tree_code code;
15581
15582   /* Doing something useful for floating point would need more work.  */
15583   if (!INTEGRAL_TYPE_P (type) && !POINTER_TYPE_P (type))
15584     return false;
15585
15586   code = TREE_CODE (t);
15587   switch (TREE_CODE_CLASS (code))
15588     {
15589     case tcc_unary:
15590       return tree_unary_nonzero_warnv_p (code, type, TREE_OPERAND (t, 0),
15591                                               strict_overflow_p);
15592     case tcc_binary:
15593     case tcc_comparison:
15594       return tree_binary_nonzero_warnv_p (code, type,
15595                                                TREE_OPERAND (t, 0),
15596                                                TREE_OPERAND (t, 1),
15597                                                strict_overflow_p);
15598     case tcc_constant:
15599     case tcc_declaration:
15600     case tcc_reference:
15601       return tree_single_nonzero_warnv_p (t, strict_overflow_p);
15602
15603     default:
15604       break;
15605     }
15606
15607   switch (code)
15608     {
15609     case TRUTH_NOT_EXPR:
15610       return tree_unary_nonzero_warnv_p (code, type, TREE_OPERAND (t, 0),
15611                                               strict_overflow_p);
15612
15613     case TRUTH_AND_EXPR:
15614     case TRUTH_OR_EXPR:
15615     case TRUTH_XOR_EXPR:
15616       return tree_binary_nonzero_warnv_p (code, type,
15617                                                TREE_OPERAND (t, 0),
15618                                                TREE_OPERAND (t, 1),
15619                                                strict_overflow_p);
15620
15621     case COND_EXPR:
15622     case CONSTRUCTOR:
15623     case OBJ_TYPE_REF:
15624     case ASSERT_EXPR:
15625     case ADDR_EXPR:
15626     case WITH_SIZE_EXPR:
15627     case SSA_NAME:
15628       return tree_single_nonzero_warnv_p (t, strict_overflow_p);
15629
15630     case COMPOUND_EXPR:
15631     case MODIFY_EXPR:
15632     case BIND_EXPR:
15633       return tree_expr_nonzero_warnv_p (TREE_OPERAND (t, 1),
15634                                         strict_overflow_p);
15635
15636     case SAVE_EXPR:
15637       return tree_expr_nonzero_warnv_p (TREE_OPERAND (t, 0),
15638                                         strict_overflow_p);
15639
15640     case CALL_EXPR:
15641       return alloca_call_p (t);
15642
15643     default:
15644       break;
15645     }
15646   return false;
15647 }
15648
15649 /* Return true when T is an address and is known to be nonzero.
15650    Handle warnings about undefined signed overflow.  */
15651
15652 bool
15653 tree_expr_nonzero_p (tree t)
15654 {
15655   bool ret, strict_overflow_p;
15656
15657   strict_overflow_p = false;
15658   ret = tree_expr_nonzero_warnv_p (t, &strict_overflow_p);
15659   if (strict_overflow_p)
15660     fold_overflow_warning (("assuming signed overflow does not occur when "
15661                             "determining that expression is always "
15662                             "non-zero"),
15663                            WARN_STRICT_OVERFLOW_MISC);
15664   return ret;
15665 }
15666
15667 /* Given the components of a binary expression CODE, TYPE, OP0 and OP1,
15668    attempt to fold the expression to a constant without modifying TYPE,
15669    OP0 or OP1.
15670
15671    If the expression could be simplified to a constant, then return
15672    the constant.  If the expression would not be simplified to a
15673    constant, then return NULL_TREE.  */
15674
15675 tree
15676 fold_binary_to_constant (enum tree_code code, tree type, tree op0, tree op1)
15677 {
15678   tree tem = fold_binary (code, type, op0, op1);
15679   return (tem && TREE_CONSTANT (tem)) ? tem : NULL_TREE;
15680 }
15681
15682 /* Given the components of a unary expression CODE, TYPE and OP0,
15683    attempt to fold the expression to a constant without modifying
15684    TYPE or OP0.
15685
15686    If the expression could be simplified to a constant, then return
15687    the constant.  If the expression would not be simplified to a
15688    constant, then return NULL_TREE.  */
15689
15690 tree
15691 fold_unary_to_constant (enum tree_code code, tree type, tree op0)
15692 {
15693   tree tem = fold_unary (code, type, op0);
15694   return (tem && TREE_CONSTANT (tem)) ? tem : NULL_TREE;
15695 }
15696
15697 /* If EXP represents referencing an element in a constant string
15698    (either via pointer arithmetic or array indexing), return the
15699    tree representing the value accessed, otherwise return NULL.  */
15700
15701 tree
15702 fold_read_from_constant_string (tree exp)
15703 {
15704   if ((TREE_CODE (exp) == INDIRECT_REF
15705        || TREE_CODE (exp) == ARRAY_REF)
15706       && TREE_CODE (TREE_TYPE (exp)) == INTEGER_TYPE)
15707     {
15708       tree exp1 = TREE_OPERAND (exp, 0);
15709       tree index;
15710       tree string;
15711       location_t loc = EXPR_LOCATION (exp);
15712
15713       if (TREE_CODE (exp) == INDIRECT_REF)
15714         string = string_constant (exp1, &index);
15715       else
15716         {
15717           tree low_bound = array_ref_low_bound (exp);
15718           index = fold_convert_loc (loc, sizetype, TREE_OPERAND (exp, 1));
15719
15720           /* Optimize the special-case of a zero lower bound.
15721
15722              We convert the low_bound to sizetype to avoid some problems
15723              with constant folding.  (E.g. suppose the lower bound is 1,
15724              and its mode is QI.  Without the conversion,l (ARRAY
15725              +(INDEX-(unsigned char)1)) becomes ((ARRAY+(-(unsigned char)1))
15726              +INDEX), which becomes (ARRAY+255+INDEX).  Oops!)  */
15727           if (! integer_zerop (low_bound))
15728             index = size_diffop_loc (loc, index,
15729                                  fold_convert_loc (loc, sizetype, low_bound));
15730
15731           string = exp1;
15732         }
15733
15734       if (string
15735           && TYPE_MODE (TREE_TYPE (exp)) == TYPE_MODE (TREE_TYPE (TREE_TYPE (string)))
15736           && TREE_CODE (string) == STRING_CST
15737           && TREE_CODE (index) == INTEGER_CST
15738           && compare_tree_int (index, TREE_STRING_LENGTH (string)) < 0
15739           && (GET_MODE_CLASS (TYPE_MODE (TREE_TYPE (TREE_TYPE (string))))
15740               == MODE_INT)
15741           && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (TREE_TYPE (string)))) == 1))
15742         return build_int_cst_type (TREE_TYPE (exp),
15743                                    (TREE_STRING_POINTER (string)
15744                                     [TREE_INT_CST_LOW (index)]));
15745     }
15746   return NULL;
15747 }
15748
15749 /* Return the tree for neg (ARG0) when ARG0 is known to be either
15750    an integer constant, real, or fixed-point constant.
15751
15752    TYPE is the type of the result.  */
15753
15754 static tree
15755 fold_negate_const (tree arg0, tree type)
15756 {
15757   tree t = NULL_TREE;
15758
15759   switch (TREE_CODE (arg0))
15760     {
15761     case INTEGER_CST:
15762       {
15763         double_int val = tree_to_double_int (arg0);
15764         int overflow = neg_double (val.low, val.high, &val.low, &val.high);
15765
15766         t = force_fit_type_double (type, val, 1,
15767                                    (overflow | TREE_OVERFLOW (arg0))
15768                                    && !TYPE_UNSIGNED (type));
15769         break;
15770       }
15771
15772     case REAL_CST:
15773       t = build_real (type, real_value_negate (&TREE_REAL_CST (arg0)));
15774       break;
15775
15776     case FIXED_CST:
15777       {
15778         FIXED_VALUE_TYPE f;
15779         bool overflow_p = fixed_arithmetic (&f, NEGATE_EXPR,
15780                                             &(TREE_FIXED_CST (arg0)), NULL,
15781                                             TYPE_SATURATING (type));
15782         t = build_fixed (type, f);
15783         /* Propagate overflow flags.  */
15784         if (overflow_p | TREE_OVERFLOW (arg0))
15785           TREE_OVERFLOW (t) = 1;
15786         break;
15787       }
15788
15789     default:
15790       gcc_unreachable ();
15791     }
15792
15793   return t;
15794 }
15795
15796 /* Return the tree for abs (ARG0) when ARG0 is known to be either
15797    an integer constant or real constant.
15798
15799    TYPE is the type of the result.  */
15800
15801 tree
15802 fold_abs_const (tree arg0, tree type)
15803 {
15804   tree t = NULL_TREE;
15805
15806   switch (TREE_CODE (arg0))
15807     {
15808     case INTEGER_CST:
15809       {
15810         double_int val = tree_to_double_int (arg0);
15811
15812         /* If the value is unsigned or non-negative, then the absolute value
15813            is the same as the ordinary value.  */
15814         if (TYPE_UNSIGNED (type)
15815             || !double_int_negative_p (val))
15816           t = arg0;
15817
15818         /* If the value is negative, then the absolute value is
15819            its negation.  */
15820         else
15821           {
15822             int overflow;
15823
15824             overflow = neg_double (val.low, val.high, &val.low, &val.high);
15825             t = force_fit_type_double (type, val, -1,
15826                                        overflow | TREE_OVERFLOW (arg0));
15827           }
15828       }
15829       break;
15830
15831     case REAL_CST:
15832       if (REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg0)))
15833         t = build_real (type, real_value_negate (&TREE_REAL_CST (arg0)));
15834       else
15835         t =  arg0;
15836       break;
15837
15838     default:
15839       gcc_unreachable ();
15840     }
15841
15842   return t;
15843 }
15844
15845 /* Return the tree for not (ARG0) when ARG0 is known to be an integer
15846    constant.  TYPE is the type of the result.  */
15847
15848 static tree
15849 fold_not_const (const_tree arg0, tree type)
15850 {
15851   double_int val;
15852
15853   gcc_assert (TREE_CODE (arg0) == INTEGER_CST);
15854
15855   val = double_int_not (tree_to_double_int (arg0));
15856   return force_fit_type_double (type, val, 0, TREE_OVERFLOW (arg0));
15857 }
15858
15859 /* Given CODE, a relational operator, the target type, TYPE and two
15860    constant operands OP0 and OP1, return the result of the
15861    relational operation.  If the result is not a compile time
15862    constant, then return NULL_TREE.  */
15863
15864 static tree
15865 fold_relational_const (enum tree_code code, tree type, tree op0, tree op1)
15866 {
15867   int result, invert;
15868
15869   /* From here on, the only cases we handle are when the result is
15870      known to be a constant.  */
15871
15872   if (TREE_CODE (op0) == REAL_CST && TREE_CODE (op1) == REAL_CST)
15873     {
15874       const REAL_VALUE_TYPE *c0 = TREE_REAL_CST_PTR (op0);
15875       const REAL_VALUE_TYPE *c1 = TREE_REAL_CST_PTR (op1);
15876
15877       /* Handle the cases where either operand is a NaN.  */
15878       if (real_isnan (c0) || real_isnan (c1))
15879         {
15880           switch (code)
15881             {
15882             case EQ_EXPR:
15883             case ORDERED_EXPR:
15884               result = 0;
15885               break;
15886
15887             case NE_EXPR:
15888             case UNORDERED_EXPR:
15889             case UNLT_EXPR:
15890             case UNLE_EXPR:
15891             case UNGT_EXPR:
15892             case UNGE_EXPR:
15893             case UNEQ_EXPR:
15894               result = 1;
15895               break;
15896
15897             case LT_EXPR:
15898             case LE_EXPR:
15899             case GT_EXPR:
15900             case GE_EXPR:
15901             case LTGT_EXPR:
15902               if (flag_trapping_math)
15903                 return NULL_TREE;
15904               result = 0;
15905               break;
15906
15907             default:
15908               gcc_unreachable ();
15909             }
15910
15911           return constant_boolean_node (result, type);
15912         }
15913
15914       return constant_boolean_node (real_compare (code, c0, c1), type);
15915     }
15916
15917   if (TREE_CODE (op0) == FIXED_CST && TREE_CODE (op1) == FIXED_CST)
15918     {
15919       const FIXED_VALUE_TYPE *c0 = TREE_FIXED_CST_PTR (op0);
15920       const FIXED_VALUE_TYPE *c1 = TREE_FIXED_CST_PTR (op1);
15921       return constant_boolean_node (fixed_compare (code, c0, c1), type);
15922     }
15923
15924   /* Handle equality/inequality of complex constants.  */
15925   if (TREE_CODE (op0) == COMPLEX_CST && TREE_CODE (op1) == COMPLEX_CST)
15926     {
15927       tree rcond = fold_relational_const (code, type,
15928                                           TREE_REALPART (op0),
15929                                           TREE_REALPART (op1));
15930       tree icond = fold_relational_const (code, type,
15931                                           TREE_IMAGPART (op0),
15932                                           TREE_IMAGPART (op1));
15933       if (code == EQ_EXPR)
15934         return fold_build2 (TRUTH_ANDIF_EXPR, type, rcond, icond);
15935       else if (code == NE_EXPR)
15936         return fold_build2 (TRUTH_ORIF_EXPR, type, rcond, icond);
15937       else
15938         return NULL_TREE;
15939     }
15940
15941   /* From here on we only handle LT, LE, GT, GE, EQ and NE.
15942
15943      To compute GT, swap the arguments and do LT.
15944      To compute GE, do LT and invert the result.
15945      To compute LE, swap the arguments, do LT and invert the result.
15946      To compute NE, do EQ and invert the result.
15947
15948      Therefore, the code below must handle only EQ and LT.  */
15949
15950   if (code == LE_EXPR || code == GT_EXPR)
15951     {
15952       tree tem = op0;
15953       op0 = op1;
15954       op1 = tem;
15955       code = swap_tree_comparison (code);
15956     }
15957
15958   /* Note that it is safe to invert for real values here because we
15959      have already handled the one case that it matters.  */
15960
15961   invert = 0;
15962   if (code == NE_EXPR || code == GE_EXPR)
15963     {
15964       invert = 1;
15965       code = invert_tree_comparison (code, false);
15966     }
15967
15968   /* Compute a result for LT or EQ if args permit;
15969      Otherwise return T.  */
15970   if (TREE_CODE (op0) == INTEGER_CST && TREE_CODE (op1) == INTEGER_CST)
15971     {
15972       if (code == EQ_EXPR)
15973         result = tree_int_cst_equal (op0, op1);
15974       else if (TYPE_UNSIGNED (TREE_TYPE (op0)))
15975         result = INT_CST_LT_UNSIGNED (op0, op1);
15976       else
15977         result = INT_CST_LT (op0, op1);
15978     }
15979   else
15980     return NULL_TREE;
15981
15982   if (invert)
15983     result ^= 1;
15984   return constant_boolean_node (result, type);
15985 }
15986
15987 /* If necessary, return a CLEANUP_POINT_EXPR for EXPR with the
15988    indicated TYPE.  If no CLEANUP_POINT_EXPR is necessary, return EXPR
15989    itself.  */
15990
15991 tree
15992 fold_build_cleanup_point_expr (tree type, tree expr)
15993 {
15994   /* If the expression does not have side effects then we don't have to wrap
15995      it with a cleanup point expression.  */
15996   if (!TREE_SIDE_EFFECTS (expr))
15997     return expr;
15998
15999   /* If the expression is a return, check to see if the expression inside the
16000      return has no side effects or the right hand side of the modify expression
16001      inside the return. If either don't have side effects set we don't need to
16002      wrap the expression in a cleanup point expression.  Note we don't check the
16003      left hand side of the modify because it should always be a return decl.  */
16004   if (TREE_CODE (expr) == RETURN_EXPR)
16005     {
16006       tree op = TREE_OPERAND (expr, 0);
16007       if (!op || !TREE_SIDE_EFFECTS (op))
16008         return expr;
16009       op = TREE_OPERAND (op, 1);
16010       if (!TREE_SIDE_EFFECTS (op))
16011         return expr;
16012     }
16013
16014   return build1 (CLEANUP_POINT_EXPR, type, expr);
16015 }
16016
16017 /* Given a pointer value OP0 and a type TYPE, return a simplified version
16018    of an indirection through OP0, or NULL_TREE if no simplification is
16019    possible.  */
16020
16021 tree
16022 fold_indirect_ref_1 (location_t loc, tree type, tree op0)
16023 {
16024   tree sub = op0;
16025   tree subtype;
16026
16027   STRIP_NOPS (sub);
16028   subtype = TREE_TYPE (sub);
16029   if (!POINTER_TYPE_P (subtype))
16030     return NULL_TREE;
16031
16032   if (TREE_CODE (sub) == ADDR_EXPR)
16033     {
16034       tree op = TREE_OPERAND (sub, 0);
16035       tree optype = TREE_TYPE (op);
16036       /* *&CONST_DECL -> to the value of the const decl.  */
16037       if (TREE_CODE (op) == CONST_DECL)
16038         return DECL_INITIAL (op);
16039       /* *&p => p;  make sure to handle *&"str"[cst] here.  */
16040       if (type == optype)
16041         {
16042           tree fop = fold_read_from_constant_string (op);
16043           if (fop)
16044             return fop;
16045           else
16046             return op;
16047         }
16048       /* *(foo *)&fooarray => fooarray[0] */
16049       else if (TREE_CODE (optype) == ARRAY_TYPE
16050                && type == TREE_TYPE (optype)
16051                && (!in_gimple_form
16052                    || TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST))
16053         {
16054           tree type_domain = TYPE_DOMAIN (optype);
16055           tree min_val = size_zero_node;
16056           if (type_domain && TYPE_MIN_VALUE (type_domain))
16057             min_val = TYPE_MIN_VALUE (type_domain);
16058           if (in_gimple_form
16059               && TREE_CODE (min_val) != INTEGER_CST)
16060             return NULL_TREE;
16061           return build4_loc (loc, ARRAY_REF, type, op, min_val,
16062                              NULL_TREE, NULL_TREE);
16063         }
16064       /* *(foo *)&complexfoo => __real__ complexfoo */
16065       else if (TREE_CODE (optype) == COMPLEX_TYPE
16066                && type == TREE_TYPE (optype))
16067         return fold_build1_loc (loc, REALPART_EXPR, type, op);
16068       /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
16069       else if (TREE_CODE (optype) == VECTOR_TYPE
16070                && type == TREE_TYPE (optype))
16071         {
16072           tree part_width = TYPE_SIZE (type);
16073           tree index = bitsize_int (0);
16074           return fold_build3_loc (loc, BIT_FIELD_REF, type, op, part_width, index);
16075         }
16076     }
16077
16078   if (TREE_CODE (sub) == POINTER_PLUS_EXPR
16079       && TREE_CODE (TREE_OPERAND (sub, 1)) == INTEGER_CST)
16080     {
16081       tree op00 = TREE_OPERAND (sub, 0);
16082       tree op01 = TREE_OPERAND (sub, 1);
16083
16084       STRIP_NOPS (op00);
16085       if (TREE_CODE (op00) == ADDR_EXPR)
16086         {
16087           tree op00type;
16088           op00 = TREE_OPERAND (op00, 0);
16089           op00type = TREE_TYPE (op00);
16090
16091           /* ((foo*)&vectorfoo)[1] => BIT_FIELD_REF<vectorfoo,...> */
16092           if (TREE_CODE (op00type) == VECTOR_TYPE
16093               && type == TREE_TYPE (op00type))
16094             {
16095               HOST_WIDE_INT offset = tree_low_cst (op01, 0);
16096               tree part_width = TYPE_SIZE (type);
16097               unsigned HOST_WIDE_INT part_widthi = tree_low_cst (part_width, 0)/BITS_PER_UNIT;
16098               unsigned HOST_WIDE_INT indexi = offset * BITS_PER_UNIT;
16099               tree index = bitsize_int (indexi);
16100
16101               if (offset/part_widthi <= TYPE_VECTOR_SUBPARTS (op00type))
16102                 return fold_build3_loc (loc,
16103                                         BIT_FIELD_REF, type, op00,
16104                                         part_width, index);
16105
16106             }
16107           /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */
16108           else if (TREE_CODE (op00type) == COMPLEX_TYPE
16109                    && type == TREE_TYPE (op00type))
16110             {
16111               tree size = TYPE_SIZE_UNIT (type);
16112               if (tree_int_cst_equal (size, op01))
16113                 return fold_build1_loc (loc, IMAGPART_EXPR, type, op00);
16114             }
16115           /* ((foo *)&fooarray)[1] => fooarray[1] */
16116           else if (TREE_CODE (op00type) == ARRAY_TYPE
16117                    && type == TREE_TYPE (op00type))
16118             {
16119               tree type_domain = TYPE_DOMAIN (op00type);
16120               tree min_val = size_zero_node;
16121               if (type_domain && TYPE_MIN_VALUE (type_domain))
16122                 min_val = TYPE_MIN_VALUE (type_domain);
16123               op01 = size_binop_loc (loc, EXACT_DIV_EXPR, op01,
16124                                      TYPE_SIZE_UNIT (type));
16125               op01 = size_binop_loc (loc, PLUS_EXPR, op01, min_val);
16126               return build4_loc (loc, ARRAY_REF, type, op00, op01,
16127                                  NULL_TREE, NULL_TREE);
16128             }
16129         }
16130     }
16131
16132   /* *(foo *)fooarrptr => (*fooarrptr)[0] */
16133   if (TREE_CODE (TREE_TYPE (subtype)) == ARRAY_TYPE
16134       && type == TREE_TYPE (TREE_TYPE (subtype))
16135       && (!in_gimple_form
16136           || TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST))
16137     {
16138       tree type_domain;
16139       tree min_val = size_zero_node;
16140       sub = build_fold_indirect_ref_loc (loc, sub);
16141       type_domain = TYPE_DOMAIN (TREE_TYPE (sub));
16142       if (type_domain && TYPE_MIN_VALUE (type_domain))
16143         min_val = TYPE_MIN_VALUE (type_domain);
16144       if (in_gimple_form
16145           && TREE_CODE (min_val) != INTEGER_CST)
16146         return NULL_TREE;
16147       return build4_loc (loc, ARRAY_REF, type, sub, min_val, NULL_TREE,
16148                          NULL_TREE);
16149     }
16150
16151   return NULL_TREE;
16152 }
16153
16154 /* Builds an expression for an indirection through T, simplifying some
16155    cases.  */
16156
16157 tree
16158 build_fold_indirect_ref_loc (location_t loc, tree t)
16159 {
16160   tree type = TREE_TYPE (TREE_TYPE (t));
16161   tree sub = fold_indirect_ref_1 (loc, type, t);
16162
16163   if (sub)
16164     return sub;
16165
16166   return build1_loc (loc, INDIRECT_REF, type, t);
16167 }
16168
16169 /* Given an INDIRECT_REF T, return either T or a simplified version.  */
16170
16171 tree
16172 fold_indirect_ref_loc (location_t loc, tree t)
16173 {
16174   tree sub = fold_indirect_ref_1 (loc, TREE_TYPE (t), TREE_OPERAND (t, 0));
16175
16176   if (sub)
16177     return sub;
16178   else
16179     return t;
16180 }
16181
16182 /* Strip non-trapping, non-side-effecting tree nodes from an expression
16183    whose result is ignored.  The type of the returned tree need not be
16184    the same as the original expression.  */
16185
16186 tree
16187 fold_ignored_result (tree t)
16188 {
16189   if (!TREE_SIDE_EFFECTS (t))
16190     return integer_zero_node;
16191
16192   for (;;)
16193     switch (TREE_CODE_CLASS (TREE_CODE (t)))
16194       {
16195       case tcc_unary:
16196         t = TREE_OPERAND (t, 0);
16197         break;
16198
16199       case tcc_binary:
16200       case tcc_comparison:
16201         if (!TREE_SIDE_EFFECTS (TREE_OPERAND (t, 1)))
16202           t = TREE_OPERAND (t, 0);
16203         else if (!TREE_SIDE_EFFECTS (TREE_OPERAND (t, 0)))
16204           t = TREE_OPERAND (t, 1);
16205         else
16206           return t;
16207         break;
16208
16209       case tcc_expression:
16210         switch (TREE_CODE (t))
16211           {
16212           case COMPOUND_EXPR:
16213             if (TREE_SIDE_EFFECTS (TREE_OPERAND (t, 1)))
16214               return t;
16215             t = TREE_OPERAND (t, 0);
16216             break;
16217
16218           case COND_EXPR:
16219             if (TREE_SIDE_EFFECTS (TREE_OPERAND (t, 1))
16220                 || TREE_SIDE_EFFECTS (TREE_OPERAND (t, 2)))
16221               return t;
16222             t = TREE_OPERAND (t, 0);
16223             break;
16224
16225           default:
16226             return t;
16227           }
16228         break;
16229
16230       default:
16231         return t;
16232       }
16233 }
16234
16235 /* Return the value of VALUE, rounded up to a multiple of DIVISOR.
16236    This can only be applied to objects of a sizetype.  */
16237
16238 tree
16239 round_up_loc (location_t loc, tree value, int divisor)
16240 {
16241   tree div = NULL_TREE;
16242
16243   gcc_assert (divisor > 0);
16244   if (divisor == 1)
16245     return value;
16246
16247   /* See if VALUE is already a multiple of DIVISOR.  If so, we don't
16248      have to do anything.  Only do this when we are not given a const,
16249      because in that case, this check is more expensive than just
16250      doing it.  */
16251   if (TREE_CODE (value) != INTEGER_CST)
16252     {
16253       div = build_int_cst (TREE_TYPE (value), divisor);
16254
16255       if (multiple_of_p (TREE_TYPE (value), value, div))
16256         return value;
16257     }
16258
16259   /* If divisor is a power of two, simplify this to bit manipulation.  */
16260   if (divisor == (divisor & -divisor))
16261     {
16262       if (TREE_CODE (value) == INTEGER_CST)
16263         {
16264           double_int val = tree_to_double_int (value);
16265           bool overflow_p;
16266
16267           if ((val.low & (divisor - 1)) == 0)
16268             return value;
16269
16270           overflow_p = TREE_OVERFLOW (value);
16271           val.low &= ~(divisor - 1);
16272           val.low += divisor;
16273           if (val.low == 0)
16274             {
16275               val.high++;
16276               if (val.high == 0)
16277                 overflow_p = true;
16278             }
16279
16280           return force_fit_type_double (TREE_TYPE (value), val,
16281                                         -1, overflow_p);
16282         }
16283       else
16284         {
16285           tree t;
16286
16287           t = build_int_cst (TREE_TYPE (value), divisor - 1);
16288           value = size_binop_loc (loc, PLUS_EXPR, value, t);
16289           t = build_int_cst (TREE_TYPE (value), -divisor);
16290           value = size_binop_loc (loc, BIT_AND_EXPR, value, t);
16291         }
16292     }
16293   else
16294     {
16295       if (!div)
16296         div = build_int_cst (TREE_TYPE (value), divisor);
16297       value = size_binop_loc (loc, CEIL_DIV_EXPR, value, div);
16298       value = size_binop_loc (loc, MULT_EXPR, value, div);
16299     }
16300
16301   return value;
16302 }
16303
16304 /* Likewise, but round down.  */
16305
16306 tree
16307 round_down_loc (location_t loc, tree value, int divisor)
16308 {
16309   tree div = NULL_TREE;
16310
16311   gcc_assert (divisor > 0);
16312   if (divisor == 1)
16313     return value;
16314
16315   /* See if VALUE is already a multiple of DIVISOR.  If so, we don't
16316      have to do anything.  Only do this when we are not given a const,
16317      because in that case, this check is more expensive than just
16318      doing it.  */
16319   if (TREE_CODE (value) != INTEGER_CST)
16320     {
16321       div = build_int_cst (TREE_TYPE (value), divisor);
16322
16323       if (multiple_of_p (TREE_TYPE (value), value, div))
16324         return value;
16325     }
16326
16327   /* If divisor is a power of two, simplify this to bit manipulation.  */
16328   if (divisor == (divisor & -divisor))
16329     {
16330       tree t;
16331
16332       t = build_int_cst (TREE_TYPE (value), -divisor);
16333       value = size_binop_loc (loc, BIT_AND_EXPR, value, t);
16334     }
16335   else
16336     {
16337       if (!div)
16338         div = build_int_cst (TREE_TYPE (value), divisor);
16339       value = size_binop_loc (loc, FLOOR_DIV_EXPR, value, div);
16340       value = size_binop_loc (loc, MULT_EXPR, value, div);
16341     }
16342
16343   return value;
16344 }
16345
16346 /* Returns the pointer to the base of the object addressed by EXP and
16347    extracts the information about the offset of the access, storing it
16348    to PBITPOS and POFFSET.  */
16349
16350 static tree
16351 split_address_to_core_and_offset (tree exp,
16352                                   HOST_WIDE_INT *pbitpos, tree *poffset)
16353 {
16354   tree core;
16355   enum machine_mode mode;
16356   int unsignedp, volatilep;
16357   HOST_WIDE_INT bitsize;
16358   location_t loc = EXPR_LOCATION (exp);
16359
16360   if (TREE_CODE (exp) == ADDR_EXPR)
16361     {
16362       core = get_inner_reference (TREE_OPERAND (exp, 0), &bitsize, pbitpos,
16363                                   poffset, &mode, &unsignedp, &volatilep,
16364                                   false);
16365       core = build_fold_addr_expr_loc (loc, core);
16366     }
16367   else
16368     {
16369       core = exp;
16370       *pbitpos = 0;
16371       *poffset = NULL_TREE;
16372     }
16373
16374   return core;
16375 }
16376
16377 /* Returns true if addresses of E1 and E2 differ by a constant, false
16378    otherwise.  If they do, E1 - E2 is stored in *DIFF.  */
16379
16380 bool
16381 ptr_difference_const (tree e1, tree e2, HOST_WIDE_INT *diff)
16382 {
16383   tree core1, core2;
16384   HOST_WIDE_INT bitpos1, bitpos2;
16385   tree toffset1, toffset2, tdiff, type;
16386
16387   core1 = split_address_to_core_and_offset (e1, &bitpos1, &toffset1);
16388   core2 = split_address_to_core_and_offset (e2, &bitpos2, &toffset2);
16389
16390   if (bitpos1 % BITS_PER_UNIT != 0
16391       || bitpos2 % BITS_PER_UNIT != 0
16392       || !operand_equal_p (core1, core2, 0))
16393     return false;
16394
16395   if (toffset1 && toffset2)
16396     {
16397       type = TREE_TYPE (toffset1);
16398       if (type != TREE_TYPE (toffset2))
16399         toffset2 = fold_convert (type, toffset2);
16400
16401       tdiff = fold_build2 (MINUS_EXPR, type, toffset1, toffset2);
16402       if (!cst_and_fits_in_hwi (tdiff))
16403         return false;
16404
16405       *diff = int_cst_value (tdiff);
16406     }
16407   else if (toffset1 || toffset2)
16408     {
16409       /* If only one of the offsets is non-constant, the difference cannot
16410          be a constant.  */
16411       return false;
16412     }
16413   else
16414     *diff = 0;
16415
16416   *diff += (bitpos1 - bitpos2) / BITS_PER_UNIT;
16417   return true;
16418 }
16419
16420 /* Simplify the floating point expression EXP when the sign of the
16421    result is not significant.  Return NULL_TREE if no simplification
16422    is possible.  */
16423
16424 tree
16425 fold_strip_sign_ops (tree exp)
16426 {
16427   tree arg0, arg1;
16428   location_t loc = EXPR_LOCATION (exp);
16429
16430   switch (TREE_CODE (exp))
16431     {
16432     case ABS_EXPR:
16433     case NEGATE_EXPR:
16434       arg0 = fold_strip_sign_ops (TREE_OPERAND (exp, 0));
16435       return arg0 ? arg0 : TREE_OPERAND (exp, 0);
16436
16437     case MULT_EXPR:
16438     case RDIV_EXPR:
16439       if (HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (TREE_TYPE (exp))))
16440         return NULL_TREE;
16441       arg0 = fold_strip_sign_ops (TREE_OPERAND (exp, 0));
16442       arg1 = fold_strip_sign_ops (TREE_OPERAND (exp, 1));
16443       if (arg0 != NULL_TREE || arg1 != NULL_TREE)
16444         return fold_build2_loc (loc, TREE_CODE (exp), TREE_TYPE (exp),
16445                             arg0 ? arg0 : TREE_OPERAND (exp, 0),
16446                             arg1 ? arg1 : TREE_OPERAND (exp, 1));
16447       break;
16448
16449     case COMPOUND_EXPR:
16450       arg0 = TREE_OPERAND (exp, 0);
16451       arg1 = fold_strip_sign_ops (TREE_OPERAND (exp, 1));
16452       if (arg1)
16453         return fold_build2_loc (loc, COMPOUND_EXPR, TREE_TYPE (exp), arg0, arg1);
16454       break;
16455
16456     case COND_EXPR:
16457       arg0 = fold_strip_sign_ops (TREE_OPERAND (exp, 1));
16458       arg1 = fold_strip_sign_ops (TREE_OPERAND (exp, 2));
16459       if (arg0 || arg1)
16460         return fold_build3_loc (loc,
16461                             COND_EXPR, TREE_TYPE (exp), TREE_OPERAND (exp, 0),
16462                             arg0 ? arg0 : TREE_OPERAND (exp, 1),
16463                             arg1 ? arg1 : TREE_OPERAND (exp, 2));
16464       break;
16465
16466     case CALL_EXPR:
16467       {
16468         const enum built_in_function fcode = builtin_mathfn_code (exp);
16469         switch (fcode)
16470         {
16471         CASE_FLT_FN (BUILT_IN_COPYSIGN):
16472           /* Strip copysign function call, return the 1st argument. */
16473           arg0 = CALL_EXPR_ARG (exp, 0);
16474           arg1 = CALL_EXPR_ARG (exp, 1);
16475           return omit_one_operand_loc (loc, TREE_TYPE (exp), arg0, arg1);
16476
16477         default:
16478           /* Strip sign ops from the argument of "odd" math functions.  */
16479           if (negate_mathfn_p (fcode))
16480             {
16481               arg0 = fold_strip_sign_ops (CALL_EXPR_ARG (exp, 0));
16482               if (arg0)
16483                 return build_call_expr_loc (loc, get_callee_fndecl (exp), 1, arg0);
16484             }
16485           break;
16486         }
16487       }
16488       break;
16489
16490     default:
16491       break;
16492     }
16493   return NULL_TREE;
16494 }