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    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 tree range_binop (enum tree_code, tree, tree, int, tree, int);
 116 static tree range_predecessor (tree);
 117 static tree range_successor (tree);
 118 extern tree make_range (tree, int *, tree *, tree *, bool *);
 119 extern bool merge_ranges (int *, tree *, tree *, int, tree, tree, int,
 120                           tree, tree);
 121 static tree fold_range_test (location_t, enum tree_code, tree, tree, tree);
 122 static tree fold_cond_expr_with_comparison (location_t, tree, tree, tree, tree);
 123 static tree unextend (tree, int, int, tree);
 124 static tree fold_truthop (location_t, enum tree_code, tree, tree, tree);
 125 static tree optimize_minmax_comparison (location_t, enum tree_code,
 126                                         tree, tree, tree);
 127 static tree extract_muldiv (tree, tree, enum tree_code, tree, bool *);
 128 static tree extract_muldiv_1 (tree, tree, enum tree_code, tree, bool *);
 129 static tree fold_binary_op_with_conditional_arg (location_t,
 130                                                  enum tree_code, tree,
 131                                                  tree, tree,
 132                                                  tree, tree, int);
 133 static tree fold_mathfn_compare (location_t,
 134                                  enum built_in_function, enum tree_code,
 135                                  tree, tree, tree);
 136 static tree fold_inf_compare (location_t, enum tree_code, tree, tree, tree);
 137 static tree fold_div_compare (location_t, enum tree_code, tree, tree, tree);
 138 static bool reorder_operands_p (const_tree, const_tree);
 139 static tree fold_negate_const (tree, tree);
 140 static tree fold_not_const (const_tree, tree);
 141 static tree fold_relational_const (enum tree_code, tree, tree, tree);
 142 static tree fold_convert_const (enum tree_code, tree, tree);
 143
 144
 145 /* Similar to protected_set_expr_location, but never modify x in place,
 146    if location can and needs to be set, unshare it.  */
 147
 148 static inline tree
 149 protected_set_expr_location_unshare (tree x, location_t loc)
 150 {
 151   if (CAN_HAVE_LOCATION_P (x)
 152       && EXPR_LOCATION (x) != loc
 153       && !(TREE_CODE (x) == SAVE_EXPR
 154            || TREE_CODE (x) == TARGET_EXPR
 155            || TREE_CODE (x) == BIND_EXPR))
 156     {
 157       x = copy_node (x);
 158       SET_EXPR_LOCATION (x, loc);
 159     }
 160   return x;
 161 }
 162
 163
 164 /* We know that A1 + B1 = SUM1, using 2's complement arithmetic and ignoring
 165    overflow.  Suppose A, B and SUM have the same respective signs as A1, B1,
 166    and SUM1.  Then this yields nonzero if overflow occurred during the
 167    addition.
 168
 169    Overflow occurs if A and B have the same sign, but A and SUM differ in
 170    sign.  Use `^' to test whether signs differ, and `< 0' to isolate the
 171    sign.  */
 172 #define OVERFLOW_SUM_SIGN(a, b, sum) ((~((a) ^ (b)) & ((a) ^ (sum))) < 0)
 173 \f
 174 /* If ARG2 divides ARG1 with zero remainder, carries out the division
 175    of type CODE and returns the quotient.
 176    Otherwise returns NULL_TREE.  */
 177
 178 tree
 179 div_if_zero_remainder (enum tree_code code, const_tree arg1, const_tree arg2)
 180 {
 181   double_int quo, rem;
 182   int uns;
 183
 184   /* The sign of the division is according to operand two, that
 185      does the correct thing for POINTER_PLUS_EXPR where we want
 186      a signed division.  */
 187   uns = TYPE_UNSIGNED (TREE_TYPE (arg2));
 188   if (TREE_CODE (TREE_TYPE (arg2)) == INTEGER_TYPE
 189       && TYPE_IS_SIZETYPE (TREE_TYPE (arg2)))
 190     uns = false;
 191
 192   quo = double_int_divmod (tree_to_double_int (arg1),
 193                            tree_to_double_int (arg2),
 194                            uns, code, &rem);
 195
 196   if (double_int_zero_p (rem))
 197     return build_int_cst_wide (TREE_TYPE (arg1), quo.low, quo.high);
 198
 199   return NULL_TREE;
 200 }
 201 \f
 202 /* This is nonzero if we should defer warnings about undefined
 203    overflow.  This facility exists because these warnings are a
 204    special case.  The code to estimate loop iterations does not want
 205    to issue any warnings, since it works with expressions which do not
 206    occur in user code.  Various bits of cleanup code call fold(), but
 207    only use the result if it has certain characteristics (e.g., is a
 208    constant); that code only wants to issue a warning if the result is
 209    used.  */
 210
 211 static int fold_deferring_overflow_warnings;
 212
 213 /* If a warning about undefined overflow is deferred, this is the
 214    warning.  Note that this may cause us to turn two warnings into
 215    one, but that is fine since it is sufficient to only give one
 216    warning per expression.  */
 217
 218 static const char* fold_deferred_overflow_warning;
 219
 220 /* If a warning about undefined overflow is deferred, this is the
 221    level at which the warning should be emitted.  */
 222
 223 static enum warn_strict_overflow_code fold_deferred_overflow_code;
 224
 225 /* Start deferring overflow warnings.  We could use a stack here to
 226    permit nested calls, but at present it is not necessary.  */
 227
 228 void
 229 fold_defer_overflow_warnings (void)
 230 {
 231   ++fold_deferring_overflow_warnings;
 232 }
 233
 234 /* Stop deferring overflow warnings.  If there is a pending warning,
 235    and ISSUE is true, then issue the warning if appropriate.  STMT is
 236    the statement with which the warning should be associated (used for
 237    location information); STMT may be NULL.  CODE is the level of the
 238    warning--a warn_strict_overflow_code value.  This function will use
 239    the smaller of CODE and the deferred code when deciding whether to
 240    issue the warning.  CODE may be zero to mean to always use the
 241    deferred code.  */
 242
 243 void
 244 fold_undefer_overflow_warnings (bool issue, const_gimple stmt, int code)
 245 {
 246   const char *warnmsg;
 247   location_t locus;
 248
 249   gcc_assert (fold_deferring_overflow_warnings > 0);
 250   --fold_deferring_overflow_warnings;
 251   if (fold_deferring_overflow_warnings > 0)
 252     {
 253       if (fold_deferred_overflow_warning != NULL
 254           && code != 0
 255           && code < (int) fold_deferred_overflow_code)
 256         fold_deferred_overflow_code = (enum warn_strict_overflow_code) code;
 257       return;
 258     }
 259
 260   warnmsg = fold_deferred_overflow_warning;
 261   fold_deferred_overflow_warning = NULL;
 262
 263   if (!issue || warnmsg == NULL)
 264     return;
 265
 266   if (gimple_no_warning_p (stmt))
 267     return;
 268
 269   /* Use the smallest code level when deciding to issue the
 270      warning.  */
 271   if (code == 0 || code > (int) fold_deferred_overflow_code)
 272     code = fold_deferred_overflow_code;
 273
 274   if (!issue_strict_overflow_warning (code))
 275     return;
 276
 277   if (stmt == NULL)
 278     locus = input_location;
 279   else
 280     locus = gimple_location (stmt);
 281   warning_at (locus, OPT_Wstrict_overflow, "%s", warnmsg);
 282 }
 283
 284 /* Stop deferring overflow warnings, ignoring any deferred
 285    warnings.  */
 286
 287 void
 288 fold_undefer_and_ignore_overflow_warnings (void)
 289 {
 290   fold_undefer_overflow_warnings (false, NULL, 0);
 291 }
 292
 293 /* Whether we are deferring overflow warnings.  */
 294
 295 bool
 296 fold_deferring_overflow_warnings_p (void)
 297 {
 298   return fold_deferring_overflow_warnings > 0;
 299 }
 300
 301 /* This is called when we fold something based on the fact that signed
 302    overflow is undefined.  */
 303
 304 static void
 305 fold_overflow_warning (const char* gmsgid, enum warn_strict_overflow_code wc)
 306 {
 307   if (fold_deferring_overflow_warnings > 0)
 308     {
 309       if (fold_deferred_overflow_warning == NULL
 310           || wc < fold_deferred_overflow_code)
 311         {
 312           fold_deferred_overflow_warning = gmsgid;
 313           fold_deferred_overflow_code = wc;
 314         }
 315     }
 316   else if (issue_strict_overflow_warning (wc))
 317     warning (OPT_Wstrict_overflow, gmsgid);
 318 }
 319 \f
 320 /* Return true if the built-in mathematical function specified by CODE
 321    is odd, i.e. -f(x) == f(-x).  */
 322
 323 static bool
 324 negate_mathfn_p (enum built_in_function code)
 325 {
 326   switch (code)
 327     {
 328     CASE_FLT_FN (BUILT_IN_ASIN):
 329     CASE_FLT_FN (BUILT_IN_ASINH):
 330     CASE_FLT_FN (BUILT_IN_ATAN):
 331     CASE_FLT_FN (BUILT_IN_ATANH):
 332     CASE_FLT_FN (BUILT_IN_CASIN):
 333     CASE_FLT_FN (BUILT_IN_CASINH):
 334     CASE_FLT_FN (BUILT_IN_CATAN):
 335     CASE_FLT_FN (BUILT_IN_CATANH):
 336     CASE_FLT_FN (BUILT_IN_CBRT):
 337     CASE_FLT_FN (BUILT_IN_CPROJ):
 338     CASE_FLT_FN (BUILT_IN_CSIN):
 339     CASE_FLT_FN (BUILT_IN_CSINH):
 340     CASE_FLT_FN (BUILT_IN_CTAN):
 341     CASE_FLT_FN (BUILT_IN_CTANH):
 342     CASE_FLT_FN (BUILT_IN_ERF):
 343     CASE_FLT_FN (BUILT_IN_LLROUND):
 344     CASE_FLT_FN (BUILT_IN_LROUND):
 345     CASE_FLT_FN (BUILT_IN_ROUND):
 346     CASE_FLT_FN (BUILT_IN_SIN):
 347     CASE_FLT_FN (BUILT_IN_SINH):
 348     CASE_FLT_FN (BUILT_IN_TAN):
 349     CASE_FLT_FN (BUILT_IN_TANH):
 350     CASE_FLT_FN (BUILT_IN_TRUNC):
 351       return true;
 352
 353     CASE_FLT_FN (BUILT_IN_LLRINT):
 354     CASE_FLT_FN (BUILT_IN_LRINT):
 355     CASE_FLT_FN (BUILT_IN_NEARBYINT):
 356     CASE_FLT_FN (BUILT_IN_RINT):
 357       return !flag_rounding_math;
 358
 359     default:
 360       break;
 361     }
 362   return false;
 363 }
 364
 365 /* Check whether we may negate an integer constant T without causing
 366    overflow.  */
 367
 368 bool
 369 may_negate_without_overflow_p (const_tree t)
 370 {
 371   unsigned HOST_WIDE_INT val;
 372   unsigned int prec;
 373   tree type;
 374
 375   gcc_assert (TREE_CODE (t) == INTEGER_CST);
 376
 377   type = TREE_TYPE (t);
 378   if (TYPE_UNSIGNED (type))
 379     return false;
 380
 381   prec = TYPE_PRECISION (type);
 382   if (prec > HOST_BITS_PER_WIDE_INT)
 383     {
 384       if (TREE_INT_CST_LOW (t) != 0)
 385         return true;
 386       prec -= HOST_BITS_PER_WIDE_INT;
 387       val = TREE_INT_CST_HIGH (t);
 388     }
 389   else
 390     val = TREE_INT_CST_LOW (t);
 391   if (prec < HOST_BITS_PER_WIDE_INT)
 392     val &= ((unsigned HOST_WIDE_INT) 1 << prec) - 1;
 393   return val != ((unsigned HOST_WIDE_INT) 1 << (prec - 1));
 394 }
 395
 396 /* Determine whether an expression T can be cheaply negated using
 397    the function negate_expr without introducing undefined overflow.  */
 398
 399 static bool
 400 negate_expr_p (tree t)
 401 {
 402   tree type;
 403
 404   if (t == 0)
 405     return false;
 406
 407   type = TREE_TYPE (t);
 408
 409   STRIP_SIGN_NOPS (t);
 410   switch (TREE_CODE (t))
 411     {
 412     case INTEGER_CST:
 413       if (TYPE_OVERFLOW_WRAPS (type))
 414         return true;
 415
 416       /* Check that -CST will not overflow type.  */
 417       return may_negate_without_overflow_p (t);
 418     case BIT_NOT_EXPR:
 419       return (INTEGRAL_TYPE_P (type)
 420               && TYPE_OVERFLOW_WRAPS (type));
 421
 422     case FIXED_CST:
 423     case NEGATE_EXPR:
 424       return true;
 425
 426     case REAL_CST:
 427       /* We want to canonicalize to positive real constants.  Pretend
 428          that only negative ones can be easily negated.  */
 429       return REAL_VALUE_NEGATIVE (TREE_REAL_CST (t));
 430
 431     case COMPLEX_CST:
 432       return negate_expr_p (TREE_REALPART (t))
 433              && negate_expr_p (TREE_IMAGPART (t));
 434
 435     case COMPLEX_EXPR:
 436       return negate_expr_p (TREE_OPERAND (t, 0))
 437              && negate_expr_p (TREE_OPERAND (t, 1));
 438
 439     case CONJ_EXPR:
 440       return negate_expr_p (TREE_OPERAND (t, 0));
 441
 442     case PLUS_EXPR:
 443       if (HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (type))
 444           || HONOR_SIGNED_ZEROS (TYPE_MODE (type)))
 445         return false;
 446       /* -(A + B) -> (-B) - A.  */
 447       if (negate_expr_p (TREE_OPERAND (t, 1))
 448           && reorder_operands_p (TREE_OPERAND (t, 0),
 449                                  TREE_OPERAND (t, 1)))
 450         return true;
 451       /* -(A + B) -> (-A) - B.  */
 452       return negate_expr_p (TREE_OPERAND (t, 0));
 453
 454     case MINUS_EXPR:
 455       /* We can't turn -(A-B) into B-A when we honor signed zeros.  */
 456       return !HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (type))
 457              && !HONOR_SIGNED_ZEROS (TYPE_MODE (type))
 458              && reorder_operands_p (TREE_OPERAND (t, 0),
 459                                     TREE_OPERAND (t, 1));
 460
 461     case MULT_EXPR:
 462       if (TYPE_UNSIGNED (TREE_TYPE (t)))
 463         break;
 464
 465       /* Fall through.  */
 466
 467     case RDIV_EXPR:
 468       if (! HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (TREE_TYPE (t))))
 469         return negate_expr_p (TREE_OPERAND (t, 1))
 470                || negate_expr_p (TREE_OPERAND (t, 0));
 471       break;
 472
 473     case TRUNC_DIV_EXPR:
 474     case ROUND_DIV_EXPR:
 475     case FLOOR_DIV_EXPR:
 476     case CEIL_DIV_EXPR:
 477     case EXACT_DIV_EXPR:
 478       /* In general we can't negate A / B, because if A is INT_MIN and
 479          B is 1, we may turn this into INT_MIN / -1 which is undefined
 480          and actually traps on some architectures.  But if overflow is
 481          undefined, we can negate, because - (INT_MIN / 1) is an
 482          overflow.  */
 483       if (INTEGRAL_TYPE_P (TREE_TYPE (t))
 484           && !TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (t)))
 485         break;
 486       return negate_expr_p (TREE_OPERAND (t, 1))
 487              || negate_expr_p (TREE_OPERAND (t, 0));
 488
 489     case NOP_EXPR:
 490       /* Negate -((double)float) as (double)(-float).  */
 491       if (TREE_CODE (type) == REAL_TYPE)
 492         {
 493           tree tem = strip_float_extensions (t);
 494           if (tem != t)
 495             return negate_expr_p (tem);
 496         }
 497       break;
 498
 499     case CALL_EXPR:
 500       /* Negate -f(x) as f(-x).  */
 501       if (negate_mathfn_p (builtin_mathfn_code (t)))
 502         return negate_expr_p (CALL_EXPR_ARG (t, 0));
 503       break;
 504
 505     case RSHIFT_EXPR:
 506       /* Optimize -((int)x >> 31) into (unsigned)x >> 31.  */
 507       if (TREE_CODE (TREE_OPERAND (t, 1)) == INTEGER_CST)
 508         {
 509           tree op1 = TREE_OPERAND (t, 1);
 510           if (TREE_INT_CST_HIGH (op1) == 0
 511               && (unsigned HOST_WIDE_INT) (TYPE_PRECISION (type) - 1)
 512                  == TREE_INT_CST_LOW (op1))
 513             return true;
 514         }
 515       break;
 516
 517     default:
 518       break;
 519     }
 520   return false;
 521 }
 522
 523 /* Given T, an expression, return a folded tree for -T or NULL_TREE, if no
 524    simplification is possible.
 525    If negate_expr_p would return true for T, NULL_TREE will never be
 526    returned.  */
 527
 528 static tree
 529 fold_negate_expr (location_t loc, tree t)
 530 {
 531   tree type = TREE_TYPE (t);
 532   tree tem;
 533
 534   switch (TREE_CODE (t))
 535     {
 536     /* Convert - (~A) to A + 1.  */
 537     case BIT_NOT_EXPR:
 538       if (INTEGRAL_TYPE_P (type))
 539         return fold_build2_loc (loc, PLUS_EXPR, type, TREE_OPERAND (t, 0),
 540                             build_int_cst (type, 1));
 541       break;
 542
 543     case INTEGER_CST:
 544       tem = fold_negate_const (t, type);
 545       if (TREE_OVERFLOW (tem) == TREE_OVERFLOW (t)
 546           || !TYPE_OVERFLOW_TRAPS (type))
 547         return tem;
 548       break;
 549
 550     case REAL_CST:
 551       tem = fold_negate_const (t, type);
 552       /* Two's complement FP formats, such as c4x, may overflow.  */
 553       if (!TREE_OVERFLOW (tem) || !flag_trapping_math)
 554         return tem;
 555       break;
 556
 557     case FIXED_CST:
 558       tem = fold_negate_const (t, type);
 559       return tem;
 560
 561     case COMPLEX_CST:
 562       {
 563         tree rpart = negate_expr (TREE_REALPART (t));
 564         tree ipart = negate_expr (TREE_IMAGPART (t));
 565
 566         if ((TREE_CODE (rpart) == REAL_CST
 567              && TREE_CODE (ipart) == REAL_CST)
 568             || (TREE_CODE (rpart) == INTEGER_CST
 569                 && TREE_CODE (ipart) == INTEGER_CST))
 570           return build_complex (type, rpart, ipart);
 571       }
 572       break;
 573
 574     case COMPLEX_EXPR:
 575       if (negate_expr_p (t))
 576         return fold_build2_loc (loc, COMPLEX_EXPR, type,
 577                             fold_negate_expr (loc, TREE_OPERAND (t, 0)),
 578                             fold_negate_expr (loc, TREE_OPERAND (t, 1)));
 579       break;
 580
 581     case CONJ_EXPR:
 582       if (negate_expr_p (t))
 583         return fold_build1_loc (loc, CONJ_EXPR, type,
 584                             fold_negate_expr (loc, TREE_OPERAND (t, 0)));
 585       break;
 586
 587     case NEGATE_EXPR:
 588       return TREE_OPERAND (t, 0);
 589
 590     case PLUS_EXPR:
 591       if (!HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (type))
 592           && !HONOR_SIGNED_ZEROS (TYPE_MODE (type)))
 593         {
 594           /* -(A + B) -> (-B) - A.  */
 595           if (negate_expr_p (TREE_OPERAND (t, 1))
 596               && reorder_operands_p (TREE_OPERAND (t, 0),
 597                                      TREE_OPERAND (t, 1)))
 598             {
 599               tem = negate_expr (TREE_OPERAND (t, 1));
 600               return fold_build2_loc (loc, MINUS_EXPR, type,
 601                                   tem, TREE_OPERAND (t, 0));
 602             }
 603
 604           /* -(A + B) -> (-A) - B.  */
 605           if (negate_expr_p (TREE_OPERAND (t, 0)))
 606             {
 607               tem = negate_expr (TREE_OPERAND (t, 0));
 608               return fold_build2_loc (loc, MINUS_EXPR, type,
 609                                   tem, TREE_OPERAND (t, 1));
 610             }
 611         }
 612       break;
 613
 614     case MINUS_EXPR:
 615       /* - (A - B) -> B - A  */
 616       if (!HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (type))
 617           && !HONOR_SIGNED_ZEROS (TYPE_MODE (type))
 618           && reorder_operands_p (TREE_OPERAND (t, 0), TREE_OPERAND (t, 1)))
 619         return fold_build2_loc (loc, MINUS_EXPR, type,
 620                             TREE_OPERAND (t, 1), TREE_OPERAND (t, 0));
 621       break;
 622
 623     case MULT_EXPR:
 624       if (TYPE_UNSIGNED (type))
 625         break;
 626
 627       /* Fall through.  */
 628
 629     case RDIV_EXPR:
 630       if (! HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (type)))
 631         {
 632           tem = TREE_OPERAND (t, 1);
 633           if (negate_expr_p (tem))
 634             return fold_build2_loc (loc, TREE_CODE (t), type,
 635                                 TREE_OPERAND (t, 0), negate_expr (tem));
 636           tem = TREE_OPERAND (t, 0);
 637           if (negate_expr_p (tem))
 638             return fold_build2_loc (loc, TREE_CODE (t), type,
 639                                 negate_expr (tem), TREE_OPERAND (t, 1));
 640         }
 641       break;
 642
 643     case TRUNC_DIV_EXPR:
 644     case ROUND_DIV_EXPR:
 645     case FLOOR_DIV_EXPR:
 646     case CEIL_DIV_EXPR:
 647     case EXACT_DIV_EXPR:
 648       /* In general we can't negate A / B, because if A is INT_MIN and
 649          B is 1, we may turn this into INT_MIN / -1 which is undefined
 650          and actually traps on some architectures.  But if overflow is
 651          undefined, we can negate, because - (INT_MIN / 1) is an
 652          overflow.  */
 653       if (!INTEGRAL_TYPE_P (type) || TYPE_OVERFLOW_UNDEFINED (type))
 654         {
 655           const char * const warnmsg = G_("assuming signed overflow does not "
 656                                           "occur when negating a division");
 657           tem = TREE_OPERAND (t, 1);
 658           if (negate_expr_p (tem))
 659             {
 660               if (INTEGRAL_TYPE_P (type)
 661                   && (TREE_CODE (tem) != INTEGER_CST
 662                       || integer_onep (tem)))
 663                 fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_MISC);
 664               return fold_build2_loc (loc, TREE_CODE (t), type,
 665                                   TREE_OPERAND (t, 0), negate_expr (tem));
 666             }
 667           tem = TREE_OPERAND (t, 0);
 668           if (negate_expr_p (tem))
 669             {
 670               if (INTEGRAL_TYPE_P (type)
 671                   && (TREE_CODE (tem) != INTEGER_CST
 672                       || tree_int_cst_equal (tem, TYPE_MIN_VALUE (type))))
 673                 fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_MISC);
 674               return fold_build2_loc (loc, TREE_CODE (t), type,
 675                                   negate_expr (tem), TREE_OPERAND (t, 1));
 676             }
 677         }
 678       break;
 679
 680     case NOP_EXPR:
 681       /* Convert -((double)float) into (double)(-float).  */
 682       if (TREE_CODE (type) == REAL_TYPE)
 683         {
 684           tem = strip_float_extensions (t);
 685           if (tem != t && negate_expr_p (tem))
 686             return fold_convert_loc (loc, type, negate_expr (tem));
 687         }
 688       break;
 689
 690     case CALL_EXPR:
 691       /* Negate -f(x) as f(-x).  */
 692       if (negate_mathfn_p (builtin_mathfn_code (t))
 693           && negate_expr_p (CALL_EXPR_ARG (t, 0)))
 694         {
 695           tree fndecl, arg;
 696
 697           fndecl = get_callee_fndecl (t);
 698           arg = negate_expr (CALL_EXPR_ARG (t, 0));
 699           return build_call_expr_loc (loc, fndecl, 1, arg);
 700         }
 701       break;
 702
 703     case RSHIFT_EXPR:
 704       /* Optimize -((int)x >> 31) into (unsigned)x >> 31.  */
 705       if (TREE_CODE (TREE_OPERAND (t, 1)) == INTEGER_CST)
 706         {
 707           tree op1 = TREE_OPERAND (t, 1);
 708           if (TREE_INT_CST_HIGH (op1) == 0
 709               && (unsigned HOST_WIDE_INT) (TYPE_PRECISION (type) - 1)
 710                  == TREE_INT_CST_LOW (op1))
 711             {
 712               tree ntype = TYPE_UNSIGNED (type)
 713                            ? signed_type_for (type)
 714                            : unsigned_type_for (type);
 715               tree temp = fold_convert_loc (loc, ntype, TREE_OPERAND (t, 0));
 716               temp = fold_build2_loc (loc, RSHIFT_EXPR, ntype, temp, op1);
 717               return fold_convert_loc (loc, type, temp);
 718             }
 719         }
 720       break;
 721
 722     default:
 723       break;
 724     }
 725
 726   return NULL_TREE;
 727 }
 728
 729 /* Like fold_negate_expr, but return a NEGATE_EXPR tree, if T can not be
 730    negated in a simpler way.  Also allow for T to be NULL_TREE, in which case
 731    return NULL_TREE. */
 732
 733 static tree
 734 negate_expr (tree t)
 735 {
 736   tree type, tem;
 737   location_t loc;
 738
 739   if (t == NULL_TREE)
 740     return NULL_TREE;
 741
 742   loc = EXPR_LOCATION (t);
 743   type = TREE_TYPE (t);
 744   STRIP_SIGN_NOPS (t);
 745
 746   tem = fold_negate_expr (loc, t);
 747   if (!tem)
 748     tem = build1_loc (loc, NEGATE_EXPR, TREE_TYPE (t), t);
 749   return fold_convert_loc (loc, type, tem);
 750 }
 751 \f
 752 /* Split a tree IN into a constant, literal and variable parts that could be
 753    combined with CODE to make IN.  "constant" means an expression with
 754    TREE_CONSTANT but that isn't an actual constant.  CODE must be a
 755    commutative arithmetic operation.  Store the constant part into *CONP,
 756    the literal in *LITP and return the variable part.  If a part isn't
 757    present, set it to null.  If the tree does not decompose in this way,
 758    return the entire tree as the variable part and the other parts as null.
 759
 760    If CODE is PLUS_EXPR we also split trees that use MINUS_EXPR.  In that
 761    case, we negate an operand that was subtracted.  Except if it is a
 762    literal for which we use *MINUS_LITP instead.
 763
 764    If NEGATE_P is true, we are negating all of IN, again except a literal
 765    for which we use *MINUS_LITP instead.
 766
 767    If IN is itself a literal or constant, return it as appropriate.
 768
 769    Note that we do not guarantee that any of the three values will be the
 770    same type as IN, but they will have the same signedness and mode.  */
 771
 772 static tree
 773 split_tree (tree in, enum tree_code code, tree *conp, tree *litp,
 774             tree *minus_litp, int negate_p)
 775 {
 776   tree var = 0;
 777
 778   *conp = 0;
 779   *litp = 0;
 780   *minus_litp = 0;
 781
 782   /* Strip any conversions that don't change the machine mode or signedness.  */
 783   STRIP_SIGN_NOPS (in);
 784
 785   if (TREE_CODE (in) == INTEGER_CST || TREE_CODE (in) == REAL_CST
 786       || TREE_CODE (in) == FIXED_CST)
 787     *litp = in;
 788   else if (TREE_CODE (in) == code
 789            || ((! FLOAT_TYPE_P (TREE_TYPE (in)) || flag_associative_math)
 790                && ! SAT_FIXED_POINT_TYPE_P (TREE_TYPE (in))
 791                /* We can associate addition and subtraction together (even
 792                   though the C standard doesn't say so) for integers because
 793                   the value is not affected.  For reals, the value might be
 794                   affected, so we can't.  */
 795                && ((code == PLUS_EXPR && TREE_CODE (in) == MINUS_EXPR)
 796                    || (code == MINUS_EXPR && TREE_CODE (in) == PLUS_EXPR))))
 797     {
 798       tree op0 = TREE_OPERAND (in, 0);
 799       tree op1 = TREE_OPERAND (in, 1);
 800       int neg1_p = TREE_CODE (in) == MINUS_EXPR;
 801       int neg_litp_p = 0, neg_conp_p = 0, neg_var_p = 0;
 802
 803       /* First see if either of the operands is a literal, then a constant.  */
 804       if (TREE_CODE (op0) == INTEGER_CST || TREE_CODE (op0) == REAL_CST
 805           || TREE_CODE (op0) == FIXED_CST)
 806         *litp = op0, op0 = 0;
 807       else if (TREE_CODE (op1) == INTEGER_CST || TREE_CODE (op1) == REAL_CST
 808                || TREE_CODE (op1) == FIXED_CST)
 809         *litp = op1, neg_litp_p = neg1_p, op1 = 0;
 810
 811       if (op0 != 0 && TREE_CONSTANT (op0))
 812         *conp = op0, op0 = 0;
 813       else if (op1 != 0 && TREE_CONSTANT (op1))
 814         *conp = op1, neg_conp_p = neg1_p, op1 = 0;
 815
 816       /* If we haven't dealt with either operand, this is not a case we can
 817          decompose.  Otherwise, VAR is either of the ones remaining, if any.  */
 818       if (op0 != 0 && op1 != 0)
 819         var = in;
 820       else if (op0 != 0)
 821         var = op0;
 822       else
 823         var = op1, neg_var_p = neg1_p;
 824
 825       /* Now do any needed negations.  */
 826       if (neg_litp_p)
 827         *minus_litp = *litp, *litp = 0;
 828       if (neg_conp_p)
 829         *conp = negate_expr (*conp);
 830       if (neg_var_p)
 831         var = negate_expr (var);
 832     }
 833   else if (TREE_CONSTANT (in))
 834     *conp = in;
 835   else
 836     var = in;
 837
 838   if (negate_p)
 839     {
 840       if (*litp)
 841         *minus_litp = *litp, *litp = 0;
 842       else if (*minus_litp)
 843         *litp = *minus_litp, *minus_litp = 0;
 844       *conp = negate_expr (*conp);
 845       var = negate_expr (var);
 846     }
 847
 848   return var;
 849 }
 850
 851 /* Re-associate trees split by the above function.  T1 and T2 are
 852    either expressions to associate or null.  Return the new
 853    expression, if any.  LOC is the location of the new expression.  If
 854    we build an operation, do it in TYPE and with CODE.  */
 855
 856 static tree
 857 associate_trees (location_t loc, tree t1, tree t2, enum tree_code code, tree type)
 858 {
 859   if (t1 == 0)
 860     return t2;
 861   else if (t2 == 0)
 862     return t1;
 863
 864   /* If either input is CODE, a PLUS_EXPR, or a MINUS_EXPR, don't
 865      try to fold this since we will have infinite recursion.  But do
 866      deal with any NEGATE_EXPRs.  */
 867   if (TREE_CODE (t1) == code || TREE_CODE (t2) == code
 868       || TREE_CODE (t1) == MINUS_EXPR || TREE_CODE (t2) == MINUS_EXPR)
 869     {
 870       if (code == PLUS_EXPR)
 871         {
 872           if (TREE_CODE (t1) == NEGATE_EXPR)
 873             return build2_loc (loc, MINUS_EXPR, type,
 874                                fold_convert_loc (loc, type, t2),
 875                                fold_convert_loc (loc, type,
 876                                                  TREE_OPERAND (t1, 0)));
 877           else if (TREE_CODE (t2) == NEGATE_EXPR)
 878             return build2_loc (loc, MINUS_EXPR, type,
 879                                fold_convert_loc (loc, type, t1),
 880                                fold_convert_loc (loc, type,
 881                                                  TREE_OPERAND (t2, 0)));
 882           else if (integer_zerop (t2))
 883             return fold_convert_loc (loc, type, t1);
 884         }
 885       else if (code == MINUS_EXPR)
 886         {
 887           if (integer_zerop (t2))
 888             return fold_convert_loc (loc, type, t1);
 889         }
 890
 891       return build2_loc (loc, code, type, fold_convert_loc (loc, type, t1),
 892                          fold_convert_loc (loc, type, t2));
 893     }
 894
 895   return fold_build2_loc (loc, code, type, fold_convert_loc (loc, type, t1),
 896                           fold_convert_loc (loc, type, t2));
 897 }
 898 \f
 899 /* Check whether TYPE1 and TYPE2 are equivalent integer types, suitable
 900    for use in int_const_binop, size_binop and size_diffop.  */
 901
 902 static bool
 903 int_binop_types_match_p (enum tree_code code, const_tree type1, const_tree type2)
 904 {
 905   if (TREE_CODE (type1) != INTEGER_TYPE && !POINTER_TYPE_P (type1))
 906     return false;
 907   if (TREE_CODE (type2) != INTEGER_TYPE && !POINTER_TYPE_P (type2))
 908     return false;
 909
 910   switch (code)
 911     {
 912     case LSHIFT_EXPR:
 913     case RSHIFT_EXPR:
 914     case LROTATE_EXPR:
 915     case RROTATE_EXPR:
 916       return true;
 917
 918     default:
 919       break;
 920     }
 921
 922   return TYPE_UNSIGNED (type1) == TYPE_UNSIGNED (type2)
 923          && TYPE_PRECISION (type1) == TYPE_PRECISION (type2)
 924          && TYPE_MODE (type1) == TYPE_MODE (type2);
 925 }
 926
 927
 928 /* Combine two integer constants ARG1 and ARG2 under operation CODE
 929    to produce a new constant.  Return NULL_TREE if we don't know how
 930    to evaluate CODE at compile-time.
 931
 932    If NOTRUNC is nonzero, do not truncate the result to fit the data type.  */
 933
 934 tree
 935 int_const_binop (enum tree_code code, const_tree arg1, const_tree arg2, int notrunc)
 936 {
 937   double_int op1, op2, res, tmp;
 938   tree t;
 939   tree type = TREE_TYPE (arg1);
 940   bool uns = TYPE_UNSIGNED (type);
 941   bool is_sizetype
 942     = (TREE_CODE (type) == INTEGER_TYPE && TYPE_IS_SIZETYPE (type));
 943   bool overflow = false;
 944
 945   op1 = tree_to_double_int (arg1);
 946   op2 = tree_to_double_int (arg2);
 947
 948   switch (code)
 949     {
 950     case BIT_IOR_EXPR:
 951       res = double_int_ior (op1, op2);
 952       break;
 953
 954     case BIT_XOR_EXPR:
 955       res = double_int_xor (op1, op2);
 956       break;
 957
 958     case BIT_AND_EXPR:
 959       res = double_int_and (op1, op2);
 960       break;
 961
 962     case RSHIFT_EXPR:
 963       res = double_int_rshift (op1, double_int_to_shwi (op2),
 964                                TYPE_PRECISION (type), !uns);
 965       break;
 966
 967     case LSHIFT_EXPR:
 968       /* It's unclear from the C standard whether shifts can overflow.
 969          The following code ignores overflow; perhaps a C standard
 970          interpretation ruling is needed.  */
 971       res = double_int_lshift (op1, double_int_to_shwi (op2),
 972                                TYPE_PRECISION (type), !uns);
 973       break;
 974
 975     case RROTATE_EXPR:
 976       res = double_int_rrotate (op1, double_int_to_shwi (op2),
 977                                 TYPE_PRECISION (type));
 978       break;
 979
 980     case LROTATE_EXPR:
 981       res = double_int_lrotate (op1, double_int_to_shwi (op2),
 982                                 TYPE_PRECISION (type));
 983       break;
 984
 985     case PLUS_EXPR:
 986       overflow = add_double (op1.low, op1.high, op2.low, op2.high,
 987                              &res.low, &res.high);
 988       break;
 989
 990     case MINUS_EXPR:
 991       neg_double (op2.low, op2.high, &res.low, &res.high);
 992       add_double (op1.low, op1.high, res.low, res.high,
 993                   &res.low, &res.high);
 994       overflow = OVERFLOW_SUM_SIGN (res.high, op2.high, op1.high);
 995       break;
 996
 997     case MULT_EXPR:
 998       overflow = mul_double (op1.low, op1.high, op2.low, op2.high,
 999                              &res.low, &res.high);
1000       break;
1001
1002     case TRUNC_DIV_EXPR:
1003     case FLOOR_DIV_EXPR: case CEIL_DIV_EXPR:
1004     case EXACT_DIV_EXPR:
1005       /* This is a shortcut for a common special case.  */
1006       if (op2.high == 0 && (HOST_WIDE_INT) op2.low > 0
1007           && !TREE_OVERFLOW (arg1)
1008           && !TREE_OVERFLOW (arg2)
1009           && op1.high == 0 && (HOST_WIDE_INT) op1.low >= 0)
1010         {
1011           if (code == CEIL_DIV_EXPR)
1012             op1.low += op2.low - 1;
1013
1014           res.low = op1.low / op2.low, res.high = 0;
1015           break;
1016         }
1017
1018       /* ... fall through ...  */
1019
1020     case ROUND_DIV_EXPR:
1021       if (double_int_zero_p (op2))
1022         return NULL_TREE;
1023       if (double_int_one_p (op2))
1024         {
1025           res = op1;
1026           break;
1027         }
1028       if (double_int_equal_p (op1, op2)
1029           && ! double_int_zero_p (op1))
1030         {
1031           res = double_int_one;
1032           break;
1033         }
1034       overflow = div_and_round_double (code, uns,
1035                                        op1.low, op1.high, op2.low, op2.high,
1036                                        &res.low, &res.high,
1037                                        &tmp.low, &tmp.high);
1038       break;
1039
1040     case TRUNC_MOD_EXPR:
1041     case FLOOR_MOD_EXPR: case CEIL_MOD_EXPR:
1042       /* This is a shortcut for a common special case.  */
1043       if (op2.high == 0 && (HOST_WIDE_INT) op2.low > 0
1044           && !TREE_OVERFLOW (arg1)
1045           && !TREE_OVERFLOW (arg2)
1046           && op1.high == 0 && (HOST_WIDE_INT) op1.low >= 0)
1047         {
1048           if (code == CEIL_MOD_EXPR)
1049             op1.low += op2.low - 1;
1050           res.low = op1.low % op2.low, res.high = 0;
1051           break;
1052         }
1053
1054       /* ... fall through ...  */
1055
1056     case ROUND_MOD_EXPR:
1057       if (double_int_zero_p (op2))
1058         return NULL_TREE;
1059       overflow = div_and_round_double (code, uns,
1060                                        op1.low, op1.high, op2.low, op2.high,
1061                                        &tmp.low, &tmp.high,
1062                                        &res.low, &res.high);
1063       break;
1064
1065     case MIN_EXPR:
1066       res = double_int_min (op1, op2, uns);
1067       break;
1068
1069     case MAX_EXPR:
1070       res = double_int_max (op1, op2, uns);
1071       break;
1072
1073     default:
1074       return NULL_TREE;
1075     }
1076
1077   if (notrunc)
1078     {
1079       t = build_int_cst_wide (TREE_TYPE (arg1), res.low, res.high);
1080
1081       /* Propagate overflow flags ourselves.  */
1082       if (((!uns || is_sizetype) && overflow)
1083           | TREE_OVERFLOW (arg1) | TREE_OVERFLOW (arg2))
1084         {
1085           t = copy_node (t);
1086           TREE_OVERFLOW (t) = 1;
1087         }
1088     }
1089   else
1090     t = force_fit_type_double (TREE_TYPE (arg1), res, 1,
1091                                ((!uns || is_sizetype) && overflow)
1092                                | TREE_OVERFLOW (arg1) | TREE_OVERFLOW (arg2));
1093
1094   return t;
1095 }
1096
1097 /* Combine two constants ARG1 and ARG2 under operation CODE to produce a new
1098    constant.  We assume ARG1 and ARG2 have the same data type, or at least
1099    are the same kind of constant and the same machine mode.  Return zero if
1100    combining the constants is not allowed in the current operating mode.  */
1101
1102 static tree
1103 const_binop (enum tree_code code, tree arg1, tree arg2)
1104 {
1105   /* Sanity check for the recursive cases.  */
1106   if (!arg1 || !arg2)
1107     return NULL_TREE;
1108
1109   STRIP_NOPS (arg1);
1110   STRIP_NOPS (arg2);
1111
1112   if (TREE_CODE (arg1) == INTEGER_CST)
1113     return int_const_binop (code, arg1, arg2, 0);
1114
1115   if (TREE_CODE (arg1) == REAL_CST)
1116     {
1117       enum machine_mode mode;
1118       REAL_VALUE_TYPE d1;
1119       REAL_VALUE_TYPE d2;
1120       REAL_VALUE_TYPE value;
1121       REAL_VALUE_TYPE result;
1122       bool inexact;
1123       tree t, type;
1124
1125       /* The following codes are handled by real_arithmetic.  */
1126       switch (code)
1127         {
1128         case PLUS_EXPR:
1129         case MINUS_EXPR:
1130         case MULT_EXPR:
1131         case RDIV_EXPR:
1132         case MIN_EXPR:
1133         case MAX_EXPR:
1134           break;
1135
1136         default:
1137           return NULL_TREE;
1138         }
1139
1140       d1 = TREE_REAL_CST (arg1);
1141       d2 = TREE_REAL_CST (arg2);
1142
1143       type = TREE_TYPE (arg1);
1144       mode = TYPE_MODE (type);
1145
1146       /* Don't perform operation if we honor signaling NaNs and
1147          either operand is a NaN.  */
1148       if (HONOR_SNANS (mode)
1149           && (REAL_VALUE_ISNAN (d1) || REAL_VALUE_ISNAN (d2)))
1150         return NULL_TREE;
1151
1152       /* Don't perform operation if it would raise a division
1153          by zero exception.  */
1154       if (code == RDIV_EXPR
1155           && REAL_VALUES_EQUAL (d2, dconst0)
1156           && (flag_trapping_math || ! MODE_HAS_INFINITIES (mode)))
1157         return NULL_TREE;
1158
1159       /* If either operand is a NaN, just return it.  Otherwise, set up
1160          for floating-point trap; we return an overflow.  */
1161       if (REAL_VALUE_ISNAN (d1))
1162         return arg1;
1163       else if (REAL_VALUE_ISNAN (d2))
1164         return arg2;
1165
1166       inexact = real_arithmetic (&value, code, &d1, &d2);
1167       real_convert (&result, mode, &value);
1168
1169       /* Don't constant fold this floating point operation if
1170          the result has overflowed and flag_trapping_math.  */
1171       if (flag_trapping_math
1172           && MODE_HAS_INFINITIES (mode)
1173           && REAL_VALUE_ISINF (result)
1174           && !REAL_VALUE_ISINF (d1)
1175           && !REAL_VALUE_ISINF (d2))
1176         return NULL_TREE;
1177
1178       /* Don't constant fold this floating point operation if the
1179          result may dependent upon the run-time rounding mode and
1180          flag_rounding_math is set, or if GCC's software emulation
1181          is unable to accurately represent the result.  */
1182       if ((flag_rounding_math
1183            || (MODE_COMPOSITE_P (mode) && !flag_unsafe_math_optimizations))
1184           && (inexact || !real_identical (&result, &value)))
1185         return NULL_TREE;
1186
1187       t = build_real (type, result);
1188
1189       TREE_OVERFLOW (t) = TREE_OVERFLOW (arg1) | TREE_OVERFLOW (arg2);
1190       return t;
1191     }
1192
1193   if (TREE_CODE (arg1) == FIXED_CST)
1194     {
1195       FIXED_VALUE_TYPE f1;
1196       FIXED_VALUE_TYPE f2;
1197       FIXED_VALUE_TYPE result;
1198       tree t, type;
1199       int sat_p;
1200       bool overflow_p;
1201
1202       /* The following codes are handled by fixed_arithmetic.  */
1203       switch (code)
1204         {
1205         case PLUS_EXPR:
1206         case MINUS_EXPR:
1207         case MULT_EXPR:
1208         case TRUNC_DIV_EXPR:
1209           f2 = TREE_FIXED_CST (arg2);
1210           break;
1211
1212         case LSHIFT_EXPR:
1213         case RSHIFT_EXPR:
1214           f2.data.high = TREE_INT_CST_HIGH (arg2);
1215           f2.data.low = TREE_INT_CST_LOW (arg2);
1216           f2.mode = SImode;
1217           break;
1218
1219         default:
1220           return NULL_TREE;
1221         }
1222
1223       f1 = TREE_FIXED_CST (arg1);
1224       type = TREE_TYPE (arg1);
1225       sat_p = TYPE_SATURATING (type);
1226       overflow_p = fixed_arithmetic (&result, code, &f1, &f2, sat_p);
1227       t = build_fixed (type, result);
1228       /* Propagate overflow flags.  */
1229       if (overflow_p | TREE_OVERFLOW (arg1) | TREE_OVERFLOW (arg2))
1230         TREE_OVERFLOW (t) = 1;
1231       return t;
1232     }
1233
1234   if (TREE_CODE (arg1) == COMPLEX_CST)
1235     {
1236       tree type = TREE_TYPE (arg1);
1237       tree r1 = TREE_REALPART (arg1);
1238       tree i1 = TREE_IMAGPART (arg1);
1239       tree r2 = TREE_REALPART (arg2);
1240       tree i2 = TREE_IMAGPART (arg2);
1241       tree real, imag;
1242
1243       switch (code)
1244         {
1245         case PLUS_EXPR:
1246         case MINUS_EXPR:
1247           real = const_binop (code, r1, r2);
1248           imag = const_binop (code, i1, i2);
1249           break;
1250
1251         case MULT_EXPR:
1252           if (COMPLEX_FLOAT_TYPE_P (type))
1253             return do_mpc_arg2 (arg1, arg2, type,
1254                                 /* do_nonfinite= */ folding_initializer,
1255                                 mpc_mul);
1256
1257           real = const_binop (MINUS_EXPR,
1258                               const_binop (MULT_EXPR, r1, r2),
1259                               const_binop (MULT_EXPR, i1, i2));
1260           imag = const_binop (PLUS_EXPR,
1261                               const_binop (MULT_EXPR, r1, i2),
1262                               const_binop (MULT_EXPR, i1, r2));
1263           break;
1264
1265         case RDIV_EXPR:
1266           if (COMPLEX_FLOAT_TYPE_P (type))
1267             return do_mpc_arg2 (arg1, arg2, type,
1268                                 /* do_nonfinite= */ folding_initializer,
1269                                 mpc_div);
1270           /* Fallthru ... */
1271         case TRUNC_DIV_EXPR:
1272         case CEIL_DIV_EXPR:
1273         case FLOOR_DIV_EXPR:
1274         case ROUND_DIV_EXPR:
1275           if (flag_complex_method == 0)
1276           {
1277             /* Keep this algorithm in sync with
1278                tree-complex.c:expand_complex_div_straight().
1279
1280                Expand complex division to scalars, straightforward algorithm.
1281                a / b = ((ar*br + ai*bi)/t) + i((ai*br - ar*bi)/t)
1282                t = br*br + bi*bi
1283             */
1284             tree magsquared
1285               = const_binop (PLUS_EXPR,
1286                              const_binop (MULT_EXPR, r2, r2),
1287                              const_binop (MULT_EXPR, i2, i2));
1288             tree t1
1289               = const_binop (PLUS_EXPR,
1290                              const_binop (MULT_EXPR, r1, r2),
1291                              const_binop (MULT_EXPR, i1, i2));
1292             tree t2
1293               = const_binop (MINUS_EXPR,
1294                              const_binop (MULT_EXPR, i1, r2),
1295                              const_binop (MULT_EXPR, r1, i2));
1296
1297             real = const_binop (code, t1, magsquared);
1298             imag = const_binop (code, t2, magsquared);
1299           }
1300           else
1301           {
1302             /* Keep this algorithm in sync with
1303                tree-complex.c:expand_complex_div_wide().
1304
1305                Expand complex division to scalars, modified algorithm to minimize
1306                overflow with wide input ranges.  */
1307             tree compare = fold_build2 (LT_EXPR, boolean_type_node,
1308                                         fold_abs_const (r2, TREE_TYPE (type)),
1309                                         fold_abs_const (i2, TREE_TYPE (type)));
1310
1311             if (integer_nonzerop (compare))
1312               {
1313                 /* In the TRUE branch, we compute
1314                    ratio = br/bi;
1315                    div = (br * ratio) + bi;
1316                    tr = (ar * ratio) + ai;
1317                    ti = (ai * ratio) - ar;
1318                    tr = tr / div;
1319                    ti = ti / div;  */
1320                 tree ratio = const_binop (code, r2, i2);
1321                 tree div = const_binop (PLUS_EXPR, i2,
1322                                         const_binop (MULT_EXPR, r2, ratio));
1323                 real = const_binop (MULT_EXPR, r1, ratio);
1324                 real = const_binop (PLUS_EXPR, real, i1);
1325                 real = const_binop (code, real, div);
1326
1327                 imag = const_binop (MULT_EXPR, i1, ratio);
1328                 imag = const_binop (MINUS_EXPR, imag, r1);
1329                 imag = const_binop (code, imag, div);
1330               }
1331             else
1332               {
1333                 /* In the FALSE branch, we compute
1334                    ratio = d/c;
1335                    divisor = (d * ratio) + c;
1336                    tr = (b * ratio) + a;
1337                    ti = b - (a * ratio);
1338                    tr = tr / div;
1339                    ti = ti / div;  */
1340                 tree ratio = const_binop (code, i2, r2);
1341                 tree div = const_binop (PLUS_EXPR, r2,
1342                                         const_binop (MULT_EXPR, i2, ratio));
1343
1344                 real = const_binop (MULT_EXPR, i1, ratio);
1345                 real = const_binop (PLUS_EXPR, real, r1);
1346                 real = const_binop (code, real, div);
1347
1348                 imag = const_binop (MULT_EXPR, r1, ratio);
1349                 imag = const_binop (MINUS_EXPR, i1, imag);
1350                 imag = const_binop (code, imag, div);
1351               }
1352           }
1353           break;
1354
1355         default:
1356           return NULL_TREE;
1357         }
1358
1359       if (real && imag)
1360         return build_complex (type, real, imag);
1361     }
1362
1363   if (TREE_CODE (arg1) == VECTOR_CST)
1364     {
1365       tree type = TREE_TYPE(arg1);
1366       int count = TYPE_VECTOR_SUBPARTS (type), i;
1367       tree elements1, elements2, list = NULL_TREE;
1368
1369       if(TREE_CODE(arg2) != VECTOR_CST)
1370         return NULL_TREE;
1371
1372       elements1 = TREE_VECTOR_CST_ELTS (arg1);
1373       elements2 = TREE_VECTOR_CST_ELTS (arg2);
1374
1375       for (i = 0; i < count; i++)
1376         {
1377           tree elem1, elem2, elem;
1378
1379           /* The trailing elements can be empty and should be treated as 0 */
1380           if(!elements1)
1381             elem1 = fold_convert_const (NOP_EXPR, TREE_TYPE (type), integer_zero_node);
1382           else
1383             {
1384               elem1 = TREE_VALUE(elements1);
1385               elements1 = TREE_CHAIN (elements1);
1386             }
1387
1388           if(!elements2)
1389             elem2 = fold_convert_const (NOP_EXPR, TREE_TYPE (type), integer_zero_node);
1390           else
1391             {
1392               elem2 = TREE_VALUE(elements2);
1393               elements2 = TREE_CHAIN (elements2);
1394             }
1395
1396           elem = const_binop (code, elem1, elem2);
1397
1398           /* It is possible that const_binop cannot handle the given
1399             code and return NULL_TREE */
1400           if(elem == NULL_TREE)
1401             return NULL_TREE;
1402
1403           list = tree_cons (NULL_TREE, elem, list);
1404         }
1405       return build_vector(type, nreverse(list));
1406     }
1407   return NULL_TREE;
1408 }
1409
1410 /* Create a size type INT_CST node with NUMBER sign extended.  KIND
1411    indicates which particular sizetype to create.  */
1412
1413 tree
1414 size_int_kind (HOST_WIDE_INT number, enum size_type_kind kind)
1415 {
1416   return build_int_cst (sizetype_tab[(int) kind], number);
1417 }
1418 \f
1419 /* Combine operands OP1 and OP2 with arithmetic operation CODE.  CODE
1420    is a tree code.  The type of the result is taken from the operands.
1421    Both must be equivalent integer types, ala int_binop_types_match_p.
1422    If the operands are constant, so is the result.  */
1423
1424 tree
1425 size_binop_loc (location_t loc, enum tree_code code, tree arg0, tree arg1)
1426 {
1427   tree type = TREE_TYPE (arg0);
1428
1429   if (arg0 == error_mark_node || arg1 == error_mark_node)
1430     return error_mark_node;
1431
1432   gcc_assert (int_binop_types_match_p (code, TREE_TYPE (arg0),
1433                                        TREE_TYPE (arg1)));
1434
1435   /* Handle the special case of two integer constants faster.  */
1436   if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
1437     {
1438       /* And some specific cases even faster than that.  */
1439       if (code == PLUS_EXPR)
1440         {
1441           if (integer_zerop (arg0) && !TREE_OVERFLOW (arg0))
1442             return arg1;
1443           if (integer_zerop (arg1) && !TREE_OVERFLOW (arg1))
1444             return arg0;
1445         }
1446       else if (code == MINUS_EXPR)
1447         {
1448           if (integer_zerop (arg1) && !TREE_OVERFLOW (arg1))
1449             return arg0;
1450         }
1451       else if (code == MULT_EXPR)
1452         {
1453           if (integer_onep (arg0) && !TREE_OVERFLOW (arg0))
1454             return arg1;
1455         }
1456
1457       /* Handle general case of two integer constants.  */
1458       return int_const_binop (code, arg0, arg1, 0);
1459     }
1460
1461   return fold_build2_loc (loc, code, type, arg0, arg1);
1462 }
1463
1464 /* Given two values, either both of sizetype or both of bitsizetype,
1465    compute the difference between the two values.  Return the value
1466    in signed type corresponding to the type of the operands.  */
1467
1468 tree
1469 size_diffop_loc (location_t loc, tree arg0, tree arg1)
1470 {
1471   tree type = TREE_TYPE (arg0);
1472   tree ctype;
1473
1474   gcc_assert (int_binop_types_match_p (MINUS_EXPR, TREE_TYPE (arg0),
1475                                        TREE_TYPE (arg1)));
1476
1477   /* If the type is already signed, just do the simple thing.  */
1478   if (!TYPE_UNSIGNED (type))
1479     return size_binop_loc (loc, MINUS_EXPR, arg0, arg1);
1480
1481   if (type == sizetype)
1482     ctype = ssizetype;
1483   else if (type == bitsizetype)
1484     ctype = sbitsizetype;
1485   else
1486     ctype = signed_type_for (type);
1487
1488   /* If either operand is not a constant, do the conversions to the signed
1489      type and subtract.  The hardware will do the right thing with any
1490      overflow in the subtraction.  */
1491   if (TREE_CODE (arg0) != INTEGER_CST || TREE_CODE (arg1) != INTEGER_CST)
1492     return size_binop_loc (loc, MINUS_EXPR,
1493                            fold_convert_loc (loc, ctype, arg0),
1494                            fold_convert_loc (loc, ctype, arg1));
1495
1496   /* If ARG0 is larger than ARG1, subtract and return the result in CTYPE.
1497      Otherwise, subtract the other way, convert to CTYPE (we know that can't
1498      overflow) and negate (which can't either).  Special-case a result
1499      of zero while we're here.  */
1500   if (tree_int_cst_equal (arg0, arg1))
1501     return build_int_cst (ctype, 0);
1502   else if (tree_int_cst_lt (arg1, arg0))
1503     return fold_convert_loc (loc, ctype,
1504                              size_binop_loc (loc, MINUS_EXPR, arg0, arg1));
1505   else
1506     return size_binop_loc (loc, MINUS_EXPR, build_int_cst (ctype, 0),
1507                            fold_convert_loc (loc, ctype,
1508                                              size_binop_loc (loc,
1509                                                              MINUS_EXPR,
1510                                                              arg1, arg0)));
1511 }
1512 \f
1513 /* A subroutine of fold_convert_const handling conversions of an
1514    INTEGER_CST to another integer type.  */
1515
1516 static tree
1517 fold_convert_const_int_from_int (tree type, const_tree arg1)
1518 {
1519   tree t;
1520
1521   /* Given an integer constant, make new constant with new type,
1522      appropriately sign-extended or truncated.  */
1523   t = force_fit_type_double (type, tree_to_double_int (arg1),
1524                              !POINTER_TYPE_P (TREE_TYPE (arg1)),
1525                              (TREE_INT_CST_HIGH (arg1) < 0
1526                               && (TYPE_UNSIGNED (type)
1527                                   < TYPE_UNSIGNED (TREE_TYPE (arg1))))
1528                              | TREE_OVERFLOW (arg1));
1529
1530   return t;
1531 }
1532
1533 /* A subroutine of fold_convert_const handling conversions a REAL_CST
1534    to an integer type.  */
1535
1536 static tree
1537 fold_convert_const_int_from_real (enum tree_code code, tree type, const_tree arg1)
1538 {
1539   int overflow = 0;
1540   tree t;
1541
1542   /* The following code implements the floating point to integer
1543      conversion rules required by the Java Language Specification,
1544      that IEEE NaNs are mapped to zero and values that overflow
1545      the target precision saturate, i.e. values greater than
1546      INT_MAX are mapped to INT_MAX, and values less than INT_MIN
1547      are mapped to INT_MIN.  These semantics are allowed by the
1548      C and C++ standards that simply state that the behavior of
1549      FP-to-integer conversion is unspecified upon overflow.  */
1550
1551   double_int val;
1552   REAL_VALUE_TYPE r;
1553   REAL_VALUE_TYPE x = TREE_REAL_CST (arg1);
1554
1555   switch (code)
1556     {
1557     case FIX_TRUNC_EXPR:
1558       real_trunc (&r, VOIDmode, &x);
1559       break;
1560
1561     default:
1562       gcc_unreachable ();
1563     }
1564
1565   /* If R is NaN, return zero and show we have an overflow.  */
1566   if (REAL_VALUE_ISNAN (r))
1567     {
1568       overflow = 1;
1569       val = double_int_zero;
1570     }
1571
1572   /* See if R is less than the lower bound or greater than the
1573      upper bound.  */
1574
1575   if (! overflow)
1576     {
1577       tree lt = TYPE_MIN_VALUE (type);
1578       REAL_VALUE_TYPE l = real_value_from_int_cst (NULL_TREE, lt);
1579       if (REAL_VALUES_LESS (r, l))
1580         {
1581           overflow = 1;
1582           val = tree_to_double_int (lt);
1583         }
1584     }
1585
1586   if (! overflow)
1587     {
1588       tree ut = TYPE_MAX_VALUE (type);
1589       if (ut)
1590         {
1591           REAL_VALUE_TYPE u = real_value_from_int_cst (NULL_TREE, ut);
1592           if (REAL_VALUES_LESS (u, r))
1593             {
1594               overflow = 1;
1595               val = tree_to_double_int (ut);
1596             }
1597         }
1598     }
1599
1600   if (! overflow)
1601     real_to_integer2 ((HOST_WIDE_INT *) &val.low, &val.high, &r);
1602
1603   t = force_fit_type_double (type, val, -1, overflow | TREE_OVERFLOW (arg1));
1604   return t;
1605 }
1606
1607 /* A subroutine of fold_convert_const handling conversions of a
1608    FIXED_CST to an integer type.  */
1609
1610 static tree
1611 fold_convert_const_int_from_fixed (tree type, const_tree arg1)
1612 {
1613   tree t;
1614   double_int temp, temp_trunc;
1615   unsigned int mode;
1616
1617   /* Right shift FIXED_CST to temp by fbit.  */
1618   temp = TREE_FIXED_CST (arg1).data;
1619   mode = TREE_FIXED_CST (arg1).mode;
1620   if (GET_MODE_FBIT (mode) < 2 * HOST_BITS_PER_WIDE_INT)
1621     {
1622       temp = double_int_rshift (temp, GET_MODE_FBIT (mode),
1623                                 HOST_BITS_PER_DOUBLE_INT,
1624                                 SIGNED_FIXED_POINT_MODE_P (mode));
1625
1626       /* Left shift temp to temp_trunc by fbit.  */
1627       temp_trunc = double_int_lshift (temp, GET_MODE_FBIT (mode),
1628                                       HOST_BITS_PER_DOUBLE_INT,
1629                                       SIGNED_FIXED_POINT_MODE_P (mode));
1630     }
1631   else
1632     {
1633       temp = double_int_zero;
1634       temp_trunc = double_int_zero;
1635     }
1636
1637   /* If FIXED_CST is negative, we need to round the value toward 0.
1638      By checking if the fractional bits are not zero to add 1 to temp.  */
1639   if (SIGNED_FIXED_POINT_MODE_P (mode)
1640       && double_int_negative_p (temp_trunc)
1641       && !double_int_equal_p (TREE_FIXED_CST (arg1).data, temp_trunc))
1642     temp = double_int_add (temp, double_int_one);
1643
1644   /* Given a fixed-point constant, make new constant with new type,
1645      appropriately sign-extended or truncated.  */
1646   t = force_fit_type_double (type, temp, -1,
1647                              (double_int_negative_p (temp)
1648                               && (TYPE_UNSIGNED (type)
1649                                   < TYPE_UNSIGNED (TREE_TYPE (arg1))))
1650                              | TREE_OVERFLOW (arg1));
1651
1652   return t;
1653 }
1654
1655 /* A subroutine of fold_convert_const handling conversions a REAL_CST
1656    to another floating point type.  */
1657
1658 static tree
1659 fold_convert_const_real_from_real (tree type, const_tree arg1)
1660 {
1661   REAL_VALUE_TYPE value;
1662   tree t;
1663
1664   real_convert (&value, TYPE_MODE (type), &TREE_REAL_CST (arg1));
1665   t = build_real (type, value);
1666
1667   /* If converting an infinity or NAN to a representation that doesn't
1668      have one, set the overflow bit so that we can produce some kind of
1669      error message at the appropriate point if necessary.  It's not the
1670      most user-friendly message, but it's better than nothing.  */
1671   if (REAL_VALUE_ISINF (TREE_REAL_CST (arg1))
1672       && !MODE_HAS_INFINITIES (TYPE_MODE (type)))
1673     TREE_OVERFLOW (t) = 1;
1674   else if (REAL_VALUE_ISNAN (TREE_REAL_CST (arg1))
1675            && !MODE_HAS_NANS (TYPE_MODE (type)))
1676     TREE_OVERFLOW (t) = 1;
1677   /* Regular overflow, conversion produced an infinity in a mode that
1678      can't represent them.  */
1679   else if (!MODE_HAS_INFINITIES (TYPE_MODE (type))
1680            && REAL_VALUE_ISINF (value)
1681            && !REAL_VALUE_ISINF (TREE_REAL_CST (arg1)))
1682     TREE_OVERFLOW (t) = 1;
1683   else
1684     TREE_OVERFLOW (t) = TREE_OVERFLOW (arg1);
1685   return t;
1686 }
1687
1688 /* A subroutine of fold_convert_const handling conversions a FIXED_CST
1689    to a floating point type.  */
1690
1691 static tree
1692 fold_convert_const_real_from_fixed (tree type, const_tree arg1)
1693 {
1694   REAL_VALUE_TYPE value;
1695   tree t;
1696
1697   real_convert_from_fixed (&value, TYPE_MODE (type), &TREE_FIXED_CST (arg1));
1698   t = build_real (type, value);
1699
1700   TREE_OVERFLOW (t) = TREE_OVERFLOW (arg1);
1701   return t;
1702 }
1703
1704 /* A subroutine of fold_convert_const handling conversions a FIXED_CST
1705    to another fixed-point type.  */
1706
1707 static tree
1708 fold_convert_const_fixed_from_fixed (tree type, const_tree arg1)
1709 {
1710   FIXED_VALUE_TYPE value;
1711   tree t;
1712   bool overflow_p;
1713
1714   overflow_p = fixed_convert (&value, TYPE_MODE (type), &TREE_FIXED_CST (arg1),
1715                               TYPE_SATURATING (type));
1716   t = build_fixed (type, value);
1717
1718   /* Propagate overflow flags.  */
1719   if (overflow_p | TREE_OVERFLOW (arg1))
1720     TREE_OVERFLOW (t) = 1;
1721   return t;
1722 }
1723
1724 /* A subroutine of fold_convert_const handling conversions an INTEGER_CST
1725    to a fixed-point type.  */
1726
1727 static tree
1728 fold_convert_const_fixed_from_int (tree type, const_tree arg1)
1729 {
1730   FIXED_VALUE_TYPE value;
1731   tree t;
1732   bool overflow_p;
1733
1734   overflow_p = fixed_convert_from_int (&value, TYPE_MODE (type),
1735                                        TREE_INT_CST (arg1),
1736                                        TYPE_UNSIGNED (TREE_TYPE (arg1)),
1737                                        TYPE_SATURATING (type));
1738   t = build_fixed (type, value);
1739
1740   /* Propagate overflow flags.  */
1741   if (overflow_p | TREE_OVERFLOW (arg1))
1742     TREE_OVERFLOW (t) = 1;
1743   return t;
1744 }
1745
1746 /* A subroutine of fold_convert_const handling conversions a REAL_CST
1747    to a fixed-point type.  */
1748
1749 static tree
1750 fold_convert_const_fixed_from_real (tree type, const_tree arg1)
1751 {
1752   FIXED_VALUE_TYPE value;
1753   tree t;
1754   bool overflow_p;
1755
1756   overflow_p = fixed_convert_from_real (&value, TYPE_MODE (type),
1757                                         &TREE_REAL_CST (arg1),
1758                                         TYPE_SATURATING (type));
1759   t = build_fixed (type, value);
1760
1761   /* Propagate overflow flags.  */
1762   if (overflow_p | TREE_OVERFLOW (arg1))
1763     TREE_OVERFLOW (t) = 1;
1764   return t;
1765 }
1766
1767 /* Attempt to fold type conversion operation CODE of expression ARG1 to
1768    type TYPE.  If no simplification can be done return NULL_TREE.  */
1769
1770 static tree
1771 fold_convert_const (enum tree_code code, tree type, tree arg1)
1772 {
1773   if (TREE_TYPE (arg1) == type)
1774     return arg1;
1775
1776   if (POINTER_TYPE_P (type) || INTEGRAL_TYPE_P (type)
1777       || TREE_CODE (type) == OFFSET_TYPE)
1778     {
1779       if (TREE_CODE (arg1) == INTEGER_CST)
1780         return fold_convert_const_int_from_int (type, arg1);
1781       else if (TREE_CODE (arg1) == REAL_CST)
1782         return fold_convert_const_int_from_real (code, type, arg1);
1783       else if (TREE_CODE (arg1) == FIXED_CST)
1784         return fold_convert_const_int_from_fixed (type, arg1);
1785     }
1786   else if (TREE_CODE (type) == REAL_TYPE)
1787     {
1788       if (TREE_CODE (arg1) == INTEGER_CST)
1789         return build_real_from_int_cst (type, arg1);
1790       else if (TREE_CODE (arg1) == REAL_CST)
1791         return fold_convert_const_real_from_real (type, arg1);
1792       else if (TREE_CODE (arg1) == FIXED_CST)
1793         return fold_convert_const_real_from_fixed (type, arg1);
1794     }
1795   else if (TREE_CODE (type) == FIXED_POINT_TYPE)
1796     {
1797       if (TREE_CODE (arg1) == FIXED_CST)
1798         return fold_convert_const_fixed_from_fixed (type, arg1);
1799       else if (TREE_CODE (arg1) == INTEGER_CST)
1800         return fold_convert_const_fixed_from_int (type, arg1);
1801       else if (TREE_CODE (arg1) == REAL_CST)
1802         return fold_convert_const_fixed_from_real (type, arg1);
1803     }
1804   return NULL_TREE;
1805 }
1806
1807 /* Construct a vector of zero elements of vector type TYPE.  */
1808
1809 static tree
1810 build_zero_vector (tree type)
1811 {
1812   tree t;
1813
1814   t = fold_convert_const (NOP_EXPR, TREE_TYPE (type), integer_zero_node);
1815   return build_vector_from_val (type, t);
1816 }
1817
1818 /* Returns true, if ARG is convertible to TYPE using a NOP_EXPR.  */
1819
1820 bool
1821 fold_convertible_p (const_tree type, const_tree arg)
1822 {
1823   tree orig = TREE_TYPE (arg);
1824
1825   if (type == orig)
1826     return true;
1827
1828   if (TREE_CODE (arg) == ERROR_MARK
1829       || TREE_CODE (type) == ERROR_MARK
1830       || TREE_CODE (orig) == ERROR_MARK)
1831     return false;
1832
1833   if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (orig))
1834     return true;
1835
1836   switch (TREE_CODE (type))
1837     {
1838     case INTEGER_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE:
1839     case POINTER_TYPE: case REFERENCE_TYPE:
1840     case OFFSET_TYPE:
1841       if (INTEGRAL_TYPE_P (orig) || POINTER_TYPE_P (orig)
1842           || TREE_CODE (orig) == OFFSET_TYPE)
1843         return true;
1844       return (TREE_CODE (orig) == VECTOR_TYPE
1845               && tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (orig)));
1846
1847     case REAL_TYPE:
1848     case FIXED_POINT_TYPE:
1849     case COMPLEX_TYPE:
1850     case VECTOR_TYPE:
1851     case VOID_TYPE:
1852       return TREE_CODE (type) == TREE_CODE (orig);
1853
1854     default:
1855       return false;
1856     }
1857 }
1858
1859 /* Convert expression ARG to type TYPE.  Used by the middle-end for
1860    simple conversions in preference to calling the front-end's convert.  */
1861
1862 tree
1863 fold_convert_loc (location_t loc, tree type, tree arg)
1864 {
1865   tree orig = TREE_TYPE (arg);
1866   tree tem;
1867
1868   if (type == orig)
1869     return arg;
1870
1871   if (TREE_CODE (arg) == ERROR_MARK
1872       || TREE_CODE (type) == ERROR_MARK
1873       || TREE_CODE (orig) == ERROR_MARK)
1874     return error_mark_node;
1875
1876   if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (orig))
1877     return fold_build1_loc (loc, NOP_EXPR, type, arg);
1878
1879   switch (TREE_CODE (type))
1880     {
1881     case POINTER_TYPE:
1882     case REFERENCE_TYPE:
1883       /* Handle conversions between pointers to different address spaces.  */
1884       if (POINTER_TYPE_P (orig)
1885           && (TYPE_ADDR_SPACE (TREE_TYPE (type))
1886               != TYPE_ADDR_SPACE (TREE_TYPE (orig))))
1887         return fold_build1_loc (loc, ADDR_SPACE_CONVERT_EXPR, type, arg);
1888       /* fall through */
1889
1890     case INTEGER_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE:
1891     case OFFSET_TYPE:
1892       if (TREE_CODE (arg) == INTEGER_CST)
1893         {
1894           tem = fold_convert_const (NOP_EXPR, type, arg);
1895           if (tem != NULL_TREE)
1896             return tem;
1897         }
1898       if (INTEGRAL_TYPE_P (orig) || POINTER_TYPE_P (orig)
1899           || TREE_CODE (orig) == OFFSET_TYPE)
1900         return fold_build1_loc (loc, NOP_EXPR, type, arg);
1901       if (TREE_CODE (orig) == COMPLEX_TYPE)
1902         return fold_convert_loc (loc, type,
1903                              fold_build1_loc (loc, REALPART_EXPR,
1904                                           TREE_TYPE (orig), arg));
1905       gcc_assert (TREE_CODE (orig) == VECTOR_TYPE
1906                   && tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (orig)));
1907       return fold_build1_loc (loc, NOP_EXPR, type, arg);
1908
1909     case REAL_TYPE:
1910       if (TREE_CODE (arg) == INTEGER_CST)
1911         {
1912           tem = fold_convert_const (FLOAT_EXPR, type, arg);
1913           if (tem != NULL_TREE)
1914             return tem;
1915         }
1916       else if (TREE_CODE (arg) == REAL_CST)
1917         {
1918           tem = fold_convert_const (NOP_EXPR, type, arg);
1919           if (tem != NULL_TREE)
1920             return tem;
1921         }
1922       else if (TREE_CODE (arg) == FIXED_CST)
1923         {
1924           tem = fold_convert_const (FIXED_CONVERT_EXPR, type, arg);
1925           if (tem != NULL_TREE)
1926             return tem;
1927         }
1928
1929       switch (TREE_CODE (orig))
1930         {
1931         case INTEGER_TYPE:
1932         case BOOLEAN_TYPE: case ENUMERAL_TYPE:
1933         case POINTER_TYPE: case REFERENCE_TYPE:
1934           return fold_build1_loc (loc, FLOAT_EXPR, type, arg);
1935
1936         case REAL_TYPE:
1937           return fold_build1_loc (loc, NOP_EXPR, type, arg);
1938
1939         case FIXED_POINT_TYPE:
1940           return fold_build1_loc (loc, FIXED_CONVERT_EXPR, type, arg);
1941
1942         case COMPLEX_TYPE:
1943           tem = fold_build1_loc (loc, REALPART_EXPR, TREE_TYPE (orig), arg);
1944           return fold_convert_loc (loc, type, tem);
1945
1946         default:
1947           gcc_unreachable ();
1948         }
1949
1950     case FIXED_POINT_TYPE:
1951       if (TREE_CODE (arg) == FIXED_CST || TREE_CODE (arg) == INTEGER_CST
1952           || TREE_CODE (arg) == REAL_CST)
1953         {
1954           tem = fold_convert_const (FIXED_CONVERT_EXPR, type, arg);
1955           if (tem != NULL_TREE)
1956             goto fold_convert_exit;
1957         }
1958
1959       switch (TREE_CODE (orig))
1960         {
1961         case FIXED_POINT_TYPE:
1962         case INTEGER_TYPE:
1963         case ENUMERAL_TYPE:
1964         case BOOLEAN_TYPE:
1965         case REAL_TYPE:
1966           return fold_build1_loc (loc, FIXED_CONVERT_EXPR, type, arg);
1967
1968         case COMPLEX_TYPE:
1969           tem = fold_build1_loc (loc, REALPART_EXPR, TREE_TYPE (orig), arg);
1970           return fold_convert_loc (loc, type, tem);
1971
1972         default:
1973           gcc_unreachable ();
1974         }
1975
1976     case COMPLEX_TYPE:
1977       switch (TREE_CODE (orig))
1978         {
1979         case INTEGER_TYPE:
1980         case BOOLEAN_TYPE: case ENUMERAL_TYPE:
1981         case POINTER_TYPE: case REFERENCE_TYPE:
1982         case REAL_TYPE:
1983         case FIXED_POINT_TYPE:
1984           return fold_build2_loc (loc, COMPLEX_EXPR, type,
1985                               fold_convert_loc (loc, TREE_TYPE (type), arg),
1986                               fold_convert_loc (loc, TREE_TYPE (type),
1987                                             integer_zero_node));
1988         case COMPLEX_TYPE:
1989           {
1990             tree rpart, ipart;
1991
1992             if (TREE_CODE (arg) == COMPLEX_EXPR)
1993               {
1994                 rpart = fold_convert_loc (loc, TREE_TYPE (type),
1995                                       TREE_OPERAND (arg, 0));
1996                 ipart = fold_convert_loc (loc, TREE_TYPE (type),
1997                                       TREE_OPERAND (arg, 1));
1998                 return fold_build2_loc (loc, COMPLEX_EXPR, type, rpart, ipart);
1999               }
2000
2001             arg = save_expr (arg);
2002             rpart = fold_build1_loc (loc, REALPART_EXPR, TREE_TYPE (orig), arg);
2003             ipart = fold_build1_loc (loc, IMAGPART_EXPR, TREE_TYPE (orig), arg);
2004             rpart = fold_convert_loc (loc, TREE_TYPE (type), rpart);
2005             ipart = fold_convert_loc (loc, TREE_TYPE (type), ipart);
2006             return fold_build2_loc (loc, COMPLEX_EXPR, type, rpart, ipart);
2007           }
2008
2009         default:
2010           gcc_unreachable ();
2011         }
2012
2013     case VECTOR_TYPE:
2014       if (integer_zerop (arg))
2015         return build_zero_vector (type);
2016       gcc_assert (tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (orig)));
2017       gcc_assert (INTEGRAL_TYPE_P (orig) || POINTER_TYPE_P (orig)
2018                   || TREE_CODE (orig) == VECTOR_TYPE);
2019       return fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, arg);
2020
2021     case VOID_TYPE:
2022       tem = fold_ignored_result (arg);
2023       if (TREE_CODE (tem) == MODIFY_EXPR)
2024         goto fold_convert_exit;
2025       return fold_build1_loc (loc, NOP_EXPR, type, tem);
2026
2027     default:
2028       gcc_unreachable ();
2029     }
2030  fold_convert_exit:
2031   protected_set_expr_location_unshare (tem, loc);
2032   return tem;
2033 }
2034 \f
2035 /* Return false if expr can be assumed not to be an lvalue, true
2036    otherwise.  */
2037
2038 static bool
2039 maybe_lvalue_p (const_tree x)
2040 {
2041   /* We only need to wrap lvalue tree codes.  */
2042   switch (TREE_CODE (x))
2043   {
2044   case VAR_DECL:
2045   case PARM_DECL:
2046   case RESULT_DECL:
2047   case LABEL_DECL:
2048   case FUNCTION_DECL:
2049   case SSA_NAME:
2050
2051   case COMPONENT_REF:
2052   case MEM_REF:
2053   case INDIRECT_REF:
2054   case ARRAY_REF:
2055   case ARRAY_RANGE_REF:
2056   case BIT_FIELD_REF:
2057   case OBJ_TYPE_REF:
2058
2059   case REALPART_EXPR:
2060   case IMAGPART_EXPR:
2061   case PREINCREMENT_EXPR:
2062   case PREDECREMENT_EXPR:
2063   case SAVE_EXPR:
2064   case TRY_CATCH_EXPR:
2065   case WITH_CLEANUP_EXPR:
2066   case COMPOUND_EXPR:
2067   case MODIFY_EXPR:
2068   case TARGET_EXPR:
2069   case COND_EXPR:
2070   case BIND_EXPR:
2071     break;
2072
2073   default:
2074     /* Assume the worst for front-end tree codes.  */
2075     if ((int)TREE_CODE (x) >= NUM_TREE_CODES)
2076       break;
2077     return false;
2078   }
2079
2080   return true;
2081 }
2082
2083 /* Return an expr equal to X but certainly not valid as an lvalue.  */
2084
2085 tree
2086 non_lvalue_loc (location_t loc, tree x)
2087 {
2088   /* While we are in GIMPLE, NON_LVALUE_EXPR doesn't mean anything to
2089      us.  */
2090   if (in_gimple_form)
2091     return x;
2092
2093   if (! maybe_lvalue_p (x))
2094     return x;
2095   return build1_loc (loc, NON_LVALUE_EXPR, TREE_TYPE (x), x);
2096 }
2097
2098 /* Nonzero means lvalues are limited to those valid in pedantic ANSI C.
2099    Zero means allow extended lvalues.  */
2100
2101 int pedantic_lvalues;
2102
2103 /* When pedantic, return an expr equal to X but certainly not valid as a
2104    pedantic lvalue.  Otherwise, return X.  */
2105
2106 static tree
2107 pedantic_non_lvalue_loc (location_t loc, tree x)
2108 {
2109   if (pedantic_lvalues)
2110     return non_lvalue_loc (loc, x);
2111
2112   return protected_set_expr_location_unshare (x, loc);
2113 }
2114 \f
2115 /* Given a tree comparison code, return the code that is the logical inverse
2116    of the given code.  It is not safe to do this for floating-point
2117    comparisons, except for NE_EXPR and EQ_EXPR, so we receive a machine mode
2118    as well: if reversing the comparison is unsafe, return ERROR_MARK.  */
2119
2120 enum tree_code
2121 invert_tree_comparison (enum tree_code code, bool honor_nans)
2122 {
2123   if (honor_nans && flag_trapping_math)
2124     return ERROR_MARK;
2125
2126   switch (code)
2127     {
2128     case EQ_EXPR:
2129       return NE_EXPR;
2130     case NE_EXPR:
2131       return EQ_EXPR;
2132     case GT_EXPR:
2133       return honor_nans ? UNLE_EXPR : LE_EXPR;
2134     case GE_EXPR:
2135       return honor_nans ? UNLT_EXPR : LT_EXPR;
2136     case LT_EXPR:
2137       return honor_nans ? UNGE_EXPR : GE_EXPR;
2138     case LE_EXPR:
2139       return honor_nans ? UNGT_EXPR : GT_EXPR;
2140     case LTGT_EXPR:
2141       return UNEQ_EXPR;
2142     case UNEQ_EXPR:
2143       return LTGT_EXPR;
2144     case UNGT_EXPR:
2145       return LE_EXPR;
2146     case UNGE_EXPR:
2147       return LT_EXPR;
2148     case UNLT_EXPR:
2149       return GE_EXPR;
2150     case UNLE_EXPR:
2151       return GT_EXPR;
2152     case ORDERED_EXPR:
2153       return UNORDERED_EXPR;
2154     case UNORDERED_EXPR:
2155       return ORDERED_EXPR;
2156     default:
2157       gcc_unreachable ();
2158     }
2159 }
2160
2161 /* Similar, but return the comparison that results if the operands are
2162    swapped.  This is safe for floating-point.  */
2163
2164 enum tree_code
2165 swap_tree_comparison (enum tree_code code)
2166 {
2167   switch (code)
2168     {
2169     case EQ_EXPR:
2170     case NE_EXPR:
2171     case ORDERED_EXPR:
2172     case UNORDERED_EXPR:
2173     case LTGT_EXPR:
2174     case UNEQ_EXPR:
2175       return code;
2176     case GT_EXPR:
2177       return LT_EXPR;
2178     case GE_EXPR:
2179       return LE_EXPR;
2180     case LT_EXPR:
2181       return GT_EXPR;
2182     case LE_EXPR:
2183       return GE_EXPR;
2184     case UNGT_EXPR:
2185       return UNLT_EXPR;
2186     case UNGE_EXPR:
2187       return UNLE_EXPR;
2188     case UNLT_EXPR:
2189       return UNGT_EXPR;
2190     case UNLE_EXPR:
2191       return UNGE_EXPR;
2192     default:
2193       gcc_unreachable ();
2194     }
2195 }
2196
2197
2198 /* Convert a comparison tree code from an enum tree_code representation
2199    into a compcode bit-based encoding.  This function is the inverse of
2200    compcode_to_comparison.  */
2201
2202 static enum comparison_code
2203 comparison_to_compcode (enum tree_code code)
2204 {
2205   switch (code)
2206     {
2207     case LT_EXPR:
2208       return COMPCODE_LT;
2209     case EQ_EXPR:
2210       return COMPCODE_EQ;
2211     case LE_EXPR:
2212       return COMPCODE_LE;
2213     case GT_EXPR:
2214       return COMPCODE_GT;
2215     case NE_EXPR:
2216       return COMPCODE_NE;
2217     case GE_EXPR:
2218       return COMPCODE_GE;
2219     case ORDERED_EXPR:
2220       return COMPCODE_ORD;
2221     case UNORDERED_EXPR:
2222       return COMPCODE_UNORD;
2223     case UNLT_EXPR:
2224       return COMPCODE_UNLT;
2225     case UNEQ_EXPR:
2226       return COMPCODE_UNEQ;
2227     case UNLE_EXPR:
2228       return COMPCODE_UNLE;
2229     case UNGT_EXPR:
2230       return COMPCODE_UNGT;
2231     case LTGT_EXPR:
2232       return COMPCODE_LTGT;
2233     case UNGE_EXPR:
2234       return COMPCODE_UNGE;
2235     default:
2236       gcc_unreachable ();
2237     }
2238 }
2239
2240 /* Convert a compcode bit-based encoding of a comparison operator back
2241    to GCC's enum tree_code representation.  This function is the
2242    inverse of comparison_to_compcode.  */
2243
2244 static enum tree_code
2245 compcode_to_comparison (enum comparison_code code)
2246 {
2247   switch (code)
2248     {
2249     case COMPCODE_LT:
2250       return LT_EXPR;
2251     case COMPCODE_EQ:
2252       return EQ_EXPR;
2253     case COMPCODE_LE:
2254       return LE_EXPR;
2255     case COMPCODE_GT:
2256       return GT_EXPR;
2257     case COMPCODE_NE:
2258       return NE_EXPR;
2259     case COMPCODE_GE:
2260       return GE_EXPR;
2261     case COMPCODE_ORD:
2262       return ORDERED_EXPR;
2263     case COMPCODE_UNORD:
2264       return UNORDERED_EXPR;
2265     case COMPCODE_UNLT:
2266       return UNLT_EXPR;
2267     case COMPCODE_UNEQ:
2268       return UNEQ_EXPR;
2269     case COMPCODE_UNLE:
2270       return UNLE_EXPR;
2271     case COMPCODE_UNGT:
2272       return UNGT_EXPR;
2273     case COMPCODE_LTGT:
2274       return LTGT_EXPR;
2275     case COMPCODE_UNGE:
2276       return UNGE_EXPR;
2277     default:
2278       gcc_unreachable ();
2279     }
2280 }
2281
2282 /* Return a tree for the comparison which is the combination of
2283    doing the AND or OR (depending on CODE) of the two operations LCODE
2284    and RCODE on the identical operands LL_ARG and LR_ARG.  Take into account
2285    the possibility of trapping if the mode has NaNs, and return NULL_TREE
2286    if this makes the transformation invalid.  */
2287
2288 tree
2289 combine_comparisons (location_t loc,
2290                      enum tree_code code, enum tree_code lcode,
2291                      enum tree_code rcode, tree truth_type,
2292                      tree ll_arg, tree lr_arg)
2293 {
2294   bool honor_nans = HONOR_NANS (TYPE_MODE (TREE_TYPE (ll_arg)));
2295   enum comparison_code lcompcode = comparison_to_compcode (lcode);
2296   enum comparison_code rcompcode = comparison_to_compcode (rcode);
2297   int compcode;
2298
2299   switch (code)
2300     {
2301     case TRUTH_AND_EXPR: case TRUTH_ANDIF_EXPR:
2302       compcode = lcompcode & rcompcode;
2303       break;
2304
2305     case TRUTH_OR_EXPR: case TRUTH_ORIF_EXPR:
2306       compcode = lcompcode | rcompcode;
2307       break;
2308
2309     default:
2310       return NULL_TREE;
2311     }
2312
2313   if (!honor_nans)
2314     {
2315       /* Eliminate unordered comparisons, as well as LTGT and ORD
2316          which are not used unless the mode has NaNs.  */
2317       compcode &= ~COMPCODE_UNORD;
2318       if (compcode == COMPCODE_LTGT)
2319         compcode = COMPCODE_NE;
2320       else if (compcode == COMPCODE_ORD)
2321         compcode = COMPCODE_TRUE;
2322     }
2323    else if (flag_trapping_math)
2324      {
2325         /* Check that the original operation and the optimized ones will trap
2326            under the same condition.  */
2327         bool ltrap = (lcompcode & COMPCODE_UNORD) == 0
2328                      && (lcompcode != COMPCODE_EQ)
2329                      && (lcompcode != COMPCODE_ORD);
2330         bool rtrap = (rcompcode & COMPCODE_UNORD) == 0
2331                      && (rcompcode != COMPCODE_EQ)
2332                      && (rcompcode != COMPCODE_ORD);
2333         bool trap = (compcode & COMPCODE_UNORD) == 0
2334                     && (compcode != COMPCODE_EQ)
2335                     && (compcode != COMPCODE_ORD);
2336
2337         /* In a short-circuited boolean expression the LHS might be
2338            such that the RHS, if evaluated, will never trap.  For
2339            example, in ORD (x, y) && (x < y), we evaluate the RHS only
2340            if neither x nor y is NaN.  (This is a mixed blessing: for
2341            example, the expression above will never trap, hence
2342            optimizing it to x < y would be invalid).  */
2343         if ((code == TRUTH_ORIF_EXPR && (lcompcode & COMPCODE_UNORD))
2344             || (code == TRUTH_ANDIF_EXPR && !(lcompcode & COMPCODE_UNORD)))
2345           rtrap = false;
2346
2347         /* If the comparison was short-circuited, and only the RHS
2348            trapped, we may now generate a spurious trap.  */
2349         if (rtrap && !ltrap
2350             && (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR))
2351           return NULL_TREE;
2352
2353         /* If we changed the conditions that cause a trap, we lose.  */
2354         if ((ltrap || rtrap) != trap)
2355           return NULL_TREE;
2356       }
2357
2358   if (compcode == COMPCODE_TRUE)
2359     return constant_boolean_node (true, truth_type);
2360   else if (compcode == COMPCODE_FALSE)
2361     return constant_boolean_node (false, truth_type);
2362   else
2363     {
2364       enum tree_code tcode;
2365
2366       tcode = compcode_to_comparison ((enum comparison_code) compcode);
2367       return fold_build2_loc (loc, tcode, truth_type, ll_arg, lr_arg);
2368     }
2369 }
2370 \f
2371 /* Return nonzero if two operands (typically of the same tree node)
2372    are necessarily equal.  If either argument has side-effects this
2373    function returns zero.  FLAGS modifies behavior as follows:
2374
2375    If OEP_ONLY_CONST is set, only return nonzero for constants.
2376    This function tests whether the operands are indistinguishable;
2377    it does not test whether they are equal using C's == operation.
2378    The distinction is important for IEEE floating point, because
2379    (1) -0.0 and 0.0 are distinguishable, but -0.0==0.0, and
2380    (2) two NaNs may be indistinguishable, but NaN!=NaN.
2381
2382    If OEP_ONLY_CONST is unset, a VAR_DECL is considered equal to itself
2383    even though it may hold multiple values during a function.
2384    This is because a GCC tree node guarantees that nothing else is
2385    executed between the evaluation of its "operands" (which may often
2386    be evaluated in arbitrary order).  Hence if the operands themselves
2387    don't side-effect, the VAR_DECLs, PARM_DECLs etc... must hold the
2388    same value in each operand/subexpression.  Hence leaving OEP_ONLY_CONST
2389    unset means assuming isochronic (or instantaneous) tree equivalence.
2390    Unless comparing arbitrary expression trees, such as from different
2391    statements, this flag can usually be left unset.
2392
2393    If OEP_PURE_SAME is set, then pure functions with identical arguments
2394    are considered the same.  It is used when the caller has other ways
2395    to ensure that global memory is unchanged in between.  */
2396
2397 int
2398 operand_equal_p (const_tree arg0, const_tree arg1, unsigned int flags)
2399 {
2400   /* If either is ERROR_MARK, they aren't equal.  */
2401   if (TREE_CODE (arg0) == ERROR_MARK || TREE_CODE (arg1) == ERROR_MARK
2402       || TREE_TYPE (arg0) == error_mark_node
2403       || TREE_TYPE (arg1) == error_mark_node)
2404     return 0;
2405
2406   /* Similar, if either does not have a type (like a released SSA name),
2407      they aren't equal.  */
2408   if (!TREE_TYPE (arg0) || !TREE_TYPE (arg1))
2409     return 0;
2410
2411   /* Check equality of integer constants before bailing out due to
2412      precision differences.  */
2413   if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
2414     return tree_int_cst_equal (arg0, arg1);
2415
2416   /* If both types don't have the same signedness, then we can't consider
2417      them equal.  We must check this before the STRIP_NOPS calls
2418      because they may change the signedness of the arguments.  As pointers
2419      strictly don't have a signedness, require either two pointers or
2420      two non-pointers as well.  */
2421   if (TYPE_UNSIGNED (TREE_TYPE (arg0)) != TYPE_UNSIGNED (TREE_TYPE (arg1))
2422       || POINTER_TYPE_P (TREE_TYPE (arg0)) != POINTER_TYPE_P (TREE_TYPE (arg1)))
2423     return 0;
2424
2425   /* We cannot consider pointers to different address space equal.  */
2426   if (POINTER_TYPE_P (TREE_TYPE (arg0)) && POINTER_TYPE_P (TREE_TYPE (arg1))
2427       && (TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (arg0)))
2428           != TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (arg1)))))
2429     return 0;
2430
2431   /* If both types don't have the same precision, then it is not safe
2432      to strip NOPs.  */
2433   if (TYPE_PRECISION (TREE_TYPE (arg0)) != TYPE_PRECISION (TREE_TYPE (arg1)))
2434     return 0;
2435
2436   STRIP_NOPS (arg0);
2437   STRIP_NOPS (arg1);
2438
2439   /* In case both args are comparisons but with different comparison
2440      code, try to swap the comparison operands of one arg to produce
2441      a match and compare that variant.  */
2442   if (TREE_CODE (arg0) != TREE_CODE (arg1)
2443       && COMPARISON_CLASS_P (arg0)
2444       && COMPARISON_CLASS_P (arg1))
2445     {
2446       enum tree_code swap_code = swap_tree_comparison (TREE_CODE (arg1));
2447
2448       if (TREE_CODE (arg0) == swap_code)
2449         return operand_equal_p (TREE_OPERAND (arg0, 0),
2450                                 TREE_OPERAND (arg1, 1), flags)
2451                && operand_equal_p (TREE_OPERAND (arg0, 1),
2452                                    TREE_OPERAND (arg1, 0), flags);
2453     }
2454
2455   if (TREE_CODE (arg0) != TREE_CODE (arg1)
2456       /* This is needed for conversions and for COMPONENT_REF.
2457          Might as well play it safe and always test this.  */
2458       || TREE_CODE (TREE_TYPE (arg0)) == ERROR_MARK
2459       || TREE_CODE (TREE_TYPE (arg1)) == ERROR_MARK
2460       || TYPE_MODE (TREE_TYPE (arg0)) != TYPE_MODE (TREE_TYPE (arg1)))
2461     return 0;
2462
2463   /* If ARG0 and ARG1 are the same SAVE_EXPR, they are necessarily equal.
2464      We don't care about side effects in that case because the SAVE_EXPR
2465      takes care of that for us. In all other cases, two expressions are
2466      equal if they have no side effects.  If we have two identical
2467      expressions with side effects that should be treated the same due
2468      to the only side effects being identical SAVE_EXPR's, that will
2469      be detected in the recursive calls below.  */
2470   if (arg0 == arg1 && ! (flags & OEP_ONLY_CONST)
2471       && (TREE_CODE (arg0) == SAVE_EXPR
2472           || (! TREE_SIDE_EFFECTS (arg0) && ! TREE_SIDE_EFFECTS (arg1))))
2473     return 1;
2474
2475   /* Next handle constant cases, those for which we can return 1 even
2476      if ONLY_CONST is set.  */
2477   if (TREE_CONSTANT (arg0) && TREE_CONSTANT (arg1))
2478     switch (TREE_CODE (arg0))
2479       {
2480       case INTEGER_CST:
2481         return tree_int_cst_equal (arg0, arg1);
2482
2483       case FIXED_CST:
2484         return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (arg0),
2485                                        TREE_FIXED_CST (arg1));
2486
2487       case REAL_CST:
2488         if (REAL_VALUES_IDENTICAL (TREE_REAL_CST (arg0),
2489                                    TREE_REAL_CST (arg1)))
2490           return 1;
2491
2492
2493         if (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0))))
2494           {
2495             /* If we do not distinguish between signed and unsigned zero,
2496                consider them equal.  */
2497             if (real_zerop (arg0) && real_zerop (arg1))
2498               return 1;
2499           }
2500         return 0;
2501
2502       case VECTOR_CST:
2503         {
2504           tree v1, v2;
2505
2506           v1 = TREE_VECTOR_CST_ELTS (arg0);
2507           v2 = TREE_VECTOR_CST_ELTS (arg1);
2508           while (v1 && v2)
2509             {
2510               if (!operand_equal_p (TREE_VALUE (v1), TREE_VALUE (v2),
2511                                     flags))
2512                 return 0;
2513               v1 = TREE_CHAIN (v1);
2514               v2 = TREE_CHAIN (v2);
2515             }
2516
2517           return v1 == v2;
2518         }
2519
2520       case COMPLEX_CST:
2521         return (operand_equal_p (TREE_REALPART (arg0), TREE_REALPART (arg1),
2522                                  flags)
2523                 && operand_equal_p (TREE_IMAGPART (arg0), TREE_IMAGPART (arg1),
2524                                     flags));
2525
2526       case STRING_CST:
2527         return (TREE_STRING_LENGTH (arg0) == TREE_STRING_LENGTH (arg1)
2528                 && ! memcmp (TREE_STRING_POINTER (arg0),
2529                               TREE_STRING_POINTER (arg1),
2530                               TREE_STRING_LENGTH (arg0)));
2531
2532       case ADDR_EXPR:
2533         return operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1, 0),
2534                                 0);
2535       default:
2536         break;
2537       }
2538
2539   if (flags & OEP_ONLY_CONST)
2540     return 0;
2541
2542 /* Define macros to test an operand from arg0 and arg1 for equality and a
2543    variant that allows null and views null as being different from any
2544    non-null value.  In the latter case, if either is null, the both
2545    must be; otherwise, do the normal comparison.  */
2546 #define OP_SAME(N) operand_equal_p (TREE_OPERAND (arg0, N),     \
2547                                     TREE_OPERAND (arg1, N), flags)
2548
2549 #define OP_SAME_WITH_NULL(N)                            \
2550   ((!TREE_OPERAND (arg0, N) || !TREE_OPERAND (arg1, N)) \
2551    ? TREE_OPERAND (arg0, N) == TREE_OPERAND (arg1, N) : OP_SAME (N))
2552
2553   switch (TREE_CODE_CLASS (TREE_CODE (arg0)))
2554     {
2555     case tcc_unary:
2556       /* Two conversions are equal only if signedness and modes match.  */
2557       switch (TREE_CODE (arg0))
2558         {
2559         CASE_CONVERT:
2560         case FIX_TRUNC_EXPR:
2561           if (TYPE_UNSIGNED (TREE_TYPE (arg0))
2562               != TYPE_UNSIGNED (TREE_TYPE (arg1)))
2563             return 0;
2564           break;
2565         default:
2566           break;
2567         }
2568
2569       return OP_SAME (0);
2570
2571
2572     case tcc_comparison:
2573     case tcc_binary:
2574       if (OP_SAME (0) && OP_SAME (1))
2575         return 1;
2576
2577       /* For commutative ops, allow the other order.  */
2578       return (commutative_tree_code (TREE_CODE (arg0))
2579               && operand_equal_p (TREE_OPERAND (arg0, 0),
2580                                   TREE_OPERAND (arg1, 1), flags)
2581               && operand_equal_p (TREE_OPERAND (arg0, 1),
2582                                   TREE_OPERAND (arg1, 0), flags));
2583
2584     case tcc_reference:
2585       /* If either of the pointer (or reference) expressions we are
2586          dereferencing contain a side effect, these cannot be equal.  */
2587       if (TREE_SIDE_EFFECTS (arg0)
2588           || TREE_SIDE_EFFECTS (arg1))
2589         return 0;
2590
2591       switch (TREE_CODE (arg0))
2592         {
2593         case INDIRECT_REF:
2594         case REALPART_EXPR:
2595         case IMAGPART_EXPR:
2596           return OP_SAME (0);
2597
2598         case MEM_REF:
2599           /* Require equal access sizes, and similar pointer types.
2600              We can have incomplete types for array references of
2601              variable-sized arrays from the Fortran frontent
2602              though.  */
2603           return ((TYPE_SIZE (TREE_TYPE (arg0)) == TYPE_SIZE (TREE_TYPE (arg1))
2604                    || (TYPE_SIZE (TREE_TYPE (arg0))
2605                        && TYPE_SIZE (TREE_TYPE (arg1))
2606                        && operand_equal_p (TYPE_SIZE (TREE_TYPE (arg0)),
2607                                            TYPE_SIZE (TREE_TYPE (arg1)), flags)))
2608                   && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (arg0, 1)))
2609                       == TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (arg1, 1))))
2610                   && OP_SAME (0) && OP_SAME (1));
2611
2612         case ARRAY_REF:
2613         case ARRAY_RANGE_REF:
2614           /* Operands 2 and 3 may be null.
2615              Compare the array index by value if it is constant first as we
2616              may have different types but same value here.  */
2617           return (OP_SAME (0)
2618                   && (tree_int_cst_equal (TREE_OPERAND (arg0, 1),
2619                                           TREE_OPERAND (arg1, 1))
2620                       || OP_SAME (1))
2621                   && OP_SAME_WITH_NULL (2)
2622                   && OP_SAME_WITH_NULL (3));
2623
2624         case COMPONENT_REF:
2625           /* Handle operand 2 the same as for ARRAY_REF.  Operand 0
2626              may be NULL when we're called to compare MEM_EXPRs.  */
2627           return OP_SAME_WITH_NULL (0)
2628                  && OP_SAME (1)
2629                  && OP_SAME_WITH_NULL (2);
2630
2631         case BIT_FIELD_REF:
2632           return OP_SAME (0) && OP_SAME (1) && OP_SAME (2);
2633
2634         default:
2635           return 0;
2636         }
2637
2638     case tcc_expression:
2639       switch (TREE_CODE (arg0))
2640         {
2641         case ADDR_EXPR:
2642         case TRUTH_NOT_EXPR:
2643           return OP_SAME (0);
2644
2645         case TRUTH_ANDIF_EXPR:
2646         case TRUTH_ORIF_EXPR:
2647           return OP_SAME (0) && OP_SAME (1);
2648
2649         case FMA_EXPR:
2650         case WIDEN_MULT_PLUS_EXPR:
2651         case WIDEN_MULT_MINUS_EXPR:
2652           if (!OP_SAME (2))
2653             return 0;
2654           /* The multiplcation operands are commutative.  */
2655           /* FALLTHRU */
2656
2657         case TRUTH_AND_EXPR:
2658         case TRUTH_OR_EXPR:
2659         case TRUTH_XOR_EXPR:
2660           if (OP_SAME (0) && OP_SAME (1))
2661             return 1;
2662
2663           /* Otherwise take into account this is a commutative operation.  */
2664           return (operand_equal_p (TREE_OPERAND (arg0, 0),
2665                                    TREE_OPERAND (arg1, 1), flags)
2666                   && operand_equal_p (TREE_OPERAND (arg0, 1),
2667                                       TREE_OPERAND (arg1, 0), flags));
2668
2669         case COND_EXPR:
2670         case VEC_COND_EXPR:
2671         case DOT_PROD_EXPR:
2672           return OP_SAME (0) && OP_SAME (1) && OP_SAME (2);
2673
2674         default:
2675           return 0;
2676         }
2677
2678     case tcc_vl_exp:
2679       switch (TREE_CODE (arg0))
2680         {
2681         case CALL_EXPR:
2682           /* If the CALL_EXPRs call different functions, then they
2683              clearly can not be equal.  */
2684           if (! operand_equal_p (CALL_EXPR_FN (arg0), CALL_EXPR_FN (arg1),
2685                                  flags))
2686             return 0;
2687
2688           {
2689             unsigned int cef = call_expr_flags (arg0);
2690             if (flags & OEP_PURE_SAME)
2691               cef &= ECF_CONST | ECF_PURE;
2692             else
2693               cef &= ECF_CONST;
2694             if (!cef)
2695               return 0;
2696           }
2697
2698           /* Now see if all the arguments are the same.  */
2699           {
2700             const_call_expr_arg_iterator iter0, iter1;
2701             const_tree a0, a1;
2702             for (a0 = first_const_call_expr_arg (arg0, &iter0),
2703                    a1 = first_const_call_expr_arg (arg1, &iter1);
2704                  a0 && a1;
2705                  a0 = next_const_call_expr_arg (&iter0),
2706                    a1 = next_const_call_expr_arg (&iter1))
2707               if (! operand_equal_p (a0, a1, flags))
2708                 return 0;
2709
2710             /* If we get here and both argument lists are exhausted
2711                then the CALL_EXPRs are equal.  */
2712             return ! (a0 || a1);
2713           }
2714         default:
2715           return 0;
2716         }
2717
2718     case tcc_declaration:
2719       /* Consider __builtin_sqrt equal to sqrt.  */
2720       return (TREE_CODE (arg0) == FUNCTION_DECL
2721               && DECL_BUILT_IN (arg0) && DECL_BUILT_IN (arg1)
2722               && DECL_BUILT_IN_CLASS (arg0) == DECL_BUILT_IN_CLASS (arg1)
2723               && DECL_FUNCTION_CODE (arg0) == DECL_FUNCTION_CODE (arg1));
2724
2725     default:
2726       return 0;
2727     }
2728
2729 #undef OP_SAME
2730 #undef OP_SAME_WITH_NULL
2731 }
2732 \f
2733 /* Similar to operand_equal_p, but see if ARG0 might have been made by
2734    shorten_compare from ARG1 when ARG1 was being compared with OTHER.
2735
2736    When in doubt, return 0.  */
2737
2738 static int
2739 operand_equal_for_comparison_p (tree arg0, tree arg1, tree other)
2740 {
2741   int unsignedp1, unsignedpo;
2742   tree primarg0, primarg1, primother;
2743   unsigned int correct_width;
2744
2745   if (operand_equal_p (arg0, arg1, 0))
2746     return 1;
2747
2748   if (! INTEGRAL_TYPE_P (TREE_TYPE (arg0))
2749       || ! INTEGRAL_TYPE_P (TREE_TYPE (arg1)))
2750     return 0;
2751
2752   /* Discard any conversions that don't change the modes of ARG0 and ARG1
2753      and see if the inner values are the same.  This removes any
2754      signedness comparison, which doesn't matter here.  */
2755   primarg0 = arg0, primarg1 = arg1;
2756   STRIP_NOPS (primarg0);
2757   STRIP_NOPS (primarg1);
2758   if (operand_equal_p (primarg0, primarg1, 0))
2759     return 1;
2760
2761   /* Duplicate what shorten_compare does to ARG1 and see if that gives the
2762      actual comparison operand, ARG0.
2763
2764      First throw away any conversions to wider types
2765      already present in the operands.  */
2766
2767   primarg1 = get_narrower (arg1, &unsignedp1);
2768   primother = get_narrower (other, &unsignedpo);
2769
2770   correct_width = TYPE_PRECISION (TREE_TYPE (arg1));
2771   if (unsignedp1 == unsignedpo
2772       && TYPE_PRECISION (TREE_TYPE (primarg1)) < correct_width
2773       && TYPE_PRECISION (TREE_TYPE (primother)) < correct_width)
2774     {
2775       tree type = TREE_TYPE (arg0);
2776
2777       /* Make sure shorter operand is extended the right way
2778          to match the longer operand.  */
2779       primarg1 = fold_convert (signed_or_unsigned_type_for
2780                                (unsignedp1, TREE_TYPE (primarg1)), primarg1);
2781
2782       if (operand_equal_p (arg0, fold_convert (type, primarg1), 0))
2783         return 1;
2784     }
2785
2786   return 0;
2787 }
2788 \f
2789 /* See if ARG is an expression that is either a comparison or is performing
2790    arithmetic on comparisons.  The comparisons must only be comparing
2791    two different values, which will be stored in *CVAL1 and *CVAL2; if
2792    they are nonzero it means that some operands have already been found.
2793    No variables may be used anywhere else in the expression except in the
2794    comparisons.  If SAVE_P is true it means we removed a SAVE_EXPR around
2795    the expression and save_expr needs to be called with CVAL1 and CVAL2.
2796
2797    If this is true, return 1.  Otherwise, return zero.  */
2798
2799 static int
2800 twoval_comparison_p (tree arg, tree *cval1, tree *cval2, int *save_p)
2801 {
2802   enum tree_code code = TREE_CODE (arg);
2803   enum tree_code_class tclass = TREE_CODE_CLASS (code);
2804
2805   /* We can handle some of the tcc_expression cases here.  */
2806   if (tclass == tcc_expression && code == TRUTH_NOT_EXPR)
2807     tclass = tcc_unary;
2808   else if (tclass == tcc_expression
2809            && (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR
2810                || code == COMPOUND_EXPR))
2811     tclass = tcc_binary;
2812
2813   else if (tclass == tcc_expression && code == SAVE_EXPR
2814            && ! TREE_SIDE_EFFECTS (TREE_OPERAND (arg, 0)))
2815     {
2816       /* If we've already found a CVAL1 or CVAL2, this expression is
2817          two complex to handle.  */
2818       if (*cval1 || *cval2)
2819         return 0;
2820
2821       tclass = tcc_unary;
2822       *save_p = 1;
2823     }
2824
2825   switch (tclass)
2826     {
2827     case tcc_unary:
2828       return twoval_comparison_p (TREE_OPERAND (arg, 0), cval1, cval2, save_p);
2829
2830     case tcc_binary:
2831       return (twoval_comparison_p (TREE_OPERAND (arg, 0), cval1, cval2, save_p)
2832               && twoval_comparison_p (TREE_OPERAND (arg, 1),
2833                                       cval1, cval2, save_p));
2834
2835     case tcc_constant:
2836       return 1;
2837
2838     case tcc_expression:
2839       if (code == COND_EXPR)
2840         return (twoval_comparison_p (TREE_OPERAND (arg, 0),
2841                                      cval1, cval2, save_p)
2842                 && twoval_comparison_p (TREE_OPERAND (arg, 1),
2843                                         cval1, cval2, save_p)
2844                 && twoval_comparison_p (TREE_OPERAND (arg, 2),
2845                                         cval1, cval2, save_p));
2846       return 0;
2847
2848     case tcc_comparison:
2849       /* First see if we can handle the first operand, then the second.  For
2850          the second operand, we know *CVAL1 can't be zero.  It must be that
2851          one side of the comparison is each of the values; test for the
2852          case where this isn't true by failing if the two operands
2853          are the same.  */
2854
2855       if (operand_equal_p (TREE_OPERAND (arg, 0),
2856                            TREE_OPERAND (arg, 1), 0))
2857         return 0;
2858
2859       if (*cval1 == 0)
2860         *cval1 = TREE_OPERAND (arg, 0);
2861       else if (operand_equal_p (*cval1, TREE_OPERAND (arg, 0), 0))
2862         ;
2863       else if (*cval2 == 0)
2864         *cval2 = TREE_OPERAND (arg, 0);
2865       else if (operand_equal_p (*cval2, TREE_OPERAND (arg, 0), 0))
2866         ;
2867       else
2868         return 0;
2869
2870       if (operand_equal_p (*cval1, TREE_OPERAND (arg, 1), 0))
2871         ;
2872       else if (*cval2 == 0)
2873         *cval2 = TREE_OPERAND (arg, 1);
2874       else if (operand_equal_p (*cval2, TREE_OPERAND (arg, 1), 0))
2875         ;
2876       else
2877         return 0;
2878
2879       return 1;
2880
2881     default:
2882       return 0;
2883     }
2884 }
2885 \f
2886 /* ARG is a tree that is known to contain just arithmetic operations and
2887    comparisons.  Evaluate the operations in the tree substituting NEW0 for
2888    any occurrence of OLD0 as an operand of a comparison and likewise for
2889    NEW1 and OLD1.  */
2890
2891 static tree
2892 eval_subst (location_t loc, tree arg, tree old0, tree new0,
2893             tree old1, tree new1)
2894 {
2895   tree type = TREE_TYPE (arg);
2896   enum tree_code code = TREE_CODE (arg);
2897   enum tree_code_class tclass = TREE_CODE_CLASS (code);
2898
2899   /* We can handle some of the tcc_expression cases here.  */
2900   if (tclass == tcc_expression && code == TRUTH_NOT_EXPR)
2901     tclass = tcc_unary;
2902   else if (tclass == tcc_expression
2903            && (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR))
2904     tclass = tcc_binary;
2905
2906   switch (tclass)
2907     {
2908     case tcc_unary:
2909       return fold_build1_loc (loc, code, type,
2910                           eval_subst (loc, TREE_OPERAND (arg, 0),
2911                                       old0, new0, old1, new1));
2912
2913     case tcc_binary:
2914       return fold_build2_loc (loc, code, type,
2915                           eval_subst (loc, TREE_OPERAND (arg, 0),
2916                                       old0, new0, old1, new1),
2917                           eval_subst (loc, TREE_OPERAND (arg, 1),
2918                                       old0, new0, old1, new1));
2919
2920     case tcc_expression:
2921       switch (code)
2922         {
2923         case SAVE_EXPR:
2924           return eval_subst (loc, TREE_OPERAND (arg, 0), old0, new0,
2925                              old1, new1);
2926
2927         case COMPOUND_EXPR:
2928           return eval_subst (loc, TREE_OPERAND (arg, 1), old0, new0,
2929                              old1, new1);
2930
2931         case COND_EXPR:
2932           return fold_build3_loc (loc, code, type,
2933                               eval_subst (loc, TREE_OPERAND (arg, 0),
2934                                           old0, new0, old1, new1),
2935                               eval_subst (loc, TREE_OPERAND (arg, 1),
2936                                           old0, new0, old1, new1),
2937                               eval_subst (loc, TREE_OPERAND (arg, 2),
2938                                           old0, new0, old1, new1));
2939         default:
2940           break;
2941         }
2942       /* Fall through - ???  */
2943
2944     case tcc_comparison:
2945       {
2946         tree arg0 = TREE_OPERAND (arg, 0);
2947         tree arg1 = TREE_OPERAND (arg, 1);
2948
2949         /* We need to check both for exact equality and tree equality.  The
2950            former will be true if the operand has a side-effect.  In that
2951            case, we know the operand occurred exactly once.  */
2952
2953         if (arg0 == old0 || operand_equal_p (arg0, old0, 0))
2954           arg0 = new0;
2955         else if (arg0 == old1 || operand_equal_p (arg0, old1, 0))
2956           arg0 = new1;
2957
2958         if (arg1 == old0 || operand_equal_p (arg1, old0, 0))
2959           arg1 = new0;
2960         else if (arg1 == old1 || operand_equal_p (arg1, old1, 0))
2961           arg1 = new1;
2962
2963         return fold_build2_loc (loc, code, type, arg0, arg1);
2964       }
2965
2966     default:
2967       return arg;
2968     }
2969 }
2970 \f
2971 /* Return a tree for the case when the result of an expression is RESULT
2972    converted to TYPE and OMITTED was previously an operand of the expression
2973    but is now not needed (e.g., we folded OMITTED * 0).
2974
2975    If OMITTED has side effects, we must evaluate it.  Otherwise, just do
2976    the conversion of RESULT to TYPE.  */
2977
2978 tree
2979 omit_one_operand_loc (location_t loc, tree type, tree result, tree omitted)
2980 {
2981   tree t = fold_convert_loc (loc, type, result);
2982
2983   /* If the resulting operand is an empty statement, just return the omitted
2984      statement casted to void. */
2985   if (IS_EMPTY_STMT (t) && TREE_SIDE_EFFECTS (omitted))
2986     return build1_loc (loc, NOP_EXPR, void_type_node,
2987                        fold_ignored_result (omitted));
2988
2989   if (TREE_SIDE_EFFECTS (omitted))
2990     return build2_loc (loc, COMPOUND_EXPR, type,
2991                        fold_ignored_result (omitted), t);
2992
2993   return non_lvalue_loc (loc, t);
2994 }
2995
2996 /* Similar, but call pedantic_non_lvalue instead of non_lvalue.  */
2997
2998 static tree
2999 pedantic_omit_one_operand_loc (location_t loc, tree type, tree result,
3000                                tree omitted)
3001 {
3002   tree t = fold_convert_loc (loc, type, result);
3003
3004   /* If the resulting operand is an empty statement, just return the omitted
3005      statement casted to void. */
3006   if (IS_EMPTY_STMT (t) && TREE_SIDE_EFFECTS (omitted))
3007     return build1_loc (loc, NOP_EXPR, void_type_node,
3008                        fold_ignored_result (omitted));
3009
3010   if (TREE_SIDE_EFFECTS (omitted))
3011     return build2_loc (loc, COMPOUND_EXPR, type,
3012                        fold_ignored_result (omitted), t);
3013
3014   return pedantic_non_lvalue_loc (loc, t);
3015 }
3016
3017 /* Return a tree for the case when the result of an expression is RESULT
3018    converted to TYPE and OMITTED1 and OMITTED2 were previously operands
3019    of the expression but are now not needed.
3020
3021    If OMITTED1 or OMITTED2 has side effects, they must be evaluated.
3022    If both OMITTED1 and OMITTED2 have side effects, OMITTED1 is
3023    evaluated before OMITTED2.  Otherwise, if neither has side effects,
3024    just do the conversion of RESULT to TYPE.  */
3025
3026 tree
3027 omit_two_operands_loc (location_t loc, tree type, tree result,
3028                        tree omitted1, tree omitted2)
3029 {
3030   tree t = fold_convert_loc (loc, type, result);
3031
3032   if (TREE_SIDE_EFFECTS (omitted2))
3033     t = build2_loc (loc, COMPOUND_EXPR, type, omitted2, t);
3034   if (TREE_SIDE_EFFECTS (omitted1))
3035     t = build2_loc (loc, COMPOUND_EXPR, type, omitted1, t);
3036
3037   return TREE_CODE (t) != COMPOUND_EXPR ? non_lvalue_loc (loc, t) : t;
3038 }
3039
3040 \f
3041 /* Return a simplified tree node for the truth-negation of ARG.  This
3042    never alters ARG itself.  We assume that ARG is an operation that
3043    returns a truth value (0 or 1).
3044
3045    FIXME: one would think we would fold the result, but it causes
3046    problems with the dominator optimizer.  */
3047
3048 tree
3049 fold_truth_not_expr (location_t loc, tree arg)
3050 {
3051   tree type = TREE_TYPE (arg);
3052   enum tree_code code = TREE_CODE (arg);
3053   location_t loc1, loc2;
3054
3055   /* If this is a comparison, we can simply invert it, except for
3056      floating-point non-equality comparisons, in which case we just
3057      enclose a TRUTH_NOT_EXPR around what we have.  */
3058
3059   if (TREE_CODE_CLASS (code) == tcc_comparison)
3060     {
3061       tree op_type = TREE_TYPE (TREE_OPERAND (arg, 0));
3062       if (FLOAT_TYPE_P (op_type)
3063           && flag_trapping_math
3064           && code != ORDERED_EXPR && code != UNORDERED_EXPR
3065           && code != NE_EXPR && code != EQ_EXPR)
3066         return NULL_TREE;
3067
3068       code = invert_tree_comparison (code, HONOR_NANS (TYPE_MODE (op_type)));
3069       if (code == ERROR_MARK)
3070         return NULL_TREE;
3071
3072       return build2_loc (loc, code, type, TREE_OPERAND (arg, 0),
3073                          TREE_OPERAND (arg, 1));
3074     }
3075
3076   switch (code)
3077     {
3078     case INTEGER_CST:
3079       return constant_boolean_node (integer_zerop (arg), type);
3080
3081     case TRUTH_AND_EXPR:
3082       loc1 = EXPR_LOCATION (TREE_OPERAND (arg, 0));
3083       loc2 = EXPR_LOCATION (TREE_OPERAND (arg, 1));
3084       if (loc1 == UNKNOWN_LOCATION)
3085         loc1 = loc;
3086       if (loc2 == UNKNOWN_LOCATION)
3087         loc2 = loc;
3088       return build2_loc (loc, TRUTH_OR_EXPR, type,
3089                          invert_truthvalue_loc (loc1, TREE_OPERAND (arg, 0)),
3090                          invert_truthvalue_loc (loc2, TREE_OPERAND (arg, 1)));
3091
3092     case TRUTH_OR_EXPR:
3093       loc1 = EXPR_LOCATION (TREE_OPERAND (arg, 0));
3094       loc2 = EXPR_LOCATION (TREE_OPERAND (arg, 1));
3095       if (loc1 == UNKNOWN_LOCATION)
3096         loc1 = loc;
3097       if (loc2 == UNKNOWN_LOCATION)
3098         loc2 = loc;
3099       return build2_loc (loc, TRUTH_AND_EXPR, type,
3100                          invert_truthvalue_loc (loc1, TREE_OPERAND (arg, 0)),
3101                          invert_truthvalue_loc (loc2, TREE_OPERAND (arg, 1)));
3102
3103     case TRUTH_XOR_EXPR:
3104       /* Here we can invert either operand.  We invert the first operand
3105          unless the second operand is a TRUTH_NOT_EXPR in which case our
3106          result is the XOR of the first operand with the inside of the
3107          negation of the second operand.  */
3108
3109       if (TREE_CODE (TREE_OPERAND (arg, 1)) == TRUTH_NOT_EXPR)
3110         return build2_loc (loc, TRUTH_XOR_EXPR, type, TREE_OPERAND (arg, 0),
3111                            TREE_OPERAND (TREE_OPERAND (arg, 1), 0));
3112       else
3113         return build2_loc (loc, TRUTH_XOR_EXPR, type,
3114                            invert_truthvalue_loc (loc, TREE_OPERAND (arg, 0)),
3115                            TREE_OPERAND (arg, 1));
3116
3117     case TRUTH_ANDIF_EXPR:
3118       loc1 = EXPR_LOCATION (TREE_OPERAND (arg, 0));
3119       loc2 = EXPR_LOCATION (TREE_OPERAND (arg, 1));
3120       if (loc1 == UNKNOWN_LOCATION)
3121         loc1 = loc;
3122       if (loc2 == UNKNOWN_LOCATION)
3123         loc2 = loc;
3124       return build2_loc (loc, TRUTH_ORIF_EXPR, type,
3125                          invert_truthvalue_loc (loc1, TREE_OPERAND (arg, 0)),
3126                          invert_truthvalue_loc (loc2, TREE_OPERAND (arg, 1)));
3127
3128     case TRUTH_ORIF_EXPR:
3129       loc1 = EXPR_LOCATION (TREE_OPERAND (arg, 0));
3130       loc2 = EXPR_LOCATION (TREE_OPERAND (arg, 1));
3131       if (loc1 == UNKNOWN_LOCATION)
3132         loc1 = loc;
3133       if (loc2 == UNKNOWN_LOCATION)
3134         loc2 = loc;
3135       return build2_loc (loc, TRUTH_ANDIF_EXPR, type,
3136                          invert_truthvalue_loc (loc1, TREE_OPERAND (arg, 0)),
3137                          invert_truthvalue_loc (loc2, TREE_OPERAND (arg, 1)));
3138
3139     case TRUTH_NOT_EXPR:
3140       return TREE_OPERAND (arg, 0);
3141
3142     case COND_EXPR:
3143       {
3144         tree arg1 = TREE_OPERAND (arg, 1);
3145         tree arg2 = TREE_OPERAND (arg, 2);
3146
3147         loc1 = EXPR_LOCATION (TREE_OPERAND (arg, 1));
3148         loc2 = EXPR_LOCATION (TREE_OPERAND (arg, 2));
3149         if (loc1 == UNKNOWN_LOCATION)
3150           loc1 = loc;
3151         if (loc2 == UNKNOWN_LOCATION)
3152           loc2 = loc;
3153
3154         /* A COND_EXPR may have a throw as one operand, which
3155            then has void type.  Just leave void operands
3156            as they are.  */
3157         return build3_loc (loc, COND_EXPR, type, TREE_OPERAND (arg, 0),
3158                            VOID_TYPE_P (TREE_TYPE (arg1))
3159                            ? arg1 : invert_truthvalue_loc (loc1, arg1),
3160                            VOID_TYPE_P (TREE_TYPE (arg2))
3161                            ? arg2 : invert_truthvalue_loc (loc2, arg2));
3162       }
3163
3164     case COMPOUND_EXPR:
3165       loc1 = EXPR_LOCATION (TREE_OPERAND (arg, 1));
3166       if (loc1 == UNKNOWN_LOCATION)
3167         loc1 = loc;
3168       return build2_loc (loc, COMPOUND_EXPR, type,
3169                          TREE_OPERAND (arg, 0),
3170                          invert_truthvalue_loc (loc1, TREE_OPERAND (arg, 1)));
3171
3172     case NON_LVALUE_EXPR:
3173       loc1 = EXPR_LOCATION (TREE_OPERAND (arg, 0));
3174       if (loc1 == UNKNOWN_LOCATION)
3175         loc1 = loc;
3176       return invert_truthvalue_loc (loc1, TREE_OPERAND (arg, 0));
3177
3178     CASE_CONVERT:
3179       if (TREE_CODE (TREE_TYPE (arg)) == BOOLEAN_TYPE)
3180         return build1_loc (loc, TRUTH_NOT_EXPR, type, arg);
3181
3182       /* ... fall through ...  */
3183
3184     case FLOAT_EXPR:
3185       loc1 = EXPR_LOCATION (TREE_OPERAND (arg, 0));
3186       if (loc1 == UNKNOWN_LOCATION)
3187         loc1 = loc;
3188       return build1_loc (loc, TREE_CODE (arg), type,
3189                          invert_truthvalue_loc (loc1, TREE_OPERAND (arg, 0)));
3190
3191     case BIT_AND_EXPR:
3192       if (!integer_onep (TREE_OPERAND (arg, 1)))
3193         return NULL_TREE;
3194       return build2_loc (loc, EQ_EXPR, type, arg, build_int_cst (type, 0));
3195
3196     case SAVE_EXPR:
3197       return build1_loc (loc, TRUTH_NOT_EXPR, type, arg);
3198
3199     case CLEANUP_POINT_EXPR:
3200       loc1 = EXPR_LOCATION (TREE_OPERAND (arg, 0));
3201       if (loc1 == UNKNOWN_LOCATION)
3202         loc1 = loc;
3203       return build1_loc (loc, CLEANUP_POINT_EXPR, type,
3204                          invert_truthvalue_loc (loc1, TREE_OPERAND (arg, 0)));
3205
3206     default:
3207       return NULL_TREE;
3208     }
3209 }
3210
3211 /* Return a simplified tree node for the truth-negation of ARG.  This
3212    never alters ARG itself.  We assume that ARG is an operation that
3213    returns a truth value (0 or 1).
3214
3215    FIXME: one would think we would fold the result, but it causes
3216    problems with the dominator optimizer.  */
3217
3218 tree
3219 invert_truthvalue_loc (location_t loc, tree arg)
3220 {
3221   tree tem;
3222
3223   if (TREE_CODE (arg) == ERROR_MARK)
3224     return arg;
3225
3226   tem = fold_truth_not_expr (loc, arg);
3227   if (!tem)
3228     tem = build1_loc (loc, TRUTH_NOT_EXPR, TREE_TYPE (arg), arg);
3229
3230   return tem;
3231 }
3232
3233 /* Given a bit-wise operation CODE applied to ARG0 and ARG1, see if both
3234    operands are another bit-wise operation with a common input.  If so,
3235    distribute the bit operations to save an operation and possibly two if
3236    constants are involved.  For example, convert
3237         (A | B) & (A | C) into A | (B & C)
3238    Further simplification will occur if B and C are constants.
3239
3240    If this optimization cannot be done, 0 will be returned.  */
3241
3242 static tree
3243 distribute_bit_expr (location_t loc, enum tree_code code, tree type,
3244                      tree arg0, tree arg1)
3245 {
3246   tree common;
3247   tree left, right;
3248
3249   if (TREE_CODE (arg0) != TREE_CODE (arg1)
3250       || TREE_CODE (arg0) == code
3251       || (TREE_CODE (arg0) != BIT_AND_EXPR
3252           && TREE_CODE (arg0) != BIT_IOR_EXPR))
3253     return 0;
3254
3255   if (operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1, 0), 0))
3256     {
3257       common = TREE_OPERAND (arg0, 0);
3258       left = TREE_OPERAND (arg0, 1);
3259       right = TREE_OPERAND (arg1, 1);
3260     }
3261   else if (operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1, 1), 0))
3262     {
3263       common = TREE_OPERAND (arg0, 0);
3264       left = TREE_OPERAND (arg0, 1);
3265       right = TREE_OPERAND (arg1, 0);
3266     }
3267   else if (operand_equal_p (TREE_OPERAND (arg0, 1), TREE_OPERAND (arg1, 0), 0))
3268     {
3269       common = TREE_OPERAND (arg0, 1);
3270       left = TREE_OPERAND (arg0, 0);
3271       right = TREE_OPERAND (arg1, 1);
3272     }
3273   else if (operand_equal_p (TREE_OPERAND (arg0, 1), TREE_OPERAND (arg1, 1), 0))
3274     {
3275       common = TREE_OPERAND (arg0, 1);
3276       left = TREE_OPERAND (arg0, 0);
3277       right = TREE_OPERAND (arg1, 0);
3278     }
3279   else
3280     return 0;
3281
3282   common = fold_convert_loc (loc, type, common);
3283   left = fold_convert_loc (loc, type, left);
3284   right = fold_convert_loc (loc, type, right);
3285   return fold_build2_loc (loc, TREE_CODE (arg0), type, common,
3286                       fold_build2_loc (loc, code, type, left, right));
3287 }
3288
3289 /* Knowing that ARG0 and ARG1 are both RDIV_EXPRs, simplify a binary operation
3290    with code CODE.  This optimization is unsafe.  */
3291 static tree
3292 distribute_real_division (location_t loc, enum tree_code code, tree type,
3293                           tree arg0, tree arg1)
3294 {
3295   bool mul0 = TREE_CODE (arg0) == MULT_EXPR;
3296   bool mul1 = TREE_CODE (arg1) == MULT_EXPR;
3297
3298   /* (A / C) +- (B / C) -> (A +- B) / C.  */
3299   if (mul0 == mul1
3300       && operand_equal_p (TREE_OPERAND (arg0, 1),
3301                        TREE_OPERAND (arg1, 1), 0))
3302     return fold_build2_loc (loc, mul0 ? MULT_EXPR : RDIV_EXPR, type,
3303                         fold_build2_loc (loc, code, type,
3304                                      TREE_OPERAND (arg0, 0),
3305                                      TREE_OPERAND (arg1, 0)),
3306                         TREE_OPERAND (arg0, 1));
3307
3308   /* (A / C1) +- (A / C2) -> A * (1 / C1 +- 1 / C2).  */
3309   if (operand_equal_p (TREE_OPERAND (arg0, 0),
3310                        TREE_OPERAND (arg1, 0), 0)
3311       && TREE_CODE (TREE_OPERAND (arg0, 1)) == REAL_CST
3312       && TREE_CODE (TREE_OPERAND (arg1, 1)) == REAL_CST)
3313     {
3314       REAL_VALUE_TYPE r0, r1;
3315       r0 = TREE_REAL_CST (TREE_OPERAND (arg0, 1));
3316       r1 = TREE_REAL_CST (TREE_OPERAND (arg1, 1));
3317       if (!mul0)
3318         real_arithmetic (&r0, RDIV_EXPR, &dconst1, &r0);
3319       if (!mul1)
3320         real_arithmetic (&r1, RDIV_EXPR, &dconst1, &r1);
3321       real_arithmetic (&r0, code, &r0, &r1);
3322       return fold_build2_loc (loc, MULT_EXPR, type,
3323                           TREE_OPERAND (arg0, 0),
3324                           build_real (type, r0));
3325     }
3326
3327   return NULL_TREE;
3328 }
3329 \f
3330 /* Return a BIT_FIELD_REF of type TYPE to refer to BITSIZE bits of INNER
3331    starting at BITPOS.  The field is unsigned if UNSIGNEDP is nonzero.  */
3332
3333 static tree
3334 make_bit_field_ref (location_t loc, tree inner, tree type,
3335                     HOST_WIDE_INT bitsize, HOST_WIDE_INT bitpos, int unsignedp)
3336 {
3337   tree result, bftype;
3338
3339   if (bitpos == 0)
3340     {
3341       tree size = TYPE_SIZE (TREE_TYPE (inner));
3342       if ((INTEGRAL_TYPE_P (TREE_TYPE (inner))
3343            || POINTER_TYPE_P (TREE_TYPE (inner)))
3344           && host_integerp (size, 0)
3345           && tree_low_cst (size, 0) == bitsize)
3346         return fold_convert_loc (loc, type, inner);
3347     }
3348
3349   bftype = type;
3350   if (TYPE_PRECISION (bftype) != bitsize
3351       || TYPE_UNSIGNED (bftype) == !unsignedp)
3352     bftype = build_nonstandard_integer_type (bitsize, 0);
3353
3354   result = build3_loc (loc, BIT_FIELD_REF, bftype, inner,
3355                        size_int (bitsize), bitsize_int (bitpos));
3356
3357   if (bftype != type)
3358     result = fold_convert_loc (loc, type, result);
3359
3360   return result;
3361 }
3362
3363 /* Optimize a bit-field compare.
3364
3365    There are two cases:  First is a compare against a constant and the
3366    second is a comparison of two items where the fields are at the same
3367    bit position relative to the start of a chunk (byte, halfword, word)
3368    large enough to contain it.  In these cases we can avoid the shift
3369    implicit in bitfield extractions.
3370
3371    For constants, we emit a compare of the shifted constant with the
3372    BIT_AND_EXPR of a mask and a byte, halfword, or word of the operand being
3373    compared.  For two fields at the same position, we do the ANDs with the
3374    similar mask and compare the result of the ANDs.
3375
3376    CODE is the comparison code, known to be either NE_EXPR or EQ_EXPR.
3377    COMPARE_TYPE is the type of the comparison, and LHS and RHS
3378    are the left and right operands of the comparison, respectively.
3379
3380    If the optimization described above can be done, we return the resulting
3381    tree.  Otherwise we return zero.  */
3382
3383 static tree
3384 optimize_bit_field_compare (location_t loc, enum tree_code code,
3385                             tree compare_type, tree lhs, tree rhs)
3386 {
3387   HOST_WIDE_INT lbitpos, lbitsize, rbitpos, rbitsize, nbitpos, nbitsize;
3388   tree type = TREE_TYPE (lhs);
3389   tree signed_type, unsigned_type;
3390   int const_p = TREE_CODE (rhs) == INTEGER_CST;
3391   enum machine_mode lmode, rmode, nmode;
3392   int lunsignedp, runsignedp;
3393   int lvolatilep = 0, rvolatilep = 0;
3394   tree linner, rinner = NULL_TREE;
3395   tree mask;
3396   tree offset;
3397
3398   /* Get all the information about the extractions being done.  If the bit size
3399      if the same as the size of the underlying object, we aren't doing an
3400      extraction at all and so can do nothing.  We also don't want to
3401      do anything if the inner expression is a PLACEHOLDER_EXPR since we
3402      then will no longer be able to replace it.  */
3403   linner = get_inner_reference (lhs, &lbitsize, &lbitpos, &offset, &lmode,
3404                                 &lunsignedp, &lvolatilep, false);
3405   if (linner == lhs || lbitsize == GET_MODE_BITSIZE (lmode) || lbitsize < 0
3406       || offset != 0 || TREE_CODE (linner) == PLACEHOLDER_EXPR)
3407     return 0;
3408
3409  if (!const_p)
3410    {
3411      /* If this is not a constant, we can only do something if bit positions,
3412         sizes, and signedness are the same.  */
3413      rinner = get_inner_reference (rhs, &rbitsize, &rbitpos, &offset, &rmode,
3414                                    &runsignedp, &rvolatilep, false);
3415
3416      if (rinner == rhs || lbitpos != rbitpos || lbitsize != rbitsize
3417          || lunsignedp != runsignedp || offset != 0
3418          || TREE_CODE (rinner) == PLACEHOLDER_EXPR)
3419        return 0;
3420    }
3421
3422   /* See if we can find a mode to refer to this field.  We should be able to,
3423      but fail if we can't.  */
3424   if (lvolatilep
3425       && GET_MODE_BITSIZE (lmode) > 0
3426       && flag_strict_volatile_bitfields > 0)
3427     nmode = lmode;
3428   else
3429     nmode = get_best_mode (lbitsize, lbitpos,
3430                            const_p ? TYPE_ALIGN (TREE_TYPE (linner))
3431                            : MIN (TYPE_ALIGN (TREE_TYPE (linner)),
3432                                   TYPE_ALIGN (TREE_TYPE (rinner))),
3433                            word_mode, lvolatilep || rvolatilep);
3434   if (nmode == VOIDmode)
3435     return 0;
3436
3437   /* Set signed and unsigned types of the precision of this mode for the
3438      shifts below.  */
3439   signed_type = lang_hooks.types.type_for_mode (nmode, 0);
3440   unsigned_type = lang_hooks.types.type_for_mode (nmode, 1);
3441
3442   /* Compute the bit position and size for the new reference and our offset
3443      within it. If the new reference is the same size as the original, we
3444      won't optimize anything, so return zero.  */
3445   nbitsize = GET_MODE_BITSIZE (nmode);
3446   nbitpos = lbitpos & ~ (nbitsize - 1);
3447   lbitpos -= nbitpos;
3448   if (nbitsize == lbitsize)
3449     return 0;
3450
3451   if (BYTES_BIG_ENDIAN)
3452     lbitpos = nbitsize - lbitsize - lbitpos;
3453
3454   /* Make the mask to be used against the extracted field.  */
3455   mask = build_int_cst_type (unsigned_type, -1);
3456   mask = const_binop (LSHIFT_EXPR, mask, size_int (nbitsize - lbitsize));
3457   mask = const_binop (RSHIFT_EXPR, mask,
3458                       size_int (nbitsize - lbitsize - lbitpos));
3459
3460   if (! const_p)
3461     /* If not comparing with constant, just rework the comparison
3462        and return.  */
3463     return fold_build2_loc (loc, code, compare_type,
3464                         fold_build2_loc (loc, BIT_AND_EXPR, unsigned_type,
3465                                      make_bit_field_ref (loc, linner,
3466                                                          unsigned_type,
3467                                                          nbitsize, nbitpos,
3468                                                          1),
3469                                      mask),
3470                         fold_build2_loc (loc, BIT_AND_EXPR, unsigned_type,
3471                                      make_bit_field_ref (loc, rinner,
3472                                                          unsigned_type,
3473                                                          nbitsize, nbitpos,
3474                                                          1),
3475                                      mask));
3476
3477   /* Otherwise, we are handling the constant case. See if the constant is too
3478      big for the field.  Warn and return a tree of for 0 (false) if so.  We do
3479      this not only for its own sake, but to avoid having to test for this
3480      error case below.  If we didn't, we might generate wrong code.
3481
3482      For unsigned fields, the constant shifted right by the field length should
3483      be all zero.  For signed fields, the high-order bits should agree with
3484      the sign bit.  */
3485
3486   if (lunsignedp)
3487     {
3488       if (! integer_zerop (const_binop (RSHIFT_EXPR,
3489                                         fold_convert_loc (loc,
3490                                                           unsigned_type, rhs),
3491                                         size_int (lbitsize))))
3492         {
3493           warning (0, "comparison is always %d due to width of bit-field",
3494                    code == NE_EXPR);
3495           return constant_boolean_node (code == NE_EXPR, compare_type);
3496         }
3497     }
3498   else
3499     {
3500       tree tem = const_binop (RSHIFT_EXPR,
3501                               fold_convert_loc (loc, signed_type, rhs),
3502                               size_int (lbitsize - 1));
3503       if (! integer_zerop (tem) && ! integer_all_onesp (tem))
3504         {
3505           warning (0, "comparison is always %d due to width of bit-field",
3506                    code == NE_EXPR);
3507           return constant_boolean_node (code == NE_EXPR, compare_type);
3508         }
3509     }
3510
3511   /* Single-bit compares should always be against zero.  */
3512   if (lbitsize == 1 && ! integer_zerop (rhs))
3513     {
3514       code = code == EQ_EXPR ? NE_EXPR : EQ_EXPR;
3515       rhs = build_int_cst (type, 0);
3516     }
3517
3518   /* Make a new bitfield reference, shift the constant over the
3519      appropriate number of bits and mask it with the computed mask
3520      (in case this was a signed field).  If we changed it, make a new one.  */
3521   lhs = make_bit_field_ref (loc, linner, unsigned_type, nbitsize, nbitpos, 1);
3522   if (lvolatilep)
3523     {
3524       TREE_SIDE_EFFECTS (lhs) = 1;
3525       TREE_THIS_VOLATILE (lhs) = 1;
3526     }
3527
3528   rhs = const_binop (BIT_AND_EXPR,
3529                      const_binop (LSHIFT_EXPR,
3530                                   fold_convert_loc (loc, unsigned_type, rhs),
3531                                   size_int (lbitpos)),
3532                      mask);
3533
3534   lhs = build2_loc (loc, code, compare_type,
3535                     build2 (BIT_AND_EXPR, unsigned_type, lhs, mask), rhs);
3536   return lhs;
3537 }
3538 \f
3539 /* Subroutine for fold_truthop: decode a field reference.
3540
3541    If EXP is a comparison reference, we return the innermost reference.
3542
3543    *PBITSIZE is set to the number of bits in the reference, *PBITPOS is
3544    set to the starting bit number.
3545
3546    If the innermost field can be completely contained in a mode-sized
3547    unit, *PMODE is set to that mode.  Otherwise, it is set to VOIDmode.
3548
3549    *PVOLATILEP is set to 1 if the any expression encountered is volatile;
3550    otherwise it is not changed.
3551
3552    *PUNSIGNEDP is set to the signedness of the field.
3553
3554    *PMASK is set to the mask used.  This is either contained in a
3555    BIT_AND_EXPR or derived from the width of the field.
3556
3557    *PAND_MASK is set to the mask found in a BIT_AND_EXPR, if any.
3558
3559    Return 0 if this is not a component reference or is one that we can't
3560    do anything with.  */
3561
3562 static tree
3563 decode_field_reference (location_t loc, tree exp, HOST_WIDE_INT *pbitsize,
3564                         HOST_WIDE_INT *pbitpos, enum machine_mode *pmode,
3565                         int *punsignedp, int *pvolatilep,
3566                         tree *pmask, tree *pand_mask)
3567 {
3568   tree outer_type = 0;
3569   tree and_mask = 0;
3570   tree mask, inner, offset;
3571   tree unsigned_type;
3572   unsigned int precision;
3573
3574   /* All the optimizations using this function assume integer fields.
3575      There are problems with FP fields since the type_for_size call
3576      below can fail for, e.g., XFmode.  */
3577   if (! INTEGRAL_TYPE_P (TREE_TYPE (exp)))
3578     return 0;
3579
3580   /* We are interested in the bare arrangement of bits, so strip everything
3581      that doesn't affect the machine mode.  However, record the type of the
3582      outermost expression if it may matter below.  */
3583   if (CONVERT_EXPR_P (exp)
3584       || TREE_CODE (exp) == NON_LVALUE_EXPR)
3585     outer_type = TREE_TYPE (exp);
3586   STRIP_NOPS (exp);
3587
3588   if (TREE_CODE (exp) == BIT_AND_EXPR)
3589     {
3590       and_mask = TREE_OPERAND (exp, 1);
3591       exp = TREE_OPERAND (exp, 0);
3592       STRIP_NOPS (exp); STRIP_NOPS (and_mask);
3593       if (TREE_CODE (and_mask) != INTEGER_CST)
3594         return 0;
3595     }
3596
3597   inner = get_inner_reference (exp, pbitsize, pbitpos, &offset, pmode,
3598                                punsignedp, pvolatilep, false);
3599   if ((inner == exp && and_mask == 0)
3600       || *pbitsize < 0 || offset != 0
3601       || TREE_CODE (inner) == PLACEHOLDER_EXPR)
3602     return 0;
3603
3604   /* If the number of bits in the reference is the same as the bitsize of
3605      the outer type, then the outer type gives the signedness. Otherwise
3606      (in case of a small bitfield) the signedness is unchanged.  */
3607   if (outer_type && *pbitsize == TYPE_PRECISION (outer_type))
3608     *punsignedp = TYPE_UNSIGNED (outer_type);
3609
3610   /* Compute the mask to access the bitfield.  */
3611   unsigned_type = lang_hooks.types.type_for_size (*pbitsize, 1);
3612   precision = TYPE_PRECISION (unsigned_type);
3613
3614   mask = build_int_cst_type (unsigned_type, -1);
3615
3616   mask = const_binop (LSHIFT_EXPR, mask, size_int (precision - *pbitsize));
3617   mask = const_binop (RSHIFT_EXPR, mask, size_int (precision - *pbitsize));
3618
3619   /* Merge it with the mask we found in the BIT_AND_EXPR, if any.  */
3620   if (and_mask != 0)
3621     mask = fold_build2_loc (loc, BIT_AND_EXPR, unsigned_type,
3622                         fold_convert_loc (loc, unsigned_type, and_mask), mask);
3623
3624   *pmask = mask;
3625   *pand_mask = and_mask;
3626   return inner;
3627 }
3628
3629 /* Return nonzero if MASK represents a mask of SIZE ones in the low-order
3630    bit positions.  */
3631
3632 static int
3633 all_ones_mask_p (const_tree mask, int size)
3634 {
3635   tree type = TREE_TYPE (mask);
3636   unsigned int precision = TYPE_PRECISION (type);
3637   tree tmask;
3638
3639   tmask = build_int_cst_type (signed_type_for (type), -1);
3640
3641   return
3642     tree_int_cst_equal (mask,
3643                         const_binop (RSHIFT_EXPR,
3644                                      const_binop (LSHIFT_EXPR, tmask,
3645                                                   size_int (precision - size)),
3646                                      size_int (precision - size)));
3647 }
3648
3649 /* Subroutine for fold: determine if VAL is the INTEGER_CONST that
3650    represents the sign bit of EXP's type.  If EXP represents a sign
3651    or zero extension, also test VAL against the unextended type.
3652    The return value is the (sub)expression whose sign bit is VAL,
3653    or NULL_TREE otherwise.  */
3654
3655 static tree
3656 sign_bit_p (tree exp, const_tree val)
3657 {
3658   unsigned HOST_WIDE_INT mask_lo, lo;
3659   HOST_WIDE_INT mask_hi, hi;
3660   int width;
3661   tree t;
3662
3663   /* Tree EXP must have an integral type.  */
3664   t = TREE_TYPE (exp);
3665   if (! INTEGRAL_TYPE_P (t))
3666     return NULL_TREE;
3667
3668   /* Tree VAL must be an integer constant.  */
3669   if (TREE_CODE (val) != INTEGER_CST
3670       || TREE_OVERFLOW (val))
3671     return NULL_TREE;
3672
3673   width = TYPE_PRECISION (t);
3674   if (width > HOST_BITS_PER_WIDE_INT)
3675     {
3676       hi = (unsigned HOST_WIDE_INT) 1 << (width - HOST_BITS_PER_WIDE_INT - 1);
3677       lo = 0;
3678
3679       mask_hi = ((unsigned HOST_WIDE_INT) -1
3680                  >> (2 * HOST_BITS_PER_WIDE_INT - width));
3681       mask_lo = -1;
3682     }
3683   else
3684     {
3685       hi = 0;
3686       lo = (unsigned HOST_WIDE_INT) 1 << (width - 1);
3687
3688       mask_hi = 0;
3689       mask_lo = ((unsigned HOST_WIDE_INT) -1
3690                  >> (HOST_BITS_PER_WIDE_INT - width));
3691     }
3692
3693   /* We mask off those bits beyond TREE_TYPE (exp) so that we can
3694      treat VAL as if it were unsigned.  */
3695   if ((TREE_INT_CST_HIGH (val) & mask_hi) == hi
3696       && (TREE_INT_CST_LOW (val) & mask_lo) == lo)
3697     return exp;
3698
3699   /* Handle extension from a narrower type.  */
3700   if (TREE_CODE (exp) == NOP_EXPR
3701       && TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (exp, 0))) < width)
3702     return sign_bit_p (TREE_OPERAND (exp, 0), val);
3703
3704   return NULL_TREE;
3705 }
3706
3707 /* Subroutine for fold_truthop: determine if an operand is simple enough
3708    to be evaluated unconditionally.  */
3709
3710 static int
3711 simple_operand_p (const_tree exp)
3712 {
3713   /* Strip any conversions that don't change the machine mode.  */
3714   STRIP_NOPS (exp);
3715
3716   return (CONSTANT_CLASS_P (exp)
3717           || TREE_CODE (exp) == SSA_NAME
3718           || (DECL_P (exp)
3719               && ! TREE_ADDRESSABLE (exp)
3720               && ! TREE_THIS_VOLATILE (exp)
3721               && ! DECL_NONLOCAL (exp)
3722               /* Don't regard global variables as simple.  They may be
3723                  allocated in ways unknown to the compiler (shared memory,
3724                  #pragma weak, etc).  */
3725               && ! TREE_PUBLIC (exp)
3726               && ! DECL_EXTERNAL (exp)
3727               /* Loading a static variable is unduly expensive, but global
3728                  registers aren't expensive.  */
3729               && (! TREE_STATIC (exp) || DECL_REGISTER (exp))));
3730 }
3731 \f
3732 /* The following functions are subroutines to fold_range_test and allow it to
3733    try to change a logical combination of comparisons into a range test.
3734
3735    For example, both
3736         X == 2 || X == 3 || X == 4 || X == 5
3737    and
3738         X >= 2 && X <= 5
3739    are converted to
3740         (unsigned) (X - 2) <= 3
3741
3742    We describe each set of comparisons as being either inside or outside
3743    a range, using a variable named like IN_P, and then describe the
3744    range with a lower and upper bound.  If one of the bounds is omitted,
3745    it represents either the highest or lowest value of the type.
3746
3747    In the comments below, we represent a range by two numbers in brackets
3748    preceded by a "+" to designate being inside that range, or a "-" to
3749    designate being outside that range, so the condition can be inverted by
3750    flipping the prefix.  An omitted bound is represented by a "-".  For
3751    example, "- [-, 10]" means being outside the range starting at the lowest
3752    possible value and ending at 10, in other words, being greater than 10.
3753    The range "+ [-, -]" is always true and hence the range "- [-, -]" is
3754    always false.
3755
3756    We set up things so that the missing bounds are handled in a consistent
3757    manner so neither a missing bound nor "true" and "false" need to be
3758    handled using a special case.  */
3759
3760 /* Return the result of applying CODE to ARG0 and ARG1, but handle the case
3761    of ARG0 and/or ARG1 being omitted, meaning an unlimited range. UPPER0_P
3762    and UPPER1_P are nonzero if the respective argument is an upper bound
3763    and zero for a lower.  TYPE, if nonzero, is the type of the result; it
3764    must be specified for a comparison.  ARG1 will be converted to ARG0's
3765    type if both are specified.  */
3766
3767 static tree
3768 range_binop (enum tree_code code, tree type, tree arg0, int upper0_p,
3769              tree arg1, int upper1_p)
3770 {
3771   tree tem;
3772   int result;
3773   int sgn0, sgn1;
3774
3775   /* If neither arg represents infinity, do the normal operation.
3776      Else, if not a comparison, return infinity.  Else handle the special
3777      comparison rules. Note that most of the cases below won't occur, but
3778      are handled for consistency.  */
3779
3780   if (arg0 != 0 && arg1 != 0)
3781     {
3782       tem = fold_build2 (code, type != 0 ? type : TREE_TYPE (arg0),
3783                          arg0, fold_convert (TREE_TYPE (arg0), arg1));
3784       STRIP_NOPS (tem);
3785       return TREE_CODE (tem) == INTEGER_CST ? tem : 0;
3786     }
3787
3788   if (TREE_CODE_CLASS (code) != tcc_comparison)
3789     return 0;
3790
3791   /* Set SGN[01] to -1 if ARG[01] is a lower bound, 1 for upper, and 0
3792      for neither.  In real maths, we cannot assume open ended ranges are
3793      the same. But, this is computer arithmetic, where numbers are finite.
3794      We can therefore make the transformation of any unbounded range with
3795      the value Z, Z being greater than any representable number. This permits
3796      us to treat unbounded ranges as equal.  */
3797   sgn0 = arg0 != 0 ? 0 : (upper0_p ? 1 : -1);
3798   sgn1 = arg1 != 0 ? 0 : (upper1_p ? 1 : -1);
3799   switch (code)
3800     {
3801     case EQ_EXPR:
3802       result = sgn0 == sgn1;
3803       break;
3804     case NE_EXPR:
3805       result = sgn0 != sgn1;
3806       break;
3807     case LT_EXPR:
3808       result = sgn0 < sgn1;
3809       break;
3810     case LE_EXPR:
3811       result = sgn0 <= sgn1;
3812       break;
3813     case GT_EXPR:
3814       result = sgn0 > sgn1;
3815       break;
3816     case GE_EXPR:
3817       result = sgn0 >= sgn1;
3818       break;
3819     default:
3820       gcc_unreachable ();
3821     }
3822
3823   return constant_boolean_node (result, type);
3824 }
3825 \f
3826 /* Given EXP, a logical expression, set the range it is testing into
3827    variables denoted by PIN_P, PLOW, and PHIGH.  Return the expression
3828    actually being tested.  *PLOW and *PHIGH will be made of the same
3829    type as the returned expression.  If EXP is not a comparison, we
3830    will most likely not be returning a useful value and range.  Set
3831    *STRICT_OVERFLOW_P to true if the return value is only valid
3832    because signed overflow is undefined; otherwise, do not change
3833    *STRICT_OVERFLOW_P.  */
3834
3835 tree
3836 make_range (tree exp, int *pin_p, tree *plow, tree *phigh,
3837             bool *strict_overflow_p)
3838 {
3839   enum tree_code code;
3840   tree arg0 = NULL_TREE, arg1 = NULL_TREE;
3841   tree exp_type = NULL_TREE, arg0_type = NULL_TREE;
3842   int in_p, n_in_p;
3843   tree low, high, n_low, n_high;
3844   location_t loc = EXPR_LOCATION (exp);
3845
3846   /* Start with simply saying "EXP != 0" and then look at the code of EXP
3847      and see if we can refine the range.  Some of the cases below may not
3848      happen, but it doesn't seem worth worrying about this.  We "continue"
3849      the outer loop when we've changed something; otherwise we "break"
3850      the switch, which will "break" the while.  */
3851
3852   in_p = 0;
3853   low = high = build_int_cst (TREE_TYPE (exp), 0);
3854
3855   while (1)
3856     {
3857       code = TREE_CODE (exp);
3858       exp_type = TREE_TYPE (exp);
3859
3860       if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code)))
3861         {
3862           if (TREE_OPERAND_LENGTH (exp) > 0)
3863             arg0 = TREE_OPERAND (exp, 0);
3864           if (TREE_CODE_CLASS (code) == tcc_comparison
3865               || TREE_CODE_CLASS (code) == tcc_unary
3866               || TREE_CODE_CLASS (code) == tcc_binary)
3867             arg0_type = TREE_TYPE (arg0);
3868           if (TREE_CODE_CLASS (code) == tcc_binary
3869               || TREE_CODE_CLASS (code) == tcc_comparison
3870               || (TREE_CODE_CLASS (code) == tcc_expression
3871                   && TREE_OPERAND_LENGTH (exp) > 1))
3872             arg1 = TREE_OPERAND (exp, 1);
3873         }
3874
3875       switch (code)
3876         {
3877         case TRUTH_NOT_EXPR:
3878           in_p = ! in_p, exp = arg0;
3879           continue;
3880
3881         case EQ_EXPR: case NE_EXPR:
3882         case LT_EXPR: case LE_EXPR: case GE_EXPR: case GT_EXPR:
3883           /* We can only do something if the range is testing for zero
3884              and if the second operand is an integer constant.  Note that
3885              saying something is "in" the range we make is done by
3886              complementing IN_P since it will set in the initial case of
3887              being not equal to zero; "out" is leaving it alone.  */
3888           if (low == 0 || high == 0
3889               || ! integer_zerop (low) || ! integer_zerop (high)
3890               || TREE_CODE (arg1) != INTEGER_CST)
3891             break;
3892
3893           switch (code)
3894             {
3895             case NE_EXPR:  /* - [c, c]  */
3896               low = high = arg1;
3897               break;
3898             case EQ_EXPR:  /* + [c, c]  */
3899               in_p = ! in_p, low = high = arg1;
3900               break;
3901             case GT_EXPR:  /* - [-, c] */
3902               low = 0, high = arg1;
3903               break;
3904             case GE_EXPR:  /* + [c, -] */
3905               in_p = ! in_p, low = arg1, high = 0;
3906               break;
3907             case LT_EXPR:  /* - [c, -] */
3908               low = arg1, high = 0;
3909               break;
3910             case LE_EXPR:  /* + [-, c] */
3911               in_p = ! in_p, low = 0, high = arg1;
3912               break;
3913             default:
3914               gcc_unreachable ();
3915             }
3916
3917           /* If this is an unsigned comparison, we also know that EXP is
3918              greater than or equal to zero.  We base the range tests we make
3919              on that fact, so we record it here so we can parse existing
3920              range tests.  We test arg0_type since often the return type
3921              of, e.g. EQ_EXPR, is boolean.  */
3922           if (TYPE_UNSIGNED (arg0_type) && (low == 0 || high == 0))
3923             {
3924               if (! merge_ranges (&n_in_p, &n_low, &n_high,
3925                                   in_p, low, high, 1,
3926                                   build_int_cst (arg0_type, 0),
3927                                   NULL_TREE))
3928                 break;
3929
3930               in_p = n_in_p, low = n_low, high = n_high;
3931
3932               /* If the high bound is missing, but we have a nonzero low
3933                  bound, reverse the range so it goes from zero to the low bound
3934                  minus 1.  */
3935               if (high == 0 && low && ! integer_zerop (low))
3936                 {
3937                   in_p = ! in_p;
3938                   high = range_binop (MINUS_EXPR, NULL_TREE, low, 0,
3939                                       integer_one_node, 0);
3940                   low = build_int_cst (arg0_type, 0);
3941                 }
3942             }
3943
3944           exp = arg0;
3945           continue;
3946
3947         case NEGATE_EXPR:
3948           /* (-x) IN [a,b] -> x in [-b, -a]  */
3949           n_low = range_binop (MINUS_EXPR, exp_type,
3950                                build_int_cst (exp_type, 0),
3951                                0, high, 1);
3952           n_high = range_binop (MINUS_EXPR, exp_type,
3953                                 build_int_cst (exp_type, 0),
3954                                 0, low, 0);
3955           if (n_high != 0 && TREE_OVERFLOW (n_high))
3956             break;
3957           goto normalize;
3958
3959         case BIT_NOT_EXPR:
3960           /* ~ X -> -X - 1  */
3961           exp = build2_loc (loc, MINUS_EXPR, exp_type, negate_expr (arg0),
3962                             build_int_cst (exp_type, 1));
3963           continue;
3964
3965         case PLUS_EXPR:  case MINUS_EXPR:
3966           if (TREE_CODE (arg1) != INTEGER_CST)
3967             break;
3968
3969           /* If flag_wrapv and ARG0_TYPE is signed, then we cannot
3970              move a constant to the other side.  */
3971           if (!TYPE_UNSIGNED (arg0_type)
3972               && !TYPE_OVERFLOW_UNDEFINED (arg0_type))
3973             break;
3974
3975           /* If EXP is signed, any overflow in the computation is undefined,
3976              so we don't worry about it so long as our computations on
3977              the bounds don't overflow.  For unsigned, overflow is defined
3978              and this is exactly the right thing.  */
3979           n_low = range_binop (code == MINUS_EXPR ? PLUS_EXPR : MINUS_EXPR,
3980                                arg0_type, low, 0, arg1, 0);
3981           n_high = range_binop (code == MINUS_EXPR ? PLUS_EXPR : MINUS_EXPR,
3982                                 arg0_type, high, 1, arg1, 0);
3983           if ((n_low != 0 && TREE_OVERFLOW (n_low))
3984               || (n_high != 0 && TREE_OVERFLOW (n_high)))
3985             break;
3986
3987           if (TYPE_OVERFLOW_UNDEFINED (arg0_type))
3988             *strict_overflow_p = true;
3989
3990         normalize:
3991           /* Check for an unsigned range which has wrapped around the maximum
3992              value thus making n_high < n_low, and normalize it.  */
3993           if (n_low && n_high && tree_int_cst_lt (n_high, n_low))
3994             {
3995               low = range_binop (PLUS_EXPR, arg0_type, n_high, 0,
3996                                  integer_one_node, 0);
3997               high = range_binop (MINUS_EXPR, arg0_type, n_low, 0,
3998                                   integer_one_node, 0);
3999
4000               /* If the range is of the form +/- [ x+1, x ], we won't
4001                  be able to normalize it.  But then, it represents the
4002                  whole range or the empty set, so make it
4003                  +/- [ -, - ].  */
4004               if (tree_int_cst_equal (n_low, low)
4005                   && tree_int_cst_equal (n_high, high))
4006                 low = high = 0;
4007               else
4008                 in_p = ! in_p;
4009             }
4010           else
4011             low = n_low, high = n_high;
4012
4013           exp = arg0;
4014           continue;
4015
4016         CASE_CONVERT: case NON_LVALUE_EXPR:
4017           if (TYPE_PRECISION (arg0_type) > TYPE_PRECISION (exp_type))
4018             break;
4019
4020           if (! INTEGRAL_TYPE_P (arg0_type)
4021               || (low != 0 && ! int_fits_type_p (low, arg0_type))
4022               || (high != 0 && ! int_fits_type_p (high, arg0_type)))
4023             break;
4024
4025           n_low = low, n_high = high;
4026
4027           if (n_low != 0)
4028             n_low = fold_convert_loc (loc, arg0_type, n_low);
4029
4030           if (n_high != 0)
4031             n_high = fold_convert_loc (loc, arg0_type, n_high);
4032
4033
4034           /* If we're converting arg0 from an unsigned type, to exp,
4035              a signed type,  we will be doing the comparison as unsigned.
4036              The tests above have already verified that LOW and HIGH
4037              are both positive.
4038
4039              So we have to ensure that we will handle large unsigned
4040              values the same way that the current signed bounds treat
4041              negative values.  */
4042
4043           if (!TYPE_UNSIGNED (exp_type) && TYPE_UNSIGNED (arg0_type))
4044             {
4045               tree high_positive;
4046               tree equiv_type;
4047               /* For fixed-point modes, we need to pass the saturating flag
4048                  as the 2nd parameter.  */
4049               if (ALL_FIXED_POINT_MODE_P (TYPE_MODE (arg0_type)))
4050                 equiv_type = lang_hooks.types.type_for_mode
4051                              (TYPE_MODE (arg0_type),
4052                               TYPE_SATURATING (arg0_type));
4053               else
4054                 equiv_type = lang_hooks.types.type_for_mode
4055                              (TYPE_MODE (arg0_type), 1);
4056
4057               /* A range without an upper bound is, naturally, unbounded.
4058                  Since convert would have cropped a very large value, use
4059                  the max value for the destination type.  */
4060               high_positive
4061                 = TYPE_MAX_VALUE (equiv_type) ? TYPE_MAX_VALUE (equiv_type)
4062                 : TYPE_MAX_VALUE (arg0_type);
4063
4064               if (TYPE_PRECISION (exp_type) == TYPE_PRECISION (arg0_type))
4065                 high_positive = fold_build2_loc (loc, RSHIFT_EXPR, arg0_type,
4066                                              fold_convert_loc (loc, arg0_type,
4067                                                                high_positive),
4068                                              build_int_cst (arg0_type, 1));
4069
4070               /* If the low bound is specified, "and" the range with the
4071                  range for which the original unsigned value will be
4072                  positive.  */
4073               if (low != 0)
4074                 {
4075                   if (! merge_ranges (&n_in_p, &n_low, &n_high,
4076                                       1, n_low, n_high, 1,
4077                                       fold_convert_loc (loc, arg0_type,
4078                                                         integer_zero_node),
4079                                       high_positive))
4080                     break;
4081
4082                   in_p = (n_in_p == in_p);
4083                 }
4084               else
4085                 {
4086                   /* Otherwise, "or" the range with the range of the input
4087                      that will be interpreted as negative.  */
4088                   if (! merge_ranges (&n_in_p, &n_low, &n_high,
4089                                       0, n_low, n_high, 1,
4090                                       fold_convert_loc (loc, arg0_type,
4091                                                         integer_zero_node),
4092                                       high_positive))
4093                     break;
4094
4095                   in_p = (in_p != n_in_p);
4096                 }
4097             }
4098
4099           exp = arg0;
4100           low = n_low, high = n_high;
4101           continue;
4102
4103         default:
4104           break;
4105         }
4106
4107       break;
4108     }
4109
4110   /* If EXP is a constant, we can evaluate whether this is true or false.  */
4111   if (TREE_CODE (exp) == INTEGER_CST)
4112     {
4113       in_p = in_p == (integer_onep (range_binop (GE_EXPR, integer_type_node,
4114                                                  exp, 0, low, 0))
4115                       && integer_onep (range_binop (LE_EXPR, integer_type_node,
4116                                                     exp, 1, high, 1)));
4117       low = high = 0;
4118       exp = 0;
4119     }
4120
4121   *pin_p = in_p, *plow = low, *phigh = high;
4122   return exp;
4123 }
4124 \f
4125 /* Given a range, LOW, HIGH, and IN_P, an expression, EXP, and a result
4126    type, TYPE, return an expression to test if EXP is in (or out of, depending
4127    on IN_P) the range.  Return 0 if the test couldn't be created.  */
4128
4129 tree
4130 build_range_check (location_t loc, tree type, tree exp, int in_p,
4131                    tree low, tree high)
4132 {
4133   tree etype = TREE_TYPE (exp), value;
4134
4135 #ifdef HAVE_canonicalize_funcptr_for_compare
4136   /* Disable this optimization for function pointer expressions
4137      on targets that require function pointer canonicalization.  */
4138   if (HAVE_canonicalize_funcptr_for_compare
4139       && TREE_CODE (etype) == POINTER_TYPE
4140       && TREE_CODE (TREE_TYPE (etype)) == FUNCTION_TYPE)
4141     return NULL_TREE;
4142 #endif
4143
4144   if (! in_p)
4145     {
4146       value = build_range_check (loc, type, exp, 1, low, high);
4147       if (value != 0)
4148         return invert_truthvalue_loc (loc, value);
4149
4150       return 0;
4151     }
4152
4153   if (low == 0 && high == 0)
4154     return build_int_cst (type, 1);
4155
4156   if (low == 0)
4157     return fold_build2_loc (loc, LE_EXPR, type, exp,
4158                         fold_convert_loc (loc, etype, high));
4159
4160   if (high == 0)
4161     return fold_build2_loc (loc, GE_EXPR, type, exp,
4162                         fold_convert_loc (loc, etype, low));
4163
4164   if (operand_equal_p (low, high, 0))
4165     return fold_build2_loc (loc, EQ_EXPR, type, exp,
4166                         fold_convert_loc (loc, etype, low));
4167
4168   if (integer_zerop (low))
4169     {
4170       if (! TYPE_UNSIGNED (etype))
4171         {
4172           etype = unsigned_type_for (etype);
4173           high = fold_convert_loc (loc, etype, high);
4174           exp = fold_convert_loc (loc, etype, exp);
4175         }
4176       return build_range_check (loc, type, exp, 1, 0, high);
4177     }
4178
4179   /* Optimize (c>=1) && (c<=127) into (signed char)c > 0.  */
4180   if (integer_onep (low) && TREE_CODE (high) == INTEGER_CST)
4181     {
4182       unsigned HOST_WIDE_INT lo;
4183       HOST_WIDE_INT hi;
4184       int prec;
4185
4186       prec = TYPE_PRECISION (etype);
4187       if (prec <= HOST_BITS_PER_WIDE_INT)
4188         {
4189           hi = 0;
4190           lo = ((unsigned HOST_WIDE_INT) 1 << (prec - 1)) - 1;
4191         }
4192       else
4193         {
4194           hi = ((HOST_WIDE_INT) 1 << (prec - HOST_BITS_PER_WIDE_INT - 1)) - 1;
4195           lo = (unsigned HOST_WIDE_INT) -1;
4196         }
4197
4198       if (TREE_INT_CST_HIGH (high) == hi && TREE_INT_CST_LOW (high) == lo)
4199         {
4200           if (TYPE_UNSIGNED (etype))
4201             {
4202               tree signed_etype = signed_type_for (etype);
4203               if (TYPE_PRECISION (signed_etype) != TYPE_PRECISION (etype))
4204                 etype
4205                   = build_nonstandard_integer_type (TYPE_PRECISION (etype), 0);
4206               else
4207                 etype = signed_etype;
4208               exp = fold_convert_loc (loc, etype, exp);
4209             }
4210           return fold_build2_loc (loc, GT_EXPR, type, exp,
4211                               build_int_cst (etype, 0));
4212         }
4213     }
4214
4215   /* Optimize (c>=low) && (c<=high) into (c-low>=0) && (c-low<=high-low).
4216      This requires wrap-around arithmetics for the type of the expression.
4217      First make sure that arithmetics in this type is valid, then make sure
4218      that it wraps around.  */
4219   if (TREE_CODE (etype) == ENUMERAL_TYPE || TREE_CODE (etype) == BOOLEAN_TYPE)
4220     etype = lang_hooks.types.type_for_size (TYPE_PRECISION (etype),
4221                                             TYPE_UNSIGNED (etype));
4222
4223   if (TREE_CODE (etype) == INTEGER_TYPE && !TYPE_OVERFLOW_WRAPS (etype))
4224     {
4225       tree utype, minv, maxv;
4226
4227       /* Check if (unsigned) INT_MAX + 1 == (unsigned) INT_MIN
4228          for the type in question, as we rely on this here.  */
4229       utype = unsigned_type_for (etype);
4230       maxv = fold_convert_loc (loc, utype, TYPE_MAX_VALUE (etype));
4231       maxv = range_binop (PLUS_EXPR, NULL_TREE, maxv, 1,
4232                           integer_one_node, 1);
4233       minv = fold_convert_loc (loc, utype, TYPE_MIN_VALUE (etype));
4234
4235       if (integer_zerop (range_binop (NE_EXPR, integer_type_node,
4236                                       minv, 1, maxv, 1)))
4237         etype = utype;
4238       else
4239         return 0;
4240     }
4241
4242   high = fold_convert_loc (loc, etype, high);
4243   low = fold_convert_loc (loc, etype, low);
4244   exp = fold_convert_loc (loc, etype, exp);
4245
4246   value = const_binop (MINUS_EXPR, high, low);
4247
4248
4249   if (POINTER_TYPE_P (etype))
4250     {
4251       if (value != 0 && !TREE_OVERFLOW (value))
4252         {
4253           low = fold_convert_loc (loc, sizetype, low);
4254           low = fold_build1_loc (loc, NEGATE_EXPR, sizetype, low);
4255           return build_range_check (loc, type,
4256                                     fold_build2_loc (loc, POINTER_PLUS_EXPR,
4257                                                  etype, exp, low),
4258                                     1, build_int_cst (etype, 0), value);
4259         }
4260       return 0;
4261     }
4262
4263   if (value != 0 && !TREE_OVERFLOW (value))
4264     return build_range_check (loc, type,
4265                               fold_build2_loc (loc, MINUS_EXPR, etype, exp, low),
4266                               1, build_int_cst (etype, 0), value);
4267
4268   return 0;
4269 }
4270 \f
4271 /* Return the predecessor of VAL in its type, handling the infinite case.  */
4272
4273 static tree
4274 range_predecessor (tree val)
4275 {
4276   tree type = TREE_TYPE (val);
4277
4278   if (INTEGRAL_TYPE_P (type)
4279       && operand_equal_p (val, TYPE_MIN_VALUE (type), 0))
4280     return 0;
4281   else
4282     return range_binop (MINUS_EXPR, NULL_TREE, val, 0, integer_one_node, 0);
4283 }
4284
4285 /* Return the successor of VAL in its type, handling the infinite case.  */
4286
4287 static tree
4288 range_successor (tree val)
4289 {
4290   tree type = TREE_TYPE (val);
4291
4292   if (INTEGRAL_TYPE_P (type)
4293       && operand_equal_p (val, TYPE_MAX_VALUE (type), 0))
4294     return 0;
4295   else
4296     return range_binop (PLUS_EXPR, NULL_TREE, val, 0, integer_one_node, 0);
4297 }
4298
4299 /* Given two ranges, see if we can merge them into one.  Return 1 if we
4300    can, 0 if we can't.  Set the output range into the specified parameters.  */
4301
4302 bool
4303 merge_ranges (int *pin_p, tree *plow, tree *phigh, int in0_p, tree low0,
4304               tree high0, int in1_p, tree low1, tree high1)
4305 {
4306   int no_overlap;
4307   int subset;
4308   int temp;
4309   tree tem;
4310   int in_p;
4311   tree low, high;
4312   int lowequal = ((low0 == 0 && low1 == 0)
4313                   || integer_onep (range_binop (EQ_EXPR, integer_type_node,
4314                                                 low0, 0, low1, 0)));
4315   int highequal = ((high0 == 0 && high1 == 0)
4316                    || integer_onep (range_binop (EQ_EXPR, integer_type_node,
4317                                                  high0, 1, high1, 1)));
4318
4319   /* Make range 0 be the range that starts first, or ends last if they
4320      start at the same value.  Swap them if it isn't.  */
4321   if (integer_onep (range_binop (GT_EXPR, integer_type_node,
4322                                  low0, 0, low1, 0))
4323       || (lowequal
4324           && integer_onep (range_binop (GT_EXPR, integer_type_node,
4325                                         high1, 1, high0, 1))))
4326     {
4327       temp = in0_p, in0_p = in1_p, in1_p = temp;
4328       tem = low0, low0 = low1, low1 = tem;
4329       tem = high0, high0 = high1, high1 = tem;
4330     }
4331
4332   /* Now flag two cases, whether the ranges are disjoint or whether the
4333      second range is totally subsumed in the first.  Note that the tests
4334      below are simplified by the ones above.  */
4335   no_overlap = integer_onep (range_binop (LT_EXPR, integer_type_node,
4336                                           high0, 1, low1, 0));
4337   subset = integer_onep (range_binop (LE_EXPR, integer_type_node,
4338                                       high1, 1, high0, 1));
4339
4340   /* We now have four cases, depending on whether we are including or
4341      excluding the two ranges.  */
4342   if (in0_p && in1_p)
4343     {
4344       /* If they don't overlap, the result is false.  If the second range
4345          is a subset it is the result.  Otherwise, the range is from the start
4346          of the second to the end of the first.  */
4347       if (no_overlap)
4348         in_p = 0, low = high = 0;
4349       else if (subset)
4350         in_p = 1, low = low1, high = high1;
4351       else
4352         in_p = 1, low = low1, high = high0;
4353     }
4354
4355   else if (in0_p && ! in1_p)
4356     {
4357       /* If they don't overlap, the result is the first range.  If they are
4358          equal, the result is false.  If the second range is a subset of the
4359          first, and the ranges begin at the same place, we go from just after
4360          the end of the second range to the end of the first.  If the second
4361          range is not a subset of the first, or if it is a subset and both
4362          ranges end at the same place, the range starts at the start of the
4363          first range and ends just before the second range.
4364          Otherwise, we can't describe this as a single range.  */
4365       if (no_overlap)
4366         in_p = 1, low = low0, high = high0;
4367       else if (lowequal && highequal)
4368         in_p = 0, low = high = 0;
4369       else if (subset && lowequal)
4370         {
4371           low = range_successor (high1);
4372           high = high0;
4373           in_p = 1;
4374           if (low == 0)
4375             {
4376               /* We are in the weird situation where high0 > high1 but
4377                  high1 has no successor.  Punt.  */
4378               return 0;
4379             }
4380         }
4381       else if (! subset || highequal)
4382         {
4383           low = low0;
4384           high = range_predecessor (low1);
4385           in_p = 1;
4386           if (high == 0)
4387             {
4388               /* low0 < low1 but low1 has no predecessor.  Punt.  */
4389               return 0;
4390             }
4391         }
4392       else
4393         return 0;
4394     }
4395
4396   else if (! in0_p && in1_p)
4397     {
4398       /* If they don't overlap, the result is the second range.  If the second
4399          is a subset of the first, the result is false.  Otherwise,
4400          the range starts just after the first range and ends at the
4401          end of the second.  */
4402       if (no_overlap)
4403         in_p = 1, low = low1, high = high1;
4404       else if (subset || highequal)
4405         in_p = 0, low = high = 0;
4406       else
4407         {
4408           low = range_successor (high0);
4409           high = high1;
4410           in_p = 1;
4411           if (low == 0)
4412             {
4413               /* high1 > high0 but high0 has no successor.  Punt.  */
4414               return 0;
4415             }
4416         }
4417     }
4418
4419   else
4420     {
4421       /* The case where we are excluding both ranges.  Here the complex case
4422          is if they don't overlap.  In that case, the only time we have a
4423          range is if they are adjacent.  If the second is a subset of the
4424          first, the result is the first.  Otherwise, the range to exclude
4425          starts at the beginning of the first range and ends at the end of the
4426          second.  */
4427       if (no_overlap)
4428         {
4429           if (integer_onep (range_binop (EQ_EXPR, integer_type_node,
4430                                          range_successor (high0),
4431                                          1, low1, 0)))
4432             in_p = 0, low = low0, high = high1;
4433           else
4434             {
4435               /* Canonicalize - [min, x] into - [-, x].  */
4436               if (low0 && TREE_CODE (low0) == INTEGER_CST)
4437                 switch (TREE_CODE (TREE_TYPE (low0)))
4438                   {
4439                   case ENUMERAL_TYPE:
4440                     if (TYPE_PRECISION (TREE_TYPE (low0))
4441                         != GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (low0))))
4442                       break;
4443                     /* FALLTHROUGH */
4444                   case INTEGER_TYPE:
4445                     if (tree_int_cst_equal (low0,
4446                                             TYPE_MIN_VALUE (TREE_TYPE (low0))))
4447                       low0 = 0;
4448                     break;
4449                   case POINTER_TYPE:
4450                     if (TYPE_UNSIGNED (TREE_TYPE (low0))
4451                         && integer_zerop (low0))
4452                       low0 = 0;
4453                     break;
4454                   default:
4455                     break;
4456                   }
4457
4458               /* Canonicalize - [x, max] into - [x, -].  */
4459               if (high1 && TREE_CODE (high1) == INTEGER_CST)
4460                 switch (TREE_CODE (TREE_TYPE (high1)))
4461                   {
4462                   case ENUMERAL_TYPE:
4463                     if (TYPE_PRECISION (TREE_TYPE (high1))
4464                         != GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (high1))))
4465                       break;
4466                     /* FALLTHROUGH */
4467                   case INTEGER_TYPE:
4468                     if (tree_int_cst_equal (high1,
4469                                             TYPE_MAX_VALUE (TREE_TYPE (high1))))
4470                       high1 = 0;
4471                     break;
4472                   case POINTER_TYPE:
4473                     if (TYPE_UNSIGNED (TREE_TYPE (high1))
4474                         && integer_zerop (range_binop (PLUS_EXPR, NULL_TREE,
4475                                                        high1, 1,
4476                                                        integer_one_node, 1)))
4477                       high1 = 0;
4478                     break;
4479                   default:
4480                     break;
4481                   }
4482
4483               /* The ranges might be also adjacent between the maximum and
4484                  minimum values of the given type.  For
4485                  - [{min,-}, x] and - [y, {max,-}] ranges where x + 1 < y
4486                  return + [x + 1, y - 1].  */
4487               if (low0 == 0 && high1 == 0)
4488                 {
4489                   low = range_successor (high0);
4490                   high = range_predecessor (low1);
4491                   if (low == 0 || high == 0)
4492                     return 0;
4493
4494                   in_p = 1;
4495                 }
4496               else
4497                 return 0;
4498             }
4499         }
4500       else if (subset)
4501         in_p = 0, low = low0, high = high0;
4502       else
4503         in_p = 0, low = low0, high = high1;
4504     }
4505
4506   *pin_p = in_p, *plow = low, *phigh = high;
4507   return 1;
4508 }
4509 \f
4510
4511 /* Subroutine of fold, looking inside expressions of the form
4512    A op B ? A : C, where ARG0, ARG1 and ARG2 are the three operands
4513    of the COND_EXPR.  This function is being used also to optimize
4514    A op B ? C : A, by reversing the comparison first.
4515
4516    Return a folded expression whose code is not a COND_EXPR
4517    anymore, or NULL_TREE if no folding opportunity is found.  */
4518
4519 static tree
4520 fold_cond_expr_with_comparison (location_t loc, tree type,
4521                                 tree arg0, tree arg1, tree arg2)
4522 {
4523   enum tree_code comp_code = TREE_CODE (arg0);
4524   tree arg00 = TREE_OPERAND (arg0, 0);
4525   tree arg01 = TREE_OPERAND (arg0, 1);
4526   tree arg1_type = TREE_TYPE (arg1);
4527   tree tem;
4528
4529   STRIP_NOPS (arg1);
4530   STRIP_NOPS (arg2);
4531
4532   /* If we have A op 0 ? A : -A, consider applying the following
4533      transformations:
4534
4535      A == 0? A : -A    same as -A
4536      A != 0? A : -A    same as A
4537      A >= 0? A : -A    same as abs (A)
4538      A > 0?  A : -A    same as abs (A)
4539      A <= 0? A : -A    same as -abs (A)
4540      A < 0?  A : -A    same as -abs (A)
4541
4542      None of these transformations work for modes with signed
4543      zeros.  If A is +/-0, the first two transformations will
4544      change the sign of the result (from +0 to -0, or vice
4545      versa).  The last four will fix the sign of the result,
4546      even though the original expressions could be positive or
4547      negative, depending on the sign of A.
4548
4549      Note that all these transformations are correct if A is
4550      NaN, since the two alternatives (A and -A) are also NaNs.  */
4551   if (!HONOR_SIGNED_ZEROS (TYPE_MODE (type))
4552       && (FLOAT_TYPE_P (TREE_TYPE (arg01))
4553           ? real_zerop (arg01)
4554           : integer_zerop (arg01))
4555       && ((TREE_CODE (arg2) == NEGATE_EXPR
4556            && operand_equal_p (TREE_OPERAND (arg2, 0), arg1, 0))
4557              /* In the case that A is of the form X-Y, '-A' (arg2) may
4558                 have already been folded to Y-X, check for that. */
4559           || (TREE_CODE (arg1) == MINUS_EXPR
4560               && TREE_CODE (arg2) == MINUS_EXPR
4561               && operand_equal_p (TREE_OPERAND (arg1, 0),
4562                                   TREE_OPERAND (arg2, 1), 0)
4563               && operand_equal_p (TREE_OPERAND (arg1, 1),
4564                                   TREE_OPERAND (arg2, 0), 0))))
4565     switch (comp_code)
4566       {
4567       case EQ_EXPR:
4568       case UNEQ_EXPR:
4569         tem = fold_convert_loc (loc, arg1_type, arg1);
4570         return pedantic_non_lvalue_loc (loc,
4571                                     fold_convert_loc (loc, type,
4572                                                   negate_expr (tem)));
4573       case NE_EXPR:
4574       case LTGT_EXPR:
4575         return pedantic_non_lvalue_loc (loc, fold_convert_loc (loc, type, arg1));
4576       case UNGE_EXPR:
4577       case UNGT_EXPR:
4578         if (flag_trapping_math)
4579           break;
4580         /* Fall through.  */
4581       case GE_EXPR:
4582       case GT_EXPR:
4583         if (TYPE_UNSIGNED (TREE_TYPE (arg1)))
4584           arg1 = fold_convert_loc (loc, signed_type_for
4585                                (TREE_TYPE (arg1)), arg1);
4586         tem = fold_build1_loc (loc, ABS_EXPR, TREE_TYPE (arg1), arg1);
4587         return pedantic_non_lvalue_loc (loc, fold_convert_loc (loc, type, tem));
4588       case UNLE_EXPR:
4589       case UNLT_EXPR:
4590         if (flag_trapping_math)
4591           break;
4592       case LE_EXPR:
4593       case LT_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 negate_expr (fold_convert_loc (loc, type, tem));
4599       default:
4600         gcc_assert (TREE_CODE_CLASS (comp_code) == tcc_comparison);
4601         break;
4602       }
4603
4604   /* A != 0 ? A : 0 is simply A, unless A is -0.  Likewise
4605      A == 0 ? A : 0 is always 0 unless A is -0.  Note that
4606      both transformations are correct when A is NaN: A != 0
4607      is then true, and A == 0 is false.  */
4608
4609   if (!HONOR_SIGNED_ZEROS (TYPE_MODE (type))
4610       && integer_zerop (arg01) && integer_zerop (arg2))
4611     {
4612       if (comp_code == NE_EXPR)
4613         return pedantic_non_lvalue_loc (loc, fold_convert_loc (loc, type, arg1));
4614       else if (comp_code == EQ_EXPR)
4615         return build_int_cst (type, 0);
4616     }
4617
4618   /* Try some transformations of A op B ? A : B.
4619
4620      A == B? A : B    same as B
4621      A != B? A : B    same as A
4622      A >= B? A : B    same as max (A, B)
4623      A > B?  A : B    same as max (B, A)
4624      A <= B? A : B    same as min (A, B)
4625      A < B?  A : B    same as min (B, A)
4626
4627      As above, these transformations don't work in the presence
4628      of signed zeros.  For example, if A and B are zeros of
4629      opposite sign, the first two transformations will change
4630      the sign of the result.  In the last four, the original
4631      expressions give different results for (A=+0, B=-0) and
4632      (A=-0, B=+0), but the transformed expressions do not.
4633
4634      The first two transformations are correct if either A or B
4635      is a NaN.  In the first transformation, the condition will
4636      be false, and B will indeed be chosen.  In the case of the
4637      second transformation, the condition A != B will be true,
4638      and A will be chosen.
4639
4640      The conversions to max() and min() are not correct if B is
4641      a number and A is not.  The conditions in the original
4642      expressions will be false, so all four give B.  The min()
4643      and max() versions would give a NaN instead.  */
4644   if (!HONOR_SIGNED_ZEROS (TYPE_MODE (type))
4645       && operand_equal_for_comparison_p (arg01, arg2, arg00)
4646       /* Avoid these transformations if the COND_EXPR may be used
4647          as an lvalue in the C++ front-end.  PR c++/19199.  */
4648       && (in_gimple_form
4649           || (strcmp (lang_hooks.name, "GNU C++") != 0
4650               && strcmp (lang_hooks.name, "GNU Objective-C++") != 0)
4651           || ! maybe_lvalue_p (arg1)
4652           || ! maybe_lvalue_p (arg2)))
4653     {
4654       tree comp_op0 = arg00;
4655       tree comp_op1 = arg01;
4656       tree comp_type = TREE_TYPE (comp_op0);
4657
4658       /* Avoid adding NOP_EXPRs in case this is an lvalue.  */
4659       if (TYPE_MAIN_VARIANT (comp_type) == TYPE_MAIN_VARIANT (type))
4660         {
4661           comp_type = type;
4662           comp_op0 = arg1;
4663           comp_op1 = arg2;
4664         }
4665
4666       switch (comp_code)
4667         {
4668         case EQ_EXPR:
4669           return pedantic_non_lvalue_loc (loc, fold_convert_loc (loc, type, arg2));
4670         case NE_EXPR:
4671           return pedantic_non_lvalue_loc (loc, fold_convert_loc (loc, type, arg1));
4672         case LE_EXPR:
4673         case LT_EXPR:
4674         case UNLE_EXPR:
4675         case UNLT_EXPR:
4676           /* In C++ a ?: expression can be an lvalue, so put the
4677              operand which will be used if they are equal first
4678              so that we can convert this back to the
4679              corresponding COND_EXPR.  */
4680           if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1))))
4681             {
4682               comp_op0 = fold_convert_loc (loc, comp_type, comp_op0);
4683               comp_op1 = fold_convert_loc (loc, comp_type, comp_op1);
4684               tem = (comp_code == LE_EXPR || comp_code == UNLE_EXPR)
4685                     ? fold_build2_loc (loc, MIN_EXPR, comp_type, comp_op0, comp_op1)
4686                     : fold_build2_loc (loc, MIN_EXPR, comp_type,
4687                                    comp_op1, comp_op0);
4688               return pedantic_non_lvalue_loc (loc,
4689                                           fold_convert_loc (loc, type, tem));
4690             }
4691           break;
4692         case GE_EXPR:
4693         case GT_EXPR:
4694         case UNGE_EXPR:
4695         case UNGT_EXPR:
4696           if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1))))
4697             {
4698               comp_op0 = fold_convert_loc (loc, comp_type, comp_op0);
4699               comp_op1 = fold_convert_loc (loc, comp_type, comp_op1);
4700               tem = (comp_code == GE_EXPR || comp_code == UNGE_EXPR)
4701                     ? fold_build2_loc (loc, MAX_EXPR, comp_type, comp_op0, comp_op1)
4702                     : fold_build2_loc (loc, MAX_EXPR, comp_type,
4703                                    comp_op1, comp_op0);
4704               return pedantic_non_lvalue_loc (loc,
4705                                           fold_convert_loc (loc, type, tem));
4706             }
4707           break;
4708         case UNEQ_EXPR:
4709           if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1))))
4710             return pedantic_non_lvalue_loc (loc,
4711                                         fold_convert_loc (loc, type, arg2));
4712           break;
4713         case LTGT_EXPR:
4714           if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1))))
4715             return pedantic_non_lvalue_loc (loc,
4716                                         fold_convert_loc (loc, type, arg1));
4717           break;
4718         default:
4719           gcc_assert (TREE_CODE_CLASS (comp_code) == tcc_comparison);
4720           break;
4721         }
4722     }
4723
4724   /* If this is A op C1 ? A : C2 with C1 and C2 constant integers,
4725      we might still be able to simplify this.  For example,
4726      if C1 is one less or one more than C2, this might have started
4727      out as a MIN or MAX and been transformed by this function.
4728      Only good for INTEGER_TYPEs, because we need TYPE_MAX_VALUE.  */
4729
4730   if (INTEGRAL_TYPE_P (type)
4731       && TREE_CODE (arg01) == INTEGER_CST
4732       && TREE_CODE (arg2) == INTEGER_CST)
4733     switch (comp_code)
4734       {
4735       case EQ_EXPR:
4736         if (TREE_CODE (arg1) == INTEGER_CST)
4737           break;
4738         /* We can replace A with C1 in this case.  */
4739         arg1 = fold_convert_loc (loc, type, arg01);
4740         return fold_build3_loc (loc, COND_EXPR, type, arg0, arg1, arg2);
4741
4742       case LT_EXPR:
4743         /* If C1 is C2 + 1, this is min(A, C2), but use ARG00's type for
4744            MIN_EXPR, to preserve the signedness of the comparison.  */
4745         if (! operand_equal_p (arg2, TYPE_MAX_VALUE (type),
4746                                OEP_ONLY_CONST)
4747             && operand_equal_p (arg01,
4748                                 const_binop (PLUS_EXPR, arg2,
4749                                              build_int_cst (type, 1)),
4750                                 OEP_ONLY_CONST))
4751           {
4752             tem = fold_build2_loc (loc, MIN_EXPR, TREE_TYPE (arg00), arg00,
4753                                    fold_convert_loc (loc, TREE_TYPE (arg00),
4754                                                      arg2));
4755             return pedantic_non_lvalue_loc (loc,
4756                                             fold_convert_loc (loc, type, tem));
4757           }
4758         break;
4759
4760       case LE_EXPR:
4761         /* If C1 is C2 - 1, this is min(A, C2), with the same care
4762            as above.  */
4763         if (! operand_equal_p (arg2, TYPE_MIN_VALUE (type),
4764                                OEP_ONLY_CONST)
4765             && operand_equal_p (arg01,
4766                                 const_binop (MINUS_EXPR, arg2,
4767                                              build_int_cst (type, 1)),
4768                                 OEP_ONLY_CONST))
4769           {
4770             tem = fold_build2_loc (loc, MIN_EXPR, TREE_TYPE (arg00), arg00,
4771                                    fold_convert_loc (loc, TREE_TYPE (arg00),
4772                                                      arg2));
4773             return pedantic_non_lvalue_loc (loc,
4774                                             fold_convert_loc (loc, type, tem));
4775           }
4776         break;
4777
4778       case GT_EXPR:
4779         /* If C1 is C2 - 1, this is max(A, C2), but use ARG00's type for
4780            MAX_EXPR, to preserve the signedness of the comparison.  */
4781         if (! operand_equal_p (arg2, TYPE_MIN_VALUE (type),
4782                                OEP_ONLY_CONST)
4783             && operand_equal_p (arg01,
4784                                 const_binop (MINUS_EXPR, arg2,
4785                                              build_int_cst (type, 1)),
4786                                 OEP_ONLY_CONST))
4787           {
4788             tem = fold_build2_loc (loc, MAX_EXPR, TREE_TYPE (arg00), arg00,
4789                                    fold_convert_loc (loc, TREE_TYPE (arg00),
4790                                                      arg2));
4791             return pedantic_non_lvalue_loc (loc, fold_convert_loc (loc, type, tem));
4792           }
4793         break;
4794
4795       case GE_EXPR:
4796         /* If C1 is C2 + 1, this is max(A, C2), with the same care as above.  */
4797         if (! operand_equal_p (arg2, TYPE_MAX_VALUE (type),
4798                                OEP_ONLY_CONST)
4799             && operand_equal_p (arg01,
4800                                 const_binop (PLUS_EXPR, arg2,
4801                                              build_int_cst (type, 1)),
4802                                 OEP_ONLY_CONST))
4803           {
4804             tem = fold_build2_loc (loc, MAX_EXPR, TREE_TYPE (arg00), arg00,
4805                                    fold_convert_loc (loc, TREE_TYPE (arg00),
4806                                                      arg2));
4807             return pedantic_non_lvalue_loc (loc, fold_convert_loc (loc, type, tem));
4808           }
4809         break;
4810       case NE_EXPR:
4811         break;
4812       default:
4813         gcc_unreachable ();
4814       }
4815
4816   return NULL_TREE;
4817 }
4818
4819
4820 \f
4821 #ifndef LOGICAL_OP_NON_SHORT_CIRCUIT
4822 #define LOGICAL_OP_NON_SHORT_CIRCUIT \
4823   (BRANCH_COST (optimize_function_for_speed_p (cfun), \
4824                 false) >= 2)
4825 #endif
4826
4827 /* EXP is some logical combination of boolean tests.  See if we can
4828    merge it into some range test.  Return the new tree if so.  */
4829
4830 static tree
4831 fold_range_test (location_t loc, enum tree_code code, tree type,
4832                  tree op0, tree op1)
4833 {
4834   int or_op = (code == TRUTH_ORIF_EXPR
4835                || code == TRUTH_OR_EXPR);
4836   int in0_p, in1_p, in_p;
4837   tree low0, low1, low, high0, high1, high;
4838   bool strict_overflow_p = false;
4839   tree lhs = make_range (op0, &in0_p, &low0, &high0, &strict_overflow_p);
4840   tree rhs = make_range (op1, &in1_p, &low1, &high1, &strict_overflow_p);
4841   tree tem;
4842   const char * const warnmsg = G_("assuming signed overflow does not occur "
4843                                   "when simplifying range test");
4844
4845   /* If this is an OR operation, invert both sides; we will invert
4846      again at the end.  */
4847   if (or_op)
4848     in0_p = ! in0_p, in1_p = ! in1_p;
4849
4850   /* If both expressions are the same, if we can merge the ranges, and we
4851      can build the range test, return it or it inverted.  If one of the
4852      ranges is always true or always false, consider it to be the same
4853      expression as the other.  */
4854   if ((lhs == 0 || rhs == 0 || operand_equal_p (lhs, rhs, 0))
4855       && merge_ranges (&in_p, &low, &high, in0_p, low0, high0,
4856                        in1_p, low1, high1)
4857       && 0 != (tem = (build_range_check (UNKNOWN_LOCATION, type,
4858                                          lhs != 0 ? lhs
4859                                          : rhs != 0 ? rhs : integer_zero_node,
4860                                          in_p, low, high))))
4861     {
4862       if (strict_overflow_p)
4863         fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_COMPARISON);
4864       return or_op ? invert_truthvalue_loc (loc, tem) : tem;
4865     }
4866
4867   /* On machines where the branch cost is expensive, if this is a
4868      short-circuited branch and the underlying object on both sides
4869      is the same, make a non-short-circuit operation.  */
4870   else if (LOGICAL_OP_NON_SHORT_CIRCUIT
4871            && lhs != 0 && rhs != 0
4872            && (code == TRUTH_ANDIF_EXPR
4873                || code == TRUTH_ORIF_EXPR)
4874            && operand_equal_p (lhs, rhs, 0))
4875     {
4876       /* If simple enough, just rewrite.  Otherwise, make a SAVE_EXPR
4877          unless we are at top level or LHS contains a PLACEHOLDER_EXPR, in
4878          which cases we can't do this.  */
4879       if (simple_operand_p (lhs))
4880         return build2_loc (loc, code == TRUTH_ANDIF_EXPR
4881                            ? TRUTH_AND_EXPR : TRUTH_OR_EXPR,
4882                            type, op0, op1);
4883
4884       else if (lang_hooks.decls.global_bindings_p () == 0
4885                && ! CONTAINS_PLACEHOLDER_P (lhs))
4886         {
4887           tree common = save_expr (lhs);
4888
4889           if (0 != (lhs = build_range_check (loc, type, common,
4890                                              or_op ? ! in0_p : in0_p,
4891                                              low0, high0))
4892               && (0 != (rhs = build_range_check (loc, type, common,
4893                                                  or_op ? ! in1_p : in1_p,
4894                                                  low1, high1))))
4895             {
4896               if (strict_overflow_p)
4897                 fold_overflow_warning (warnmsg,
4898                                        WARN_STRICT_OVERFLOW_COMPARISON);
4899               return build2_loc (loc, code == TRUTH_ANDIF_EXPR
4900                                  ? TRUTH_AND_EXPR : TRUTH_OR_EXPR,
4901                                  type, lhs, rhs);
4902             }
4903         }
4904     }
4905
4906   return 0;
4907 }
4908 \f
4909 /* Subroutine for fold_truthop: C is an INTEGER_CST interpreted as a P
4910    bit value.  Arrange things so the extra bits will be set to zero if and
4911    only if C is signed-extended to its full width.  If MASK is nonzero,
4912    it is an INTEGER_CST that should be AND'ed with the extra bits.  */
4913
4914 static tree
4915 unextend (tree c, int p, int unsignedp, tree mask)
4916 {
4917   tree type = TREE_TYPE (c);
4918   int modesize = GET_MODE_BITSIZE (TYPE_MODE (type));
4919   tree temp;
4920
4921   if (p == modesize || unsignedp)
4922     return c;
4923
4924   /* We work by getting just the sign bit into the low-order bit, then
4925      into the high-order bit, then sign-extend.  We then XOR that value
4926      with C.  */
4927   temp = const_binop (RSHIFT_EXPR, c, size_int (p - 1));
4928   temp = const_binop (BIT_AND_EXPR, temp, size_int (1));
4929
4930   /* We must use a signed type in order to get an arithmetic right shift.
4931      However, we must also avoid introducing accidental overflows, so that
4932      a subsequent call to integer_zerop will work.  Hence we must
4933      do the type conversion here.  At this point, the constant is either
4934      zero or one, and the conversion to a signed type can never overflow.
4935      We could get an overflow if this conversion is done anywhere else.  */
4936   if (TYPE_UNSIGNED (type))
4937     temp = fold_convert (signed_type_for (type), temp);
4938
4939   temp = const_binop (LSHIFT_EXPR, temp, size_int (modesize - 1));
4940   temp = const_binop (RSHIFT_EXPR, temp, size_int (modesize - p - 1));
4941   if (mask != 0)
4942     temp = const_binop (BIT_AND_EXPR, temp,
4943                         fold_convert (TREE_TYPE (c), mask));
4944   /* If necessary, convert the type back to match the type of C.  */
4945   if (TYPE_UNSIGNED (type))
4946     temp = fold_convert (type, temp);
4947
4948   return fold_convert (type, const_binop (BIT_XOR_EXPR, c, temp));
4949 }
4950 \f
4951 /* For an expression that has the form
4952      (A && B) || ~B
4953    or
4954      (A || B) && ~B,
4955    we can drop one of the inner expressions and simplify to
4956      A || ~B
4957    or
4958      A && ~B
4959    LOC is the location of the resulting expression.  OP is the inner
4960    logical operation; the left-hand side in the examples above, while CMPOP
4961    is the right-hand side.  RHS_ONLY is used to prevent us from accidentally
4962    removing a condition that guards another, as in
4963      (A != NULL && A->...) || A == NULL
4964    which we must not transform.  If RHS_ONLY is true, only eliminate the
4965    right-most operand of the inner logical operation.  */
4966
4967 static tree
4968 merge_truthop_with_opposite_arm (location_t loc, tree op, tree cmpop,
4969                                  bool rhs_only)
4970 {
4971   tree type = TREE_TYPE (cmpop);
4972   enum tree_code code = TREE_CODE (cmpop);
4973   enum tree_code truthop_code = TREE_CODE (op);
4974   tree lhs = TREE_OPERAND (op, 0);
4975   tree rhs = TREE_OPERAND (op, 1);
4976   tree orig_lhs = lhs, orig_rhs = rhs;
4977   enum tree_code rhs_code = TREE_CODE (rhs);
4978   enum tree_code lhs_code = TREE_CODE (lhs);
4979   enum tree_code inv_code;
4980
4981   if (TREE_SIDE_EFFECTS (op) || TREE_SIDE_EFFECTS (cmpop))
4982     return NULL_TREE;
4983
4984   if (TREE_CODE_CLASS (code) != tcc_comparison)
4985     return NULL_TREE;
4986
4987   if (rhs_code == truthop_code)
4988     {
4989       tree newrhs = merge_truthop_with_opposite_arm (loc, rhs, cmpop, rhs_only);
4990       if (newrhs != NULL_TREE)
4991         {
4992           rhs = newrhs;
4993           rhs_code = TREE_CODE (rhs);
4994         }
4995     }
4996   if (lhs_code == truthop_code && !rhs_only)
4997     {
4998       tree newlhs = merge_truthop_with_opposite_arm (loc, lhs, cmpop, false);
4999       if (newlhs != NULL_TREE)
5000         {
5001           lhs = newlhs;
5002           lhs_code = TREE_CODE (lhs);
5003         }
5004     }
5005
5006   inv_code = invert_tree_comparison (code, HONOR_NANS (TYPE_MODE (type)));
5007   if (inv_code == rhs_code
5008       && operand_equal_p (TREE_OPERAND (rhs, 0), TREE_OPERAND (cmpop, 0), 0)
5009       && operand_equal_p (TREE_OPERAND (rhs, 1), TREE_OPERAND (cmpop, 1), 0))
5010     return lhs;
5011   if (!rhs_only && inv_code == lhs_code
5012       && operand_equal_p (TREE_OPERAND (lhs, 0), TREE_OPERAND (cmpop, 0), 0)
5013       && operand_equal_p (TREE_OPERAND (lhs, 1), TREE_OPERAND (cmpop, 1), 0))
5014     return rhs;
5015   if (rhs != orig_rhs || lhs != orig_lhs)
5016     return fold_build2_loc (loc, truthop_code, TREE_TYPE (cmpop),
5017                             lhs, rhs);
5018   return NULL_TREE;
5019 }
5020
5021 /* Find ways of folding logical expressions of LHS and RHS:
5022    Try to merge two comparisons to the same innermost item.
5023    Look for range tests like "ch >= '0' && ch <= '9'".
5024    Look for combinations of simple terms on machines with expensive branches
5025    and evaluate the RHS unconditionally.
5026
5027    For example, if we have p->a == 2 && p->b == 4 and we can make an
5028    object large enough to span both A and B, we can do this with a comparison
5029    against the object ANDed with the a mask.
5030
5031    If we have p->a == q->a && p->b == q->b, we may be able to use bit masking
5032    operations to do this with one comparison.
5033
5034    We check for both normal comparisons and the BIT_AND_EXPRs made this by
5035    function and the one above.
5036
5037    CODE is the logical operation being done.  It can be TRUTH_ANDIF_EXPR,
5038    TRUTH_AND_EXPR, TRUTH_ORIF_EXPR, or TRUTH_OR_EXPR.
5039
5040    TRUTH_TYPE is the type of the logical operand and LHS and RHS are its
5041    two operands.
5042
5043    We return the simplified tree or 0 if no optimization is possible.  */
5044
5045 static tree
5046 fold_truthop (location_t loc, enum tree_code code, tree truth_type,
5047               tree lhs, tree rhs)
5048 {
5049   /* If this is the "or" of two comparisons, we can do something if
5050      the comparisons are NE_EXPR.  If this is the "and", we can do something
5051      if the comparisons are EQ_EXPR.  I.e.,
5052         (a->b == 2 && a->c == 4) can become (a->new == NEW).
5053
5054      WANTED_CODE is this operation code.  For single bit fields, we can
5055      convert EQ_EXPR to NE_EXPR so we need not reject the "wrong"
5056      comparison for one-bit fields.  */
5057
5058   enum tree_code wanted_code;
5059   enum tree_code lcode, rcode;
5060   tree ll_arg, lr_arg, rl_arg, rr_arg;
5061   tree ll_inner, lr_inner, rl_inner, rr_inner;
5062   HOST_WIDE_INT ll_bitsize, ll_bitpos, lr_bitsize, lr_bitpos;
5063   HOST_WIDE_INT rl_bitsize, rl_bitpos, rr_bitsize, rr_bitpos;
5064   HOST_WIDE_INT xll_bitpos, xlr_bitpos, xrl_bitpos, xrr_bitpos;
5065   HOST_WIDE_INT lnbitsize, lnbitpos, rnbitsize, rnbitpos;
5066   int ll_unsignedp, lr_unsignedp, rl_unsignedp, rr_unsignedp;
5067   enum machine_mode ll_mode, lr_mode, rl_mode, rr_mode;
5068   enum machine_mode lnmode, rnmode;
5069   tree ll_mask, lr_mask, rl_mask, rr_mask;
5070   tree ll_and_mask, lr_and_mask, rl_and_mask, rr_and_mask;
5071   tree l_const, r_const;
5072   tree lntype, rntype, result;
5073   HOST_WIDE_INT first_bit, end_bit;
5074   int volatilep;
5075   tree orig_lhs = lhs, orig_rhs = rhs;
5076   enum tree_code orig_code = code;
5077
5078   /* Start by getting the comparison codes.  Fail if anything is volatile.
5079      If one operand is a BIT_AND_EXPR with the constant one, treat it as if
5080      it were surrounded with a NE_EXPR.  */
5081
5082   if (TREE_SIDE_EFFECTS (lhs) || TREE_SIDE_EFFECTS (rhs))
5083     return 0;
5084
5085   lcode = TREE_CODE (lhs);
5086   rcode = TREE_CODE (rhs);
5087
5088   if (lcode == BIT_AND_EXPR && integer_onep (TREE_OPERAND (lhs, 1)))
5089     {
5090       lhs = build2 (NE_EXPR, truth_type, lhs,
5091                     build_int_cst (TREE_TYPE (lhs), 0));
5092       lcode = NE_EXPR;
5093     }
5094
5095   if (rcode == BIT_AND_EXPR && integer_onep (TREE_OPERAND (rhs, 1)))
5096     {
5097       rhs = build2 (NE_EXPR, truth_type, rhs,
5098                     build_int_cst (TREE_TYPE (rhs), 0));
5099       rcode = NE_EXPR;
5100     }
5101
5102   if (TREE_CODE_CLASS (lcode) != tcc_comparison
5103       || TREE_CODE_CLASS (rcode) != tcc_comparison)
5104     return 0;
5105
5106   ll_arg = TREE_OPERAND (lhs, 0);
5107   lr_arg = TREE_OPERAND (lhs, 1);
5108   rl_arg = TREE_OPERAND (rhs, 0);
5109   rr_arg = TREE_OPERAND (rhs, 1);
5110
5111   /* Simplify (x<y) && (x==y) into (x<=y) and related optimizations.  */
5112   if (simple_operand_p (ll_arg)
5113       && simple_operand_p (lr_arg))
5114     {
5115       if (operand_equal_p (ll_arg, rl_arg, 0)
5116           && operand_equal_p (lr_arg, rr_arg, 0))
5117         {
5118           result = combine_comparisons (loc, code, lcode, rcode,
5119                                         truth_type, ll_arg, lr_arg);
5120           if (result)
5121             return result;
5122         }
5123       else if (operand_equal_p (ll_arg, rr_arg, 0)
5124                && operand_equal_p (lr_arg, rl_arg, 0))
5125         {
5126           result = combine_comparisons (loc, code, lcode,
5127                                         swap_tree_comparison (rcode),
5128                                         truth_type, ll_arg, lr_arg);
5129           if (result)
5130             return result;
5131         }
5132     }
5133
5134   code = ((code == TRUTH_AND_EXPR || code == TRUTH_ANDIF_EXPR)
5135           ? TRUTH_AND_EXPR : TRUTH_OR_EXPR);
5136
5137   /* If the RHS can be evaluated unconditionally and its operands are
5138      simple, it wins to evaluate the RHS unconditionally on machines
5139      with expensive branches.  In this case, this isn't a comparison
5140      that can be merged.  Avoid doing this if the RHS is a floating-point
5141      comparison since those can trap.  */
5142
5143   if (BRANCH_COST (optimize_function_for_speed_p (cfun),
5144                    false) >= 2
5145       && ! FLOAT_TYPE_P (TREE_TYPE (rl_arg))
5146       && simple_operand_p (rl_arg)
5147       && simple_operand_p (rr_arg))
5148     {
5149       /* Convert (a != 0) || (b != 0) into (a | b) != 0.  */
5150       if (code == TRUTH_OR_EXPR
5151           && lcode == NE_EXPR && integer_zerop (lr_arg)
5152           && rcode == NE_EXPR && integer_zerop (rr_arg)
5153           && TREE_TYPE (ll_arg) == TREE_TYPE (rl_arg)
5154           && INTEGRAL_TYPE_P (TREE_TYPE (ll_arg)))
5155         return build2_loc (loc, NE_EXPR, truth_type,
5156                            build2 (BIT_IOR_EXPR, TREE_TYPE (ll_arg),
5157                                    ll_arg, rl_arg),
5158                            build_int_cst (TREE_TYPE (ll_arg), 0));
5159
5160       /* Convert (a == 0) && (b == 0) into (a | b) == 0.  */
5161       if (code == TRUTH_AND_EXPR
5162           && lcode == EQ_EXPR && integer_zerop (lr_arg)
5163           && rcode == EQ_EXPR && integer_zerop (rr_arg)
5164           && TREE_TYPE (ll_arg) == TREE_TYPE (rl_arg)
5165           && INTEGRAL_TYPE_P (TREE_TYPE (ll_arg)))
5166         return build2_loc (loc, EQ_EXPR, truth_type,
5167                            build2 (BIT_IOR_EXPR, TREE_TYPE (ll_arg),
5168                                    ll_arg, rl_arg),
5169                            build_int_cst (TREE_TYPE (ll_arg), 0));
5170
5171       if (LOGICAL_OP_NON_SHORT_CIRCUIT)
5172         {
5173           if (code != orig_code || lhs != orig_lhs || rhs != orig_rhs)
5174             return build2_loc (loc, code, truth_type, lhs, rhs);
5175           return NULL_TREE;
5176         }
5177     }
5178
5179   /* See if the comparisons can be merged.  Then get all the parameters for
5180      each side.  */
5181
5182   if ((lcode != EQ_EXPR && lcode != NE_EXPR)
5183       || (rcode != EQ_EXPR && rcode != NE_EXPR))
5184     return 0;
5185
5186   volatilep = 0;
5187   ll_inner = decode_field_reference (loc, ll_arg,
5188                                      &ll_bitsize, &ll_bitpos, &ll_mode,
5189                                      &ll_unsignedp, &volatilep, &ll_mask,
5190                                      &ll_and_mask);
5191   lr_inner = decode_field_reference (loc, lr_arg,
5192                                      &lr_bitsize, &lr_bitpos, &lr_mode,
5193                                      &lr_unsignedp, &volatilep, &lr_mask,
5194                                      &lr_and_mask);
5195   rl_inner = decode_field_reference (loc, rl_arg,
5196                                      &rl_bitsize, &rl_bitpos, &rl_mode,
5197                                      &rl_unsignedp, &volatilep, &rl_mask,
5198                                      &rl_and_mask);
5199   rr_inner = decode_field_reference (loc, rr_arg,
5200                                      &rr_bitsize, &rr_bitpos, &rr_mode,
5201                                      &rr_unsignedp, &volatilep, &rr_mask,
5202                                      &rr_and_mask);
5203
5204   /* It must be true that the inner operation on the lhs of each
5205      comparison must be the same if we are to be able to do anything.
5206      Then see if we have constants.  If not, the same must be true for
5207      the rhs's.  */
5208   if (volatilep || ll_inner == 0 || rl_inner == 0
5209       || ! operand_equal_p (ll_inner, rl_inner, 0))
5210     return 0;
5211
5212   if (TREE_CODE (lr_arg) == INTEGER_CST
5213       && TREE_CODE (rr_arg) == INTEGER_CST)
5214     l_const = lr_arg, r_const = rr_arg;
5215   else if (lr_inner == 0 || rr_inner == 0
5216            || ! operand_equal_p (lr_inner, rr_inner, 0))
5217     return 0;
5218   else
5219     l_const = r_const = 0;
5220
5221   /* If either comparison code is not correct for our logical operation,
5222      fail.  However, we can convert a one-bit comparison against zero into
5223      the opposite comparison against that bit being set in the field.  */
5224
5225   wanted_code = (code == TRUTH_AND_EXPR ? EQ_EXPR : NE_EXPR);
5226   if (lcode != wanted_code)
5227     {
5228       if (l_const && integer_zerop (l_const) && integer_pow2p (ll_mask))
5229         {
5230           /* Make the left operand unsigned, since we are only interested
5231              in the value of one bit.  Otherwise we are doing the wrong
5232              thing below.  */
5233           ll_unsignedp = 1;
5234           l_const = ll_mask;
5235         }
5236       else
5237         return 0;
5238     }
5239
5240   /* This is analogous to the code for l_const above.  */
5241   if (rcode != wanted_code)
5242     {
5243       if (r_const && integer_zerop (r_const) && integer_pow2p (rl_mask))
5244         {
5245           rl_unsignedp = 1;
5246           r_const = rl_mask;
5247         }
5248       else
5249         return 0;
5250     }
5251
5252   /* See if we can find a mode that contains both fields being compared on
5253      the left.  If we can't, fail.  Otherwise, update all constants and masks
5254      to be relative to a field of that size.  */
5255   first_bit = MIN (ll_bitpos, rl_bitpos);
5256   end_bit = MAX (ll_bitpos + ll_bitsize, rl_bitpos + rl_bitsize);
5257   lnmode = get_best_mode (end_bit - first_bit, first_bit,
5258                           TYPE_ALIGN (TREE_TYPE (ll_inner)), word_mode,
5259                           volatilep);
5260   if (lnmode == VOIDmode)
5261     return 0;
5262
5263   lnbitsize = GET_MODE_BITSIZE (lnmode);
5264   lnbitpos = first_bit & ~ (lnbitsize - 1);
5265   lntype = lang_hooks.types.type_for_size (lnbitsize, 1);
5266   xll_bitpos = ll_bitpos - lnbitpos, xrl_bitpos = rl_bitpos - lnbitpos;
5267
5268   if (BYTES_BIG_ENDIAN)
5269     {
5270       xll_bitpos = lnbitsize - xll_bitpos - ll_bitsize;
5271       xrl_bitpos = lnbitsize - xrl_bitpos - rl_bitsize;
5272     }
5273
5274   ll_mask = const_binop (LSHIFT_EXPR, fold_convert_loc (loc, lntype, ll_mask),
5275                          size_int (xll_bitpos));
5276   rl_mask = const_binop (LSHIFT_EXPR, fold_convert_loc (loc, lntype, rl_mask),
5277                          size_int (xrl_bitpos));
5278
5279   if (l_const)
5280     {
5281       l_const = fold_convert_loc (loc, lntype, l_const);
5282       l_const = unextend (l_const, ll_bitsize, ll_unsignedp, ll_and_mask);
5283       l_const = const_binop (LSHIFT_EXPR, l_const, size_int (xll_bitpos));
5284       if (! integer_zerop (const_binop (BIT_AND_EXPR, l_const,
5285                                         fold_build1_loc (loc, BIT_NOT_EXPR,
5286                                                      lntype, ll_mask))))
5287         {
5288           warning (0, "comparison is always %d", wanted_code == NE_EXPR);
5289
5290           return constant_boolean_node (wanted_code == NE_EXPR, truth_type);
5291         }
5292     }
5293   if (r_const)
5294     {
5295       r_const = fold_convert_loc (loc, lntype, r_const);
5296       r_const = unextend (r_const, rl_bitsize, rl_unsignedp, rl_and_mask);
5297       r_const = const_binop (LSHIFT_EXPR, r_const, size_int (xrl_bitpos));
5298       if (! integer_zerop (const_binop (BIT_AND_EXPR, r_const,
5299                                         fold_build1_loc (loc, BIT_NOT_EXPR,
5300                                                      lntype, rl_mask))))
5301         {
5302           warning (0, "comparison is always %d", wanted_code == NE_EXPR);
5303
5304           return constant_boolean_node (wanted_code == NE_EXPR, truth_type);
5305         }
5306     }
5307
5308   /* If the right sides are not constant, do the same for it.  Also,
5309      disallow this optimization if a size or signedness mismatch occurs
5310      between the left and right sides.  */
5311   if (l_const == 0)
5312     {
5313       if (ll_bitsize != lr_bitsize || rl_bitsize != rr_bitsize
5314           || ll_unsignedp != lr_unsignedp || rl_unsignedp != rr_unsignedp
5315           /* Make sure the two fields on the right
5316              correspond to the left without being swapped.  */
5317           || ll_bitpos - rl_bitpos != lr_bitpos - rr_bitpos)
5318         return 0;
5319
5320       first_bit = MIN (lr_bitpos, rr_bitpos);
5321       end_bit = MAX (lr_bitpos + lr_bitsize, rr_bitpos + rr_bitsize);
5322       rnmode = get_best_mode (end_bit - first_bit, first_bit,
5323                               TYPE_ALIGN (TREE_TYPE (lr_inner)), word_mode,
5324                               volatilep);
5325       if (rnmode == VOIDmode)
5326         return 0;
5327
5328       rnbitsize = GET_MODE_BITSIZE (rnmode);
5329       rnbitpos = first_bit & ~ (rnbitsize - 1);
5330       rntype = lang_hooks.types.type_for_size (rnbitsize, 1);
5331       xlr_bitpos = lr_bitpos - rnbitpos, xrr_bitpos = rr_bitpos - rnbitpos;
5332
5333       if (BYTES_BIG_ENDIAN)
5334         {
5335           xlr_bitpos = rnbitsize - xlr_bitpos - lr_bitsize;
5336           xrr_bitpos = rnbitsize - xrr_bitpos - rr_bitsize;
5337         }
5338
5339       lr_mask = const_binop (LSHIFT_EXPR, fold_convert_loc (loc,
5340                                                             rntype, lr_mask),
5341                              size_int (xlr_bitpos));
5342       rr_mask = const_binop (LSHIFT_EXPR, fold_convert_loc (loc,
5343                                                             rntype, rr_mask),
5344                              size_int (xrr_bitpos));
5345
5346       /* Make a mask that corresponds to both fields being compared.
5347          Do this for both items being compared.  If the operands are the
5348          same size and the bits being compared are in the same position
5349          then we can do this by masking both and comparing the masked
5350          results.  */
5351       ll_mask = const_binop (BIT_IOR_EXPR, ll_mask, rl_mask);
5352       lr_mask = const_binop (BIT_IOR_EXPR, lr_mask, rr_mask);
5353       if (lnbitsize == rnbitsize && xll_bitpos == xlr_bitpos)
5354         {
5355           lhs = make_bit_field_ref (loc, ll_inner, lntype, lnbitsize, lnbitpos,
5356                                     ll_unsignedp || rl_unsignedp);
5357           if (! all_ones_mask_p (ll_mask, lnbitsize))
5358             lhs = build2 (BIT_AND_EXPR, lntype, lhs, ll_mask);
5359
5360           rhs = make_bit_field_ref (loc, lr_inner, rntype, rnbitsize, rnbitpos,
5361                                     lr_unsignedp || rr_unsignedp);
5362           if (! all_ones_mask_p (lr_mask, rnbitsize))
5363             rhs = build2 (BIT_AND_EXPR, rntype, rhs, lr_mask);
5364
5365           return build2_loc (loc, wanted_code, truth_type, lhs, rhs);
5366         }
5367
5368       /* There is still another way we can do something:  If both pairs of
5369          fields being compared are adjacent, we may be able to make a wider
5370          field containing them both.
5371
5372          Note that we still must mask the lhs/rhs expressions.  Furthermore,
5373          the mask must be shifted to account for the shift done by
5374          make_bit_field_ref.  */
5375       if ((ll_bitsize + ll_bitpos == rl_bitpos
5376            && lr_bitsize + lr_bitpos == rr_bitpos)
5377           || (ll_bitpos == rl_bitpos + rl_bitsize
5378               && lr_bitpos == rr_bitpos + rr_bitsize))
5379         {
5380           tree type;
5381
5382           lhs = make_bit_field_ref (loc, ll_inner, lntype,
5383                                     ll_bitsize + rl_bitsize,
5384                                     MIN (ll_bitpos, rl_bitpos), ll_unsignedp);
5385           rhs = make_bit_field_ref (loc, lr_inner, rntype,
5386                                     lr_bitsize + rr_bitsize,
5387                                     MIN (lr_bitpos, rr_bitpos), lr_unsignedp);
5388
5389           ll_mask = const_binop (RSHIFT_EXPR, ll_mask,
5390                                  size_int (MIN (xll_bitpos, xrl_bitpos)));
5391           lr_mask = const_binop (RSHIFT_EXPR, lr_mask,
5392                                  size_int (MIN (xlr_bitpos, xrr_bitpos)));
5393
5394           /* Convert to the smaller type before masking out unwanted bits.  */
5395           type = lntype;
5396           if (lntype != rntype)
5397             {
5398               if (lnbitsize > rnbitsize)
5399                 {
5400                   lhs = fold_convert_loc (loc, rntype, lhs);
5401                   ll_mask = fold_convert_loc (loc, rntype, ll_mask);
5402                   type = rntype;
5403                 }
5404               else if (lnbitsize < rnbitsize)
5405                 {
5406                   rhs = fold_convert_loc (loc, lntype, rhs);
5407                   lr_mask = fold_convert_loc (loc, lntype, lr_mask);
5408                   type = lntype;
5409                 }
5410             }
5411
5412           if (! all_ones_mask_p (ll_mask, ll_bitsize + rl_bitsize))
5413             lhs = build2 (BIT_AND_EXPR, type, lhs, ll_mask);
5414
5415           if (! all_ones_mask_p (lr_mask, lr_bitsize + rr_bitsize))
5416             rhs = build2 (BIT_AND_EXPR, type, rhs, lr_mask);
5417
5418           return build2_loc (loc, wanted_code, truth_type, lhs, rhs);
5419         }
5420
5421       return 0;
5422     }
5423
5424   /* Handle the case of comparisons with constants.  If there is something in
5425      common between the masks, those bits of the constants must be the same.
5426      If not, the condition is always false.  Test for this to avoid generating
5427      incorrect code below.  */
5428   result = const_binop (BIT_AND_EXPR, ll_mask, rl_mask);
5429   if (! integer_zerop (result)
5430       && simple_cst_equal (const_binop (BIT_AND_EXPR, result, l_const),
5431                            const_binop (BIT_AND_EXPR, result, r_const)) != 1)
5432     {
5433       if (wanted_code == NE_EXPR)
5434         {
5435           warning (0, "%<or%> of unmatched not-equal tests is always 1");
5436           return constant_boolean_node (true, truth_type);
5437         }
5438       else
5439         {
5440           warning (0, "%<and%> of mutually exclusive equal-tests is always 0");
5441           return constant_boolean_node (false, truth_type);
5442         }
5443     }
5444
5445   /* Construct the expression we will return.  First get the component
5446      reference we will make.  Unless the mask is all ones the width of
5447      that field, perform the mask operation.  Then compare with the
5448      merged constant.  */
5449   result = make_bit_field_ref (loc, ll_inner, lntype, lnbitsize, lnbitpos,
5450                                ll_unsignedp || rl_unsignedp);
5451
5452   ll_mask = const_binop (BIT_IOR_EXPR, ll_mask, rl_mask);
5453   if (! all_ones_mask_p (ll_mask, lnbitsize))
5454     result = build2_loc (loc, BIT_AND_EXPR, lntype, result, ll_mask);
5455
5456   return build2_loc (loc, wanted_code, truth_type, result,
5457                      const_binop (BIT_IOR_EXPR, l_const, r_const));
5458 }
5459 \f
5460 /* Optimize T, which is a comparison of a MIN_EXPR or MAX_EXPR with a
5461    constant.  */
5462
5463 static tree
5464 optimize_minmax_comparison (location_t loc, enum tree_code code, tree type,
5465                             tree op0, tree op1)
5466 {
5467   tree arg0 = op0;
5468   enum tree_code op_code;
5469   tree comp_const;
5470   tree minmax_const;
5471   int consts_equal, consts_lt;
5472   tree inner;
5473
5474   STRIP_SIGN_NOPS (arg0);
5475
5476   op_code = TREE_CODE (arg0);
5477   minmax_const = TREE_OPERAND (arg0, 1);
5478   comp_const = fold_convert_loc (loc, TREE_TYPE (arg0), op1);
5479   consts_equal = tree_int_cst_equal (minmax_const, comp_const);
5480   consts_lt = tree_int_cst_lt (minmax_const, comp_const);
5481   inner = TREE_OPERAND (arg0, 0);
5482
5483   /* If something does not permit us to optimize, return the original tree.  */
5484   if ((op_code != MIN_EXPR && op_code != MAX_EXPR)
5485       || TREE_CODE (comp_const) != INTEGER_CST
5486       || TREE_OVERFLOW (comp_const)
5487       || TREE_CODE (minmax_const) != INTEGER_CST
5488       || TREE_OVERFLOW (minmax_const))
5489     return NULL_TREE;
5490
5491   /* Now handle all the various comparison codes.  We only handle EQ_EXPR
5492      and GT_EXPR, doing the rest with recursive calls using logical
5493      simplifications.  */
5494   switch (code)
5495     {
5496     case NE_EXPR:  case LT_EXPR:  case LE_EXPR:
5497       {
5498         tree tem
5499           = optimize_minmax_comparison (loc,
5500                                         invert_tree_comparison (code, false),
5501                                         type, op0, op1);
5502         if (tem)
5503           return invert_truthvalue_loc (loc, tem);
5504         return NULL_TREE;
5505       }
5506
5507     case GE_EXPR:
5508       return
5509         fold_build2_loc (loc, TRUTH_ORIF_EXPR, type,
5510                      optimize_minmax_comparison
5511                      (loc, EQ_EXPR, type, arg0, comp_const),
5512                      optimize_minmax_comparison
5513                      (loc, GT_EXPR, type, arg0, comp_const));
5514
5515     case EQ_EXPR:
5516       if (op_code == MAX_EXPR && consts_equal)
5517         /* MAX (X, 0) == 0  ->  X <= 0  */
5518         return fold_build2_loc (loc, LE_EXPR, type, inner, comp_const);
5519
5520       else if (op_code == MAX_EXPR && consts_lt)
5521         /* MAX (X, 0) == 5  ->  X == 5   */
5522         return fold_build2_loc (loc, EQ_EXPR, type, inner, comp_const);
5523
5524       else if (op_code == MAX_EXPR)
5525         /* MAX (X, 0) == -1  ->  false  */
5526         return omit_one_operand_loc (loc, type, integer_zero_node, inner);
5527
5528       else if (consts_equal)
5529         /* MIN (X, 0) == 0  ->  X >= 0  */
5530         return fold_build2_loc (loc, GE_EXPR, type, inner, comp_const);
5531
5532       else if (consts_lt)
5533         /* MIN (X, 0) == 5  ->  false  */
5534         return omit_one_operand_loc (loc, type, integer_zero_node, inner);
5535
5536       else
5537         /* MIN (X, 0) == -1  ->  X == -1  */
5538         return fold_build2_loc (loc, EQ_EXPR, type, inner, comp_const);
5539
5540     case GT_EXPR:
5541       if (op_code == MAX_EXPR && (consts_equal || consts_lt))
5542         /* MAX (X, 0) > 0  ->  X > 0
5543            MAX (X, 0) > 5  ->  X > 5  */
5544         return fold_build2_loc (loc, GT_EXPR, type, inner, comp_const);
5545
5546       else if (op_code == MAX_EXPR)
5547         /* MAX (X, 0) > -1  ->  true  */
5548         return omit_one_operand_loc (loc, type, integer_one_node, inner);
5549
5550       else if (op_code == MIN_EXPR && (consts_equal || consts_lt))
5551         /* MIN (X, 0) > 0  ->  false
5552            MIN (X, 0) > 5  ->  false  */
5553         return omit_one_operand_loc (loc, type, integer_zero_node, inner);
5554
5555       else
5556         /* MIN (X, 0) > -1  ->  X > -1  */
5557         return fold_build2_loc (loc, GT_EXPR, type, inner, comp_const);
5558
5559     default:
5560       return NULL_TREE;
5561     }
5562 }
5563 \f
5564 /* T is an integer expression that is being multiplied, divided, or taken a
5565    modulus (CODE says which and what kind of divide or modulus) by a
5566    constant C.  See if we can eliminate that operation by folding it with
5567    other operations already in T.  WIDE_TYPE, if non-null, is a type that
5568    should be used for the computation if wider than our type.
5569
5570    For example, if we are dividing (X * 8) + (Y * 16) by 4, we can return
5571    (X * 2) + (Y * 4).  We must, however, be assured that either the original
5572    expression would not overflow or that overflow is undefined for the type
5573    in the language in question.
5574
5575    If we return a non-null expression, it is an equivalent form of the
5576    original computation, but need not be in the original type.
5577
5578    We set *STRICT_OVERFLOW_P to true if the return values depends on
5579    signed overflow being undefined.  Otherwise we do not change
5580    *STRICT_OVERFLOW_P.  */
5581
5582 static tree
5583 extract_muldiv (tree t, tree c, enum tree_code code, tree wide_type,
5584                 bool *strict_overflow_p)
5585 {
5586   /* To avoid exponential search depth, refuse to allow recursion past
5587      three levels.  Beyond that (1) it's highly unlikely that we'll find
5588      something interesting and (2) we've probably processed it before
5589      when we built the inner expression.  */
5590
5591   static int depth;
5592   tree ret;
5593
5594   if (depth > 3)
5595     return NULL;
5596
5597   depth++;
5598   ret = extract_muldiv_1 (t, c, code, wide_type, strict_overflow_p);
5599   depth--;
5600
5601   return ret;
5602 }
5603
5604 static tree
5605 extract_muldiv_1 (tree t, tree c, enum tree_code code, tree wide_type,
5606                   bool *strict_overflow_p)
5607 {
5608   tree type = TREE_TYPE (t);
5609   enum tree_code tcode = TREE_CODE (t);
5610   tree ctype = (wide_type != 0 && (GET_MODE_SIZE (TYPE_MODE (wide_type))
5611                                    > GET_MODE_SIZE (TYPE_MODE (type)))
5612                 ? wide_type : type);
5613   tree t1, t2;
5614   int same_p = tcode == code;
5615   tree op0 = NULL_TREE, op1 = NULL_TREE;
5616   bool sub_strict_overflow_p;
5617
5618   /* Don't deal with constants of zero here; they confuse the code below.  */
5619   if (integer_zerop (c))
5620     return NULL_TREE;
5621
5622   if (TREE_CODE_CLASS (tcode) == tcc_unary)
5623     op0 = TREE_OPERAND (t, 0);
5624
5625   if (TREE_CODE_CLASS (tcode) == tcc_binary)
5626     op0 = TREE_OPERAND (t, 0), op1 = TREE_OPERAND (t, 1);
5627
5628   /* Note that we need not handle conditional operations here since fold
5629      already handles those cases.  So just do arithmetic here.  */
5630   switch (tcode)
5631     {
5632     case INTEGER_CST:
5633       /* For a constant, we can always simplify if we are a multiply
5634          or (for divide and modulus) if it is a multiple of our constant.  */
5635       if (code == MULT_EXPR
5636           || integer_zerop (const_binop (TRUNC_MOD_EXPR, t, c)))
5637         return const_binop (code, fold_convert (ctype, t),
5638                             fold_convert (ctype, c));
5639       break;
5640
5641     CASE_CONVERT: case NON_LVALUE_EXPR:
5642       /* If op0 is an expression ...  */
5643       if ((COMPARISON_CLASS_P (op0)
5644            || UNARY_CLASS_P (op0)
5645            || BINARY_CLASS_P (op0)
5646            || VL_EXP_CLASS_P (op0)
5647            || EXPRESSION_CLASS_P (op0))
5648           /* ... and has wrapping overflow, and its type is smaller
5649              than ctype, then we cannot pass through as widening.  */
5650           && ((TYPE_OVERFLOW_WRAPS (TREE_TYPE (op0))
5651                && ! (TREE_CODE (TREE_TYPE (op0)) == INTEGER_TYPE
5652                      && TYPE_IS_SIZETYPE (TREE_TYPE (op0)))
5653                && (TYPE_PRECISION (ctype)
5654                    > TYPE_PRECISION (TREE_TYPE (op0))))
5655               /* ... or this is a truncation (t is narrower than op0),
5656                  then we cannot pass through this narrowing.  */
5657               || (TYPE_PRECISION (type)
5658                   < TYPE_PRECISION (TREE_TYPE (op0)))
5659               /* ... or signedness changes for division or modulus,
5660                  then we cannot pass through this conversion.  */
5661               || (code != MULT_EXPR
5662                   && (TYPE_UNSIGNED (ctype)
5663                       != TYPE_UNSIGNED (TREE_TYPE (op0))))
5664               /* ... or has undefined overflow while the converted to
5665                  type has not, we cannot do the operation in the inner type
5666                  as that would introduce undefined overflow.  */
5667               || (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (op0))
5668                   && !TYPE_OVERFLOW_UNDEFINED (type))))
5669         break;
5670
5671       /* Pass the constant down and see if we can make a simplification.  If
5672          we can, replace this expression with the inner simplification for
5673          possible later conversion to our or some other type.  */
5674       if ((t2 = fold_convert (TREE_TYPE (op0), c)) != 0
5675           && TREE_CODE (t2) == INTEGER_CST
5676           && !TREE_OVERFLOW (t2)
5677           && (0 != (t1 = extract_muldiv (op0, t2, code,
5678                                          code == MULT_EXPR
5679                                          ? ctype : NULL_TREE,
5680                                          strict_overflow_p))))
5681         return t1;
5682       break;
5683
5684     case ABS_EXPR:
5685       /* If widening the type changes it from signed to unsigned, then we
5686          must avoid building ABS_EXPR itself as unsigned.  */
5687       if (TYPE_UNSIGNED (ctype) && !TYPE_UNSIGNED (type))
5688         {
5689           tree cstype = (*signed_type_for) (ctype);
5690           if ((t1 = extract_muldiv (op0, c, code, cstype, strict_overflow_p))
5691               != 0)
5692             {
5693               t1 = fold_build1 (tcode, cstype, fold_convert (cstype, t1));
5694               return fold_convert (ctype, t1);
5695             }
5696           break;
5697         }
5698       /* If the constant is negative, we cannot simplify this.  */
5699       if (tree_int_cst_sgn (c) == -1)
5700         break;
5701       /* FALLTHROUGH */
5702     case NEGATE_EXPR:
5703       if ((t1 = extract_muldiv (op0, c, code, wide_type, strict_overflow_p))
5704           != 0)
5705         return fold_build1 (tcode, ctype, fold_convert (ctype, t1));
5706       break;
5707
5708     case MIN_EXPR:  case MAX_EXPR:
5709       /* If widening the type changes the signedness, then we can't perform
5710          this optimization as that changes the result.  */
5711       if (TYPE_UNSIGNED (ctype) != TYPE_UNSIGNED (type))
5712         break;
5713
5714       /* MIN (a, b) / 5 -> MIN (a / 5, b / 5)  */
5715       sub_strict_overflow_p = false;
5716       if ((t1 = extract_muldiv (op0, c, code, wide_type,
5717                                 &sub_strict_overflow_p)) != 0
5718           && (t2 = extract_muldiv (op1, c, code, wide_type,
5719                                    &sub_strict_overflow_p)) != 0)
5720         {
5721           if (tree_int_cst_sgn (c) < 0)
5722             tcode = (tcode == MIN_EXPR ? MAX_EXPR : MIN_EXPR);
5723           if (sub_strict_overflow_p)
5724             *strict_overflow_p = true;
5725           return fold_build2 (tcode, ctype, fold_convert (ctype, t1),
5726                               fold_convert (ctype, t2));
5727         }
5728       break;
5729
5730     case LSHIFT_EXPR:  case RSHIFT_EXPR:
5731       /* If the second operand is constant, this is a multiplication
5732          or floor division, by a power of two, so we can treat it that
5733          way unless the multiplier or divisor overflows.  Signed
5734          left-shift overflow is implementation-defined rather than
5735          undefined in C90, so do not convert signed left shift into
5736          multiplication.  */
5737       if (TREE_CODE (op1) == INTEGER_CST
5738           && (tcode == RSHIFT_EXPR || TYPE_UNSIGNED (TREE_TYPE (op0)))
5739           /* const_binop may not detect overflow correctly,
5740              so check for it explicitly here.  */
5741           && TYPE_PRECISION (TREE_TYPE (size_one_node)) > TREE_INT_CST_LOW (op1)
5742           && TREE_INT_CST_HIGH (op1) == 0
5743           && 0 != (t1 = fold_convert (ctype,
5744                                       const_binop (LSHIFT_EXPR,
5745                                                    size_one_node,
5746                                                    op1)))
5747           && !TREE_OVERFLOW (t1))
5748         return extract_muldiv (build2 (tcode == LSHIFT_EXPR
5749                                        ? MULT_EXPR : FLOOR_DIV_EXPR,
5750                                        ctype,
5751                                        fold_convert (ctype, op0),
5752                                        t1),
5753                                c, code, wide_type, strict_overflow_p);
5754       break;
5755
5756     case PLUS_EXPR:  case MINUS_EXPR:
5757       /* See if we can eliminate the operation on both sides.  If we can, we
5758          can return a new PLUS or MINUS.  If we can't, the only remaining
5759          cases where we can do anything are if the second operand is a
5760          constant.  */
5761       sub_strict_overflow_p = false;
5762       t1 = extract_muldiv (op0, c, code, wide_type, &sub_strict_overflow_p);
5763       t2 = extract_muldiv (op1, c, code, wide_type, &sub_strict_overflow_p);
5764       if (t1 != 0 && t2 != 0
5765           && (code == MULT_EXPR
5766               /* If not multiplication, we can only do this if both operands
5767                  are divisible by c.  */
5768               || (multiple_of_p (ctype, op0, c)
5769                   && multiple_of_p (ctype, op1, c))))
5770         {
5771           if (sub_strict_overflow_p)
5772             *strict_overflow_p = true;
5773           return fold_build2 (tcode, ctype, fold_convert (ctype, t1),
5774                               fold_convert (ctype, t2));
5775         }
5776
5777       /* If this was a subtraction, negate OP1 and set it to be an addition.
5778          This simplifies the logic below.  */
5779       if (tcode == MINUS_EXPR)
5780         {
5781           tcode = PLUS_EXPR, op1 = negate_expr (op1);
5782           /* If OP1 was not easily negatable, the constant may be OP0.  */
5783           if (TREE_CODE (op0) == INTEGER_CST)
5784             {
5785               tree tem = op0;
5786               op0 = op1;
5787               op1 = tem;
5788               tem = t1;
5789               t1 = t2;
5790               t2 = tem;
5791             }
5792         }
5793
5794       if (TREE_CODE (op1) != INTEGER_CST)
5795         break;
5796
5797       /* If either OP1 or C are negative, this optimization is not safe for
5798          some of the division and remainder types while for others we need
5799          to change the code.  */
5800       if (tree_int_cst_sgn (op1) < 0 || tree_int_cst_sgn (c) < 0)
5801         {
5802           if (code == CEIL_DIV_EXPR)
5803             code = FLOOR_DIV_EXPR;
5804           else if (code == FLOOR_DIV_EXPR)
5805             code = CEIL_DIV_EXPR;
5806           else if (code != MULT_EXPR
5807                    && code != CEIL_MOD_EXPR && code != FLOOR_MOD_EXPR)
5808             break;
5809         }
5810
5811       /* If it's a multiply or a division/modulus operation of a multiple
5812          of our constant, do the operation and verify it doesn't overflow.  */
5813       if (code == MULT_EXPR
5814           || integer_zerop (const_binop (TRUNC_MOD_EXPR, op1, c)))
5815         {
5816           op1 = const_binop (code, fold_convert (ctype, op1),
5817                              fold_convert (ctype, c));
5818           /* We allow the constant to overflow with wrapping semantics.  */
5819           if (op1 == 0
5820               || (TREE_OVERFLOW (op1) && !TYPE_OVERFLOW_WRAPS (ctype)))
5821             break;
5822         }
5823       else
5824         break;
5825
5826       /* If we have an unsigned type is not a sizetype, we cannot widen
5827          the operation since it will change the result if the original
5828          computation overflowed.  */
5829       if (TYPE_UNSIGNED (ctype)
5830           && ! (TREE_CODE (ctype) == INTEGER_TYPE && TYPE_IS_SIZETYPE (ctype))
5831           && ctype != type)
5832         break;
5833
5834       /* If we were able to eliminate our operation from the first side,
5835          apply our operation to the second side and reform the PLUS.  */
5836       if (t1 != 0 && (TREE_CODE (t1) != code || code == MULT_EXPR))
5837         return fold_build2 (tcode, ctype, fold_convert (ctype, t1), op1);
5838
5839       /* The last case is if we are a multiply.  In that case, we can
5840          apply the distributive law to commute the multiply and addition
5841          if the multiplication of the constants doesn't overflow.  */
5842       if (code == MULT_EXPR)
5843         return fold_build2 (tcode, ctype,
5844                             fold_build2 (code, ctype,
5845                                          fold_convert (ctype, op0),
5846                                          fold_convert (ctype, c)),
5847                             op1);
5848
5849       break;
5850
5851     case MULT_EXPR:
5852       /* We have a special case here if we are doing something like
5853          (C * 8) % 4 since we know that's zero.  */
5854       if ((code == TRUNC_MOD_EXPR || code == CEIL_MOD_EXPR
5855            || code == FLOOR_MOD_EXPR || code == ROUND_MOD_EXPR)
5856           /* If the multiplication can overflow we cannot optimize this.
5857              ???  Until we can properly mark individual operations as
5858              not overflowing we need to treat sizetype special here as
5859              stor-layout relies on this opimization to make
5860              DECL_FIELD_BIT_OFFSET always a constant.  */
5861           && (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (t))
5862               || (TREE_CODE (TREE_TYPE (t)) == INTEGER_TYPE
5863                   && TYPE_IS_SIZETYPE (TREE_TYPE (t))))
5864           && TREE_CODE (TREE_OPERAND (t, 1)) == INTEGER_CST
5865           && integer_zerop (const_binop (TRUNC_MOD_EXPR, op1, c)))
5866         {
5867           *strict_overflow_p = true;
5868           return omit_one_operand (type, integer_zero_node, op0);
5869         }
5870
5871       /* ... fall through ...  */
5872
5873     case TRUNC_DIV_EXPR:  case CEIL_DIV_EXPR:  case FLOOR_DIV_EXPR:
5874     case ROUND_DIV_EXPR:  case EXACT_DIV_EXPR:
5875       /* If we can extract our operation from the LHS, do so and return a
5876          new operation.  Likewise for the RHS from a MULT_EXPR.  Otherwise,
5877          do something only if the second operand is a constant.  */
5878       if (same_p
5879           && (t1 = extract_muldiv (op0, c, code, wide_type,
5880                                    strict_overflow_p)) != 0)
5881         return fold_build2 (tcode, ctype, fold_convert (ctype, t1),
5882                             fold_convert (ctype, op1));
5883       else if (tcode == MULT_EXPR && code == MULT_EXPR
5884                && (t1 = extract_muldiv (op1, c, code, wide_type,
5885                                         strict_overflow_p)) != 0)
5886         return fold_build2 (tcode, ctype, fold_convert (ctype, op0),
5887                             fold_convert (ctype, t1));
5888       else if (TREE_CODE (op1) != INTEGER_CST)
5889         return 0;
5890
5891       /* If these are the same operation types, we can associate them
5892          assuming no overflow.  */
5893       if (tcode == code
5894           && 0 != (t1 = int_const_binop (MULT_EXPR,
5895                                          fold_convert (ctype, op1),
5896                                          fold_convert (ctype, c), 1))
5897           && 0 != (t1 = force_fit_type_double (ctype, tree_to_double_int (t1),
5898                                                (TYPE_UNSIGNED (ctype)
5899                                                 && tcode != MULT_EXPR) ? -1 : 1,
5900                                                TREE_OVERFLOW (t1)))
5901           && !TREE_OVERFLOW (t1))
5902         return fold_build2 (tcode, ctype, fold_convert (ctype, op0), t1);
5903
5904       /* If these operations "cancel" each other, we have the main
5905          optimizations of this pass, which occur when either constant is a
5906          multiple of the other, in which case we replace this with either an
5907          operation or CODE or TCODE.
5908
5909          If we have an unsigned type that is not a sizetype, we cannot do
5910          this since it will change the result if the original computation
5911          overflowed.  */
5912       if ((TYPE_OVERFLOW_UNDEFINED (ctype)
5913            || (TREE_CODE (ctype) == INTEGER_TYPE && TYPE_IS_SIZETYPE (ctype)))
5914           && ((code == MULT_EXPR && tcode == EXACT_DIV_EXPR)
5915               || (tcode == MULT_EXPR
5916                   && code != TRUNC_MOD_EXPR && code != CEIL_MOD_EXPR
5917                   && code != FLOOR_MOD_EXPR && code != ROUND_MOD_EXPR
5918                   && code != MULT_EXPR)))
5919         {
5920           if (integer_zerop (const_binop (TRUNC_MOD_EXPR, op1, c)))
5921             {
5922               if (TYPE_OVERFLOW_UNDEFINED (ctype))
5923                 *strict_overflow_p = true;
5924               return fold_build2 (tcode, ctype, fold_convert (ctype, op0),
5925                                   fold_convert (ctype,
5926                                                 const_binop (TRUNC_DIV_EXPR,
5927                                                              op1, c)));
5928             }
5929           else if (integer_zerop (const_binop (TRUNC_MOD_EXPR, c, op1)))
5930             {
5931               if (TYPE_OVERFLOW_UNDEFINED (ctype))
5932                 *strict_overflow_p = true;
5933               return fold_build2 (code, ctype, fold_convert (ctype, op0),
5934                                   fold_convert (ctype,
5935                                                 const_binop (TRUNC_DIV_EXPR,
5936                                                              c, op1)));
5937             }
5938         }
5939       break;
5940
5941     default:
5942       break;
5943     }
5944
5945   return 0;
5946 }
5947 \f
5948 /* Return a node which has the indicated constant VALUE (either 0 or
5949    1), and is of the indicated TYPE.  */
5950
5951 tree
5952 constant_boolean_node (int value, tree type)
5953 {
5954   if (type == integer_type_node)
5955     return value ? integer_one_node : integer_zero_node;
5956   else if (type == boolean_type_node)
5957     return value ? boolean_true_node : boolean_false_node;
5958   else
5959     return build_int_cst (type, value);
5960 }
5961
5962
5963 /* Transform `a + (b ? x : y)' into `b ? (a + x) : (a + y)'.
5964    Transform, `a + (x < y)' into `(x < y) ? (a + 1) : (a + 0)'.  Here
5965    CODE corresponds to the `+', COND to the `(b ? x : y)' or `(x < y)'
5966    expression, and ARG to `a'.  If COND_FIRST_P is nonzero, then the
5967    COND is the first argument to CODE; otherwise (as in the example
5968    given here), it is the second argument.  TYPE is the type of the
5969    original expression.  Return NULL_TREE if no simplification is
5970    possible.  */
5971
5972 static tree
5973 fold_binary_op_with_conditional_arg (location_t loc,
5974                                      enum tree_code code,
5975                                      tree type, tree op0, tree op1,
5976                                      tree cond, tree arg, int cond_first_p)
5977 {
5978   tree cond_type = cond_first_p ? TREE_TYPE (op0) : TREE_TYPE (op1);
5979   tree arg_type = cond_first_p ? TREE_TYPE (op1) : TREE_TYPE (op0);
5980   tree test, true_value, false_value;
5981   tree lhs = NULL_TREE;
5982   tree rhs = NULL_TREE;
5983
5984   if (TREE_CODE (cond) == COND_EXPR)
5985     {
5986       test = TREE_OPERAND (cond, 0);
5987       true_value = TREE_OPERAND (cond, 1);
5988       false_value = TREE_OPERAND (cond, 2);
5989       /* If this operand throws an expression, then it does not make
5990          sense to try to perform a logical or arithmetic operation
5991          involving it.  */
5992       if (VOID_TYPE_P (TREE_TYPE (true_value)))
5993         lhs = true_value;
5994       if (VOID_TYPE_P (TREE_TYPE (false_value)))
5995         rhs = false_value;
5996     }
5997   else
5998     {
5999       tree testtype = TREE_TYPE (cond);
6000       test = cond;
6001       true_value = constant_boolean_node (true, testtype);
6002       false_value = constant_boolean_node (false, testtype);
6003     }
6004
6005   /* This transformation is only worthwhile if we don't have to wrap ARG
6006      in a SAVE_EXPR and the operation can be simplified on at least one
6007      of the branches once its pushed inside the COND_EXPR.  */
6008   if (!TREE_CONSTANT (arg)
6009       && (TREE_SIDE_EFFECTS (arg)
6010           || TREE_CONSTANT (true_value) || TREE_CONSTANT (false_value)))
6011     return NULL_TREE;
6012
6013   arg = fold_convert_loc (loc, arg_type, arg);
6014   if (lhs == 0)
6015     {
6016       true_value = fold_convert_loc (loc, cond_type, true_value);
6017       if (cond_first_p)
6018         lhs = fold_build2_loc (loc, code, type, true_value, arg);
6019       else
6020         lhs = fold_build2_loc (loc, code, type, arg, true_value);
6021     }
6022   if (rhs == 0)
6023     {
6024       false_value = fold_convert_loc (loc, cond_type, false_value);
6025       if (cond_first_p)
6026         rhs = fold_build2_loc (loc, code, type, false_value, arg);
6027       else
6028         rhs = fold_build2_loc (loc, code, type, arg, false_value);
6029     }
6030
6031   /* Check that we have simplified at least one of the branches.  */
6032   if (!TREE_CONSTANT (arg) && !TREE_CONSTANT (lhs) && !TREE_CONSTANT (rhs))
6033     return NULL_TREE;
6034
6035   return fold_build3_loc (loc, COND_EXPR, type, test, lhs, rhs);
6036 }
6037
6038 \f
6039 /* Subroutine of fold() that checks for the addition of +/- 0.0.
6040
6041    If !NEGATE, return true if ADDEND is +/-0.0 and, for all X of type
6042    TYPE, X + ADDEND is the same as X.  If NEGATE, return true if X -
6043    ADDEND is the same as X.
6044
6045    X + 0 and X - 0 both give X when X is NaN, infinite, or nonzero
6046    and finite.  The problematic cases are when X is zero, and its mode
6047    has signed zeros.  In the case of rounding towards -infinity,
6048    X - 0 is not the same as X because 0 - 0 is -0.  In other rounding
6049    modes, X + 0 is not the same as X because -0 + 0 is 0.  */
6050
6051 bool
6052 fold_real_zero_addition_p (const_tree type, const_tree addend, int negate)
6053 {
6054   if (!real_zerop (addend))
6055     return false;
6056
6057   /* Don't allow the fold with -fsignaling-nans.  */
6058   if (HONOR_SNANS (TYPE_MODE (type)))
6059     return false;
6060
6061   /* Allow the fold if zeros aren't signed, or their sign isn't important.  */
6062   if (!HONOR_SIGNED_ZEROS (TYPE_MODE (type)))
6063     return true;
6064
6065   /* Treat x + -0 as x - 0 and x - -0 as x + 0.  */
6066   if (TREE_CODE (addend) == REAL_CST
6067       && REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (addend)))
6068     negate = !negate;
6069
6070   /* The mode has signed zeros, and we have to honor their sign.
6071      In this situation, there is only one case we can return true for.
6072      X - 0 is the same as X unless rounding towards -infinity is
6073      supported.  */
6074   return negate && !HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (type));
6075 }
6076
6077 /* Subroutine of fold() that checks comparisons of built-in math
6078    functions against real constants.
6079
6080    FCODE is the DECL_FUNCTION_CODE of the built-in, CODE is the comparison
6081    operator: EQ_EXPR, NE_EXPR, GT_EXPR, LT_EXPR, GE_EXPR or LE_EXPR.  TYPE
6082    is the type of the result and ARG0 and ARG1 are the operands of the
6083    comparison.  ARG1 must be a TREE_REAL_CST.
6084
6085    The function returns the constant folded tree if a simplification
6086    can be made, and NULL_TREE otherwise.  */
6087
6088 static tree
6089 fold_mathfn_compare (location_t loc,
6090                      enum built_in_function fcode, enum tree_code code,
6091                      tree type, tree arg0, tree arg1)
6092 {
6093   REAL_VALUE_TYPE c;
6094
6095   if (BUILTIN_SQRT_P (fcode))
6096     {
6097       tree arg = CALL_EXPR_ARG (arg0, 0);
6098       enum machine_mode mode = TYPE_MODE (TREE_TYPE (arg0));
6099
6100       c = TREE_REAL_CST (arg1);
6101       if (REAL_VALUE_NEGATIVE (c))
6102         {
6103           /* sqrt(x) < y is always false, if y is negative.  */
6104           if (code == EQ_EXPR || code == LT_EXPR || code == LE_EXPR)
6105             return omit_one_operand_loc (loc, type, integer_zero_node, arg);
6106
6107           /* sqrt(x) > y is always true, if y is negative and we
6108              don't care about NaNs, i.e. negative values of x.  */
6109           if (code == NE_EXPR || !HONOR_NANS (mode))
6110             return omit_one_operand_loc (loc, type, integer_one_node, arg);
6111
6112           /* sqrt(x) > y is the same as x >= 0, if y is negative.  */
6113           return fold_build2_loc (loc, GE_EXPR, type, arg,
6114                               build_real (TREE_TYPE (arg), dconst0));
6115         }
6116       else if (code == GT_EXPR || code == GE_EXPR)
6117         {
6118           REAL_VALUE_TYPE c2;
6119
6120           REAL_ARITHMETIC (c2, MULT_EXPR, c, c);
6121           real_convert (&c2, mode, &c2);
6122
6123           if (REAL_VALUE_ISINF (c2))
6124             {
6125               /* sqrt(x) > y is x == +Inf, when y is very large.  */
6126               if (HONOR_INFINITIES (mode))
6127                 return fold_build2_loc (loc, EQ_EXPR, type, arg,
6128                                     build_real (TREE_TYPE (arg), c2));
6129
6130               /* sqrt(x) > y is always false, when y is very large
6131                  and we don't care about infinities.  */
6132               return omit_one_operand_loc (loc, type, integer_zero_node, arg);
6133             }
6134
6135           /* sqrt(x) > c is the same as x > c*c.  */
6136           return fold_build2_loc (loc, code, type, arg,
6137                               build_real (TREE_TYPE (arg), c2));
6138         }
6139       else if (code == LT_EXPR || code == LE_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 always true, when y is a very large
6149                  value and we don't care about NaNs or Infinities.  */
6150               if (! HONOR_NANS (mode) && ! HONOR_INFINITIES (mode))
6151                 return omit_one_operand_loc (loc, type, integer_one_node, arg);
6152
6153               /* sqrt(x) < y is x != +Inf when y is very large and we
6154                  don't care about NaNs.  */
6155               if (! HONOR_NANS (mode))
6156                 return fold_build2_loc (loc, NE_EXPR, type, arg,
6157                                     build_real (TREE_TYPE (arg), c2));
6158
6159               /* sqrt(x) < y is x >= 0 when y is very large and we
6160                  don't care about Infinities.  */
6161               if (! HONOR_INFINITIES (mode))
6162                 return fold_build2_loc (loc, GE_EXPR, type, arg,
6163                                     build_real (TREE_TYPE (arg), dconst0));
6164
6165               /* sqrt(x) < y is x >= 0 && x != +Inf, when y is large.  */
6166               if (lang_hooks.decls.global_bindings_p () != 0
6167                   || CONTAINS_PLACEHOLDER_P (arg))
6168                 return NULL_TREE;
6169
6170               arg = save_expr (arg);
6171               return fold_build2_loc (loc, TRUTH_ANDIF_EXPR, type,
6172                                   fold_build2_loc (loc, GE_EXPR, type, arg,
6173                                                build_real (TREE_TYPE (arg),
6174                                                            dconst0)),
6175                                   fold_build2_loc (loc, NE_EXPR, type, arg,
6176                                                build_real (TREE_TYPE (arg),
6177                                                            c2)));
6178             }
6179
6180           /* sqrt(x) < c is the same as x < c*c, if we ignore NaNs.  */
6181           if (! HONOR_NANS (mode))
6182             return fold_build2_loc (loc, code, type, arg,
6183                                 build_real (TREE_TYPE (arg), c2));
6184
6185           /* sqrt(x) < c is the same as x >= 0 && x < c*c.  */
6186           if (lang_hooks.decls.global_bindings_p () == 0
6187               && ! CONTAINS_PLACEHOLDER_P (arg))
6188             {
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, code, type, arg,
6195                                                build_real (TREE_TYPE (arg),
6196                                                            c2)));
6197             }
6198         }
6199     }
6200
6201   return NULL_TREE;
6202 }
6203
6204 /* Subroutine of fold() that optimizes comparisons against Infinities,
6205    either +Inf or -Inf.
6206
6207    CODE is the comparison operator: EQ_EXPR, NE_EXPR, GT_EXPR, LT_EXPR,
6208    GE_EXPR or LE_EXPR.  TYPE is the type of the result and ARG0 and ARG1
6209    are the operands of the comparison.  ARG1 must be a TREE_REAL_CST.
6210
6211    The function returns the constant folded tree if a simplification
6212    can be made, and NULL_TREE otherwise.  */
6213
6214 static tree
6215 fold_inf_compare (location_t loc, enum tree_code code, tree type,
6216                   tree arg0, tree arg1)
6217 {
6218   enum machine_mode mode;
6219   REAL_VALUE_TYPE max;
6220   tree temp;
6221   bool neg;
6222
6223   mode = TYPE_MODE (TREE_TYPE (arg0));
6224
6225   /* For negative infinity swap the sense of the comparison.  */
6226   neg = REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg1));
6227   if (neg)
6228     code = swap_tree_comparison (code);
6229
6230   switch (code)
6231     {
6232     case GT_EXPR:
6233       /* x > +Inf is always false, if with ignore sNANs.  */
6234       if (HONOR_SNANS (mode))
6235         return NULL_TREE;
6236       return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
6237
6238     case LE_EXPR:
6239       /* x <= +Inf is always true, if we don't case about NaNs.  */
6240       if (! HONOR_NANS (mode))
6241         return omit_one_operand_loc (loc, type, integer_one_node, arg0);
6242
6243       /* x <= +Inf is the same as x == x, i.e. isfinite(x).  */
6244       if (lang_hooks.decls.global_bindings_p () == 0
6245           && ! CONTAINS_PLACEHOLDER_P (arg0))
6246         {
6247           arg0 = save_expr (arg0);
6248           return fold_build2_loc (loc, EQ_EXPR, type, arg0, arg0);
6249         }
6250       break;
6251
6252     case EQ_EXPR:
6253     case GE_EXPR:
6254       /* x == +Inf and x >= +Inf are always equal to x > DBL_MAX.  */
6255       real_maxval (&max, neg, mode);
6256       return fold_build2_loc (loc, neg ? LT_EXPR : GT_EXPR, type,
6257                           arg0, build_real (TREE_TYPE (arg0), max));
6258
6259     case LT_EXPR:
6260       /* x < +Inf is always equal to x <= DBL_MAX.  */
6261       real_maxval (&max, neg, mode);
6262       return fold_build2_loc (loc, neg ? GE_EXPR : LE_EXPR, type,
6263                           arg0, build_real (TREE_TYPE (arg0), max));
6264
6265     case NE_EXPR:
6266       /* x != +Inf is always equal to !(x > DBL_MAX).  */
6267       real_maxval (&max, neg, mode);
6268       if (! HONOR_NANS (mode))
6269         return fold_build2_loc (loc, neg ? GE_EXPR : LE_EXPR, type,
6270                             arg0, build_real (TREE_TYPE (arg0), max));
6271
6272       temp = fold_build2_loc (loc, neg ? LT_EXPR : GT_EXPR, type,
6273                           arg0, build_real (TREE_TYPE (arg0), max));
6274       return fold_build1_loc (loc, TRUTH_NOT_EXPR, type, temp);
6275
6276     default:
6277       break;
6278     }
6279
6280   return NULL_TREE;
6281 }
6282
6283 /* Subroutine of fold() that optimizes comparisons of a division by
6284    a nonzero integer constant against an integer constant, i.e.
6285    X/C1 op C2.
6286
6287    CODE is the comparison operator: EQ_EXPR, NE_EXPR, GT_EXPR, LT_EXPR,
6288    GE_EXPR or LE_EXPR.  TYPE is the type of the result and ARG0 and ARG1
6289    are the operands of the comparison.  ARG1 must be a TREE_REAL_CST.
6290
6291    The function returns the constant folded tree if a simplification
6292    can be made, and NULL_TREE otherwise.  */
6293
6294 static tree
6295 fold_div_compare (location_t loc,
6296                   enum tree_code code, tree type, tree arg0, tree arg1)
6297 {
6298   tree prod, tmp, hi, lo;
6299   tree arg00 = TREE_OPERAND (arg0, 0);
6300   tree arg01 = TREE_OPERAND (arg0, 1);
6301   double_int val;
6302   bool unsigned_p = TYPE_UNSIGNED (TREE_TYPE (arg0));
6303   bool neg_overflow;
6304   int overflow;
6305
6306   /* We have to do this the hard way to detect unsigned overflow.
6307      prod = int_const_binop (MULT_EXPR, arg01, arg1, 0);  */
6308   overflow = mul_double_with_sign (TREE_INT_CST_LOW (arg01),
6309                                    TREE_INT_CST_HIGH (arg01),
6310                                    TREE_INT_CST_LOW (arg1),
6311                                    TREE_INT_CST_HIGH (arg1),
6312                                    &val.low, &val.high, unsigned_p);
6313   prod = force_fit_type_double (TREE_TYPE (arg00), val, -1, overflow);
6314   neg_overflow = false;
6315
6316   if (unsigned_p)
6317     {
6318       tmp = int_const_binop (MINUS_EXPR, arg01,
6319                              build_int_cst (TREE_TYPE (arg01), 1), 0);
6320       lo = prod;
6321
6322       /* Likewise hi = int_const_binop (PLUS_EXPR, prod, tmp, 0).  */
6323       overflow = add_double_with_sign (TREE_INT_CST_LOW (prod),
6324                                        TREE_INT_CST_HIGH (prod),
6325                                        TREE_INT_CST_LOW (tmp),
6326                                        TREE_INT_CST_HIGH (tmp),
6327                                        &val.low, &val.high, unsigned_p);
6328       hi = force_fit_type_double (TREE_TYPE (arg00), val,
6329                                   -1, overflow | TREE_OVERFLOW (prod));
6330     }
6331   else if (tree_int_cst_sgn (arg01) >= 0)
6332     {
6333       tmp = int_const_binop (MINUS_EXPR, arg01,
6334                              build_int_cst (TREE_TYPE (arg01), 1), 0);
6335       switch (tree_int_cst_sgn (arg1))
6336         {
6337         case -1:
6338           neg_overflow = true;
6339           lo = int_const_binop (MINUS_EXPR, prod, tmp, 0);
6340           hi = prod;
6341           break;
6342
6343         case  0:
6344           lo = fold_negate_const (tmp, TREE_TYPE (arg0));
6345           hi = tmp;
6346           break;
6347
6348         case  1:
6349           hi = int_const_binop (PLUS_EXPR, prod, tmp, 0);
6350           lo = prod;
6351           break;
6352
6353         default:
6354           gcc_unreachable ();
6355         }
6356     }
6357   else
6358     {
6359       /* A negative divisor reverses the relational operators.  */
6360       code = swap_tree_comparison (code);
6361
6362       tmp = int_const_binop (PLUS_EXPR, arg01,
6363                              build_int_cst (TREE_TYPE (arg01), 1), 0);
6364       switch (tree_int_cst_sgn (arg1))
6365         {
6366         case -1:
6367           hi = int_const_binop (MINUS_EXPR, prod, tmp, 0);
6368           lo = prod;
6369           break;
6370
6371         case  0:
6372           hi = fold_negate_const (tmp, TREE_TYPE (arg0));
6373           lo = tmp;
6374           break;
6375
6376         case  1:
6377           neg_overflow = true;
6378           lo = int_const_binop (PLUS_EXPR, prod, tmp, 0);
6379           hi = prod;
6380           break;
6381
6382         default:
6383           gcc_unreachable ();
6384         }
6385     }
6386
6387   switch (code)
6388     {
6389     case EQ_EXPR:
6390       if (TREE_OVERFLOW (lo) && TREE_OVERFLOW (hi))
6391         return omit_one_operand_loc (loc, type, integer_zero_node, arg00);
6392       if (TREE_OVERFLOW (hi))
6393         return fold_build2_loc (loc, GE_EXPR, type, arg00, lo);
6394       if (TREE_OVERFLOW (lo))
6395         return fold_build2_loc (loc, LE_EXPR, type, arg00, hi);
6396       return build_range_check (loc, type, arg00, 1, lo, hi);
6397
6398     case NE_EXPR:
6399       if (TREE_OVERFLOW (lo) && TREE_OVERFLOW (hi))
6400         return omit_one_operand_loc (loc, type, integer_one_node, arg00);
6401       if (TREE_OVERFLOW (hi))
6402         return fold_build2_loc (loc, LT_EXPR, type, arg00, lo);
6403       if (TREE_OVERFLOW (lo))
6404         return fold_build2_loc (loc, GT_EXPR, type, arg00, hi);
6405       return build_range_check (loc, type, arg00, 0, lo, hi);
6406
6407     case LT_EXPR:
6408       if (TREE_OVERFLOW (lo))
6409         {
6410           tmp = neg_overflow ? integer_zero_node : integer_one_node;
6411           return omit_one_operand_loc (loc, type, tmp, arg00);
6412         }
6413       return fold_build2_loc (loc, LT_EXPR, type, arg00, lo);
6414
6415     case LE_EXPR:
6416       if (TREE_OVERFLOW (hi))
6417         {
6418           tmp = neg_overflow ? integer_zero_node : integer_one_node;
6419           return omit_one_operand_loc (loc, type, tmp, arg00);
6420         }
6421       return fold_build2_loc (loc, LE_EXPR, type, arg00, hi);
6422
6423     case GT_EXPR:
6424       if (TREE_OVERFLOW (hi))
6425         {
6426           tmp = neg_overflow ? integer_one_node : integer_zero_node;
6427           return omit_one_operand_loc (loc, type, tmp, arg00);
6428         }
6429       return fold_build2_loc (loc, GT_EXPR, type, arg00, hi);
6430
6431     case GE_EXPR:
6432       if (TREE_OVERFLOW (lo))
6433         {
6434           tmp = neg_overflow ? integer_one_node : integer_zero_node;
6435           return omit_one_operand_loc (loc, type, tmp, arg00);
6436         }
6437       return fold_build2_loc (loc, GE_EXPR, type, arg00, lo);
6438
6439     default:
6440       break;
6441     }
6442
6443   return NULL_TREE;
6444 }
6445
6446
6447 /* If CODE with arguments ARG0 and ARG1 represents a single bit
6448    equality/inequality test, then return a simplified form of the test
6449    using a sign testing.  Otherwise return NULL.  TYPE is the desired
6450    result type.  */
6451
6452 static tree
6453 fold_single_bit_test_into_sign_test (location_t loc,
6454                                      enum tree_code code, tree arg0, tree arg1,
6455                                      tree result_type)
6456 {
6457   /* If this is testing a single bit, we can optimize the test.  */
6458   if ((code == NE_EXPR || code == EQ_EXPR)
6459       && TREE_CODE (arg0) == BIT_AND_EXPR && integer_zerop (arg1)
6460       && integer_pow2p (TREE_OPERAND (arg0, 1)))
6461     {
6462       /* If we have (A & C) != 0 where C is the sign bit of A, convert
6463          this into A < 0.  Similarly for (A & C) == 0 into A >= 0.  */
6464       tree arg00 = sign_bit_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg0, 1));
6465
6466       if (arg00 != NULL_TREE
6467           /* This is only a win if casting to a signed type is cheap,
6468              i.e. when arg00's type is not a partial mode.  */
6469           && TYPE_PRECISION (TREE_TYPE (arg00))
6470              == GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (arg00))))
6471         {
6472           tree stype = signed_type_for (TREE_TYPE (arg00));
6473           return fold_build2_loc (loc, code == EQ_EXPR ? GE_EXPR : LT_EXPR,
6474                               result_type,
6475                               fold_convert_loc (loc, stype, arg00),
6476                               build_int_cst (stype, 0));
6477         }
6478     }
6479
6480   return NULL_TREE;
6481 }
6482
6483 /* If CODE with arguments ARG0 and ARG1 represents a single bit
6484    equality/inequality test, then return a simplified form of
6485    the test using shifts and logical operations.  Otherwise return
6486    NULL.  TYPE is the desired result type.  */
6487
6488 tree
6489 fold_single_bit_test (location_t loc, enum tree_code code,
6490                       tree arg0, tree arg1, tree result_type)
6491 {
6492   /* If this is testing a single bit, we can optimize the test.  */
6493   if ((code == NE_EXPR || code == EQ_EXPR)
6494       && TREE_CODE (arg0) == BIT_AND_EXPR && integer_zerop (arg1)
6495       && integer_pow2p (TREE_OPERAND (arg0, 1)))
6496     {
6497       tree inner = TREE_OPERAND (arg0, 0);
6498       tree type = TREE_TYPE (arg0);
6499       int bitnum = tree_log2 (TREE_OPERAND (arg0, 1));
6500       enum machine_mode operand_mode = TYPE_MODE (type);
6501       int ops_unsigned;
6502       tree signed_type, unsigned_type, intermediate_type;
6503       tree tem, one;
6504
6505       /* First, see if we can fold the single bit test into a sign-bit
6506          test.  */
6507       tem = fold_single_bit_test_into_sign_test (loc, code, arg0, arg1,
6508                                                  result_type);
6509       if (tem)
6510         return tem;
6511
6512       /* Otherwise we have (A & C) != 0 where C is a single bit,
6513          convert that into ((A >> C2) & 1).  Where C2 = log2(C).
6514          Similarly for (A & C) == 0.  */
6515
6516       /* If INNER is a right shift of a constant and it plus BITNUM does
6517          not overflow, adjust BITNUM and INNER.  */
6518       if (TREE_CODE (inner) == RSHIFT_EXPR
6519           && TREE_CODE (TREE_OPERAND (inner, 1)) == INTEGER_CST
6520           && TREE_INT_CST_HIGH (TREE_OPERAND (inner, 1)) == 0
6521           && bitnum < TYPE_PRECISION (type)
6522           && 0 > compare_tree_int (TREE_OPERAND (inner, 1),
6523                                    bitnum - TYPE_PRECISION (type)))
6524         {
6525           bitnum += TREE_INT_CST_LOW (TREE_OPERAND (inner, 1));
6526           inner = TREE_OPERAND (inner, 0);
6527         }
6528
6529       /* If we are going to be able to omit the AND below, we must do our
6530          operations as unsigned.  If we must use the AND, we have a choice.
6531          Normally unsigned is faster, but for some machines signed is.  */
6532 #ifdef LOAD_EXTEND_OP
6533       ops_unsigned = (LOAD_EXTEND_OP (operand_mode) == SIGN_EXTEND
6534                       && !flag_syntax_only) ? 0 : 1;
6535 #else
6536       ops_unsigned = 1;
6537 #endif
6538
6539       signed_type = lang_hooks.types.type_for_mode (operand_mode, 0);
6540       unsigned_type = lang_hooks.types.type_for_mode (operand_mode, 1);
6541       intermediate_type = ops_unsigned ? unsigned_type : signed_type;
6542       inner = fold_convert_loc (loc, intermediate_type, inner);
6543
6544       if (bitnum != 0)
6545         inner = build2 (RSHIFT_EXPR, intermediate_type,
6546                         inner, size_int (bitnum));
6547
6548       one = build_int_cst (intermediate_type, 1);
6549
6550       if (code == EQ_EXPR)
6551         inner = fold_build2_loc (loc, BIT_XOR_EXPR, intermediate_type, inner, one);
6552
6553       /* Put the AND last so it can combine with more things.  */
6554       inner = build2 (BIT_AND_EXPR, intermediate_type, inner, one);
6555
6556       /* Make sure to return the proper type.  */
6557       inner = fold_convert_loc (loc, result_type, inner);
6558
6559       return inner;
6560     }
6561   return NULL_TREE;
6562 }
6563
6564 /* Check whether we are allowed to reorder operands arg0 and arg1,
6565    such that the evaluation of arg1 occurs before arg0.  */
6566
6567 static bool
6568 reorder_operands_p (const_tree arg0, const_tree arg1)
6569 {
6570   if (! flag_evaluation_order)
6571       return true;
6572   if (TREE_CONSTANT (arg0) || TREE_CONSTANT (arg1))
6573     return true;
6574   return ! TREE_SIDE_EFFECTS (arg0)
6575          && ! TREE_SIDE_EFFECTS (arg1);
6576 }
6577
6578 /* Test whether it is preferable two swap two operands, ARG0 and
6579    ARG1, for example because ARG0 is an integer constant and ARG1
6580    isn't.  If REORDER is true, only recommend swapping if we can
6581    evaluate the operands in reverse order.  */
6582
6583 bool
6584 tree_swap_operands_p (const_tree arg0, const_tree arg1, bool reorder)
6585 {
6586   STRIP_SIGN_NOPS (arg0);
6587   STRIP_SIGN_NOPS (arg1);
6588
6589   if (TREE_CODE (arg1) == INTEGER_CST)
6590     return 0;
6591   if (TREE_CODE (arg0) == INTEGER_CST)
6592     return 1;
6593
6594   if (TREE_CODE (arg1) == REAL_CST)
6595     return 0;
6596   if (TREE_CODE (arg0) == REAL_CST)
6597     return 1;
6598
6599   if (TREE_CODE (arg1) == FIXED_CST)
6600     return 0;
6601   if (TREE_CODE (arg0) == FIXED_CST)
6602     return 1;
6603
6604   if (TREE_CODE (arg1) == COMPLEX_CST)
6605     return 0;
6606   if (TREE_CODE (arg0) == COMPLEX_CST)
6607     return 1;
6608
6609   if (TREE_CONSTANT (arg1))
6610     return 0;
6611   if (TREE_CONSTANT (arg0))
6612     return 1;
6613
6614   if (optimize_function_for_size_p (cfun))
6615     return 0;
6616
6617   if (reorder && flag_evaluation_order
6618       && (TREE_SIDE_EFFECTS (arg0) || TREE_SIDE_EFFECTS (arg1)))
6619     return 0;
6620
6621   /* It is preferable to swap two SSA_NAME to ensure a canonical form
6622      for commutative and comparison operators.  Ensuring a canonical
6623      form allows the optimizers to find additional redundancies without
6624      having to explicitly check for both orderings.  */
6625   if (TREE_CODE (arg0) == SSA_NAME
6626       && TREE_CODE (arg1) == SSA_NAME
6627       && SSA_NAME_VERSION (arg0) > SSA_NAME_VERSION (arg1))
6628     return 1;
6629
6630   /* Put SSA_NAMEs last.  */
6631   if (TREE_CODE (arg1) == SSA_NAME)
6632     return 0;
6633   if (TREE_CODE (arg0) == SSA_NAME)
6634     return 1;
6635
6636   /* Put variables last.  */
6637   if (DECL_P (arg1))
6638     return 0;
6639   if (DECL_P (arg0))
6640     return 1;
6641
6642   return 0;
6643 }
6644
6645 /* Fold comparison ARG0 CODE ARG1 (with result in TYPE), where
6646    ARG0 is extended to a wider type.  */
6647
6648 static tree
6649 fold_widened_comparison (location_t loc, enum tree_code code,
6650                          tree type, tree arg0, tree arg1)
6651 {
6652   tree arg0_unw = get_unwidened (arg0, NULL_TREE);
6653   tree arg1_unw;
6654   tree shorter_type, outer_type;
6655   tree min, max;
6656   bool above, below;
6657
6658   if (arg0_unw == arg0)
6659     return NULL_TREE;
6660   shorter_type = TREE_TYPE (arg0_unw);
6661
6662 #ifdef HAVE_canonicalize_funcptr_for_compare
6663   /* Disable this optimization if we're casting a function pointer
6664      type on targets that require function pointer canonicalization.  */
6665   if (HAVE_canonicalize_funcptr_for_compare
6666       && TREE_CODE (shorter_type) == POINTER_TYPE
6667       && TREE_CODE (TREE_TYPE (shorter_type)) == FUNCTION_TYPE)
6668     return NULL_TREE;
6669 #endif
6670
6671   if (TYPE_PRECISION (TREE_TYPE (arg0)) <= TYPE_PRECISION (shorter_type))
6672     return NULL_TREE;
6673
6674   arg1_unw = get_unwidened (arg1, NULL_TREE);
6675
6676   /* If possible, express the comparison in the shorter mode.  */
6677   if ((code == EQ_EXPR || code == NE_EXPR
6678        || TYPE_UNSIGNED (TREE_TYPE (arg0)) == TYPE_UNSIGNED (shorter_type))
6679       && (TREE_TYPE (arg1_unw) == shorter_type
6680           || ((TYPE_PRECISION (shorter_type)
6681                >= TYPE_PRECISION (TREE_TYPE (arg1_unw)))
6682               && (TYPE_UNSIGNED (shorter_type)
6683                   == TYPE_UNSIGNED (TREE_TYPE (arg1_unw))))
6684           || (TREE_CODE (arg1_unw) == INTEGER_CST
6685               && (TREE_CODE (shorter_type) == INTEGER_TYPE
6686                   || TREE_CODE (shorter_type) == BOOLEAN_TYPE)
6687               && int_fits_type_p (arg1_unw, shorter_type))))
6688     return fold_build2_loc (loc, code, type, arg0_unw,
6689                         fold_convert_loc (loc, shorter_type, arg1_unw));
6690
6691   if (TREE_CODE (arg1_unw) != INTEGER_CST
6692       || TREE_CODE (shorter_type) != INTEGER_TYPE
6693       || !int_fits_type_p (arg1_unw, shorter_type))
6694     return NULL_TREE;
6695
6696   /* If we are comparing with the integer that does not fit into the range
6697      of the shorter type, the result is known.  */
6698   outer_type = TREE_TYPE (arg1_unw);
6699   min = lower_bound_in_type (outer_type, shorter_type);
6700   max = upper_bound_in_type (outer_type, shorter_type);
6701
6702   above = integer_nonzerop (fold_relational_const (LT_EXPR, type,
6703                                                    max, arg1_unw));
6704   below = integer_nonzerop (fold_relational_const (LT_EXPR, type,
6705                                                    arg1_unw, min));
6706
6707   switch (code)
6708     {
6709     case EQ_EXPR:
6710       if (above || below)
6711         return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
6712       break;
6713
6714     case NE_EXPR:
6715       if (above || below)
6716         return omit_one_operand_loc (loc, type, integer_one_node, arg0);
6717       break;
6718
6719     case LT_EXPR:
6720     case LE_EXPR:
6721       if (above)
6722         return omit_one_operand_loc (loc, type, integer_one_node, arg0);
6723       else if (below)
6724         return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
6725
6726     case GT_EXPR:
6727     case GE_EXPR:
6728       if (above)
6729         return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
6730       else if (below)
6731         return omit_one_operand_loc (loc, type, integer_one_node, arg0);
6732
6733     default:
6734       break;
6735     }
6736
6737   return NULL_TREE;
6738 }
6739
6740 /* Fold comparison ARG0 CODE ARG1 (with result in TYPE), where for
6741    ARG0 just the signedness is changed.  */
6742
6743 static tree
6744 fold_sign_changed_comparison (location_t loc, enum tree_code code, tree type,
6745                               tree arg0, tree arg1)
6746 {
6747   tree arg0_inner;
6748   tree inner_type, outer_type;
6749
6750   if (!CONVERT_EXPR_P (arg0))
6751     return NULL_TREE;
6752
6753   outer_type = TREE_TYPE (arg0);
6754   arg0_inner = TREE_OPERAND (arg0, 0);
6755   inner_type = TREE_TYPE (arg0_inner);
6756
6757 #ifdef HAVE_canonicalize_funcptr_for_compare
6758   /* Disable this optimization if we're casting a function pointer
6759      type on targets that require function pointer canonicalization.  */
6760   if (HAVE_canonicalize_funcptr_for_compare
6761       && TREE_CODE (inner_type) == POINTER_TYPE
6762       && TREE_CODE (TREE_TYPE (inner_type)) == FUNCTION_TYPE)
6763     return NULL_TREE;
6764 #endif
6765
6766   if (TYPE_PRECISION (inner_type) != TYPE_PRECISION (outer_type))
6767     return NULL_TREE;
6768
6769   if (TREE_CODE (arg1) != INTEGER_CST
6770       && !(CONVERT_EXPR_P (arg1)
6771            && TREE_TYPE (TREE_OPERAND (arg1, 0)) == inner_type))
6772     return NULL_TREE;
6773
6774   if ((TYPE_UNSIGNED (inner_type) != TYPE_UNSIGNED (outer_type)
6775        || POINTER_TYPE_P (inner_type) != POINTER_TYPE_P (outer_type))
6776       && code != NE_EXPR
6777       && code != EQ_EXPR)
6778     return NULL_TREE;
6779
6780   if (TREE_CODE (arg1) == INTEGER_CST)
6781     arg1 = force_fit_type_double (inner_type, tree_to_double_int (arg1),
6782                                   0, TREE_OVERFLOW (arg1));
6783   else
6784     arg1 = fold_convert_loc (loc, inner_type, arg1);
6785
6786   return fold_build2_loc (loc, code, type, arg0_inner, arg1);
6787 }
6788
6789 /* Tries to replace &a[idx] p+ s * delta with &a[idx + delta], if s is
6790    step of the array.  Reconstructs s and delta in the case of s *
6791    delta being an integer constant (and thus already folded).  ADDR is
6792    the address. MULT is the multiplicative expression.  If the
6793    function succeeds, the new address expression is returned.
6794    Otherwise NULL_TREE is returned.  LOC is the location of the
6795    resulting expression.  */
6796
6797 static tree
6798 try_move_mult_to_index (location_t loc, tree addr, tree op1)
6799 {
6800   tree s, delta, step;
6801   tree ref = TREE_OPERAND (addr, 0), pref;
6802   tree ret, pos;
6803   tree itype;
6804   bool mdim = false;
6805
6806   /*  Strip the nops that might be added when converting op1 to sizetype. */
6807   STRIP_NOPS (op1);
6808
6809   /* Canonicalize op1 into a possibly non-constant delta
6810      and an INTEGER_CST s.  */
6811   if (TREE_CODE (op1) == MULT_EXPR)
6812     {
6813       tree arg0 = TREE_OPERAND (op1, 0), arg1 = TREE_OPERAND (op1, 1);
6814
6815       STRIP_NOPS (arg0);
6816       STRIP_NOPS (arg1);
6817
6818       if (TREE_CODE (arg0) == INTEGER_CST)
6819         {
6820           s = arg0;
6821           delta = arg1;
6822         }
6823       else if (TREE_CODE (arg1) == INTEGER_CST)
6824         {
6825           s = arg1;
6826           delta = arg0;
6827         }
6828       else
6829         return NULL_TREE;
6830     }
6831   else if (TREE_CODE (op1) == INTEGER_CST)
6832     {
6833       delta = op1;
6834       s = NULL_TREE;
6835     }
6836   else
6837     {
6838       /* Simulate we are delta * 1.  */
6839       delta = op1;
6840       s = integer_one_node;
6841     }
6842
6843   for (;; ref = TREE_OPERAND (ref, 0))
6844     {
6845       if (TREE_CODE (ref) == ARRAY_REF)
6846         {
6847           tree domain;
6848
6849           /* Remember if this was a multi-dimensional array.  */
6850           if (TREE_CODE (TREE_OPERAND (ref, 0)) == ARRAY_REF)
6851             mdim = true;
6852
6853           domain = TYPE_DOMAIN (TREE_TYPE (TREE_OPERAND (ref, 0)));
6854           if (! domain)
6855             continue;
6856           itype = TREE_TYPE (domain);
6857
6858           step = array_ref_element_size (ref);
6859           if (TREE_CODE (step) != INTEGER_CST)
6860             continue;
6861
6862           if (s)
6863             {
6864               if (! tree_int_cst_equal (step, s))
6865                 continue;
6866             }
6867           else
6868             {
6869               /* Try if delta is a multiple of step.  */
6870               tree tmp = div_if_zero_remainder (EXACT_DIV_EXPR, op1, step);
6871               if (! tmp)
6872                 continue;
6873               delta = tmp;
6874             }
6875
6876           /* Only fold here if we can verify we do not overflow one
6877              dimension of a multi-dimensional array.  */
6878           if (mdim)
6879             {
6880               tree tmp;
6881
6882               if (TREE_CODE (TREE_OPERAND (ref, 1)) != INTEGER_CST
6883                   || !TYPE_MAX_VALUE (domain)
6884                   || TREE_CODE (TYPE_MAX_VALUE (domain)) != INTEGER_CST)
6885                 continue;
6886
6887               tmp = fold_binary_loc (loc, PLUS_EXPR, itype,
6888                                      fold_convert_loc (loc, itype,
6889                                                        TREE_OPERAND (ref, 1)),
6890                                      fold_convert_loc (loc, itype, delta));
6891               if (!tmp
6892                   || TREE_CODE (tmp) != INTEGER_CST
6893                   || tree_int_cst_lt (TYPE_MAX_VALUE (domain), tmp))
6894                 continue;
6895             }
6896
6897           break;
6898         }
6899       else
6900         mdim = false;
6901
6902       if (!handled_component_p (ref))
6903         return NULL_TREE;
6904     }
6905
6906   /* We found the suitable array reference.  So copy everything up to it,
6907      and replace the index.  */
6908
6909   pref = TREE_OPERAND (addr, 0);
6910   ret = copy_node (pref);
6911   SET_EXPR_LOCATION (ret, loc);
6912   pos = ret;
6913
6914   while (pref != ref)
6915     {
6916       pref = TREE_OPERAND (pref, 0);
6917       TREE_OPERAND (pos, 0) = copy_node (pref);
6918       pos = TREE_OPERAND (pos, 0);
6919     }
6920
6921   TREE_OPERAND (pos, 1) = fold_build2_loc (loc, PLUS_EXPR, itype,
6922                                        fold_convert_loc (loc, itype,
6923                                                          TREE_OPERAND (pos, 1)),
6924                                        fold_convert_loc (loc, itype, delta));
6925
6926   return fold_build1_loc (loc, ADDR_EXPR, TREE_TYPE (addr), ret);
6927 }
6928
6929
6930 /* Fold A < X && A + 1 > Y to A < X && A >= Y.  Normally A + 1 > Y
6931    means A >= Y && A != MAX, but in this case we know that
6932    A < X <= MAX.  INEQ is A + 1 > Y, BOUND is A < X.  */
6933
6934 static tree
6935 fold_to_nonsharp_ineq_using_bound (location_t loc, tree ineq, tree bound)
6936 {
6937   tree a, typea, type = TREE_TYPE (ineq), a1, diff, y;
6938
6939   if (TREE_CODE (bound) == LT_EXPR)
6940     a = TREE_OPERAND (bound, 0);
6941   else if (TREE_CODE (bound) == GT_EXPR)
6942     a = TREE_OPERAND (bound, 1);
6943   else
6944     return NULL_TREE;
6945
6946   typea = TREE_TYPE (a);
6947   if (!INTEGRAL_TYPE_P (typea)
6948       && !POINTER_TYPE_P (typea))
6949     return NULL_TREE;
6950
6951   if (TREE_CODE (ineq) == LT_EXPR)
6952     {
6953       a1 = TREE_OPERAND (ineq, 1);
6954       y = TREE_OPERAND (ineq, 0);
6955     }
6956   else if (TREE_CODE (ineq) == GT_EXPR)
6957     {
6958       a1 = TREE_OPERAND (ineq, 0);
6959       y = TREE_OPERAND (ineq, 1);
6960     }
6961   else
6962     return NULL_TREE;
6963
6964   if (TREE_TYPE (a1) != typea)
6965     return NULL_TREE;
6966
6967   if (POINTER_TYPE_P (typea))
6968     {
6969       /* Convert the pointer types into integer before taking the difference.  */
6970       tree ta = fold_convert_loc (loc, ssizetype, a);
6971       tree ta1 = fold_convert_loc (loc, ssizetype, a1);
6972       diff = fold_binary_loc (loc, MINUS_EXPR, ssizetype, ta1, ta);
6973     }
6974   else
6975     diff = fold_binary_loc (loc, MINUS_EXPR, typea, a1, a);
6976
6977   if (!diff || !integer_onep (diff))
6978    return NULL_TREE;
6979
6980   return fold_build2_loc (loc, GE_EXPR, type, a, y);
6981 }
6982
6983 /* Fold a sum or difference of at least one multiplication.
6984    Returns the folded tree or NULL if no simplification could be made.  */
6985
6986 static tree
6987 fold_plusminus_mult_expr (location_t loc, enum tree_code code, tree type,
6988                           tree arg0, tree arg1)
6989 {
6990   tree arg00, arg01, arg10, arg11;
6991   tree alt0 = NULL_TREE, alt1 = NULL_TREE, same;
6992
6993   /* (A * C) +- (B * C) -> (A+-B) * C.
6994      (A * C) +- A -> A * (C+-1).
6995      We are most concerned about the case where C is a constant,
6996      but other combinations show up during loop reduction.  Since
6997      it is not difficult, try all four possibilities.  */
6998
6999   if (TREE_CODE (arg0) == MULT_EXPR)
7000     {
7001       arg00 = TREE_OPERAND (arg0, 0);
7002       arg01 = TREE_OPERAND (arg0, 1);
7003     }
7004   else if (TREE_CODE (arg0) == INTEGER_CST)
7005     {
7006       arg00 = build_one_cst (type);
7007       arg01 = arg0;
7008     }
7009   else
7010     {
7011       /* We cannot generate constant 1 for fract.  */
7012       if (ALL_FRACT_MODE_P (TYPE_MODE (type)))
7013         return NULL_TREE;
7014       arg00 = arg0;
7015       arg01 = build_one_cst (type);
7016     }
7017   if (TREE_CODE (arg1) == MULT_EXPR)
7018     {
7019       arg10 = TREE_OPERAND (arg1, 0);
7020       arg11 = TREE_OPERAND (arg1, 1);
7021     }
7022   else if (TREE_CODE (arg1) == INTEGER_CST)
7023     {
7024       arg10 = build_one_cst (type);
7025       /* As we canonicalize A - 2 to A + -2 get rid of that sign for
7026          the purpose of this canonicalization.  */
7027       if (TREE_INT_CST_HIGH (arg1) == -1
7028           && negate_expr_p (arg1)
7029           && code == PLUS_EXPR)
7030         {
7031           arg11 = negate_expr (arg1);
7032           code = MINUS_EXPR;
7033         }
7034       else
7035         arg11 = arg1;
7036     }
7037   else
7038     {
7039       /* We cannot generate constant 1 for fract.  */
7040       if (ALL_FRACT_MODE_P (TYPE_MODE (type)))
7041         return NULL_TREE;
7042       arg10 = arg1;
7043       arg11 = build_one_cst (type);
7044     }
7045   same = NULL_TREE;
7046
7047   if (operand_equal_p (arg01, arg11, 0))
7048     same = arg01, alt0 = arg00, alt1 = arg10;
7049   else if (operand_equal_p (arg00, arg10, 0))
7050     same = arg00, alt0 = arg01, alt1 = arg11;
7051   else if (operand_equal_p (arg00, arg11, 0))
7052     same = arg00, alt0 = arg01, alt1 = arg10;
7053   else if (operand_equal_p (arg01, arg10, 0))
7054     same = arg01, alt0 = arg00, alt1 = arg11;
7055
7056   /* No identical multiplicands; see if we can find a common
7057      power-of-two factor in non-power-of-two multiplies.  This
7058      can help in multi-dimensional array access.  */
7059   else if (host_integerp (arg01, 0)
7060            && host_integerp (arg11, 0))
7061     {
7062       HOST_WIDE_INT int01, int11, tmp;
7063       bool swap = false;
7064       tree maybe_same;
7065       int01 = TREE_INT_CST_LOW (arg01);
7066       int11 = TREE_INT_CST_LOW (arg11);
7067
7068       /* Move min of absolute values to int11.  */
7069       if ((int01 >= 0 ? int01 : -int01)
7070           < (int11 >= 0 ? int11 : -int11))
7071         {
7072           tmp = int01, int01 = int11, int11 = tmp;
7073           alt0 = arg00, arg00 = arg10, arg10 = alt0;
7074           maybe_same = arg01;
7075           swap = true;
7076         }
7077       else
7078         maybe_same = arg11;
7079
7080       if (exact_log2 (abs (int11)) > 0 && int01 % int11 == 0
7081           /* The remainder should not be a constant, otherwise we
7082              end up folding i * 4 + 2 to (i * 2 + 1) * 2 which has
7083              increased the number of multiplications necessary.  */
7084           && TREE_CODE (arg10) != INTEGER_CST)
7085         {
7086           alt0 = fold_build2_loc (loc, MULT_EXPR, TREE_TYPE (arg00), arg00,
7087                               build_int_cst (TREE_TYPE (arg00),
7088                                              int01 / int11));
7089           alt1 = arg10;
7090           same = maybe_same;
7091           if (swap)
7092             maybe_same = alt0, alt0 = alt1, alt1 = maybe_same;
7093         }
7094     }
7095
7096   if (same)
7097     return fold_build2_loc (loc, MULT_EXPR, type,
7098                         fold_build2_loc (loc, code, type,
7099                                      fold_convert_loc (loc, type, alt0),
7100                                      fold_convert_loc (loc, type, alt1)),
7101                         fold_convert_loc (loc, type, same));
7102
7103   return NULL_TREE;
7104 }
7105
7106 /* Subroutine of native_encode_expr.  Encode the INTEGER_CST
7107    specified by EXPR into the buffer PTR of length LEN bytes.
7108    Return the number of bytes placed in the buffer, or zero
7109    upon failure.  */
7110
7111 static int
7112 native_encode_int (const_tree expr, unsigned char *ptr, int len)
7113 {
7114   tree type = TREE_TYPE (expr);
7115   int total_bytes = GET_MODE_SIZE (TYPE_MODE (type));
7116   int byte, offset, word, words;
7117   unsigned char value;
7118
7119   if (total_bytes > len)
7120     return 0;
7121   words = total_bytes / UNITS_PER_WORD;
7122
7123   for (byte = 0; byte < total_bytes; byte++)
7124     {
7125       int bitpos = byte * BITS_PER_UNIT;
7126       if (bitpos < HOST_BITS_PER_WIDE_INT)
7127         value = (unsigned char) (TREE_INT_CST_LOW (expr) >> bitpos);
7128       else
7129         value = (unsigned char) (TREE_INT_CST_HIGH (expr)
7130                                  >> (bitpos - HOST_BITS_PER_WIDE_INT));
7131
7132       if (total_bytes > UNITS_PER_WORD)
7133         {
7134           word = byte / UNITS_PER_WORD;
7135           if (WORDS_BIG_ENDIAN)
7136             word = (words - 1) - word;
7137           offset = word * UNITS_PER_WORD;
7138           if (BYTES_BIG_ENDIAN)
7139             offset += (UNITS_PER_WORD - 1) - (byte % UNITS_PER_WORD);
7140           else
7141             offset += byte % UNITS_PER_WORD;
7142         }
7143       else
7144         offset = BYTES_BIG_ENDIAN ? (total_bytes - 1) - byte : byte;
7145       ptr[offset] = value;
7146     }
7147   return total_bytes;
7148 }
7149
7150
7151 /* Subroutine of native_encode_expr.  Encode the REAL_CST
7152    specified by EXPR into the buffer PTR of length LEN bytes.
7153    Return the number of bytes placed in the buffer, or zero
7154    upon failure.  */
7155
7156 static int
7157 native_encode_real (const_tree expr, unsigned char *ptr, int len)
7158 {
7159   tree type = TREE_TYPE (expr);
7160   int total_bytes = GET_MODE_SIZE (TYPE_MODE (type));
7161   int byte, offset, word, words, bitpos;
7162   unsigned char value;
7163
7164   /* There are always 32 bits in each long, no matter the size of
7165      the hosts long.  We handle floating point representations with
7166      up to 192 bits.  */
7167   long tmp[6];
7168
7169   if (total_bytes > len)
7170     return 0;
7171   words = (32 / BITS_PER_UNIT) / UNITS_PER_WORD;
7172
7173   real_to_target (tmp, TREE_REAL_CST_PTR (expr), TYPE_MODE (type));
7174
7175   for (bitpos = 0; bitpos < total_bytes * BITS_PER_UNIT;
7176        bitpos += BITS_PER_UNIT)
7177     {
7178       byte = (bitpos / BITS_PER_UNIT) & 3;
7179       value = (unsigned char) (tmp[bitpos / 32] >> (bitpos & 31));
7180
7181       if (UNITS_PER_WORD < 4)
7182         {
7183           word = byte / UNITS_PER_WORD;
7184           if (WORDS_BIG_ENDIAN)
7185             word = (words - 1) - word;
7186           offset = word * UNITS_PER_WORD;
7187           if (BYTES_BIG_ENDIAN)
7188             offset += (UNITS_PER_WORD - 1) - (byte % UNITS_PER_WORD);
7189           else
7190             offset += byte % UNITS_PER_WORD;
7191         }
7192       else
7193         offset = BYTES_BIG_ENDIAN ? 3 - byte : byte;
7194       ptr[offset + ((bitpos / BITS_PER_UNIT) & ~3)] = value;
7195     }
7196   return total_bytes;
7197 }
7198
7199 /* Subroutine of native_encode_expr.  Encode the COMPLEX_CST
7200    specified by EXPR into the buffer PTR of length LEN bytes.
7201    Return the number of bytes placed in the buffer, or zero
7202    upon failure.  */
7203
7204 static int
7205 native_encode_complex (const_tree expr, unsigned char *ptr, int len)
7206 {
7207   int rsize, isize;
7208   tree part;
7209
7210   part = TREE_REALPART (expr);
7211   rsize = native_encode_expr (part, ptr, len);
7212   if (rsize == 0)
7213     return 0;
7214   part = TREE_IMAGPART (expr);
7215   isize = native_encode_expr (part, ptr+rsize, len-rsize);
7216   if (isize != rsize)
7217     return 0;
7218   return rsize + isize;
7219 }
7220
7221
7222 /* Subroutine of native_encode_expr.  Encode the VECTOR_CST
7223    specified by EXPR into the buffer PTR of length LEN bytes.
7224    Return the number of bytes placed in the buffer, or zero
7225    upon failure.  */
7226
7227 static int
7228 native_encode_vector (const_tree expr, unsigned char *ptr, int len)
7229 {
7230   int i, size, offset, count;
7231   tree itype, elem, elements;
7232
7233   offset = 0;
7234   elements = TREE_VECTOR_CST_ELTS (expr);
7235   count = TYPE_VECTOR_SUBPARTS (TREE_TYPE (expr));
7236   itype = TREE_TYPE (TREE_TYPE (expr));
7237   size = GET_MODE_SIZE (TYPE_MODE (itype));
7238   for (i = 0; i < count; i++)
7239     {
7240       if (elements)
7241         {
7242           elem = TREE_VALUE (elements);
7243           elements = TREE_CHAIN (elements);
7244         }
7245       else
7246         elem = NULL_TREE;
7247
7248       if (elem)
7249         {
7250           if (native_encode_expr (elem, ptr+offset, len-offset) != size)
7251             return 0;
7252         }
7253       else
7254         {
7255           if (offset + size > len)
7256             return 0;
7257           memset (ptr+offset, 0, size);
7258         }
7259       offset += size;
7260     }
7261   return offset;
7262 }
7263
7264
7265 /* Subroutine of native_encode_expr.  Encode the STRING_CST
7266    specified by EXPR into the buffer PTR of length LEN bytes.
7267    Return the number of bytes placed in the buffer, or zero
7268    upon failure.  */
7269
7270 static int
7271 native_encode_string (const_tree expr, unsigned char *ptr, int len)
7272 {
7273   tree type = TREE_TYPE (expr);
7274   HOST_WIDE_INT total_bytes;
7275
7276   if (TREE_CODE (type) != ARRAY_TYPE
7277       || TREE_CODE (TREE_TYPE (type)) != INTEGER_TYPE
7278       || GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (type))) != BITS_PER_UNIT
7279       || !host_integerp (TYPE_SIZE_UNIT (type), 0))
7280     return 0;
7281   total_bytes = tree_low_cst (TYPE_SIZE_UNIT (type), 0);
7282   if (total_bytes > len)
7283     return 0;
7284   if (TREE_STRING_LENGTH (expr) < total_bytes)
7285     {
7286       memcpy (ptr, TREE_STRING_POINTER (expr), TREE_STRING_LENGTH (expr));
7287       memset (ptr + TREE_STRING_LENGTH (expr), 0,
7288               total_bytes - TREE_STRING_LENGTH (expr));
7289     }
7290   else
7291     memcpy (ptr, TREE_STRING_POINTER (expr), total_bytes);
7292   return total_bytes;
7293 }
7294
7295
7296 /* Subroutine of fold_view_convert_expr.  Encode the INTEGER_CST,
7297    REAL_CST, COMPLEX_CST or VECTOR_CST specified by EXPR into the
7298    buffer PTR of length LEN bytes.  Return the number of bytes
7299    placed in the buffer, or zero upon failure.  */
7300
7301 int
7302 native_encode_expr (const_tree expr, unsigned char *ptr, int len)
7303 {
7304   switch (TREE_CODE (expr))
7305     {
7306     case INTEGER_CST:
7307       return native_encode_int (expr, ptr, len);
7308
7309     case REAL_CST:
7310       return native_encode_real (expr, ptr, len);
7311
7312     case COMPLEX_CST:
7313       return native_encode_complex (expr, ptr, len);
7314
7315     case VECTOR_CST:
7316       return native_encode_vector (expr, ptr, len);
7317
7318     case STRING_CST:
7319       return native_encode_string (expr, ptr, len);
7320
7321     default:
7322       return 0;
7323     }
7324 }
7325
7326
7327 /* Subroutine of native_interpret_expr.  Interpret the contents of
7328    the buffer PTR of length LEN as an INTEGER_CST of type TYPE.
7329    If the buffer cannot be interpreted, return NULL_TREE.  */
7330
7331 static tree
7332 native_interpret_int (tree type, const unsigned char *ptr, int len)
7333 {
7334   int total_bytes = GET_MODE_SIZE (TYPE_MODE (type));
7335   int byte, offset, word, words;
7336   unsigned char value;
7337   double_int result;
7338
7339   if (total_bytes > len)
7340     return NULL_TREE;
7341   if (total_bytes * BITS_PER_UNIT > 2 * HOST_BITS_PER_WIDE_INT)
7342     return NULL_TREE;
7343
7344   result = double_int_zero;
7345   words = total_bytes / UNITS_PER_WORD;
7346
7347   for (byte = 0; byte < total_bytes; byte++)
7348     {
7349       int bitpos = byte * BITS_PER_UNIT;
7350       if (total_bytes > UNITS_PER_WORD)
7351         {
7352           word = byte / UNITS_PER_WORD;
7353           if (WORDS_BIG_ENDIAN)
7354             word = (words - 1) - word;
7355           offset = word * UNITS_PER_WORD;
7356           if (BYTES_BIG_ENDIAN)
7357             offset += (UNITS_PER_WORD - 1) - (byte % UNITS_PER_WORD);
7358           else
7359             offset += byte % UNITS_PER_WORD;
7360         }
7361       else
7362         offset = BYTES_BIG_ENDIAN ? (total_bytes - 1) - byte : byte;
7363       value = ptr[offset];
7364
7365       if (bitpos < HOST_BITS_PER_WIDE_INT)
7366         result.low |= (unsigned HOST_WIDE_INT) value << bitpos;
7367       else
7368         result.high |= (unsigned HOST_WIDE_INT) value
7369                        << (bitpos - HOST_BITS_PER_WIDE_INT);
7370     }
7371
7372   return double_int_to_tree (type, result);
7373 }
7374
7375
7376 /* Subroutine of native_interpret_expr.  Interpret the contents of
7377    the buffer PTR of length LEN as a REAL_CST of type TYPE.
7378    If the buffer cannot be interpreted, return NULL_TREE.  */
7379
7380 static tree
7381 native_interpret_real (tree type, const unsigned char *ptr, int len)
7382 {
7383   enum machine_mode mode = TYPE_MODE (type);
7384   int total_bytes = GET_MODE_SIZE (mode);
7385   int byte, offset, word, words, bitpos;
7386   unsigned char value;
7387   /* There are always 32 bits in each long, no matter the size of
7388      the hosts long.  We handle floating point representations with
7389      up to 192 bits.  */
7390   REAL_VALUE_TYPE r;
7391   long tmp[6];
7392
7393   total_bytes = GET_MODE_SIZE (TYPE_MODE (type));
7394   if (total_bytes > len || total_bytes > 24)
7395     return NULL_TREE;
7396   words = (32 / BITS_PER_UNIT) / UNITS_PER_WORD;
7397
7398   memset (tmp, 0, sizeof (tmp));
7399   for (bitpos = 0; bitpos < total_bytes * BITS_PER_UNIT;
7400        bitpos += BITS_PER_UNIT)
7401     {
7402       byte = (bitpos / BITS_PER_UNIT) & 3;
7403       if (UNITS_PER_WORD < 4)
7404         {
7405           word = byte / UNITS_PER_WORD;
7406           if (WORDS_BIG_ENDIAN)
7407             word = (words - 1) - word;
7408           offset = word * UNITS_PER_WORD;
7409           if (BYTES_BIG_ENDIAN)
7410             offset += (UNITS_PER_WORD - 1) - (byte % UNITS_PER_WORD);
7411           else
7412             offset += byte % UNITS_PER_WORD;
7413         }
7414       else
7415         offset = BYTES_BIG_ENDIAN ? 3 - byte : byte;
7416       value = ptr[offset + ((bitpos / BITS_PER_UNIT) & ~3)];
7417
7418       tmp[bitpos / 32] |= (unsigned long)value << (bitpos & 31);
7419     }
7420
7421   real_from_target (&r, tmp, mode);
7422   return build_real (type, r);
7423 }
7424
7425
7426 /* Subroutine of native_interpret_expr.  Interpret the contents of
7427    the buffer PTR of length LEN as a COMPLEX_CST of type TYPE.
7428    If the buffer cannot be interpreted, return NULL_TREE.  */
7429
7430 static tree
7431 native_interpret_complex (tree type, const unsigned char *ptr, int len)
7432 {
7433   tree etype, rpart, ipart;
7434   int size;
7435
7436   etype = TREE_TYPE (type);
7437   size = GET_MODE_SIZE (TYPE_MODE (etype));
7438   if (size * 2 > len)
7439     return NULL_TREE;
7440   rpart = native_interpret_expr (etype, ptr, size);
7441   if (!rpart)
7442     return NULL_TREE;
7443   ipart = native_interpret_expr (etype, ptr+size, size);
7444   if (!ipart)
7445     return NULL_TREE;
7446   return build_complex (type, rpart, ipart);
7447 }
7448
7449
7450 /* Subroutine of native_interpret_expr.  Interpret the contents of
7451    the buffer PTR of length LEN as a VECTOR_CST of type TYPE.
7452    If the buffer cannot be interpreted, return NULL_TREE.  */
7453
7454 static tree
7455 native_interpret_vector (tree type, const unsigned char *ptr, int len)
7456 {
7457   tree etype, elem, elements;
7458   int i, size, count;
7459
7460   etype = TREE_TYPE (type);
7461   size = GET_MODE_SIZE (TYPE_MODE (etype));
7462   count = TYPE_VECTOR_SUBPARTS (type);
7463   if (size * count > len)
7464     return NULL_TREE;
7465
7466   elements = NULL_TREE;
7467   for (i = count - 1; i >= 0; i--)
7468     {
7469       elem = native_interpret_expr (etype, ptr+(i*size), size);
7470       if (!elem)
7471         return NULL_TREE;
7472       elements = tree_cons (NULL_TREE, elem, elements);
7473     }
7474   return build_vector (type, elements);
7475 }
7476
7477
7478 /* Subroutine of fold_view_convert_expr.  Interpret the contents of
7479    the buffer PTR of length LEN as a constant of type TYPE.  For
7480    INTEGRAL_TYPE_P we return an INTEGER_CST, for SCALAR_FLOAT_TYPE_P
7481    we return a REAL_CST, etc...  If the buffer cannot be interpreted,
7482    return NULL_TREE.  */
7483
7484 tree
7485 native_interpret_expr (tree type, const unsigned char *ptr, int len)
7486 {
7487   switch (TREE_CODE (type))
7488     {
7489     case INTEGER_TYPE:
7490     case ENUMERAL_TYPE:
7491     case BOOLEAN_TYPE:
7492       return native_interpret_int (type, ptr, len);
7493
7494     case REAL_TYPE:
7495       return native_interpret_real (type, ptr, len);
7496
7497     case COMPLEX_TYPE:
7498       return native_interpret_complex (type, ptr, len);
7499
7500     case VECTOR_TYPE:
7501       return native_interpret_vector (type, ptr, len);
7502
7503     default:
7504       return NULL_TREE;
7505     }
7506 }
7507
7508
7509 /* Fold a VIEW_CONVERT_EXPR of a constant expression EXPR to type
7510    TYPE at compile-time.  If we're unable to perform the conversion
7511    return NULL_TREE.  */
7512
7513 static tree
7514 fold_view_convert_expr (tree type, tree expr)
7515 {
7516   /* We support up to 512-bit values (for V8DFmode).  */
7517   unsigned char buffer[64];
7518   int len;
7519
7520   /* Check that the host and target are sane.  */
7521   if (CHAR_BIT != 8 || BITS_PER_UNIT != 8)
7522     return NULL_TREE;
7523
7524   len = native_encode_expr (expr, buffer, sizeof (buffer));
7525   if (len == 0)
7526     return NULL_TREE;
7527
7528   return native_interpret_expr (type, buffer, len);
7529 }
7530
7531 /* Build an expression for the address of T.  Folds away INDIRECT_REF
7532    to avoid confusing the gimplify process.  */
7533
7534 tree
7535 build_fold_addr_expr_with_type_loc (location_t loc, tree t, tree ptrtype)
7536 {
7537   /* The size of the object is not relevant when talking about its address.  */
7538   if (TREE_CODE (t) == WITH_SIZE_EXPR)
7539     t = TREE_OPERAND (t, 0);
7540
7541   if (TREE_CODE (t) == INDIRECT_REF)
7542     {
7543       t = TREE_OPERAND (t, 0);
7544
7545       if (TREE_TYPE (t) != ptrtype)
7546         t = build1_loc (loc, NOP_EXPR, ptrtype, t);
7547     }
7548   else if (TREE_CODE (t) == MEM_REF
7549       && integer_zerop (TREE_OPERAND (t, 1)))
7550     return TREE_OPERAND (t, 0);
7551   else if (TREE_CODE (t) == VIEW_CONVERT_EXPR)
7552     {
7553       t = build_fold_addr_expr_loc (loc, TREE_OPERAND (t, 0));
7554
7555       if (TREE_TYPE (t) != ptrtype)
7556         t = fold_convert_loc (loc, ptrtype, t);
7557     }
7558   else
7559     t = build1_loc (loc, ADDR_EXPR, ptrtype, t);
7560
7561   return t;
7562 }
7563
7564 /* Build an expression for the address of T.  */
7565
7566 tree
7567 build_fold_addr_expr_loc (location_t loc, tree t)
7568 {
7569   tree ptrtype = build_pointer_type (TREE_TYPE (t));
7570
7571   return build_fold_addr_expr_with_type_loc (loc, t, ptrtype);
7572 }
7573
7574 /* Fold a unary expression of code CODE and type TYPE with operand
7575    OP0.  Return the folded expression if folding is successful.
7576    Otherwise, return NULL_TREE.  */
7577
7578 tree
7579 fold_unary_loc (location_t loc, enum tree_code code, tree type, tree op0)
7580 {
7581   tree tem;
7582   tree arg0;
7583   enum tree_code_class kind = TREE_CODE_CLASS (code);
7584
7585   gcc_assert (IS_EXPR_CODE_CLASS (kind)
7586               && TREE_CODE_LENGTH (code) == 1);
7587
7588   arg0 = op0;
7589   if (arg0)
7590     {
7591       if (CONVERT_EXPR_CODE_P (code)
7592           || code == FLOAT_EXPR || code == ABS_EXPR)
7593         {
7594           /* Don't use STRIP_NOPS, because signedness of argument type
7595              matters.  */
7596           STRIP_SIGN_NOPS (arg0);
7597         }
7598       else
7599         {
7600           /* Strip any conversions that don't change the mode.  This
7601              is safe for every expression, except for a comparison
7602              expression because its signedness is derived from its
7603              operands.
7604
7605              Note that this is done as an internal manipulation within
7606              the constant folder, in order to find the simplest
7607              representation of the arguments so that their form can be
7608              studied.  In any cases, the appropriate type conversions
7609              should be put back in the tree that will get out of the
7610              constant folder.  */
7611           STRIP_NOPS (arg0);
7612         }
7613     }
7614
7615   if (TREE_CODE_CLASS (code) == tcc_unary)
7616     {
7617       if (TREE_CODE (arg0) == COMPOUND_EXPR)
7618         return build2 (COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
7619                        fold_build1_loc (loc, code, type,
7620                                     fold_convert_loc (loc, TREE_TYPE (op0),
7621                                                       TREE_OPERAND (arg0, 1))));
7622       else if (TREE_CODE (arg0) == COND_EXPR)
7623         {
7624           tree arg01 = TREE_OPERAND (arg0, 1);
7625           tree arg02 = TREE_OPERAND (arg0, 2);
7626           if (! VOID_TYPE_P (TREE_TYPE (arg01)))
7627             arg01 = fold_build1_loc (loc, code, type,
7628                                  fold_convert_loc (loc,
7629                                                    TREE_TYPE (op0), arg01));
7630           if (! VOID_TYPE_P (TREE_TYPE (arg02)))
7631             arg02 = fold_build1_loc (loc, code, type,
7632                                  fold_convert_loc (loc,
7633                                                    TREE_TYPE (op0), arg02));
7634           tem = fold_build3_loc (loc, COND_EXPR, type, TREE_OPERAND (arg0, 0),
7635                              arg01, arg02);
7636
7637           /* If this was a conversion, and all we did was to move into
7638              inside the COND_EXPR, bring it back out.  But leave it if
7639              it is a conversion from integer to integer and the
7640              result precision is no wider than a word since such a
7641              conversion is cheap and may be optimized away by combine,
7642              while it couldn't if it were outside the COND_EXPR.  Then return
7643              so we don't get into an infinite recursion loop taking the
7644              conversion out and then back in.  */
7645
7646           if ((CONVERT_EXPR_CODE_P (code)
7647                || code == NON_LVALUE_EXPR)
7648               && TREE_CODE (tem) == COND_EXPR
7649               && TREE_CODE (TREE_OPERAND (tem, 1)) == code
7650               && TREE_CODE (TREE_OPERAND (tem, 2)) == code
7651               && ! VOID_TYPE_P (TREE_OPERAND (tem, 1))
7652               && ! VOID_TYPE_P (TREE_OPERAND (tem, 2))
7653               && (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (tem, 1), 0))
7654                   == TREE_TYPE (TREE_OPERAND (TREE_OPERAND (tem, 2), 0)))
7655               && (! (INTEGRAL_TYPE_P (TREE_TYPE (tem))
7656                      && (INTEGRAL_TYPE_P
7657                          (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (tem, 1), 0))))
7658                      && TYPE_PRECISION (TREE_TYPE (tem)) <= BITS_PER_WORD)
7659                   || flag_syntax_only))
7660             tem = build1_loc (loc, code, type,
7661                               build3 (COND_EXPR,
7662                                       TREE_TYPE (TREE_OPERAND
7663                                                  (TREE_OPERAND (tem, 1), 0)),
7664                                       TREE_OPERAND (tem, 0),
7665                                       TREE_OPERAND (TREE_OPERAND (tem, 1), 0),
7666                                       TREE_OPERAND (TREE_OPERAND (tem, 2),
7667                                                     0)));
7668           return tem;
7669         }
7670       else if (COMPARISON_CLASS_P (arg0))
7671         {
7672           if (TREE_CODE (type) == BOOLEAN_TYPE)
7673             {
7674               arg0 = copy_node (arg0);
7675               TREE_TYPE (arg0) = type;
7676               return arg0;
7677             }
7678           else if (TREE_CODE (type) != INTEGER_TYPE)
7679             return fold_build3_loc (loc, COND_EXPR, type, arg0,
7680                                 fold_build1_loc (loc, code, type,
7681                                              integer_one_node),
7682                                 fold_build1_loc (loc, code, type,
7683                                              integer_zero_node));
7684         }
7685    }
7686
7687   switch (code)
7688     {
7689     case PAREN_EXPR:
7690       /* Re-association barriers around constants and other re-association
7691          barriers can be removed.  */
7692       if (CONSTANT_CLASS_P (op0)
7693           || TREE_CODE (op0) == PAREN_EXPR)
7694         return fold_convert_loc (loc, type, op0);
7695       return NULL_TREE;
7696
7697     CASE_CONVERT:
7698     case FLOAT_EXPR:
7699     case FIX_TRUNC_EXPR:
7700       if (TREE_TYPE (op0) == type)
7701         return op0;
7702
7703       /* If we have (type) (a CMP b) and type is an integral type, return
7704          new expression involving the new type.  */
7705       if (COMPARISON_CLASS_P (op0) && INTEGRAL_TYPE_P (type))
7706         return fold_build2_loc (loc, TREE_CODE (op0), type, TREE_OPERAND (op0, 0),
7707                             TREE_OPERAND (op0, 1));
7708
7709       /* Handle cases of two conversions in a row.  */
7710       if (CONVERT_EXPR_P (op0))
7711         {
7712           tree inside_type = TREE_TYPE (TREE_OPERAND (op0, 0));
7713           tree inter_type = TREE_TYPE (op0);
7714           int inside_int = INTEGRAL_TYPE_P (inside_type);
7715           int inside_ptr = POINTER_TYPE_P (inside_type);
7716           int inside_float = FLOAT_TYPE_P (inside_type);
7717           int inside_vec = TREE_CODE (inside_type) == VECTOR_TYPE;
7718           unsigned int inside_prec = TYPE_PRECISION (inside_type);
7719           int inside_unsignedp = TYPE_UNSIGNED (inside_type);
7720           int inter_int = INTEGRAL_TYPE_P (inter_type);
7721           int inter_ptr = POINTER_TYPE_P (inter_type);
7722           int inter_float = FLOAT_TYPE_P (inter_type);
7723           int inter_vec = TREE_CODE (inter_type) == VECTOR_TYPE;
7724           unsigned int inter_prec = TYPE_PRECISION (inter_type);
7725           int inter_unsignedp = TYPE_UNSIGNED (inter_type);
7726           int final_int = INTEGRAL_TYPE_P (type);
7727           int final_ptr = POINTER_TYPE_P (type);
7728           int final_float = FLOAT_TYPE_P (type);
7729           int final_vec = TREE_CODE (type) == VECTOR_TYPE;
7730           unsigned int final_prec = TYPE_PRECISION (type);
7731           int final_unsignedp = TYPE_UNSIGNED (type);
7732
7733           /* In addition to the cases of two conversions in a row
7734              handled below, if we are converting something to its own
7735              type via an object of identical or wider precision, neither
7736              conversion is needed.  */
7737           if (TYPE_MAIN_VARIANT (inside_type) == TYPE_MAIN_VARIANT (type)
7738               && (((inter_int || inter_ptr) && final_int)
7739                   || (inter_float && final_float))
7740               && inter_prec >= final_prec)
7741             return fold_build1_loc (loc, code, type, TREE_OPERAND (op0, 0));
7742
7743           /* Likewise, if the intermediate and initial types are either both
7744              float or both integer, we don't need the middle conversion if the
7745              former is wider than the latter and doesn't change the signedness
7746              (for integers).  Avoid this if the final type is a pointer since
7747              then we sometimes need the middle conversion.  Likewise if the
7748              final type has a precision not equal to the size of its mode.  */
7749           if (((inter_int && inside_int)
7750                || (inter_float && inside_float)
7751                || (inter_vec && inside_vec))
7752               && inter_prec >= inside_prec
7753               && (inter_float || inter_vec
7754                   || inter_unsignedp == inside_unsignedp)
7755               && ! (final_prec != GET_MODE_BITSIZE (TYPE_MODE (type))
7756                     && TYPE_MODE (type) == TYPE_MODE (inter_type))
7757               && ! final_ptr
7758               && (! final_vec || inter_prec == inside_prec))
7759             return fold_build1_loc (loc, code, type, TREE_OPERAND (op0, 0));
7760
7761           /* If we have a sign-extension of a zero-extended value, we can
7762              replace that by a single zero-extension.  */
7763           if (inside_int && inter_int && final_int
7764               && inside_prec < inter_prec && inter_prec < final_prec
7765               && inside_unsignedp && !inter_unsignedp)
7766             return fold_build1_loc (loc, code, type, TREE_OPERAND (op0, 0));
7767
7768           /* Two conversions in a row are not needed unless:
7769              - some conversion is floating-point (overstrict for now), or
7770              - some conversion is a vector (overstrict for now), or
7771              - the intermediate type is narrower than both initial and
7772                final, or
7773              - the intermediate type and innermost type differ in signedness,
7774                and the outermost type is wider than the intermediate, or
7775              - the initial type is a pointer type and the precisions of the
7776                intermediate and final types differ, or
7777              - the final type is a pointer type and the precisions of the
7778                initial and intermediate types differ.  */
7779           if (! inside_float && ! inter_float && ! final_float
7780               && ! inside_vec && ! inter_vec && ! final_vec
7781               && (inter_prec >= inside_prec || inter_prec >= final_prec)
7782               && ! (inside_int && inter_int
7783                     && inter_unsignedp != inside_unsignedp
7784                     && inter_prec < final_prec)
7785               && ((inter_unsignedp && inter_prec > inside_prec)
7786                   == (final_unsignedp && final_prec > inter_prec))
7787               && ! (inside_ptr && inter_prec != final_prec)
7788               && ! (final_ptr && inside_prec != inter_prec)
7789               && ! (final_prec != GET_MODE_BITSIZE (TYPE_MODE (type))
7790                     && TYPE_MODE (type) == TYPE_MODE (inter_type)))
7791             return fold_build1_loc (loc, code, type, TREE_OPERAND (op0, 0));
7792         }
7793
7794       /* Handle (T *)&A.B.C for A being of type T and B and C
7795          living at offset zero.  This occurs frequently in
7796          C++ upcasting and then accessing the base.  */
7797       if (TREE_CODE (op0) == ADDR_EXPR
7798           && POINTER_TYPE_P (type)
7799           && handled_component_p (TREE_OPERAND (op0, 0)))
7800         {
7801           HOST_WIDE_INT bitsize, bitpos;
7802           tree offset;
7803           enum machine_mode mode;
7804           int unsignedp, volatilep;
7805           tree base = TREE_OPERAND (op0, 0);
7806           base = get_inner_reference (base, &bitsize, &bitpos, &offset,
7807                                       &mode, &unsignedp, &volatilep, false);
7808           /* If the reference was to a (constant) zero offset, we can use
7809              the address of the base if it has the same base type
7810              as the result type and the pointer type is unqualified.  */
7811           if (! offset && bitpos == 0
7812               && (TYPE_MAIN_VARIANT (TREE_TYPE (type))
7813                   == TYPE_MAIN_VARIANT (TREE_TYPE (base)))
7814               && TYPE_QUALS (type) == TYPE_UNQUALIFIED)
7815             return fold_convert_loc (loc, type,
7816                                      build_fold_addr_expr_loc (loc, base));
7817         }
7818
7819       if (TREE_CODE (op0) == MODIFY_EXPR
7820           && TREE_CONSTANT (TREE_OPERAND (op0, 1))
7821           /* Detect assigning a bitfield.  */
7822           && !(TREE_CODE (TREE_OPERAND (op0, 0)) == COMPONENT_REF
7823                && DECL_BIT_FIELD
7824                (TREE_OPERAND (TREE_OPERAND (op0, 0), 1))))
7825         {
7826           /* Don't leave an assignment inside a conversion
7827              unless assigning a bitfield.  */
7828           tem = fold_build1_loc (loc, code, type, TREE_OPERAND (op0, 1));
7829           /* First do the assignment, then return converted constant.  */
7830           tem = build2_loc (loc, COMPOUND_EXPR, TREE_TYPE (tem), op0, tem);
7831           TREE_NO_WARNING (tem) = 1;
7832           TREE_USED (tem) = 1;
7833           return tem;
7834         }
7835
7836       /* Convert (T)(x & c) into (T)x & (T)c, if c is an integer
7837          constants (if x has signed type, the sign bit cannot be set
7838          in c).  This folds extension into the BIT_AND_EXPR.
7839          ??? We don't do it for BOOLEAN_TYPE or ENUMERAL_TYPE because they
7840          very likely don't have maximal range for their precision and this
7841          transformation effectively doesn't preserve non-maximal ranges.  */
7842       if (TREE_CODE (type) == INTEGER_TYPE
7843           && TREE_CODE (op0) == BIT_AND_EXPR
7844           && TREE_CODE (TREE_OPERAND (op0, 1)) == INTEGER_CST)
7845         {
7846           tree and_expr = op0;
7847           tree and0 = TREE_OPERAND (and_expr, 0);
7848           tree and1 = TREE_OPERAND (and_expr, 1);
7849           int change = 0;
7850
7851           if (TYPE_UNSIGNED (TREE_TYPE (and_expr))
7852               || (TYPE_PRECISION (type)
7853                   <= TYPE_PRECISION (TREE_TYPE (and_expr))))
7854             change = 1;
7855           else if (TYPE_PRECISION (TREE_TYPE (and1))
7856                    <= HOST_BITS_PER_WIDE_INT
7857                    && host_integerp (and1, 1))
7858             {
7859               unsigned HOST_WIDE_INT cst;
7860
7861               cst = tree_low_cst (and1, 1);
7862               cst &= (HOST_WIDE_INT) -1
7863                      << (TYPE_PRECISION (TREE_TYPE (and1)) - 1);
7864               change = (cst == 0);
7865 #ifdef LOAD_EXTEND_OP
7866               if (change
7867                   && !flag_syntax_only
7868                   && (LOAD_EXTEND_OP (TYPE_MODE (TREE_TYPE (and0)))
7869                       == ZERO_EXTEND))
7870                 {
7871                   tree uns = unsigned_type_for (TREE_TYPE (and0));
7872                   and0 = fold_convert_loc (loc, uns, and0);
7873                   and1 = fold_convert_loc (loc, uns, and1);
7874                 }
7875 #endif
7876             }
7877           if (change)
7878             {
7879               tem = force_fit_type_double (type, tree_to_double_int (and1),
7880                                            0, TREE_OVERFLOW (and1));
7881               return fold_build2_loc (loc, BIT_AND_EXPR, type,
7882                                   fold_convert_loc (loc, type, and0), tem);
7883             }
7884         }
7885
7886       /* Convert (T1)(X p+ Y) into ((T1)X p+ Y), for pointer type,
7887          when one of the new casts will fold away. Conservatively we assume
7888          that this happens when X or Y is NOP_EXPR or Y is INTEGER_CST. */
7889       if (POINTER_TYPE_P (type)
7890           && TREE_CODE (arg0) == POINTER_PLUS_EXPR
7891           && (TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
7892               || TREE_CODE (TREE_OPERAND (arg0, 0)) == NOP_EXPR
7893               || TREE_CODE (TREE_OPERAND (arg0, 1)) == NOP_EXPR))
7894         {
7895           tree arg00 = TREE_OPERAND (arg0, 0);
7896           tree arg01 = TREE_OPERAND (arg0, 1);
7897
7898           return fold_build2_loc (loc,
7899                               TREE_CODE (arg0), type,
7900                               fold_convert_loc (loc, type, arg00),
7901                               fold_convert_loc (loc, sizetype, arg01));
7902         }
7903
7904       /* Convert (T1)(~(T2)X) into ~(T1)X if T1 and T2 are integral types
7905          of the same precision, and X is an integer type not narrower than
7906          types T1 or T2, i.e. the cast (T2)X isn't an extension.  */
7907       if (INTEGRAL_TYPE_P (type)
7908           && TREE_CODE (op0) == BIT_NOT_EXPR
7909           && INTEGRAL_TYPE_P (TREE_TYPE (op0))
7910           && CONVERT_EXPR_P (TREE_OPERAND (op0, 0))
7911           && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (op0)))
7912         {
7913           tem = TREE_OPERAND (TREE_OPERAND (op0, 0), 0);
7914           if (INTEGRAL_TYPE_P (TREE_TYPE (tem))
7915               && TYPE_PRECISION (type) <= TYPE_PRECISION (TREE_TYPE (tem)))
7916             return fold_build1_loc (loc, BIT_NOT_EXPR, type,
7917                                 fold_convert_loc (loc, type, tem));
7918         }
7919
7920       /* Convert (T1)(X * Y) into (T1)X * (T1)Y if T1 is narrower than the
7921          type of X and Y (integer types only).  */
7922       if (INTEGRAL_TYPE_P (type)
7923           && TREE_CODE (op0) == MULT_EXPR
7924           && INTEGRAL_TYPE_P (TREE_TYPE (op0))
7925           && TYPE_PRECISION (type) < TYPE_PRECISION (TREE_TYPE (op0)))
7926         {
7927           /* Be careful not to introduce new overflows.  */
7928           tree mult_type;
7929           if (TYPE_OVERFLOW_WRAPS (type))
7930             mult_type = type;
7931           else
7932             mult_type = unsigned_type_for (type);
7933
7934           if (TYPE_PRECISION (mult_type) < TYPE_PRECISION (TREE_TYPE (op0)))
7935             {
7936               tem = fold_build2_loc (loc, MULT_EXPR, mult_type,
7937                                  fold_convert_loc (loc, mult_type,
7938                                                    TREE_OPERAND (op0, 0)),
7939                                  fold_convert_loc (loc, mult_type,
7940                                                    TREE_OPERAND (op0, 1)));
7941               return fold_convert_loc (loc, type, tem);
7942             }
7943         }
7944
7945       tem = fold_convert_const (code, type, op0);
7946       return tem ? tem : NULL_TREE;
7947
7948     case ADDR_SPACE_CONVERT_EXPR:
7949       if (integer_zerop (arg0))
7950         return fold_convert_const (code, type, arg0);
7951       return NULL_TREE;
7952
7953     case FIXED_CONVERT_EXPR:
7954       tem = fold_convert_const (code, type, arg0);
7955       return tem ? tem : NULL_TREE;
7956
7957     case VIEW_CONVERT_EXPR:
7958       if (TREE_TYPE (op0) == type)
7959         return op0;
7960       if (TREE_CODE (op0) == VIEW_CONVERT_EXPR)
7961         return fold_build1_loc (loc, VIEW_CONVERT_EXPR,
7962                             type, TREE_OPERAND (op0, 0));
7963       if (TREE_CODE (op0) == MEM_REF)
7964         return fold_build2_loc (loc, MEM_REF, type,
7965                                 TREE_OPERAND (op0, 0), TREE_OPERAND (op0, 1));
7966
7967       /* For integral conversions with the same precision or pointer
7968          conversions use a NOP_EXPR instead.  */
7969       if ((INTEGRAL_TYPE_P (type)
7970            || POINTER_TYPE_P (type))
7971           && (INTEGRAL_TYPE_P (TREE_TYPE (op0))
7972               || POINTER_TYPE_P (TREE_TYPE (op0)))
7973           && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (op0)))
7974         return fold_convert_loc (loc, type, op0);
7975
7976       /* Strip inner integral conversions that do not change the precision.  */
7977       if (CONVERT_EXPR_P (op0)
7978           && (INTEGRAL_TYPE_P (TREE_TYPE (op0))
7979               || POINTER_TYPE_P (TREE_TYPE (op0)))
7980           && (INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (op0, 0)))
7981               || POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (op0, 0))))
7982           && (TYPE_PRECISION (TREE_TYPE (op0))
7983               == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op0, 0)))))
7984         return fold_build1_loc (loc, VIEW_CONVERT_EXPR,
7985                             type, TREE_OPERAND (op0, 0));
7986
7987       return fold_view_convert_expr (type, op0);
7988
7989     case NEGATE_EXPR:
7990       tem = fold_negate_expr (loc, arg0);
7991       if (tem)
7992         return fold_convert_loc (loc, type, tem);
7993       return NULL_TREE;
7994
7995     case ABS_EXPR:
7996       if (TREE_CODE (arg0) == INTEGER_CST || TREE_CODE (arg0) == REAL_CST)
7997         return fold_abs_const (arg0, type);
7998       else if (TREE_CODE (arg0) == NEGATE_EXPR)
7999         return fold_build1_loc (loc, ABS_EXPR, type, TREE_OPERAND (arg0, 0));
8000       /* Convert fabs((double)float) into (double)fabsf(float).  */
8001       else if (TREE_CODE (arg0) == NOP_EXPR
8002                && TREE_CODE (type) == REAL_TYPE)
8003         {
8004           tree targ0 = strip_float_extensions (arg0);
8005           if (targ0 != arg0)
8006             return fold_convert_loc (loc, type,
8007                                      fold_build1_loc (loc, ABS_EXPR,
8008                                                   TREE_TYPE (targ0),
8009                                                   targ0));
8010         }
8011       /* ABS_EXPR<ABS_EXPR<x>> = ABS_EXPR<x> even if flag_wrapv is on.  */
8012       else if (TREE_CODE (arg0) == ABS_EXPR)
8013         return arg0;
8014       else if (tree_expr_nonnegative_p (arg0))
8015         return arg0;
8016
8017       /* Strip sign ops from argument.  */
8018       if (TREE_CODE (type) == REAL_TYPE)
8019         {
8020           tem = fold_strip_sign_ops (arg0);
8021           if (tem)
8022             return fold_build1_loc (loc, ABS_EXPR, type,
8023                                 fold_convert_loc (loc, type, tem));
8024         }
8025       return NULL_TREE;
8026
8027     case CONJ_EXPR:
8028       if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
8029         return fold_convert_loc (loc, type, arg0);
8030       if (TREE_CODE (arg0) == COMPLEX_EXPR)
8031         {
8032           tree itype = TREE_TYPE (type);
8033           tree rpart = fold_convert_loc (loc, itype, TREE_OPERAND (arg0, 0));
8034           tree ipart = fold_convert_loc (loc, itype, TREE_OPERAND (arg0, 1));
8035           return fold_build2_loc (loc, COMPLEX_EXPR, type, rpart,
8036                               negate_expr (ipart));
8037         }
8038       if (TREE_CODE (arg0) == COMPLEX_CST)
8039         {
8040           tree itype = TREE_TYPE (type);
8041           tree rpart = fold_convert_loc (loc, itype, TREE_REALPART (arg0));
8042           tree ipart = fold_convert_loc (loc, itype, TREE_IMAGPART (arg0));
8043           return build_complex (type, rpart, negate_expr (ipart));
8044         }
8045       if (TREE_CODE (arg0) == CONJ_EXPR)
8046         return fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
8047       return NULL_TREE;
8048
8049     case BIT_NOT_EXPR:
8050       if (TREE_CODE (arg0) == INTEGER_CST)
8051         return fold_not_const (arg0, type);
8052       else if (TREE_CODE (arg0) == BIT_NOT_EXPR)
8053         return fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
8054       /* Convert ~ (-A) to A - 1.  */
8055       else if (INTEGRAL_TYPE_P (type) && TREE_CODE (arg0) == NEGATE_EXPR)
8056         return fold_build2_loc (loc, MINUS_EXPR, type,
8057                             fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0)),
8058                             build_int_cst (type, 1));
8059       /* Convert ~ (A - 1) or ~ (A + -1) to -A.  */
8060       else if (INTEGRAL_TYPE_P (type)
8061                && ((TREE_CODE (arg0) == MINUS_EXPR
8062                     && integer_onep (TREE_OPERAND (arg0, 1)))
8063                    || (TREE_CODE (arg0) == PLUS_EXPR
8064                        && integer_all_onesp (TREE_OPERAND (arg0, 1)))))
8065         return fold_build1_loc (loc, NEGATE_EXPR, type,
8066                             fold_convert_loc (loc, type,
8067                                               TREE_OPERAND (arg0, 0)));
8068       /* Convert ~(X ^ Y) to ~X ^ Y or X ^ ~Y if ~X or ~Y simplify.  */
8069       else if (TREE_CODE (arg0) == BIT_XOR_EXPR
8070                && (tem = fold_unary_loc (loc, BIT_NOT_EXPR, type,
8071                                      fold_convert_loc (loc, type,
8072                                                        TREE_OPERAND (arg0, 0)))))
8073         return fold_build2_loc (loc, BIT_XOR_EXPR, type, tem,
8074                             fold_convert_loc (loc, type,
8075                                               TREE_OPERAND (arg0, 1)));
8076       else if (TREE_CODE (arg0) == BIT_XOR_EXPR
8077                && (tem = fold_unary_loc (loc, BIT_NOT_EXPR, type,
8078                                      fold_convert_loc (loc, type,
8079                                                        TREE_OPERAND (arg0, 1)))))
8080         return fold_build2_loc (loc, BIT_XOR_EXPR, type,
8081                             fold_convert_loc (loc, type,
8082                                               TREE_OPERAND (arg0, 0)), tem);
8083       /* Perform BIT_NOT_EXPR on each element individually.  */
8084       else if (TREE_CODE (arg0) == VECTOR_CST)
8085         {
8086           tree elements = TREE_VECTOR_CST_ELTS (arg0), elem, list = NULL_TREE;
8087           int count = TYPE_VECTOR_SUBPARTS (type), i;
8088
8089           for (i = 0; i < count; i++)
8090             {
8091               if (elements)
8092                 {
8093                   elem = TREE_VALUE (elements);
8094                   elem = fold_unary_loc (loc, BIT_NOT_EXPR, TREE_TYPE (type), elem);
8095                   if (elem == NULL_TREE)
8096                     break;
8097                   elements = TREE_CHAIN (elements);
8098                 }
8099               else
8100                 elem = build_int_cst (TREE_TYPE (type), -1);
8101               list = tree_cons (NULL_TREE, elem, list);
8102             }
8103           if (i == count)
8104             return build_vector (type, nreverse (list));
8105         }
8106
8107       return NULL_TREE;
8108
8109     case TRUTH_NOT_EXPR:
8110       /* The argument to invert_truthvalue must have Boolean type.  */
8111       if (TREE_CODE (TREE_TYPE (arg0)) != BOOLEAN_TYPE)
8112           arg0 = fold_convert_loc (loc, boolean_type_node, arg0);
8113
8114       /* Note that the operand of this must be an int
8115          and its values must be 0 or 1.
8116          ("true" is a fixed value perhaps depending on the language,
8117          but we don't handle values other than 1 correctly yet.)  */
8118       tem = fold_truth_not_expr (loc, arg0);
8119       if (!tem)
8120         return NULL_TREE;
8121       return fold_convert_loc (loc, type, tem);
8122
8123     case REALPART_EXPR:
8124       if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
8125         return fold_convert_loc (loc, type, arg0);
8126       if (TREE_CODE (arg0) == COMPLEX_EXPR)
8127         return omit_one_operand_loc (loc, type, TREE_OPERAND (arg0, 0),
8128                                  TREE_OPERAND (arg0, 1));
8129       if (TREE_CODE (arg0) == COMPLEX_CST)
8130         return fold_convert_loc (loc, type, TREE_REALPART (arg0));
8131       if (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
8132         {
8133           tree itype = TREE_TYPE (TREE_TYPE (arg0));
8134           tem = fold_build2_loc (loc, TREE_CODE (arg0), itype,
8135                              fold_build1_loc (loc, REALPART_EXPR, itype,
8136                                           TREE_OPERAND (arg0, 0)),
8137                              fold_build1_loc (loc, REALPART_EXPR, itype,
8138                                           TREE_OPERAND (arg0, 1)));
8139           return fold_convert_loc (loc, type, tem);
8140         }
8141       if (TREE_CODE (arg0) == CONJ_EXPR)
8142         {
8143           tree itype = TREE_TYPE (TREE_TYPE (arg0));
8144           tem = fold_build1_loc (loc, REALPART_EXPR, itype,
8145                              TREE_OPERAND (arg0, 0));
8146           return fold_convert_loc (loc, type, tem);
8147         }
8148       if (TREE_CODE (arg0) == CALL_EXPR)
8149         {
8150           tree fn = get_callee_fndecl (arg0);
8151           if (fn && DECL_BUILT_IN_CLASS (fn) == BUILT_IN_NORMAL)
8152             switch (DECL_FUNCTION_CODE (fn))
8153               {
8154               CASE_FLT_FN (BUILT_IN_CEXPI):
8155                 fn = mathfn_built_in (type, BUILT_IN_COS);
8156                 if (fn)
8157                   return build_call_expr_loc (loc, fn, 1, CALL_EXPR_ARG (arg0, 0));
8158                 break;
8159
8160               default:
8161                 break;
8162               }
8163         }
8164       return NULL_TREE;
8165
8166     case IMAGPART_EXPR:
8167       if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
8168         return build_zero_cst (type);
8169       if (TREE_CODE (arg0) == COMPLEX_EXPR)
8170         return omit_one_operand_loc (loc, type, TREE_OPERAND (arg0, 1),
8171                                  TREE_OPERAND (arg0, 0));
8172       if (TREE_CODE (arg0) == COMPLEX_CST)
8173         return fold_convert_loc (loc, type, TREE_IMAGPART (arg0));
8174       if (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
8175         {
8176           tree itype = TREE_TYPE (TREE_TYPE (arg0));
8177           tem = fold_build2_loc (loc, TREE_CODE (arg0), itype,
8178                              fold_build1_loc (loc, IMAGPART_EXPR, itype,
8179                                           TREE_OPERAND (arg0, 0)),
8180                              fold_build1_loc (loc, IMAGPART_EXPR, itype,
8181                                           TREE_OPERAND (arg0, 1)));
8182           return fold_convert_loc (loc, type, tem);
8183         }
8184       if (TREE_CODE (arg0) == CONJ_EXPR)
8185         {
8186           tree itype = TREE_TYPE (TREE_TYPE (arg0));
8187           tem = fold_build1_loc (loc, IMAGPART_EXPR, itype, TREE_OPERAND (arg0, 0));
8188           return fold_convert_loc (loc, type, negate_expr (tem));
8189         }
8190       if (TREE_CODE (arg0) == CALL_EXPR)
8191         {
8192           tree fn = get_callee_fndecl (arg0);
8193           if (fn && DECL_BUILT_IN_CLASS (fn) == BUILT_IN_NORMAL)
8194             switch (DECL_FUNCTION_CODE (fn))
8195               {
8196               CASE_FLT_FN (BUILT_IN_CEXPI):
8197                 fn = mathfn_built_in (type, BUILT_IN_SIN);
8198                 if (fn)
8199                   return build_call_expr_loc (loc, fn, 1, CALL_EXPR_ARG (arg0, 0));
8200                 break;
8201
8202               default:
8203                 break;
8204               }
8205         }
8206       return NULL_TREE;
8207
8208     case INDIRECT_REF:
8209       /* Fold *&X to X if X is an lvalue.  */
8210       if (TREE_CODE (op0) == ADDR_EXPR)
8211         {
8212           tree op00 = TREE_OPERAND (op0, 0);
8213           if ((TREE_CODE (op00) == VAR_DECL
8214                || TREE_CODE (op00) == PARM_DECL
8215                || TREE_CODE (op00) == RESULT_DECL)
8216               && !TREE_READONLY (op00))
8217             return op00;
8218         }
8219       return NULL_TREE;
8220
8221     default:
8222       return NULL_TREE;
8223     } /* switch (code) */
8224 }
8225
8226
8227 /* If the operation was a conversion do _not_ mark a resulting constant
8228    with TREE_OVERFLOW if the original constant was not.  These conversions
8229    have implementation defined behavior and retaining the TREE_OVERFLOW
8230    flag here would confuse later passes such as VRP.  */
8231 tree
8232 fold_unary_ignore_overflow_loc (location_t loc, enum tree_code code,
8233                                 tree type, tree op0)
8234 {
8235   tree res = fold_unary_loc (loc, code, type, op0);
8236   if (res
8237       && TREE_CODE (res) == INTEGER_CST
8238       && TREE_CODE (op0) == INTEGER_CST
8239       && CONVERT_EXPR_CODE_P (code))
8240     TREE_OVERFLOW (res) = TREE_OVERFLOW (op0);
8241
8242   return res;
8243 }
8244
8245 /* Fold a binary expression of code CODE and type TYPE with operands
8246    OP0 and OP1, containing either a MIN-MAX or a MAX-MIN combination.
8247    Return the folded expression if folding is successful.  Otherwise,
8248    return NULL_TREE.  */
8249
8250 static tree
8251 fold_minmax (location_t loc, enum tree_code code, tree type, tree op0, tree op1)
8252 {
8253   enum tree_code compl_code;
8254
8255   if (code == MIN_EXPR)
8256     compl_code = MAX_EXPR;
8257   else if (code == MAX_EXPR)
8258     compl_code = MIN_EXPR;
8259   else
8260     gcc_unreachable ();
8261
8262   /* MIN (MAX (a, b), b) == b.  */
8263   if (TREE_CODE (op0) == compl_code
8264       && operand_equal_p (TREE_OPERAND (op0, 1), op1, 0))
8265     return omit_one_operand_loc (loc, type, op1, TREE_OPERAND (op0, 0));
8266
8267   /* MIN (MAX (b, a), b) == b.  */
8268   if (TREE_CODE (op0) == compl_code
8269       && operand_equal_p (TREE_OPERAND (op0, 0), op1, 0)
8270       && reorder_operands_p (TREE_OPERAND (op0, 1), op1))
8271     return omit_one_operand_loc (loc, type, op1, TREE_OPERAND (op0, 1));
8272
8273   /* MIN (a, MAX (a, b)) == a.  */
8274   if (TREE_CODE (op1) == compl_code
8275       && operand_equal_p (op0, TREE_OPERAND (op1, 0), 0)
8276       && reorder_operands_p (op0, TREE_OPERAND (op1, 1)))
8277     return omit_one_operand_loc (loc, type, op0, TREE_OPERAND (op1, 1));
8278
8279   /* MIN (a, MAX (b, a)) == a.  */
8280   if (TREE_CODE (op1) == compl_code
8281       && operand_equal_p (op0, TREE_OPERAND (op1, 1), 0)
8282       && reorder_operands_p (op0, TREE_OPERAND (op1, 0)))
8283     return omit_one_operand_loc (loc, type, op0, TREE_OPERAND (op1, 0));
8284
8285   return NULL_TREE;
8286 }
8287
8288 /* Helper that tries to canonicalize the comparison ARG0 CODE ARG1
8289    by changing CODE to reduce the magnitude of constants involved in
8290    ARG0 of the comparison.
8291    Returns a canonicalized comparison tree if a simplification was
8292    possible, otherwise returns NULL_TREE.
8293    Set *STRICT_OVERFLOW_P to true if the canonicalization is only
8294    valid if signed overflow is undefined.  */
8295
8296 static tree
8297 maybe_canonicalize_comparison_1 (location_t loc, enum tree_code code, tree type,
8298                                  tree arg0, tree arg1,
8299                                  bool *strict_overflow_p)
8300 {
8301   enum tree_code code0 = TREE_CODE (arg0);
8302   tree t, cst0 = NULL_TREE;
8303   int sgn0;
8304   bool swap = false;
8305
8306   /* Match A +- CST code arg1 and CST code arg1.  We can change the
8307      first form only if overflow is undefined.  */
8308   if (!((TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg0))
8309          /* In principle pointers also have undefined overflow behavior,
8310             but that causes problems elsewhere.  */
8311          && !POINTER_TYPE_P (TREE_TYPE (arg0))
8312          && (code0 == MINUS_EXPR
8313              || code0 == PLUS_EXPR)
8314          && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
8315         || code0 == INTEGER_CST))
8316     return NULL_TREE;
8317
8318   /* Identify the constant in arg0 and its sign.  */
8319   if (code0 == INTEGER_CST)
8320     cst0 = arg0;
8321   else
8322     cst0 = TREE_OPERAND (arg0, 1);
8323   sgn0 = tree_int_cst_sgn (cst0);
8324
8325   /* Overflowed constants and zero will cause problems.  */
8326   if (integer_zerop (cst0)
8327       || TREE_OVERFLOW (cst0))
8328     return NULL_TREE;
8329
8330   /* See if we can reduce the magnitude of the constant in
8331      arg0 by changing the comparison code.  */
8332   if (code0 == INTEGER_CST)
8333     {
8334       /* CST <= arg1  ->  CST-1 < arg1.  */
8335       if (code == LE_EXPR && sgn0 == 1)
8336         code = LT_EXPR;
8337       /* -CST < arg1  ->  -CST-1 <= arg1.  */
8338       else if (code == LT_EXPR && sgn0 == -1)
8339         code = LE_EXPR;
8340       /* CST > arg1  ->  CST-1 >= arg1.  */
8341       else if (code == GT_EXPR && sgn0 == 1)
8342         code = GE_EXPR;
8343       /* -CST >= arg1  ->  -CST-1 > arg1.  */
8344       else if (code == GE_EXPR && sgn0 == -1)
8345         code = GT_EXPR;
8346       else
8347         return NULL_TREE;
8348       /* arg1 code' CST' might be more canonical.  */
8349       swap = true;
8350     }
8351   else
8352     {
8353       /* A - CST < arg1  ->  A - CST-1 <= arg1.  */
8354       if (code == LT_EXPR
8355           && code0 == ((sgn0 == -1) ? PLUS_EXPR : MINUS_EXPR))
8356         code = LE_EXPR;
8357       /* A + CST > arg1  ->  A + CST-1 >= arg1.  */
8358       else if (code == GT_EXPR
8359                && code0 == ((sgn0 == -1) ? MINUS_EXPR : PLUS_EXPR))
8360         code = GE_EXPR;
8361       /* A + CST <= arg1  ->  A + CST-1 < arg1.  */
8362       else if (code == LE_EXPR
8363                && code0 == ((sgn0 == -1) ? MINUS_EXPR : PLUS_EXPR))
8364         code = LT_EXPR;
8365       /* A - CST >= arg1  ->  A - CST-1 > arg1.  */
8366       else if (code == GE_EXPR
8367                && code0 == ((sgn0 == -1) ? PLUS_EXPR : MINUS_EXPR))
8368         code = GT_EXPR;
8369       else
8370         return NULL_TREE;
8371       *strict_overflow_p = true;
8372     }
8373
8374   /* Now build the constant reduced in magnitude.  But not if that
8375      would produce one outside of its types range.  */
8376   if (INTEGRAL_TYPE_P (TREE_TYPE (cst0))
8377       && ((sgn0 == 1
8378            && TYPE_MIN_VALUE (TREE_TYPE (cst0))
8379            && tree_int_cst_equal (cst0, TYPE_MIN_VALUE (TREE_TYPE (cst0))))
8380           || (sgn0 == -1
8381               && TYPE_MAX_VALUE (TREE_TYPE (cst0))
8382               && tree_int_cst_equal (cst0, TYPE_MAX_VALUE (TREE_TYPE (cst0))))))
8383     /* We cannot swap the comparison here as that would cause us to
8384        endlessly recurse.  */
8385     return NULL_TREE;
8386
8387   t = int_const_binop (sgn0 == -1 ? PLUS_EXPR : MINUS_EXPR,
8388                        cst0, build_int_cst (TREE_TYPE (cst0), 1), 0);
8389   if (code0 != INTEGER_CST)
8390     t = fold_build2_loc (loc, code0, TREE_TYPE (arg0), TREE_OPERAND (arg0, 0), t);
8391
8392   /* If swapping might yield to a more canonical form, do so.  */
8393   if (swap)
8394     return fold_build2_loc (loc, swap_tree_comparison (code), type, arg1, t);
8395   else
8396     return fold_build2_loc (loc, code, type, t, arg1);
8397 }
8398
8399 /* Canonicalize the comparison ARG0 CODE ARG1 with type TYPE with undefined
8400    overflow further.  Try to decrease the magnitude of constants involved
8401    by changing LE_EXPR and GE_EXPR to LT_EXPR and GT_EXPR or vice versa
8402    and put sole constants at the second argument position.
8403    Returns the canonicalized tree if changed, otherwise NULL_TREE.  */
8404
8405 static tree
8406 maybe_canonicalize_comparison (location_t loc, enum tree_code code, tree type,
8407                                tree arg0, tree arg1)
8408 {
8409   tree t;
8410   bool strict_overflow_p;
8411   const char * const warnmsg = G_("assuming signed overflow does not occur "
8412                                   "when reducing constant in comparison");
8413
8414   /* Try canonicalization by simplifying arg0.  */
8415   strict_overflow_p = false;
8416   t = maybe_canonicalize_comparison_1 (loc, code, type, arg0, arg1,
8417                                        &strict_overflow_p);
8418   if (t)
8419     {
8420       if (strict_overflow_p)
8421         fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_MAGNITUDE);
8422       return t;
8423     }
8424
8425   /* Try canonicalization by simplifying arg1 using the swapped
8426      comparison.  */
8427   code = swap_tree_comparison (code);
8428   strict_overflow_p = false;
8429   t = maybe_canonicalize_comparison_1 (loc, code, type, arg1, arg0,
8430                                        &strict_overflow_p);
8431   if (t && strict_overflow_p)
8432     fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_MAGNITUDE);
8433   return t;
8434 }
8435
8436 /* Return whether BASE + OFFSET + BITPOS may wrap around the address
8437    space.  This is used to avoid issuing overflow warnings for
8438    expressions like &p->x which can not wrap.  */
8439
8440 static bool
8441 pointer_may_wrap_p (tree base, tree offset, HOST_WIDE_INT bitpos)
8442 {
8443   unsigned HOST_WIDE_INT offset_low, total_low;
8444   HOST_WIDE_INT size, offset_high, total_high;
8445
8446   if (!POINTER_TYPE_P (TREE_TYPE (base)))
8447     return true;
8448
8449   if (bitpos < 0)
8450     return true;
8451
8452   if (offset == NULL_TREE)
8453     {
8454       offset_low = 0;
8455       offset_high = 0;
8456     }
8457   else if (TREE_CODE (offset) != INTEGER_CST || TREE_OVERFLOW (offset))
8458     return true;
8459   else
8460     {
8461       offset_low = TREE_INT_CST_LOW (offset);
8462       offset_high = TREE_INT_CST_HIGH (offset);
8463     }
8464
8465   if (add_double_with_sign (offset_low, offset_high,
8466                             bitpos / BITS_PER_UNIT, 0,
8467                             &total_low, &total_high,
8468                             true))
8469     return true;
8470
8471   if (total_high != 0)
8472     return true;
8473
8474   size = int_size_in_bytes (TREE_TYPE (TREE_TYPE (base)));
8475   if (size <= 0)
8476     return true;
8477
8478   /* We can do slightly better for SIZE if we have an ADDR_EXPR of an
8479      array.  */
8480   if (TREE_CODE (base) == ADDR_EXPR)
8481     {
8482       HOST_WIDE_INT base_size;
8483
8484       base_size = int_size_in_bytes (TREE_TYPE (TREE_OPERAND (base, 0)));
8485       if (base_size > 0 && size < base_size)
8486         size = base_size;
8487     }
8488
8489   return total_low > (unsigned HOST_WIDE_INT) size;
8490 }
8491
8492 /* Subroutine of fold_binary.  This routine performs all of the
8493    transformations that are common to the equality/inequality
8494    operators (EQ_EXPR and NE_EXPR) and the ordering operators
8495    (LT_EXPR, LE_EXPR, GE_EXPR and GT_EXPR).  Callers other than
8496    fold_binary should call fold_binary.  Fold a comparison with
8497    tree code CODE and type TYPE with operands OP0 and OP1.  Return
8498    the folded comparison or NULL_TREE.  */
8499
8500 static tree
8501 fold_comparison (location_t loc, enum tree_code code, tree type,
8502                  tree op0, tree op1)
8503 {
8504   tree arg0, arg1, tem;
8505
8506   arg0 = op0;
8507   arg1 = op1;
8508
8509   STRIP_SIGN_NOPS (arg0);
8510   STRIP_SIGN_NOPS (arg1);
8511
8512   tem = fold_relational_const (code, type, arg0, arg1);
8513   if (tem != NULL_TREE)
8514     return tem;
8515
8516   /* If one arg is a real or integer constant, put it last.  */
8517   if (tree_swap_operands_p (arg0, arg1, true))
8518     return fold_build2_loc (loc, swap_tree_comparison (code), type, op1, op0);
8519
8520   /* Transform comparisons of the form X +- C1 CMP C2 to X CMP C2 +- C1.  */
8521   if ((TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
8522       && (TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
8523           && !TREE_OVERFLOW (TREE_OPERAND (arg0, 1))
8524           && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
8525       && (TREE_CODE (arg1) == INTEGER_CST
8526           && !TREE_OVERFLOW (arg1)))
8527     {
8528       tree const1 = TREE_OPERAND (arg0, 1);
8529       tree const2 = arg1;
8530       tree variable = TREE_OPERAND (arg0, 0);
8531       tree lhs;
8532       int lhs_add;
8533       lhs_add = TREE_CODE (arg0) != PLUS_EXPR;
8534
8535       lhs = fold_build2_loc (loc, lhs_add ? PLUS_EXPR : MINUS_EXPR,
8536                          TREE_TYPE (arg1), const2, const1);
8537
8538       /* If the constant operation overflowed this can be
8539          simplified as a comparison against INT_MAX/INT_MIN.  */
8540       if (TREE_CODE (lhs) == INTEGER_CST
8541           && TREE_OVERFLOW (lhs))
8542         {
8543           int const1_sgn = tree_int_cst_sgn (const1);
8544           enum tree_code code2 = code;
8545
8546           /* Get the sign of the constant on the lhs if the
8547              operation were VARIABLE + CONST1.  */
8548           if (TREE_CODE (arg0) == MINUS_EXPR)
8549             const1_sgn = -const1_sgn;
8550
8551           /* The sign of the constant determines if we overflowed
8552              INT_MAX (const1_sgn == -1) or INT_MIN (const1_sgn == 1).
8553              Canonicalize to the INT_MIN overflow by swapping the comparison
8554              if necessary.  */
8555           if (const1_sgn == -1)
8556             code2 = swap_tree_comparison (code);
8557
8558           /* We now can look at the canonicalized case
8559                VARIABLE + 1  CODE2  INT_MIN
8560              and decide on the result.  */
8561           if (code2 == LT_EXPR
8562               || code2 == LE_EXPR
8563               || code2 == EQ_EXPR)
8564             return omit_one_operand_loc (loc, type, boolean_false_node, variable);
8565           else if (code2 == NE_EXPR
8566                    || code2 == GE_EXPR
8567                    || code2 == GT_EXPR)
8568             return omit_one_operand_loc (loc, type, boolean_true_node, variable);
8569         }
8570
8571       if (TREE_CODE (lhs) == TREE_CODE (arg1)
8572           && (TREE_CODE (lhs) != INTEGER_CST
8573               || !TREE_OVERFLOW (lhs)))
8574         {
8575           if (code != EQ_EXPR && code != NE_EXPR)
8576             fold_overflow_warning ("assuming signed overflow does not occur "
8577                                    "when changing X +- C1 cmp C2 to "
8578                                    "X cmp C1 +- C2",
8579                                    WARN_STRICT_OVERFLOW_COMPARISON);
8580           return fold_build2_loc (loc, code, type, variable, lhs);
8581         }
8582     }
8583
8584   /* For comparisons of pointers we can decompose it to a compile time
8585      comparison of the base objects and the offsets into the object.
8586      This requires at least one operand being an ADDR_EXPR or a
8587      POINTER_PLUS_EXPR to do more than the operand_equal_p test below.  */
8588   if (POINTER_TYPE_P (TREE_TYPE (arg0))
8589       && (TREE_CODE (arg0) == ADDR_EXPR
8590           || TREE_CODE (arg1) == ADDR_EXPR
8591           || TREE_CODE (arg0) == POINTER_PLUS_EXPR
8592           || TREE_CODE (arg1) == POINTER_PLUS_EXPR))
8593     {
8594       tree base0, base1, offset0 = NULL_TREE, offset1 = NULL_TREE;
8595       HOST_WIDE_INT bitsize, bitpos0 = 0, bitpos1 = 0;
8596       enum machine_mode mode;
8597       int volatilep, unsignedp;
8598       bool indirect_base0 = false, indirect_base1 = false;
8599
8600       /* Get base and offset for the access.  Strip ADDR_EXPR for
8601          get_inner_reference, but put it back by stripping INDIRECT_REF
8602          off the base object if possible.  indirect_baseN will be true
8603          if baseN is not an address but refers to the object itself.  */
8604       base0 = arg0;
8605       if (TREE_CODE (arg0) == ADDR_EXPR)
8606         {
8607           base0 = get_inner_reference (TREE_OPERAND (arg0, 0),
8608                                        &bitsize, &bitpos0, &offset0, &mode,
8609                                        &unsignedp, &volatilep, false);
8610           if (TREE_CODE (base0) == INDIRECT_REF)
8611             base0 = TREE_OPERAND (base0, 0);
8612           else
8613             indirect_base0 = true;
8614         }
8615       else if (TREE_CODE (arg0) == POINTER_PLUS_EXPR)
8616         {
8617           base0 = TREE_OPERAND (arg0, 0);
8618           STRIP_SIGN_NOPS (base0);
8619           if (TREE_CODE (base0) == ADDR_EXPR)
8620             {
8621               base0 = TREE_OPERAND (base0, 0);
8622               indirect_base0 = true;
8623             }
8624           offset0 = TREE_OPERAND (arg0, 1);
8625         }
8626
8627       base1 = arg1;
8628       if (TREE_CODE (arg1) == ADDR_EXPR)
8629         {
8630           base1 = get_inner_reference (TREE_OPERAND (arg1, 0),
8631                                        &bitsize, &bitpos1, &offset1, &mode,
8632                                        &unsignedp, &volatilep, false);
8633           if (TREE_CODE (base1) == INDIRECT_REF)
8634             base1 = TREE_OPERAND (base1, 0);
8635           else
8636             indirect_base1 = true;
8637         }
8638       else if (TREE_CODE (arg1) == POINTER_PLUS_EXPR)
8639         {
8640           base1 = TREE_OPERAND (arg1, 0);
8641           STRIP_SIGN_NOPS (base1);
8642           if (TREE_CODE (base1) == ADDR_EXPR)
8643             {
8644               base1 = TREE_OPERAND (base1, 0);
8645               indirect_base1 = true;
8646             }
8647           offset1 = TREE_OPERAND (arg1, 1);
8648         }
8649
8650       /* A local variable can never be pointed to by
8651          the default SSA name of an incoming parameter.  */
8652       if ((TREE_CODE (arg0) == ADDR_EXPR
8653            && indirect_base0
8654            && TREE_CODE (base0) == VAR_DECL
8655            && auto_var_in_fn_p (base0, current_function_decl)
8656            && !indirect_base1
8657            && TREE_CODE (base1) == SSA_NAME
8658            && TREE_CODE (SSA_NAME_VAR (base1)) == PARM_DECL
8659            && SSA_NAME_IS_DEFAULT_DEF (base1))
8660           || (TREE_CODE (arg1) == ADDR_EXPR
8661               && indirect_base1
8662               && TREE_CODE (base1) == VAR_DECL
8663               && auto_var_in_fn_p (base1, current_function_decl)
8664               && !indirect_base0
8665               && TREE_CODE (base0) == SSA_NAME
8666               && TREE_CODE (SSA_NAME_VAR (base0)) == PARM_DECL
8667               && SSA_NAME_IS_DEFAULT_DEF (base0)))
8668         {
8669           if (code == NE_EXPR)
8670             return constant_boolean_node (1, type);
8671           else if (code == EQ_EXPR)
8672             return constant_boolean_node (0, type);
8673         }
8674       /* If we have equivalent bases we might be able to simplify.  */
8675       else if (indirect_base0 == indirect_base1
8676                && operand_equal_p (base0, base1, 0))
8677         {
8678           /* We can fold this expression to a constant if the non-constant
8679              offset parts are equal.  */
8680           if ((offset0 == offset1
8681                || (offset0 && offset1
8682                    && operand_equal_p (offset0, offset1, 0)))
8683               && (code == EQ_EXPR
8684                   || code == NE_EXPR
8685                   || POINTER_TYPE_OVERFLOW_UNDEFINED))
8686
8687             {
8688               if (code != EQ_EXPR
8689                   && code != NE_EXPR
8690                   && bitpos0 != bitpos1
8691                   && (pointer_may_wrap_p (base0, offset0, bitpos0)
8692                       || pointer_may_wrap_p (base1, offset1, bitpos1)))
8693                 fold_overflow_warning (("assuming pointer wraparound does not "
8694                                         "occur when comparing P +- C1 with "
8695                                         "P +- C2"),
8696                                        WARN_STRICT_OVERFLOW_CONDITIONAL);
8697
8698               switch (code)
8699                 {
8700                 case EQ_EXPR:
8701                   return constant_boolean_node (bitpos0 == bitpos1, type);
8702                 case NE_EXPR:
8703                   return constant_boolean_node (bitpos0 != bitpos1, type);
8704                 case LT_EXPR:
8705                   return constant_boolean_node (bitpos0 < bitpos1, type);
8706                 case LE_EXPR:
8707                   return constant_boolean_node (bitpos0 <= bitpos1, type);
8708                 case GE_EXPR:
8709                   return constant_boolean_node (bitpos0 >= bitpos1, type);
8710                 case GT_EXPR:
8711                   return constant_boolean_node (bitpos0 > bitpos1, type);
8712                 default:;
8713                 }
8714             }
8715           /* We can simplify the comparison to a comparison of the variable
8716              offset parts if the constant offset parts are equal.
8717              Be careful to use signed size type here because otherwise we
8718              mess with array offsets in the wrong way.  This is possible
8719              because pointer arithmetic is restricted to retain within an
8720              object and overflow on pointer differences is undefined as of
8721              6.5.6/8 and /9 with respect to the signed ptrdiff_t.  */
8722           else if (bitpos0 == bitpos1
8723                    && ((code == EQ_EXPR || code == NE_EXPR)
8724                        || POINTER_TYPE_OVERFLOW_UNDEFINED))
8725             {
8726               /* By converting to signed size type we cover middle-end pointer
8727                  arithmetic which operates on unsigned pointer types of size
8728                  type size and ARRAY_REF offsets which are properly sign or
8729                  zero extended from their type in case it is narrower than
8730                  size type.  */
8731               if (offset0 == NULL_TREE)
8732                 offset0 = build_int_cst (ssizetype, 0);
8733               else
8734                 offset0 = fold_convert_loc (loc, ssizetype, offset0);
8735               if (offset1 == NULL_TREE)
8736                 offset1 = build_int_cst (ssizetype, 0);
8737               else
8738                 offset1 = fold_convert_loc (loc, ssizetype, offset1);
8739
8740               if (code != EQ_EXPR
8741                   && code != NE_EXPR
8742                   && (pointer_may_wrap_p (base0, offset0, bitpos0)
8743                       || pointer_may_wrap_p (base1, offset1, bitpos1)))
8744                 fold_overflow_warning (("assuming pointer wraparound does not "
8745                                         "occur when comparing P +- C1 with "
8746                                         "P +- C2"),
8747                                        WARN_STRICT_OVERFLOW_COMPARISON);
8748
8749               return fold_build2_loc (loc, code, type, offset0, offset1);
8750             }
8751         }
8752       /* For non-equal bases we can simplify if they are addresses
8753          of local binding decls or constants.  */
8754       else if (indirect_base0 && indirect_base1
8755                /* We know that !operand_equal_p (base0, base1, 0)
8756                   because the if condition was false.  But make
8757                   sure two decls are not the same.  */
8758                && base0 != base1
8759                && TREE_CODE (arg0) == ADDR_EXPR
8760                && TREE_CODE (arg1) == ADDR_EXPR
8761                && (((TREE_CODE (base0) == VAR_DECL
8762                      || TREE_CODE (base0) == PARM_DECL)
8763                     && (targetm.binds_local_p (base0)
8764                         || CONSTANT_CLASS_P (base1)))
8765                    || CONSTANT_CLASS_P (base0))
8766                && (((TREE_CODE (base1) == VAR_DECL
8767                      || TREE_CODE (base1) == PARM_DECL)
8768                     && (targetm.binds_local_p (base1)
8769                         || CONSTANT_CLASS_P (base0)))
8770                    || CONSTANT_CLASS_P (base1)))
8771         {
8772           if (code == EQ_EXPR)
8773             return omit_two_operands_loc (loc, type, boolean_false_node,
8774                                       arg0, arg1);
8775           else if (code == NE_EXPR)
8776             return omit_two_operands_loc (loc, type, boolean_true_node,
8777                                       arg0, arg1);
8778         }
8779       /* For equal offsets we can simplify to a comparison of the
8780          base addresses.  */
8781       else if (bitpos0 == bitpos1
8782                && (indirect_base0
8783                    ? base0 != TREE_OPERAND (arg0, 0) : base0 != arg0)
8784                && (indirect_base1
8785                    ? base1 != TREE_OPERAND (arg1, 0) : base1 != arg1)
8786                && ((offset0 == offset1)
8787                    || (offset0 && offset1
8788                        && operand_equal_p (offset0, offset1, 0))))
8789         {
8790           if (indirect_base0)
8791             base0 = build_fold_addr_expr_loc (loc, base0);
8792           if (indirect_base1)
8793             base1 = build_fold_addr_expr_loc (loc, base1);
8794           return fold_build2_loc (loc, code, type, base0, base1);
8795         }
8796     }
8797
8798   /* Transform comparisons of the form X +- C1 CMP Y +- C2 to
8799      X CMP Y +- C2 +- C1 for signed X, Y.  This is valid if
8800      the resulting offset is smaller in absolute value than the
8801      original one.  */
8802   if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg0))
8803       && (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
8804       && (TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
8805           && !TREE_OVERFLOW (TREE_OPERAND (arg0, 1)))
8806       && (TREE_CODE (arg1) == PLUS_EXPR || TREE_CODE (arg1) == MINUS_EXPR)
8807       && (TREE_CODE (TREE_OPERAND (arg1, 1)) == INTEGER_CST
8808           && !TREE_OVERFLOW (TREE_OPERAND (arg1, 1))))
8809     {
8810       tree const1 = TREE_OPERAND (arg0, 1);
8811       tree const2 = TREE_OPERAND (arg1, 1);
8812       tree variable1 = TREE_OPERAND (arg0, 0);
8813       tree variable2 = TREE_OPERAND (arg1, 0);
8814       tree cst;
8815       const char * const warnmsg = G_("assuming signed overflow does not "
8816                                       "occur when combining constants around "
8817                                       "a comparison");
8818
8819       /* Put the constant on the side where it doesn't overflow and is
8820          of lower absolute value than before.  */
8821       cst = int_const_binop (TREE_CODE (arg0) == TREE_CODE (arg1)
8822                              ? MINUS_EXPR : PLUS_EXPR,
8823                              const2, const1, 0);
8824       if (!TREE_OVERFLOW (cst)
8825           && tree_int_cst_compare (const2, cst) == tree_int_cst_sgn (const2))
8826         {
8827           fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_COMPARISON);
8828           return fold_build2_loc (loc, code, type,
8829                               variable1,
8830                               fold_build2_loc (loc,
8831                                            TREE_CODE (arg1), TREE_TYPE (arg1),
8832                                            variable2, cst));
8833         }
8834
8835       cst = int_const_binop (TREE_CODE (arg0) == TREE_CODE (arg1)
8836                              ? MINUS_EXPR : PLUS_EXPR,
8837                              const1, const2, 0);
8838       if (!TREE_OVERFLOW (cst)
8839           && tree_int_cst_compare (const1, cst) == tree_int_cst_sgn (const1))
8840         {
8841           fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_COMPARISON);
8842           return fold_build2_loc (loc, code, type,
8843                               fold_build2_loc (loc, TREE_CODE (arg0), TREE_TYPE (arg0),
8844                                            variable1, cst),
8845                               variable2);
8846         }
8847     }
8848
8849   /* Transform comparisons of the form X * C1 CMP 0 to X CMP 0 in the
8850      signed arithmetic case.  That form is created by the compiler
8851      often enough for folding it to be of value.  One example is in
8852      computing loop trip counts after Operator Strength Reduction.  */
8853   if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg0))
8854       && TREE_CODE (arg0) == MULT_EXPR
8855       && (TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
8856           && !TREE_OVERFLOW (TREE_OPERAND (arg0, 1)))
8857       && integer_zerop (arg1))
8858     {
8859       tree const1 = TREE_OPERAND (arg0, 1);
8860       tree const2 = arg1;                       /* zero */
8861       tree variable1 = TREE_OPERAND (arg0, 0);
8862       enum tree_code cmp_code = code;
8863
8864       /* Handle unfolded multiplication by zero.  */
8865       if (integer_zerop (const1))
8866         return fold_build2_loc (loc, cmp_code, type, const1, const2);
8867
8868       fold_overflow_warning (("assuming signed overflow does not occur when "
8869                               "eliminating multiplication in comparison "
8870                               "with zero"),
8871                              WARN_STRICT_OVERFLOW_COMPARISON);
8872
8873       /* If const1 is negative we swap the sense of the comparison.  */
8874       if (tree_int_cst_sgn (const1) < 0)
8875         cmp_code = swap_tree_comparison (cmp_code);
8876
8877       return fold_build2_loc (loc, cmp_code, type, variable1, const2);
8878     }
8879
8880   tem = maybe_canonicalize_comparison (loc, code, type, op0, op1);
8881   if (tem)
8882     return tem;
8883
8884   if (FLOAT_TYPE_P (TREE_TYPE (arg0)))
8885     {
8886       tree targ0 = strip_float_extensions (arg0);
8887       tree targ1 = strip_float_extensions (arg1);
8888       tree newtype = TREE_TYPE (targ0);
8889
8890       if (TYPE_PRECISION (TREE_TYPE (targ1)) > TYPE_PRECISION (newtype))
8891         newtype = TREE_TYPE (targ1);
8892
8893       /* Fold (double)float1 CMP (double)float2 into float1 CMP float2.  */
8894       if (TYPE_PRECISION (newtype) < TYPE_PRECISION (TREE_TYPE (arg0)))
8895         return fold_build2_loc (loc, code, type,
8896                             fold_convert_loc (loc, newtype, targ0),
8897                             fold_convert_loc (loc, newtype, targ1));
8898
8899       /* (-a) CMP (-b) -> b CMP a  */
8900       if (TREE_CODE (arg0) == NEGATE_EXPR
8901           && TREE_CODE (arg1) == NEGATE_EXPR)
8902         return fold_build2_loc (loc, code, type, TREE_OPERAND (arg1, 0),
8903                             TREE_OPERAND (arg0, 0));
8904
8905       if (TREE_CODE (arg1) == REAL_CST)
8906         {
8907           REAL_VALUE_TYPE cst;
8908           cst = TREE_REAL_CST (arg1);
8909
8910           /* (-a) CMP CST -> a swap(CMP) (-CST)  */
8911           if (TREE_CODE (arg0) == NEGATE_EXPR)
8912             return fold_build2_loc (loc, swap_tree_comparison (code), type,
8913                                 TREE_OPERAND (arg0, 0),
8914                                 build_real (TREE_TYPE (arg1),
8915                                             real_value_negate (&cst)));
8916
8917           /* IEEE doesn't distinguish +0 and -0 in comparisons.  */
8918           /* a CMP (-0) -> a CMP 0  */
8919           if (REAL_VALUE_MINUS_ZERO (cst))
8920             return fold_build2_loc (loc, code, type, arg0,
8921                                 build_real (TREE_TYPE (arg1), dconst0));
8922
8923           /* x != NaN is always true, other ops are always false.  */
8924           if (REAL_VALUE_ISNAN (cst)
8925               && ! HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg1))))
8926             {
8927               tem = (code == NE_EXPR) ? integer_one_node : integer_zero_node;
8928               return omit_one_operand_loc (loc, type, tem, arg0);
8929             }
8930
8931           /* Fold comparisons against infinity.  */
8932           if (REAL_VALUE_ISINF (cst)
8933               && MODE_HAS_INFINITIES (TYPE_MODE (TREE_TYPE (arg1))))
8934             {
8935               tem = fold_inf_compare (loc, code, type, arg0, arg1);
8936               if (tem != NULL_TREE)
8937                 return tem;
8938             }
8939         }
8940
8941       /* If this is a comparison of a real constant with a PLUS_EXPR
8942          or a MINUS_EXPR of a real constant, we can convert it into a
8943          comparison with a revised real constant as long as no overflow
8944          occurs when unsafe_math_optimizations are enabled.  */
8945       if (flag_unsafe_math_optimizations
8946           && TREE_CODE (arg1) == REAL_CST
8947           && (TREE_CODE (arg0) == PLUS_EXPR
8948               || TREE_CODE (arg0) == MINUS_EXPR)
8949           && TREE_CODE (TREE_OPERAND (arg0, 1)) == REAL_CST
8950           && 0 != (tem = const_binop (TREE_CODE (arg0) == PLUS_EXPR
8951                                       ? MINUS_EXPR : PLUS_EXPR,
8952                                       arg1, TREE_OPERAND (arg0, 1)))
8953           && !TREE_OVERFLOW (tem))
8954         return fold_build2_loc (loc, code, type, TREE_OPERAND (arg0, 0), tem);
8955
8956       /* Likewise, we can simplify a comparison of a real constant with
8957          a MINUS_EXPR whose first operand is also a real constant, i.e.
8958          (c1 - x) < c2 becomes x > c1-c2.  Reordering is allowed on
8959          floating-point types only if -fassociative-math is set.  */
8960       if (flag_associative_math
8961           && TREE_CODE (arg1) == REAL_CST
8962           && TREE_CODE (arg0) == MINUS_EXPR
8963           && TREE_CODE (TREE_OPERAND (arg0, 0)) == REAL_CST
8964           && 0 != (tem = const_binop (MINUS_EXPR, TREE_OPERAND (arg0, 0),
8965                                       arg1))
8966           && !TREE_OVERFLOW (tem))
8967         return fold_build2_loc (loc, swap_tree_comparison (code), type,
8968                             TREE_OPERAND (arg0, 1), tem);
8969
8970       /* Fold comparisons against built-in math functions.  */
8971       if (TREE_CODE (arg1) == REAL_CST
8972           && flag_unsafe_math_optimizations
8973           && ! flag_errno_math)
8974         {
8975           enum built_in_function fcode = builtin_mathfn_code (arg0);
8976
8977           if (fcode != END_BUILTINS)
8978             {
8979               tem = fold_mathfn_compare (loc, fcode, code, type, arg0, arg1);
8980               if (tem != NULL_TREE)
8981                 return tem;
8982             }
8983         }
8984     }
8985
8986   if (TREE_CODE (TREE_TYPE (arg0)) == INTEGER_TYPE
8987       && CONVERT_EXPR_P (arg0))
8988     {
8989       /* If we are widening one operand of an integer comparison,
8990          see if the other operand is similarly being widened.  Perhaps we
8991          can do the comparison in the narrower type.  */
8992       tem = fold_widened_comparison (loc, code, type, arg0, arg1);
8993       if (tem)
8994         return tem;
8995
8996       /* Or if we are changing signedness.  */
8997       tem = fold_sign_changed_comparison (loc, code, type, arg0, arg1);
8998       if (tem)
8999         return tem;
9000     }
9001
9002   /* If this is comparing a constant with a MIN_EXPR or a MAX_EXPR of a
9003      constant, we can simplify it.  */
9004   if (TREE_CODE (arg1) == INTEGER_CST
9005       && (TREE_CODE (arg0) == MIN_EXPR
9006           || TREE_CODE (arg0) == MAX_EXPR)
9007       && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
9008     {
9009       tem = optimize_minmax_comparison (loc, code, type, op0, op1);
9010       if (tem)
9011         return tem;
9012     }
9013
9014   /* Simplify comparison of something with itself.  (For IEEE
9015      floating-point, we can only do some of these simplifications.)  */
9016   if (operand_equal_p (arg0, arg1, 0))
9017     {
9018       switch (code)
9019         {
9020         case EQ_EXPR:
9021           if (! FLOAT_TYPE_P (TREE_TYPE (arg0))
9022               || ! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))))
9023             return constant_boolean_node (1, type);
9024           break;
9025
9026         case GE_EXPR:
9027         case LE_EXPR:
9028           if (! FLOAT_TYPE_P (TREE_TYPE (arg0))
9029               || ! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))))
9030             return constant_boolean_node (1, type);
9031           return fold_build2_loc (loc, EQ_EXPR, type, arg0, arg1);
9032
9033         case NE_EXPR:
9034           /* For NE, we can only do this simplification if integer
9035              or we don't honor IEEE floating point NaNs.  */
9036           if (FLOAT_TYPE_P (TREE_TYPE (arg0))
9037               && HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))))
9038             break;
9039           /* ... fall through ...  */
9040         case GT_EXPR:
9041         case LT_EXPR:
9042           return constant_boolean_node (0, type);
9043         default:
9044           gcc_unreachable ();
9045         }
9046     }
9047
9048   /* If we are comparing an expression that just has comparisons
9049      of two integer values, arithmetic expressions of those comparisons,
9050      and constants, we can simplify it.  There are only three cases
9051      to check: the two values can either be equal, the first can be
9052      greater, or the second can be greater.  Fold the expression for
9053      those three values.  Since each value must be 0 or 1, we have
9054      eight possibilities, each of which corresponds to the constant 0
9055      or 1 or one of the six possible comparisons.
9056
9057      This handles common cases like (a > b) == 0 but also handles
9058      expressions like  ((x > y) - (y > x)) > 0, which supposedly
9059      occur in macroized code.  */
9060
9061   if (TREE_CODE (arg1) == INTEGER_CST && TREE_CODE (arg0) != INTEGER_CST)
9062     {
9063       tree cval1 = 0, cval2 = 0;
9064       int save_p = 0;
9065
9066       if (twoval_comparison_p (arg0, &cval1, &cval2, &save_p)
9067           /* Don't handle degenerate cases here; they should already
9068              have been handled anyway.  */
9069           && cval1 != 0 && cval2 != 0
9070           && ! (TREE_CONSTANT (cval1) && TREE_CONSTANT (cval2))
9071           && TREE_TYPE (cval1) == TREE_TYPE (cval2)
9072           && INTEGRAL_TYPE_P (TREE_TYPE (cval1))
9073           && TYPE_MAX_VALUE (TREE_TYPE (cval1))
9074           && TYPE_MAX_VALUE (TREE_TYPE (cval2))
9075           && ! operand_equal_p (TYPE_MIN_VALUE (TREE_TYPE (cval1)),
9076                                 TYPE_MAX_VALUE (TREE_TYPE (cval2)), 0))
9077         {
9078           tree maxval = TYPE_MAX_VALUE (TREE_TYPE (cval1));
9079           tree minval = TYPE_MIN_VALUE (TREE_TYPE (cval1));
9080
9081           /* We can't just pass T to eval_subst in case cval1 or cval2
9082              was the same as ARG1.  */
9083
9084           tree high_result
9085                 = fold_build2_loc (loc, code, type,
9086                                eval_subst (loc, arg0, cval1, maxval,
9087                                            cval2, minval),
9088                                arg1);
9089           tree equal_result
9090                 = fold_build2_loc (loc, code, type,
9091                                eval_subst (loc, arg0, cval1, maxval,
9092                                            cval2, maxval),
9093                                arg1);
9094           tree low_result
9095                 = fold_build2_loc (loc, code, type,
9096                                eval_subst (loc, arg0, cval1, minval,
9097                                            cval2, maxval),
9098                                arg1);
9099
9100           /* All three of these results should be 0 or 1.  Confirm they are.
9101              Then use those values to select the proper code to use.  */
9102
9103           if (TREE_CODE (high_result) == INTEGER_CST
9104               && TREE_CODE (equal_result) == INTEGER_CST
9105               && TREE_CODE (low_result) == INTEGER_CST)
9106             {
9107               /* Make a 3-bit mask with the high-order bit being the
9108                  value for `>', the next for '=', and the low for '<'.  */
9109               switch ((integer_onep (high_result) * 4)
9110                       + (integer_onep (equal_result) * 2)
9111                       + integer_onep (low_result))
9112                 {
9113                 case 0:
9114                   /* Always false.  */
9115                   return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
9116                 case 1:
9117                   code = LT_EXPR;
9118                   break;
9119                 case 2:
9120                   code = EQ_EXPR;
9121                   break;
9122                 case 3:
9123                   code = LE_EXPR;
9124                   break;
9125                 case 4:
9126                   code = GT_EXPR;
9127                   break;
9128                 case 5:
9129                   code = NE_EXPR;
9130                   break;
9131                 case 6:
9132                   code = GE_EXPR;
9133                   break;
9134                 case 7:
9135                   /* Always true.  */
9136                   return omit_one_operand_loc (loc, type, integer_one_node, arg0);
9137                 }
9138
9139               if (save_p)
9140                 {
9141                   tem = save_expr (build2 (code, type, cval1, cval2));
9142                   SET_EXPR_LOCATION (tem, loc);
9143                   return tem;
9144                 }
9145               return fold_build2_loc (loc, code, type, cval1, cval2);
9146             }
9147         }
9148     }
9149
9150   /* We can fold X/C1 op C2 where C1 and C2 are integer constants
9151      into a single range test.  */
9152   if ((TREE_CODE (arg0) == TRUNC_DIV_EXPR
9153        || TREE_CODE (arg0) == EXACT_DIV_EXPR)
9154       && TREE_CODE (arg1) == INTEGER_CST
9155       && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
9156       && !integer_zerop (TREE_OPERAND (arg0, 1))
9157       && !TREE_OVERFLOW (TREE_OPERAND (arg0, 1))
9158       && !TREE_OVERFLOW (arg1))
9159     {
9160       tem = fold_div_compare (loc, code, type, arg0, arg1);
9161       if (tem != NULL_TREE)
9162         return tem;
9163     }
9164
9165   /* Fold ~X op ~Y as Y op X.  */
9166   if (TREE_CODE (arg0) == BIT_NOT_EXPR
9167       && TREE_CODE (arg1) == BIT_NOT_EXPR)
9168     {
9169       tree cmp_type = TREE_TYPE (TREE_OPERAND (arg0, 0));
9170       return fold_build2_loc (loc, code, type,
9171                           fold_convert_loc (loc, cmp_type,
9172                                             TREE_OPERAND (arg1, 0)),
9173                           TREE_OPERAND (arg0, 0));
9174     }
9175
9176   /* Fold ~X op C as X op' ~C, where op' is the swapped comparison.  */
9177   if (TREE_CODE (arg0) == BIT_NOT_EXPR
9178       && TREE_CODE (arg1) == INTEGER_CST)
9179     {
9180       tree cmp_type = TREE_TYPE (TREE_OPERAND (arg0, 0));
9181       return fold_build2_loc (loc, swap_tree_comparison (code), type,
9182                           TREE_OPERAND (arg0, 0),
9183                           fold_build1_loc (loc, BIT_NOT_EXPR, cmp_type,
9184                                        fold_convert_loc (loc, cmp_type, arg1)));
9185     }
9186
9187   return NULL_TREE;
9188 }
9189
9190
9191 /* Subroutine of fold_binary.  Optimize complex multiplications of the
9192    form z * conj(z), as pow(realpart(z),2) + pow(imagpart(z),2).  The
9193    argument EXPR represents the expression "z" of type TYPE.  */
9194
9195 static tree
9196 fold_mult_zconjz (location_t loc, tree type, tree expr)
9197 {
9198   tree itype = TREE_TYPE (type);
9199   tree rpart, ipart, tem;
9200
9201   if (TREE_CODE (expr) == COMPLEX_EXPR)
9202     {
9203       rpart = TREE_OPERAND (expr, 0);
9204       ipart = TREE_OPERAND (expr, 1);
9205     }
9206   else if (TREE_CODE (expr) == COMPLEX_CST)
9207     {
9208       rpart = TREE_REALPART (expr);
9209       ipart = TREE_IMAGPART (expr);
9210     }
9211   else
9212     {
9213       expr = save_expr (expr);
9214       rpart = fold_build1_loc (loc, REALPART_EXPR, itype, expr);
9215       ipart = fold_build1_loc (loc, IMAGPART_EXPR, itype, expr);
9216     }
9217
9218   rpart = save_expr (rpart);
9219   ipart = save_expr (ipart);
9220   tem = fold_build2_loc (loc, PLUS_EXPR, itype,
9221                      fold_build2_loc (loc, MULT_EXPR, itype, rpart, rpart),
9222                      fold_build2_loc (loc, MULT_EXPR, itype, ipart, ipart));
9223   return fold_build2_loc (loc, COMPLEX_EXPR, type, tem,
9224                           build_zero_cst (itype));
9225 }
9226
9227
9228 /* Subroutine of fold_binary.  If P is the value of EXPR, computes
9229    power-of-two M and (arbitrary) N such that M divides (P-N).  This condition
9230    guarantees that P and N have the same least significant log2(M) bits.
9231    N is not otherwise constrained.  In particular, N is not normalized to
9232    0 <= N < M as is common.  In general, the precise value of P is unknown.
9233    M is chosen as large as possible such that constant N can be determined.
9234
9235    Returns M and sets *RESIDUE to N.
9236
9237    If ALLOW_FUNC_ALIGN is true, do take functions' DECL_ALIGN_UNIT into
9238    account.  This is not always possible due to PR 35705.
9239  */
9240
9241 static unsigned HOST_WIDE_INT
9242 get_pointer_modulus_and_residue (tree expr, unsigned HOST_WIDE_INT *residue,
9243                                  bool allow_func_align)
9244 {
9245   enum tree_code code;
9246
9247   *residue = 0;
9248
9249   code = TREE_CODE (expr);
9250   if (code == ADDR_EXPR)
9251     {
9252       expr = TREE_OPERAND (expr, 0);
9253       if (handled_component_p (expr))
9254         {
9255           HOST_WIDE_INT bitsize, bitpos;
9256           tree offset;
9257           enum machine_mode mode;
9258           int unsignedp, volatilep;
9259
9260           expr = get_inner_reference (expr, &bitsize, &bitpos, &offset,
9261                                       &mode, &unsignedp, &volatilep, false);
9262           *residue = bitpos / BITS_PER_UNIT;
9263           if (offset)
9264             {
9265               if (TREE_CODE (offset) == INTEGER_CST)
9266                 *residue += TREE_INT_CST_LOW (offset);
9267               else
9268                 /* We don't handle more complicated offset expressions.  */
9269                 return 1;
9270             }
9271         }
9272
9273       if (DECL_P (expr)
9274           && (allow_func_align || TREE_CODE (expr) != FUNCTION_DECL))
9275         return DECL_ALIGN_UNIT (expr);
9276     }
9277   else if (code == POINTER_PLUS_EXPR)
9278     {
9279       tree op0, op1;
9280       unsigned HOST_WIDE_INT modulus;
9281       enum tree_code inner_code;
9282
9283       op0 = TREE_OPERAND (expr, 0);
9284       STRIP_NOPS (op0);
9285       modulus = get_pointer_modulus_and_residue (op0, residue,
9286                                                  allow_func_align);
9287
9288       op1 = TREE_OPERAND (expr, 1);
9289       STRIP_NOPS (op1);
9290       inner_code = TREE_CODE (op1);
9291       if (inner_code == INTEGER_CST)
9292         {
9293           *residue += TREE_INT_CST_LOW (op1);
9294           return modulus;
9295         }
9296       else if (inner_code == MULT_EXPR)
9297         {
9298           op1 = TREE_OPERAND (op1, 1);
9299           if (TREE_CODE (op1) == INTEGER_CST)
9300             {
9301               unsigned HOST_WIDE_INT align;
9302
9303               /* Compute the greatest power-of-2 divisor of op1.  */
9304               align = TREE_INT_CST_LOW (op1);
9305               align &= -align;
9306
9307               /* If align is non-zero and less than *modulus, replace
9308                  *modulus with align., If align is 0, then either op1 is 0
9309                  or the greatest power-of-2 divisor of op1 doesn't fit in an
9310                  unsigned HOST_WIDE_INT.  In either case, no additional
9311                  constraint is imposed.  */
9312               if (align)
9313                 modulus = MIN (modulus, align);
9314
9315               return modulus;
9316             }
9317         }
9318     }
9319
9320     /* If we get here, we were unable to determine anything useful about the
9321        expression.  */
9322     return 1;
9323 }
9324
9325
9326 /* Fold a binary expression of code CODE and type TYPE with operands
9327    OP0 and OP1.  LOC is the location of the resulting expression.
9328    Return the folded expression if folding is successful.  Otherwise,
9329    return NULL_TREE.  */
9330
9331 tree
9332 fold_binary_loc (location_t loc,
9333              enum tree_code code, tree type, tree op0, tree op1)
9334 {
9335   enum tree_code_class kind = TREE_CODE_CLASS (code);
9336   tree arg0, arg1, tem;
9337   tree t1 = NULL_TREE;
9338   bool strict_overflow_p;
9339
9340   gcc_assert (IS_EXPR_CODE_CLASS (kind)
9341               && TREE_CODE_LENGTH (code) == 2
9342               && op0 != NULL_TREE
9343               && op1 != NULL_TREE);
9344
9345   arg0 = op0;
9346   arg1 = op1;
9347
9348   /* Strip any conversions that don't change the mode.  This is
9349      safe for every expression, except for a comparison expression
9350      because its signedness is derived from its operands.  So, in
9351      the latter case, only strip conversions that don't change the
9352      signedness.  MIN_EXPR/MAX_EXPR also need signedness of arguments
9353      preserved.
9354
9355      Note that this is done as an internal manipulation within the
9356      constant folder, in order to find the simplest representation
9357      of the arguments so that their form can be studied.  In any
9358      cases, the appropriate type conversions should be put back in
9359      the tree that will get out of the constant folder.  */
9360
9361   if (kind == tcc_comparison || code == MIN_EXPR || code == MAX_EXPR)
9362     {
9363       STRIP_SIGN_NOPS (arg0);
9364       STRIP_SIGN_NOPS (arg1);
9365     }
9366   else
9367     {
9368       STRIP_NOPS (arg0);
9369       STRIP_NOPS (arg1);
9370     }
9371
9372   /* Note that TREE_CONSTANT isn't enough: static var addresses are
9373      constant but we can't do arithmetic on them.  */
9374   if ((TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
9375       || (TREE_CODE (arg0) == REAL_CST && TREE_CODE (arg1) == REAL_CST)
9376       || (TREE_CODE (arg0) == FIXED_CST && TREE_CODE (arg1) == FIXED_CST)
9377       || (TREE_CODE (arg0) == FIXED_CST && TREE_CODE (arg1) == INTEGER_CST)
9378       || (TREE_CODE (arg0) == COMPLEX_CST && TREE_CODE (arg1) == COMPLEX_CST)
9379       || (TREE_CODE (arg0) == VECTOR_CST && TREE_CODE (arg1) == VECTOR_CST))
9380     {
9381       if (kind == tcc_binary)
9382         {
9383           /* Make sure type and arg0 have the same saturating flag.  */
9384           gcc_assert (TYPE_SATURATING (type)
9385                       == TYPE_SATURATING (TREE_TYPE (arg0)));
9386           tem = const_binop (code, arg0, arg1);
9387         }
9388       else if (kind == tcc_comparison)
9389         tem = fold_relational_const (code, type, arg0, arg1);
9390       else
9391         tem = NULL_TREE;
9392
9393       if (tem != NULL_TREE)
9394         {
9395           if (TREE_TYPE (tem) != type)
9396             tem = fold_convert_loc (loc, type, tem);
9397           return tem;
9398         }
9399     }
9400
9401   /* If this is a commutative operation, and ARG0 is a constant, move it
9402      to ARG1 to reduce the number of tests below.  */
9403   if (commutative_tree_code (code)
9404       && tree_swap_operands_p (arg0, arg1, true))
9405     return fold_build2_loc (loc, code, type, op1, op0);
9406
9407   /* ARG0 is the first operand of EXPR, and ARG1 is the second operand.
9408
9409      First check for cases where an arithmetic operation is applied to a
9410      compound, conditional, or comparison operation.  Push the arithmetic
9411      operation inside the compound or conditional to see if any folding
9412      can then be done.  Convert comparison to conditional for this purpose.
9413      The also optimizes non-constant cases that used to be done in
9414      expand_expr.
9415
9416      Before we do that, see if this is a BIT_AND_EXPR or a BIT_IOR_EXPR,
9417      one of the operands is a comparison and the other is a comparison, a
9418      BIT_AND_EXPR with the constant 1, or a truth value.  In that case, the
9419      code below would make the expression more complex.  Change it to a
9420      TRUTH_{AND,OR}_EXPR.  Likewise, convert a similar NE_EXPR to
9421      TRUTH_XOR_EXPR and an EQ_EXPR to the inversion of a TRUTH_XOR_EXPR.  */
9422
9423   if ((code == BIT_AND_EXPR || code == BIT_IOR_EXPR
9424        || code == EQ_EXPR || code == NE_EXPR)
9425       && ((truth_value_p (TREE_CODE (arg0))
9426            && (truth_value_p (TREE_CODE (arg1))
9427                || (TREE_CODE (arg1) == BIT_AND_EXPR
9428                    && integer_onep (TREE_OPERAND (arg1, 1)))))
9429           || (truth_value_p (TREE_CODE (arg1))
9430               && (truth_value_p (TREE_CODE (arg0))
9431                   || (TREE_CODE (arg0) == BIT_AND_EXPR
9432                       && integer_onep (TREE_OPERAND (arg0, 1)))))))
9433     {
9434       tem = fold_build2_loc (loc, code == BIT_AND_EXPR ? TRUTH_AND_EXPR
9435                          : code == BIT_IOR_EXPR ? TRUTH_OR_EXPR
9436                          : TRUTH_XOR_EXPR,
9437                          boolean_type_node,
9438                          fold_convert_loc (loc, boolean_type_node, arg0),
9439                          fold_convert_loc (loc, boolean_type_node, arg1));
9440
9441       if (code == EQ_EXPR)
9442         tem = invert_truthvalue_loc (loc, tem);
9443
9444       return fold_convert_loc (loc, type, tem);
9445     }
9446
9447   if (TREE_CODE_CLASS (code) == tcc_binary
9448       || TREE_CODE_CLASS (code) == tcc_comparison)
9449     {
9450       if (TREE_CODE (arg0) == COMPOUND_EXPR)
9451         {
9452           tem = fold_build2_loc (loc, code, type,
9453                              fold_convert_loc (loc, TREE_TYPE (op0),
9454                                                TREE_OPERAND (arg0, 1)), op1);
9455           return build2_loc (loc, COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
9456                              tem);
9457         }
9458       if (TREE_CODE (arg1) == COMPOUND_EXPR
9459           && reorder_operands_p (arg0, TREE_OPERAND (arg1, 0)))
9460         {
9461           tem = fold_build2_loc (loc, code, type, op0,
9462                              fold_convert_loc (loc, TREE_TYPE (op1),
9463                                                TREE_OPERAND (arg1, 1)));
9464           return build2_loc (loc, COMPOUND_EXPR, type, TREE_OPERAND (arg1, 0),
9465                              tem);
9466         }
9467
9468       if (TREE_CODE (arg0) == COND_EXPR || COMPARISON_CLASS_P (arg0))
9469         {
9470           tem = fold_binary_op_with_conditional_arg (loc, code, type, op0, op1,
9471                                                      arg0, arg1,
9472                                                      /*cond_first_p=*/1);
9473           if (tem != NULL_TREE)
9474             return tem;
9475         }
9476
9477       if (TREE_CODE (arg1) == COND_EXPR || COMPARISON_CLASS_P (arg1))
9478         {
9479           tem = fold_binary_op_with_conditional_arg (loc, code, type, op0, op1,
9480                                                      arg1, arg0,
9481                                                      /*cond_first_p=*/0);
9482           if (tem != NULL_TREE)
9483             return tem;
9484         }
9485     }
9486
9487   switch (code)
9488     {
9489     case MEM_REF:
9490       /* MEM[&MEM[p, CST1], CST2] -> MEM[p, CST1 + CST2].  */
9491       if (TREE_CODE (arg0) == ADDR_EXPR
9492           && TREE_CODE (TREE_OPERAND (arg0, 0)) == MEM_REF)
9493         {
9494           tree iref = TREE_OPERAND (arg0, 0);
9495           return fold_build2 (MEM_REF, type,
9496                               TREE_OPERAND (iref, 0),
9497                               int_const_binop (PLUS_EXPR, arg1,
9498                                                TREE_OPERAND (iref, 1), 0));
9499         }
9500
9501       /* MEM[&a.b, CST2] -> MEM[&a, offsetof (a, b) + CST2].  */
9502       if (TREE_CODE (arg0) == ADDR_EXPR
9503           && handled_component_p (TREE_OPERAND (arg0, 0)))
9504         {
9505           tree base;
9506           HOST_WIDE_INT coffset;
9507           base = get_addr_base_and_unit_offset (TREE_OPERAND (arg0, 0),
9508                                                 &coffset);
9509           if (!base)
9510             return NULL_TREE;
9511           return fold_build2 (MEM_REF, type,
9512                               build_fold_addr_expr (base),
9513                               int_const_binop (PLUS_EXPR, arg1,
9514                                                size_int (coffset), 0));
9515         }
9516
9517       return NULL_TREE;
9518
9519     case POINTER_PLUS_EXPR:
9520       /* 0 +p index -> (type)index */
9521       if (integer_zerop (arg0))
9522         return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg1));
9523
9524       /* PTR +p 0 -> PTR */
9525       if (integer_zerop (arg1))
9526         return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
9527
9528       /* INT +p INT -> (PTR)(INT + INT).  Stripping types allows for this. */
9529       if (INTEGRAL_TYPE_P (TREE_TYPE (arg1))
9530            && INTEGRAL_TYPE_P (TREE_TYPE (arg0)))
9531         return fold_convert_loc (loc, type,
9532                                  fold_build2_loc (loc, PLUS_EXPR, sizetype,
9533                                               fold_convert_loc (loc, sizetype,
9534                                                                 arg1),
9535                                               fold_convert_loc (loc, sizetype,
9536                                                                 arg0)));
9537
9538       /* index +p PTR -> PTR +p index */
9539       if (POINTER_TYPE_P (TREE_TYPE (arg1))
9540           && INTEGRAL_TYPE_P (TREE_TYPE (arg0)))
9541         return fold_build2_loc (loc, POINTER_PLUS_EXPR, type,
9542                             fold_convert_loc (loc, type, arg1),
9543                             fold_convert_loc (loc, sizetype, arg0));
9544
9545       /* (PTR +p B) +p A -> PTR +p (B + A) */
9546       if (TREE_CODE (arg0) == POINTER_PLUS_EXPR)
9547         {
9548           tree inner;
9549           tree arg01 = fold_convert_loc (loc, sizetype, TREE_OPERAND (arg0, 1));
9550           tree arg00 = TREE_OPERAND (arg0, 0);
9551           inner = fold_build2_loc (loc, PLUS_EXPR, sizetype,
9552                                arg01, fold_convert_loc (loc, sizetype, arg1));
9553           return fold_convert_loc (loc, type,
9554                                    fold_build2_loc (loc, POINTER_PLUS_EXPR,
9555                                                 TREE_TYPE (arg00),
9556                                                 arg00, inner));
9557         }
9558
9559       /* PTR_CST +p CST -> CST1 */
9560       if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
9561         return fold_build2_loc (loc, PLUS_EXPR, type, arg0,
9562                             fold_convert_loc (loc, type, arg1));
9563
9564      /* Try replacing &a[i1] +p c * i2 with &a[i1 + i2], if c is step
9565         of the array.  Loop optimizer sometimes produce this type of
9566         expressions.  */
9567       if (TREE_CODE (arg0) == ADDR_EXPR)
9568         {
9569           tem = try_move_mult_to_index (loc, arg0,
9570                                         fold_convert_loc (loc, sizetype, arg1));
9571           if (tem)
9572             return fold_convert_loc (loc, type, tem);
9573         }
9574
9575       return NULL_TREE;
9576
9577     case PLUS_EXPR:
9578       /* A + (-B) -> A - B */
9579       if (TREE_CODE (arg1) == NEGATE_EXPR)
9580         return fold_build2_loc (loc, MINUS_EXPR, type,
9581                             fold_convert_loc (loc, type, arg0),
9582                             fold_convert_loc (loc, type,
9583                                               TREE_OPERAND (arg1, 0)));
9584       /* (-A) + B -> B - A */
9585       if (TREE_CODE (arg0) == NEGATE_EXPR
9586           && reorder_operands_p (TREE_OPERAND (arg0, 0), arg1))
9587         return fold_build2_loc (loc, MINUS_EXPR, type,
9588                             fold_convert_loc (loc, type, arg1),
9589                             fold_convert_loc (loc, type,
9590                                               TREE_OPERAND (arg0, 0)));
9591
9592       if (INTEGRAL_TYPE_P (type))
9593         {
9594           /* Convert ~A + 1 to -A.  */
9595           if (TREE_CODE (arg0) == BIT_NOT_EXPR
9596               && integer_onep (arg1))
9597             return fold_build1_loc (loc, NEGATE_EXPR, type,
9598                                 fold_convert_loc (loc, type,
9599                                                   TREE_OPERAND (arg0, 0)));
9600
9601           /* ~X + X is -1.  */
9602           if (TREE_CODE (arg0) == BIT_NOT_EXPR
9603               && !TYPE_OVERFLOW_TRAPS (type))
9604             {
9605               tree tem = TREE_OPERAND (arg0, 0);
9606
9607               STRIP_NOPS (tem);
9608               if (operand_equal_p (tem, arg1, 0))
9609                 {
9610                   t1 = build_int_cst_type (type, -1);
9611                   return omit_one_operand_loc (loc, type, t1, arg1);
9612                 }
9613             }
9614
9615           /* X + ~X is -1.  */
9616           if (TREE_CODE (arg1) == BIT_NOT_EXPR
9617               && !TYPE_OVERFLOW_TRAPS (type))
9618             {
9619               tree tem = TREE_OPERAND (arg1, 0);
9620
9621               STRIP_NOPS (tem);
9622               if (operand_equal_p (arg0, tem, 0))
9623                 {
9624                   t1 = build_int_cst_type (type, -1);
9625                   return omit_one_operand_loc (loc, type, t1, arg0);
9626                 }
9627             }
9628
9629           /* X + (X / CST) * -CST is X % CST.  */
9630           if (TREE_CODE (arg1) == MULT_EXPR
9631               && TREE_CODE (TREE_OPERAND (arg1, 0)) == TRUNC_DIV_EXPR
9632               && operand_equal_p (arg0,
9633                                   TREE_OPERAND (TREE_OPERAND (arg1, 0), 0), 0))
9634             {
9635               tree cst0 = TREE_OPERAND (TREE_OPERAND (arg1, 0), 1);
9636               tree cst1 = TREE_OPERAND (arg1, 1);
9637               tree sum = fold_binary_loc (loc, PLUS_EXPR, TREE_TYPE (cst1),
9638                                       cst1, cst0);
9639               if (sum && integer_zerop (sum))
9640                 return fold_convert_loc (loc, type,
9641                                          fold_build2_loc (loc, TRUNC_MOD_EXPR,
9642                                                       TREE_TYPE (arg0), arg0,
9643                                                       cst0));
9644             }
9645         }
9646
9647       /* Handle (A1 * C1) + (A2 * C2) with A1, A2 or C1, C2 being the
9648          same or one.  Make sure type is not saturating.
9649          fold_plusminus_mult_expr will re-associate.  */
9650       if ((TREE_CODE (arg0) == MULT_EXPR
9651            || TREE_CODE (arg1) == MULT_EXPR)
9652           && !TYPE_SATURATING (type)
9653           && (!FLOAT_TYPE_P (type) || flag_associative_math))
9654         {
9655           tree tem = fold_plusminus_mult_expr (loc, code, type, arg0, arg1);
9656           if (tem)
9657             return tem;
9658         }
9659
9660       if (! FLOAT_TYPE_P (type))
9661         {
9662           if (integer_zerop (arg1))
9663             return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
9664
9665           /* If we are adding two BIT_AND_EXPR's, both of which are and'ing
9666              with a constant, and the two constants have no bits in common,
9667              we should treat this as a BIT_IOR_EXPR since this may produce more
9668              simplifications.  */
9669           if (TREE_CODE (arg0) == BIT_AND_EXPR
9670               && TREE_CODE (arg1) == BIT_AND_EXPR
9671               && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
9672               && TREE_CODE (TREE_OPERAND (arg1, 1)) == INTEGER_CST
9673               && integer_zerop (const_binop (BIT_AND_EXPR,
9674                                              TREE_OPERAND (arg0, 1),
9675                                              TREE_OPERAND (arg1, 1))))
9676             {
9677               code = BIT_IOR_EXPR;
9678               goto bit_ior;
9679             }
9680
9681           /* Reassociate (plus (plus (mult) (foo)) (mult)) as
9682              (plus (plus (mult) (mult)) (foo)) so that we can
9683              take advantage of the factoring cases below.  */
9684           if (((TREE_CODE (arg0) == PLUS_EXPR
9685                 || TREE_CODE (arg0) == MINUS_EXPR)
9686                && TREE_CODE (arg1) == MULT_EXPR)
9687               || ((TREE_CODE (arg1) == PLUS_EXPR
9688                    || TREE_CODE (arg1) == MINUS_EXPR)
9689                   && TREE_CODE (arg0) == MULT_EXPR))
9690             {
9691               tree parg0, parg1, parg, marg;
9692               enum tree_code pcode;
9693
9694               if (TREE_CODE (arg1) == MULT_EXPR)
9695                 parg = arg0, marg = arg1;
9696               else
9697                 parg = arg1, marg = arg0;
9698               pcode = TREE_CODE (parg);
9699               parg0 = TREE_OPERAND (parg, 0);
9700               parg1 = TREE_OPERAND (parg, 1);
9701               STRIP_NOPS (parg0);
9702               STRIP_NOPS (parg1);
9703
9704               if (TREE_CODE (parg0) == MULT_EXPR
9705                   && TREE_CODE (parg1) != MULT_EXPR)
9706                 return fold_build2_loc (loc, pcode, type,
9707                                     fold_build2_loc (loc, PLUS_EXPR, type,
9708                                                  fold_convert_loc (loc, type,
9709                                                                    parg0),
9710                                                  fold_convert_loc (loc, type,
9711                                                                    marg)),
9712                                     fold_convert_loc (loc, type, parg1));
9713               if (TREE_CODE (parg0) != MULT_EXPR
9714                   && TREE_CODE (parg1) == MULT_EXPR)
9715                 return
9716                   fold_build2_loc (loc, PLUS_EXPR, type,
9717                                fold_convert_loc (loc, type, parg0),
9718                                fold_build2_loc (loc, pcode, type,
9719                                             fold_convert_loc (loc, type, marg),
9720                                             fold_convert_loc (loc, type,
9721                                                               parg1)));
9722             }
9723         }
9724       else
9725         {
9726           /* See if ARG1 is zero and X + ARG1 reduces to X.  */
9727           if (fold_real_zero_addition_p (TREE_TYPE (arg0), arg1, 0))
9728             return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
9729
9730           /* Likewise if the operands are reversed.  */
9731           if (fold_real_zero_addition_p (TREE_TYPE (arg1), arg0, 0))
9732             return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg1));
9733
9734           /* Convert X + -C into X - C.  */
9735           if (TREE_CODE (arg1) == REAL_CST
9736               && REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg1)))
9737             {
9738               tem = fold_negate_const (arg1, type);
9739               if (!TREE_OVERFLOW (arg1) || !flag_trapping_math)
9740                 return fold_build2_loc (loc, MINUS_EXPR, type,
9741                                     fold_convert_loc (loc, type, arg0),
9742                                     fold_convert_loc (loc, type, tem));
9743             }
9744
9745           /* Fold __complex__ ( x, 0 ) + __complex__ ( 0, y )
9746              to __complex__ ( x, y ).  This is not the same for SNaNs or
9747              if signed zeros are involved.  */
9748           if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
9749               && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0)))
9750               && COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0)))
9751             {
9752               tree rtype = TREE_TYPE (TREE_TYPE (arg0));
9753               tree arg0r = fold_unary_loc (loc, REALPART_EXPR, rtype, arg0);
9754               tree arg0i = fold_unary_loc (loc, IMAGPART_EXPR, rtype, arg0);
9755               bool arg0rz = false, arg0iz = false;
9756               if ((arg0r && (arg0rz = real_zerop (arg0r)))
9757                   || (arg0i && (arg0iz = real_zerop (arg0i))))
9758                 {
9759                   tree arg1r = fold_unary_loc (loc, REALPART_EXPR, rtype, arg1);
9760                   tree arg1i = fold_unary_loc (loc, IMAGPART_EXPR, rtype, arg1);
9761                   if (arg0rz && arg1i && real_zerop (arg1i))
9762                     {
9763                       tree rp = arg1r ? arg1r
9764                                   : build1 (REALPART_EXPR, rtype, arg1);
9765                       tree ip = arg0i ? arg0i
9766                                   : build1 (IMAGPART_EXPR, rtype, arg0);
9767                       return fold_build2_loc (loc, COMPLEX_EXPR, type, rp, ip);
9768                     }
9769                   else if (arg0iz && arg1r && real_zerop (arg1r))
9770                     {
9771                       tree rp = arg0r ? arg0r
9772                                   : build1 (REALPART_EXPR, rtype, arg0);
9773                       tree ip = arg1i ? arg1i
9774                                   : build1 (IMAGPART_EXPR, rtype, arg1);
9775                       return fold_build2_loc (loc, COMPLEX_EXPR, type, rp, ip);
9776                     }
9777                 }
9778             }
9779
9780           if (flag_unsafe_math_optimizations
9781               && (TREE_CODE (arg0) == RDIV_EXPR || TREE_CODE (arg0) == MULT_EXPR)
9782               && (TREE_CODE (arg1) == RDIV_EXPR || TREE_CODE (arg1) == MULT_EXPR)
9783               && (tem = distribute_real_division (loc, code, type, arg0, arg1)))
9784             return tem;
9785
9786           /* Convert x+x into x*2.0.  */
9787           if (operand_equal_p (arg0, arg1, 0)
9788               && SCALAR_FLOAT_TYPE_P (type))
9789             return fold_build2_loc (loc, MULT_EXPR, type, arg0,
9790                                 build_real (type, dconst2));
9791
9792           /* Convert a + (b*c + d*e) into (a + b*c) + d*e.
9793              We associate floats only if the user has specified
9794              -fassociative-math.  */
9795           if (flag_associative_math
9796               && TREE_CODE (arg1) == PLUS_EXPR
9797               && TREE_CODE (arg0) != MULT_EXPR)
9798             {
9799               tree tree10 = TREE_OPERAND (arg1, 0);
9800               tree tree11 = TREE_OPERAND (arg1, 1);
9801               if (TREE_CODE (tree11) == MULT_EXPR
9802                   && TREE_CODE (tree10) == MULT_EXPR)
9803                 {
9804                   tree tree0;
9805                   tree0 = fold_build2_loc (loc, PLUS_EXPR, type, arg0, tree10);
9806                   return fold_build2_loc (loc, PLUS_EXPR, type, tree0, tree11);
9807                 }
9808             }
9809           /* Convert (b*c + d*e) + a into b*c + (d*e +a).
9810              We associate floats only if the user has specified
9811              -fassociative-math.  */
9812           if (flag_associative_math
9813               && TREE_CODE (arg0) == PLUS_EXPR
9814               && TREE_CODE (arg1) != MULT_EXPR)
9815             {
9816               tree tree00 = TREE_OPERAND (arg0, 0);
9817               tree tree01 = TREE_OPERAND (arg0, 1);
9818               if (TREE_CODE (tree01) == MULT_EXPR
9819                   && TREE_CODE (tree00) == MULT_EXPR)
9820                 {
9821                   tree tree0;
9822                   tree0 = fold_build2_loc (loc, PLUS_EXPR, type, tree01, arg1);
9823                   return fold_build2_loc (loc, PLUS_EXPR, type, tree00, tree0);
9824                 }
9825             }
9826         }
9827
9828      bit_rotate:
9829       /* (A << C1) + (A >> C2) if A is unsigned and C1+C2 is the size of A
9830          is a rotate of A by C1 bits.  */
9831       /* (A << B) + (A >> (Z - B)) if A is unsigned and Z is the size of A
9832          is a rotate of A by B bits.  */
9833       {
9834         enum tree_code code0, code1;
9835         tree rtype;
9836         code0 = TREE_CODE (arg0);
9837         code1 = TREE_CODE (arg1);
9838         if (((code0 == RSHIFT_EXPR && code1 == LSHIFT_EXPR)
9839              || (code1 == RSHIFT_EXPR && code0 == LSHIFT_EXPR))
9840             && operand_equal_p (TREE_OPERAND (arg0, 0),
9841                                 TREE_OPERAND (arg1, 0), 0)
9842             && (rtype = TREE_TYPE (TREE_OPERAND (arg0, 0)),
9843                 TYPE_UNSIGNED (rtype))
9844             /* Only create rotates in complete modes.  Other cases are not
9845                expanded properly.  */
9846             && TYPE_PRECISION (rtype) == GET_MODE_PRECISION (TYPE_MODE (rtype)))
9847           {
9848             tree tree01, tree11;
9849             enum tree_code code01, code11;
9850
9851             tree01 = TREE_OPERAND (arg0, 1);
9852             tree11 = TREE_OPERAND (arg1, 1);
9853             STRIP_NOPS (tree01);
9854             STRIP_NOPS (tree11);
9855             code01 = TREE_CODE (tree01);
9856             code11 = TREE_CODE (tree11);
9857             if (code01 == INTEGER_CST
9858                 && code11 == INTEGER_CST
9859                 && TREE_INT_CST_HIGH (tree01) == 0
9860                 && TREE_INT_CST_HIGH (tree11) == 0
9861                 && ((TREE_INT_CST_LOW (tree01) + TREE_INT_CST_LOW (tree11))
9862                     == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0)))))
9863               {
9864                 tem = build2_loc (loc, LROTATE_EXPR,
9865                                   TREE_TYPE (TREE_OPERAND (arg0, 0)),
9866                                   TREE_OPERAND (arg0, 0),
9867                                   code0 == LSHIFT_EXPR ? tree01 : tree11);
9868                 return fold_convert_loc (loc, type, tem);
9869               }
9870             else if (code11 == MINUS_EXPR)
9871               {
9872                 tree tree110, tree111;
9873                 tree110 = TREE_OPERAND (tree11, 0);
9874                 tree111 = TREE_OPERAND (tree11, 1);
9875                 STRIP_NOPS (tree110);
9876                 STRIP_NOPS (tree111);
9877                 if (TREE_CODE (tree110) == INTEGER_CST
9878                     && 0 == compare_tree_int (tree110,
9879                                               TYPE_PRECISION
9880                                               (TREE_TYPE (TREE_OPERAND
9881                                                           (arg0, 0))))
9882                     && operand_equal_p (tree01, tree111, 0))
9883                   return
9884                     fold_convert_loc (loc, type,
9885                                       build2 ((code0 == LSHIFT_EXPR
9886                                                ? LROTATE_EXPR
9887                                                : RROTATE_EXPR),
9888                                               TREE_TYPE (TREE_OPERAND (arg0, 0)),
9889                                               TREE_OPERAND (arg0, 0), tree01));
9890               }
9891             else if (code01 == MINUS_EXPR)
9892               {
9893                 tree tree010, tree011;
9894                 tree010 = TREE_OPERAND (tree01, 0);
9895                 tree011 = TREE_OPERAND (tree01, 1);
9896                 STRIP_NOPS (tree010);
9897                 STRIP_NOPS (tree011);
9898                 if (TREE_CODE (tree010) == INTEGER_CST
9899                     && 0 == compare_tree_int (tree010,
9900                                               TYPE_PRECISION
9901                                               (TREE_TYPE (TREE_OPERAND
9902                                                           (arg0, 0))))
9903                     && operand_equal_p (tree11, tree011, 0))
9904                     return fold_convert_loc
9905                       (loc, type,
9906                        build2 ((code0 != LSHIFT_EXPR
9907                                 ? LROTATE_EXPR
9908                                 : RROTATE_EXPR),
9909                                TREE_TYPE (TREE_OPERAND (arg0, 0)),
9910                                TREE_OPERAND (arg0, 0), tree11));
9911               }
9912           }
9913       }
9914
9915     associate:
9916       /* In most languages, can't associate operations on floats through
9917          parentheses.  Rather than remember where the parentheses were, we
9918          don't associate floats at all, unless the user has specified
9919          -fassociative-math.
9920          And, we need to make sure type is not saturating.  */
9921
9922       if ((! FLOAT_TYPE_P (type) || flag_associative_math)
9923           && !TYPE_SATURATING (type))
9924         {
9925           tree var0, con0, lit0, minus_lit0;
9926           tree var1, con1, lit1, minus_lit1;
9927           bool ok = true;
9928
9929           /* Split both trees into variables, constants, and literals.  Then
9930              associate each group together, the constants with literals,
9931              then the result with variables.  This increases the chances of
9932              literals being recombined later and of generating relocatable
9933              expressions for the sum of a constant and literal.  */
9934           var0 = split_tree (arg0, code, &con0, &lit0, &minus_lit0, 0);
9935           var1 = split_tree (arg1, code, &con1, &lit1, &minus_lit1,
9936                              code == MINUS_EXPR);
9937
9938           /* Recombine MINUS_EXPR operands by using PLUS_EXPR.  */
9939           if (code == MINUS_EXPR)
9940             code = PLUS_EXPR;
9941
9942           /* With undefined overflow we can only associate constants with one
9943              variable, and constants whose association doesn't overflow.  */
9944           if ((POINTER_TYPE_P (type) && POINTER_TYPE_OVERFLOW_UNDEFINED)
9945               || (INTEGRAL_TYPE_P (type) && !TYPE_OVERFLOW_WRAPS (type)))
9946             {
9947               if (var0 && var1)
9948                 {
9949                   tree tmp0 = var0;
9950                   tree tmp1 = var1;
9951
9952                   if (TREE_CODE (tmp0) == NEGATE_EXPR)
9953                     tmp0 = TREE_OPERAND (tmp0, 0);
9954                   if (TREE_CODE (tmp1) == NEGATE_EXPR)
9955                     tmp1 = TREE_OPERAND (tmp1, 0);
9956                   /* The only case we can still associate with two variables
9957                      is if they are the same, modulo negation.  */
9958                   if (!operand_equal_p (tmp0, tmp1, 0))
9959                     ok = false;
9960                 }
9961
9962               if (ok && lit0 && lit1)
9963                 {
9964                   tree tmp0 = fold_convert (type, lit0);
9965                   tree tmp1 = fold_convert (type, lit1);
9966
9967                   if (!TREE_OVERFLOW (tmp0) && !TREE_OVERFLOW (tmp1)
9968                       && TREE_OVERFLOW (fold_build2 (code, type, tmp0, tmp1)))
9969                     ok = false;
9970                 }
9971             }
9972
9973           /* Only do something if we found more than two objects.  Otherwise,
9974              nothing has changed and we risk infinite recursion.  */
9975           if (ok
9976               && (2 < ((var0 != 0) + (var1 != 0)
9977                        + (con0 != 0) + (con1 != 0)
9978                        + (lit0 != 0) + (lit1 != 0)
9979                        + (minus_lit0 != 0) + (minus_lit1 != 0))))
9980             {
9981               var0 = associate_trees (loc, var0, var1, code, type);
9982               con0 = associate_trees (loc, con0, con1, code, type);
9983               lit0 = associate_trees (loc, lit0, lit1, code, type);
9984               minus_lit0 = associate_trees (loc, minus_lit0, minus_lit1, code, type);
9985
9986               /* Preserve the MINUS_EXPR if the negative part of the literal is
9987                  greater than the positive part.  Otherwise, the multiplicative
9988                  folding code (i.e extract_muldiv) may be fooled in case
9989                  unsigned constants are subtracted, like in the following
9990                  example: ((X*2 + 4) - 8U)/2.  */
9991               if (minus_lit0 && lit0)
9992                 {
9993                   if (TREE_CODE (lit0) == INTEGER_CST
9994                       && TREE_CODE (minus_lit0) == INTEGER_CST
9995                       && tree_int_cst_lt (lit0, minus_lit0))
9996                     {
9997                       minus_lit0 = associate_trees (loc, minus_lit0, lit0,
9998                                                     MINUS_EXPR, type);
9999                       lit0 = 0;
10000                     }
10001                   else
10002                     {
10003                       lit0 = associate_trees (loc, lit0, minus_lit0,
10004                                               MINUS_EXPR, type);
10005                       minus_lit0 = 0;
10006                     }
10007                 }
10008               if (minus_lit0)
10009                 {
10010                   if (con0 == 0)
10011                     return
10012                       fold_convert_loc (loc, type,
10013                                         associate_trees (loc, var0, minus_lit0,
10014                                                          MINUS_EXPR, type));
10015                   else
10016                     {
10017                       con0 = associate_trees (loc, con0, minus_lit0,
10018                                               MINUS_EXPR, type);
10019                       return
10020                         fold_convert_loc (loc, type,
10021                                           associate_trees (loc, var0, con0,
10022                                                            PLUS_EXPR, type));
10023                     }
10024                 }
10025
10026               con0 = associate_trees (loc, con0, lit0, code, type);
10027               return
10028                 fold_convert_loc (loc, type, associate_trees (loc, var0, con0,
10029                                                               code, type));
10030             }
10031         }
10032
10033       return NULL_TREE;
10034
10035     case MINUS_EXPR:
10036       /* Pointer simplifications for subtraction, simple reassociations. */
10037       if (POINTER_TYPE_P (TREE_TYPE (arg1)) && POINTER_TYPE_P (TREE_TYPE (arg0)))
10038         {
10039           /* (PTR0 p+ A) - (PTR1 p+ B) -> (PTR0 - PTR1) + (A - B) */
10040           if (TREE_CODE (arg0) == POINTER_PLUS_EXPR
10041               && TREE_CODE (arg1) == POINTER_PLUS_EXPR)
10042             {
10043               tree arg00 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
10044               tree arg01 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 1));
10045               tree arg10 = fold_convert_loc (loc, type, TREE_OPERAND (arg1, 0));
10046               tree arg11 = fold_convert_loc (loc, type, TREE_OPERAND (arg1, 1));
10047               return fold_build2_loc (loc, PLUS_EXPR, type,
10048                                   fold_build2_loc (loc, MINUS_EXPR, type,
10049                                                arg00, arg10),
10050                                   fold_build2_loc (loc, MINUS_EXPR, type,
10051                                                arg01, arg11));
10052             }
10053           /* (PTR0 p+ A) - PTR1 -> (PTR0 - PTR1) + A, assuming PTR0 - PTR1 simplifies. */
10054           else if (TREE_CODE (arg0) == POINTER_PLUS_EXPR)
10055             {
10056               tree arg00 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
10057               tree arg01 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 1));
10058               tree tmp = fold_binary_loc (loc, MINUS_EXPR, type, arg00,
10059                                       fold_convert_loc (loc, type, arg1));
10060               if (tmp)
10061                 return fold_build2_loc (loc, PLUS_EXPR, type, tmp, arg01);
10062             }
10063         }
10064       /* A - (-B) -> A + B */
10065       if (TREE_CODE (arg1) == NEGATE_EXPR)
10066         return fold_build2_loc (loc, PLUS_EXPR, type, op0,
10067                             fold_convert_loc (loc, type,
10068                                               TREE_OPERAND (arg1, 0)));
10069       /* (-A) - B -> (-B) - A  where B is easily negated and we can swap.  */
10070       if (TREE_CODE (arg0) == NEGATE_EXPR
10071           && (FLOAT_TYPE_P (type)
10072               || INTEGRAL_TYPE_P (type))
10073           && negate_expr_p (arg1)
10074           && reorder_operands_p (arg0, arg1))
10075         return fold_build2_loc (loc, MINUS_EXPR, type,
10076                             fold_convert_loc (loc, type,
10077                                               negate_expr (arg1)),
10078                             fold_convert_loc (loc, type,
10079                                               TREE_OPERAND (arg0, 0)));
10080       /* Convert -A - 1 to ~A.  */
10081       if (INTEGRAL_TYPE_P (type)
10082           && TREE_CODE (arg0) == NEGATE_EXPR
10083           && integer_onep (arg1)
10084           && !TYPE_OVERFLOW_TRAPS (type))
10085         return fold_build1_loc (loc, BIT_NOT_EXPR, type,
10086                             fold_convert_loc (loc, type,
10087                                               TREE_OPERAND (arg0, 0)));
10088
10089       /* Convert -1 - A to ~A.  */
10090       if (INTEGRAL_TYPE_P (type)
10091           && integer_all_onesp (arg0))
10092         return fold_build1_loc (loc, BIT_NOT_EXPR, type, op1);
10093
10094
10095       /* X - (X / CST) * CST is X % CST.  */
10096       if (INTEGRAL_TYPE_P (type)
10097           && TREE_CODE (arg1) == MULT_EXPR
10098           && TREE_CODE (TREE_OPERAND (arg1, 0)) == TRUNC_DIV_EXPR
10099           && operand_equal_p (arg0,
10100                               TREE_OPERAND (TREE_OPERAND (arg1, 0), 0), 0)
10101           && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg1, 0), 1),
10102                               TREE_OPERAND (arg1, 1), 0))
10103         return
10104           fold_convert_loc (loc, type,
10105                             fold_build2_loc (loc, TRUNC_MOD_EXPR, TREE_TYPE (arg0),
10106                                          arg0, TREE_OPERAND (arg1, 1)));
10107
10108       if (! FLOAT_TYPE_P (type))
10109         {
10110           if (integer_zerop (arg0))
10111             return negate_expr (fold_convert_loc (loc, type, arg1));
10112           if (integer_zerop (arg1))
10113             return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
10114
10115           /* Fold A - (A & B) into ~B & A.  */
10116           if (!TREE_SIDE_EFFECTS (arg0)
10117               && TREE_CODE (arg1) == BIT_AND_EXPR)
10118             {
10119               if (operand_equal_p (arg0, TREE_OPERAND (arg1, 1), 0))
10120                 {
10121                   tree arg10 = fold_convert_loc (loc, type,
10122                                                  TREE_OPERAND (arg1, 0));
10123                   return fold_build2_loc (loc, BIT_AND_EXPR, type,
10124                                       fold_build1_loc (loc, BIT_NOT_EXPR,
10125                                                    type, arg10),
10126                                       fold_convert_loc (loc, type, arg0));
10127                 }
10128               if (operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
10129                 {
10130                   tree arg11 = fold_convert_loc (loc,
10131                                                  type, TREE_OPERAND (arg1, 1));
10132                   return fold_build2_loc (loc, BIT_AND_EXPR, type,
10133                                       fold_build1_loc (loc, BIT_NOT_EXPR,
10134                                                    type, arg11),
10135                                       fold_convert_loc (loc, type, arg0));
10136                 }
10137             }
10138
10139           /* Fold (A & ~B) - (A & B) into (A ^ B) - B, where B is
10140              any power of 2 minus 1.  */
10141           if (TREE_CODE (arg0) == BIT_AND_EXPR
10142               && TREE_CODE (arg1) == BIT_AND_EXPR
10143               && operand_equal_p (TREE_OPERAND (arg0, 0),
10144                                   TREE_OPERAND (arg1, 0), 0))
10145             {
10146               tree mask0 = TREE_OPERAND (arg0, 1);
10147               tree mask1 = TREE_OPERAND (arg1, 1);
10148               tree tem = fold_build1_loc (loc, BIT_NOT_EXPR, type, mask0);
10149
10150               if (operand_equal_p (tem, mask1, 0))
10151                 {
10152                   tem = fold_build2_loc (loc, BIT_XOR_EXPR, type,
10153                                      TREE_OPERAND (arg0, 0), mask1);
10154                   return fold_build2_loc (loc, MINUS_EXPR, type, tem, mask1);
10155                 }
10156             }
10157         }
10158
10159       /* See if ARG1 is zero and X - ARG1 reduces to X.  */
10160       else if (fold_real_zero_addition_p (TREE_TYPE (arg0), arg1, 1))
10161         return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
10162
10163       /* (ARG0 - ARG1) is the same as (-ARG1 + ARG0).  So check whether
10164          ARG0 is zero and X + ARG0 reduces to X, since that would mean
10165          (-ARG1 + ARG0) reduces to -ARG1.  */
10166       else if (fold_real_zero_addition_p (TREE_TYPE (arg1), arg0, 0))
10167         return negate_expr (fold_convert_loc (loc, type, arg1));
10168
10169       /* Fold __complex__ ( x, 0 ) - __complex__ ( 0, y ) to
10170          __complex__ ( x, -y ).  This is not the same for SNaNs or if
10171          signed zeros are involved.  */
10172       if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
10173           && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0)))
10174           && COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0)))
10175         {
10176           tree rtype = TREE_TYPE (TREE_TYPE (arg0));
10177           tree arg0r = fold_unary_loc (loc, REALPART_EXPR, rtype, arg0);
10178           tree arg0i = fold_unary_loc (loc, IMAGPART_EXPR, rtype, arg0);
10179           bool arg0rz = false, arg0iz = false;
10180           if ((arg0r && (arg0rz = real_zerop (arg0r)))
10181               || (arg0i && (arg0iz = real_zerop (arg0i))))
10182             {
10183               tree arg1r = fold_unary_loc (loc, REALPART_EXPR, rtype, arg1);
10184               tree arg1i = fold_unary_loc (loc, IMAGPART_EXPR, rtype, arg1);
10185               if (arg0rz && arg1i && real_zerop (arg1i))
10186                 {
10187                   tree rp = fold_build1_loc (loc, NEGATE_EXPR, rtype,
10188                                          arg1r ? arg1r
10189                                          : build1 (REALPART_EXPR, rtype, arg1));
10190                   tree ip = arg0i ? arg0i
10191                     : build1 (IMAGPART_EXPR, rtype, arg0);
10192                   return fold_build2_loc (loc, COMPLEX_EXPR, type, rp, ip);
10193                 }
10194               else if (arg0iz && arg1r && real_zerop (arg1r))
10195                 {
10196                   tree rp = arg0r ? arg0r
10197                     : build1 (REALPART_EXPR, rtype, arg0);
10198                   tree ip = fold_build1_loc (loc, NEGATE_EXPR, rtype,
10199                                          arg1i ? arg1i
10200                                          : build1 (IMAGPART_EXPR, rtype, arg1));
10201                   return fold_build2_loc (loc, COMPLEX_EXPR, type, rp, ip);
10202                 }
10203             }
10204         }
10205
10206       /* Fold &x - &x.  This can happen from &x.foo - &x.
10207          This is unsafe for certain floats even in non-IEEE formats.
10208          In IEEE, it is unsafe because it does wrong for NaNs.
10209          Also note that operand_equal_p is always false if an operand
10210          is volatile.  */
10211
10212       if ((!FLOAT_TYPE_P (type) || !HONOR_NANS (TYPE_MODE (type)))
10213           && operand_equal_p (arg0, arg1, 0))
10214         return build_zero_cst (type);
10215
10216       /* A - B -> A + (-B) if B is easily negatable.  */
10217       if (negate_expr_p (arg1)
10218           && ((FLOAT_TYPE_P (type)
10219                /* Avoid this transformation if B is a positive REAL_CST.  */
10220                && (TREE_CODE (arg1) != REAL_CST
10221                    ||  REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg1))))
10222               || INTEGRAL_TYPE_P (type)))
10223         return fold_build2_loc (loc, PLUS_EXPR, type,
10224                             fold_convert_loc (loc, type, arg0),
10225                             fold_convert_loc (loc, type,
10226                                               negate_expr (arg1)));
10227
10228       /* Try folding difference of addresses.  */
10229       {
10230         HOST_WIDE_INT diff;
10231
10232         if ((TREE_CODE (arg0) == ADDR_EXPR
10233              || TREE_CODE (arg1) == ADDR_EXPR)
10234             && ptr_difference_const (arg0, arg1, &diff))
10235           return build_int_cst_type (type, diff);
10236       }
10237
10238       /* Fold &a[i] - &a[j] to i-j.  */
10239       if (TREE_CODE (arg0) == ADDR_EXPR
10240           && TREE_CODE (TREE_OPERAND (arg0, 0)) == ARRAY_REF
10241           && TREE_CODE (arg1) == ADDR_EXPR
10242           && TREE_CODE (TREE_OPERAND (arg1, 0)) == ARRAY_REF)
10243         {
10244           tree aref0 = TREE_OPERAND (arg0, 0);
10245           tree aref1 = TREE_OPERAND (arg1, 0);
10246           if (operand_equal_p (TREE_OPERAND (aref0, 0),
10247                                TREE_OPERAND (aref1, 0), 0))
10248             {
10249               tree op0 = fold_convert_loc (loc, type, TREE_OPERAND (aref0, 1));
10250               tree op1 = fold_convert_loc (loc, type, TREE_OPERAND (aref1, 1));
10251               tree esz = array_ref_element_size (aref0);
10252               tree diff = build2 (MINUS_EXPR, type, op0, op1);
10253               return fold_build2_loc (loc, MULT_EXPR, type, diff,
10254                                   fold_convert_loc (loc, type, esz));
10255
10256             }
10257         }
10258
10259       if (FLOAT_TYPE_P (type)
10260           && flag_unsafe_math_optimizations
10261           && (TREE_CODE (arg0) == RDIV_EXPR || TREE_CODE (arg0) == MULT_EXPR)
10262           && (TREE_CODE (arg1) == RDIV_EXPR || TREE_CODE (arg1) == MULT_EXPR)
10263           && (tem = distribute_real_division (loc, code, type, arg0, arg1)))
10264         return tem;
10265
10266       /* Handle (A1 * C1) - (A2 * C2) with A1, A2 or C1, C2 being the
10267          same or one.  Make sure type is not saturating.
10268          fold_plusminus_mult_expr will re-associate.  */
10269       if ((TREE_CODE (arg0) == MULT_EXPR
10270            || TREE_CODE (arg1) == MULT_EXPR)
10271           && !TYPE_SATURATING (type)
10272           && (!FLOAT_TYPE_P (type) || flag_associative_math))
10273         {
10274           tree tem = fold_plusminus_mult_expr (loc, code, type, arg0, arg1);
10275           if (tem)
10276             return tem;
10277         }
10278
10279       goto associate;
10280
10281     case MULT_EXPR:
10282       /* (-A) * (-B) -> A * B  */
10283       if (TREE_CODE (arg0) == NEGATE_EXPR && negate_expr_p (arg1))
10284         return fold_build2_loc (loc, MULT_EXPR, type,
10285                             fold_convert_loc (loc, type,
10286                                               TREE_OPERAND (arg0, 0)),
10287                             fold_convert_loc (loc, type,
10288                                               negate_expr (arg1)));
10289       if (TREE_CODE (arg1) == NEGATE_EXPR && negate_expr_p (arg0))
10290         return fold_build2_loc (loc, MULT_EXPR, type,
10291                             fold_convert_loc (loc, type,
10292                                               negate_expr (arg0)),
10293                             fold_convert_loc (loc, type,
10294                                               TREE_OPERAND (arg1, 0)));
10295
10296       if (! FLOAT_TYPE_P (type))
10297         {
10298           if (integer_zerop (arg1))
10299             return omit_one_operand_loc (loc, type, arg1, arg0);
10300           if (integer_onep (arg1))
10301             return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
10302           /* Transform x * -1 into -x.  Make sure to do the negation
10303              on the original operand with conversions not stripped
10304              because we can only strip non-sign-changing conversions.  */
10305           if (integer_all_onesp (arg1))
10306             return fold_convert_loc (loc, type, negate_expr (op0));
10307           /* Transform x * -C into -x * C if x is easily negatable.  */
10308           if (TREE_CODE (arg1) == INTEGER_CST
10309               && tree_int_cst_sgn (arg1) == -1
10310               && negate_expr_p (arg0)
10311               && (tem = negate_expr (arg1)) != arg1
10312               && !TREE_OVERFLOW (tem))
10313             return fold_build2_loc (loc, MULT_EXPR, type,
10314                                 fold_convert_loc (loc, type,
10315                                                   negate_expr (arg0)),
10316                                 tem);
10317
10318           /* (a * (1 << b)) is (a << b)  */
10319           if (TREE_CODE (arg1) == LSHIFT_EXPR
10320               && integer_onep (TREE_OPERAND (arg1, 0)))
10321             return fold_build2_loc (loc, LSHIFT_EXPR, type, op0,
10322                                 TREE_OPERAND (arg1, 1));
10323           if (TREE_CODE (arg0) == LSHIFT_EXPR
10324               && integer_onep (TREE_OPERAND (arg0, 0)))
10325             return fold_build2_loc (loc, LSHIFT_EXPR, type, op1,
10326                                 TREE_OPERAND (arg0, 1));
10327
10328           /* (A + A) * C -> A * 2 * C  */
10329           if (TREE_CODE (arg0) == PLUS_EXPR
10330               && TREE_CODE (arg1) == INTEGER_CST
10331               && operand_equal_p (TREE_OPERAND (arg0, 0),
10332                                   TREE_OPERAND (arg0, 1), 0))
10333             return fold_build2_loc (loc, MULT_EXPR, type,
10334                                 omit_one_operand_loc (loc, type,
10335                                                   TREE_OPERAND (arg0, 0),
10336                                                   TREE_OPERAND (arg0, 1)),
10337                                 fold_build2_loc (loc, MULT_EXPR, type,
10338                                              build_int_cst (type, 2) , arg1));
10339
10340           strict_overflow_p = false;
10341           if (TREE_CODE (arg1) == INTEGER_CST
10342               && 0 != (tem = extract_muldiv (op0, arg1, code, NULL_TREE,
10343                                              &strict_overflow_p)))
10344             {
10345               if (strict_overflow_p)
10346                 fold_overflow_warning (("assuming signed overflow does not "
10347                                         "occur when simplifying "
10348                                         "multiplication"),
10349                                        WARN_STRICT_OVERFLOW_MISC);
10350               return fold_convert_loc (loc, type, tem);
10351             }
10352
10353           /* Optimize z * conj(z) for integer complex numbers.  */
10354           if (TREE_CODE (arg0) == CONJ_EXPR
10355               && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
10356             return fold_mult_zconjz (loc, type, arg1);
10357           if (TREE_CODE (arg1) == CONJ_EXPR
10358               && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
10359             return fold_mult_zconjz (loc, type, arg0);
10360         }
10361       else
10362         {
10363           /* Maybe fold x * 0 to 0.  The expressions aren't the same
10364              when x is NaN, since x * 0 is also NaN.  Nor are they the
10365              same in modes with signed zeros, since multiplying a
10366              negative value by 0 gives -0, not +0.  */
10367           if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0)))
10368               && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0)))
10369               && real_zerop (arg1))
10370             return omit_one_operand_loc (loc, type, arg1, arg0);
10371           /* In IEEE floating point, x*1 is not equivalent to x for snans.
10372              Likewise for complex arithmetic with signed zeros.  */
10373           if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
10374               && (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0)))
10375                   || !COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0)))
10376               && real_onep (arg1))
10377             return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
10378
10379           /* Transform x * -1.0 into -x.  */
10380           if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
10381               && (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0)))
10382                   || !COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0)))
10383               && real_minus_onep (arg1))
10384             return fold_convert_loc (loc, type, negate_expr (arg0));
10385
10386           /* Convert (C1/X)*C2 into (C1*C2)/X.  This transformation may change
10387              the result for floating point types due to rounding so it is applied
10388              only if -fassociative-math was specify.  */
10389           if (flag_associative_math
10390               && TREE_CODE (arg0) == RDIV_EXPR
10391               && TREE_CODE (arg1) == REAL_CST
10392               && TREE_CODE (TREE_OPERAND (arg0, 0)) == REAL_CST)
10393             {
10394               tree tem = const_binop (MULT_EXPR, TREE_OPERAND (arg0, 0),
10395                                       arg1);
10396               if (tem)
10397                 return fold_build2_loc (loc, RDIV_EXPR, type, tem,
10398                                     TREE_OPERAND (arg0, 1));
10399             }
10400
10401           /* Strip sign operations from X in X*X, i.e. -Y*-Y -> Y*Y.  */
10402           if (operand_equal_p (arg0, arg1, 0))
10403             {
10404               tree tem = fold_strip_sign_ops (arg0);
10405               if (tem != NULL_TREE)
10406                 {
10407                   tem = fold_convert_loc (loc, type, tem);
10408                   return fold_build2_loc (loc, MULT_EXPR, type, tem, tem);
10409                 }
10410             }
10411
10412           /* Fold z * +-I to __complex__ (-+__imag z, +-__real z).
10413              This is not the same for NaNs or if signed zeros are
10414              involved.  */
10415           if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0)))
10416               && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0)))
10417               && COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0))
10418               && TREE_CODE (arg1) == COMPLEX_CST
10419               && real_zerop (TREE_REALPART (arg1)))
10420             {
10421               tree rtype = TREE_TYPE (TREE_TYPE (arg0));
10422               if (real_onep (TREE_IMAGPART (arg1)))
10423                 return
10424                   fold_build2_loc (loc, COMPLEX_EXPR, type,
10425                                negate_expr (fold_build1_loc (loc, IMAGPART_EXPR,
10426                                                              rtype, arg0)),
10427                                fold_build1_loc (loc, REALPART_EXPR, rtype, arg0));
10428               else if (real_minus_onep (TREE_IMAGPART (arg1)))
10429                 return
10430                   fold_build2_loc (loc, COMPLEX_EXPR, type,
10431                                fold_build1_loc (loc, IMAGPART_EXPR, rtype, arg0),
10432                                negate_expr (fold_build1_loc (loc, REALPART_EXPR,
10433                                                              rtype, arg0)));
10434             }
10435
10436           /* Optimize z * conj(z) for floating point complex numbers.
10437              Guarded by flag_unsafe_math_optimizations as non-finite
10438              imaginary components don't produce scalar results.  */
10439           if (flag_unsafe_math_optimizations
10440               && TREE_CODE (arg0) == CONJ_EXPR
10441               && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
10442             return fold_mult_zconjz (loc, type, arg1);
10443           if (flag_unsafe_math_optimizations
10444               && TREE_CODE (arg1) == CONJ_EXPR
10445               && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
10446             return fold_mult_zconjz (loc, type, arg0);
10447
10448           if (flag_unsafe_math_optimizations)
10449             {
10450               enum built_in_function fcode0 = builtin_mathfn_code (arg0);
10451               enum built_in_function fcode1 = builtin_mathfn_code (arg1);
10452
10453               /* Optimizations of root(...)*root(...).  */
10454               if (fcode0 == fcode1 && BUILTIN_ROOT_P (fcode0))
10455                 {
10456                   tree rootfn, arg;
10457                   tree arg00 = CALL_EXPR_ARG (arg0, 0);
10458                   tree arg10 = CALL_EXPR_ARG (arg1, 0);
10459
10460                   /* Optimize sqrt(x)*sqrt(x) as x.  */
10461                   if (BUILTIN_SQRT_P (fcode0)
10462                       && operand_equal_p (arg00, arg10, 0)
10463                       && ! HONOR_SNANS (TYPE_MODE (type)))
10464                     return arg00;
10465
10466                   /* Optimize root(x)*root(y) as root(x*y).  */
10467                   rootfn = TREE_OPERAND (CALL_EXPR_FN (arg0), 0);
10468                   arg = fold_build2_loc (loc, MULT_EXPR, type, arg00, arg10);
10469                   return build_call_expr_loc (loc, rootfn, 1, arg);
10470                 }
10471
10472               /* Optimize expN(x)*expN(y) as expN(x+y).  */
10473               if (fcode0 == fcode1 && BUILTIN_EXPONENT_P (fcode0))
10474                 {
10475                   tree expfn = TREE_OPERAND (CALL_EXPR_FN (arg0), 0);
10476                   tree arg = fold_build2_loc (loc, PLUS_EXPR, type,
10477                                           CALL_EXPR_ARG (arg0, 0),
10478                                           CALL_EXPR_ARG (arg1, 0));
10479                   return build_call_expr_loc (loc, expfn, 1, arg);
10480                 }
10481
10482               /* Optimizations of pow(...)*pow(...).  */
10483               if ((fcode0 == BUILT_IN_POW && fcode1 == BUILT_IN_POW)
10484                   || (fcode0 == BUILT_IN_POWF && fcode1 == BUILT_IN_POWF)
10485                   || (fcode0 == BUILT_IN_POWL && fcode1 == BUILT_IN_POWL))
10486                 {
10487                   tree arg00 = CALL_EXPR_ARG (arg0, 0);
10488                   tree arg01 = CALL_EXPR_ARG (arg0, 1);
10489                   tree arg10 = CALL_EXPR_ARG (arg1, 0);
10490                   tree arg11 = CALL_EXPR_ARG (arg1, 1);
10491
10492                   /* Optimize pow(x,y)*pow(z,y) as pow(x*z,y).  */
10493                   if (operand_equal_p (arg01, arg11, 0))
10494                     {
10495                       tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg0), 0);
10496                       tree arg = fold_build2_loc (loc, MULT_EXPR, type,
10497                                               arg00, arg10);
10498                       return build_call_expr_loc (loc, powfn, 2, arg, arg01);
10499                     }
10500
10501                   /* Optimize pow(x,y)*pow(x,z) as pow(x,y+z).  */
10502                   if (operand_equal_p (arg00, arg10, 0))
10503                     {
10504                       tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg0), 0);
10505                       tree arg = fold_build2_loc (loc, PLUS_EXPR, type,
10506                                               arg01, arg11);
10507                       return build_call_expr_loc (loc, powfn, 2, arg00, arg);
10508                     }
10509                 }
10510
10511               /* Optimize tan(x)*cos(x) as sin(x).  */
10512               if (((fcode0 == BUILT_IN_TAN && fcode1 == BUILT_IN_COS)
10513                    || (fcode0 == BUILT_IN_TANF && fcode1 == BUILT_IN_COSF)
10514                    || (fcode0 == BUILT_IN_TANL && fcode1 == BUILT_IN_COSL)
10515                    || (fcode0 == BUILT_IN_COS && fcode1 == BUILT_IN_TAN)
10516                    || (fcode0 == BUILT_IN_COSF && fcode1 == BUILT_IN_TANF)
10517                    || (fcode0 == BUILT_IN_COSL && fcode1 == BUILT_IN_TANL))
10518                   && operand_equal_p (CALL_EXPR_ARG (arg0, 0),
10519                                       CALL_EXPR_ARG (arg1, 0), 0))
10520                 {
10521                   tree sinfn = mathfn_built_in (type, BUILT_IN_SIN);
10522
10523                   if (sinfn != NULL_TREE)
10524                     return build_call_expr_loc (loc, sinfn, 1,
10525                                             CALL_EXPR_ARG (arg0, 0));
10526                 }
10527
10528               /* Optimize x*pow(x,c) as pow(x,c+1).  */
10529               if (fcode1 == BUILT_IN_POW
10530                   || fcode1 == BUILT_IN_POWF
10531                   || fcode1 == BUILT_IN_POWL)
10532                 {
10533                   tree arg10 = CALL_EXPR_ARG (arg1, 0);
10534                   tree arg11 = CALL_EXPR_ARG (arg1, 1);
10535                   if (TREE_CODE (arg11) == REAL_CST
10536                       && !TREE_OVERFLOW (arg11)
10537                       && operand_equal_p (arg0, arg10, 0))
10538                     {
10539                       tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg1), 0);
10540                       REAL_VALUE_TYPE c;
10541                       tree arg;
10542
10543                       c = TREE_REAL_CST (arg11);
10544                       real_arithmetic (&c, PLUS_EXPR, &c, &dconst1);
10545                       arg = build_real (type, c);
10546                       return build_call_expr_loc (loc, powfn, 2, arg0, arg);
10547                     }
10548                 }
10549
10550               /* Optimize pow(x,c)*x as pow(x,c+1).  */
10551               if (fcode0 == BUILT_IN_POW
10552                   || fcode0 == BUILT_IN_POWF
10553                   || fcode0 == BUILT_IN_POWL)
10554                 {
10555                   tree arg00 = CALL_EXPR_ARG (arg0, 0);
10556                   tree arg01 = CALL_EXPR_ARG (arg0, 1);
10557                   if (TREE_CODE (arg01) == REAL_CST
10558                       && !TREE_OVERFLOW (arg01)
10559                       && operand_equal_p (arg1, arg00, 0))
10560                     {
10561                       tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg0), 0);
10562                       REAL_VALUE_TYPE c;
10563                       tree arg;
10564
10565                       c = TREE_REAL_CST (arg01);
10566                       real_arithmetic (&c, PLUS_EXPR, &c, &dconst1);
10567                       arg = build_real (type, c);
10568                       return build_call_expr_loc (loc, powfn, 2, arg1, arg);
10569                     }
10570                 }
10571
10572               /* Optimize x*x as pow(x,2.0), which is expanded as x*x.  */
10573               if (optimize_function_for_speed_p (cfun)
10574                   && operand_equal_p (arg0, arg1, 0))
10575                 {
10576                   tree powfn = mathfn_built_in (type, BUILT_IN_POW);
10577
10578                   if (powfn)
10579                     {
10580                       tree arg = build_real (type, dconst2);
10581                       return build_call_expr_loc (loc, powfn, 2, arg0, arg);
10582                     }
10583                 }
10584             }
10585         }
10586       goto associate;
10587
10588     case BIT_IOR_EXPR:
10589     bit_ior:
10590       if (integer_all_onesp (arg1))
10591         return omit_one_operand_loc (loc, type, arg1, arg0);
10592       if (integer_zerop (arg1))
10593         return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
10594       if (operand_equal_p (arg0, arg1, 0))
10595         return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
10596
10597       /* ~X | X is -1.  */
10598       if (TREE_CODE (arg0) == BIT_NOT_EXPR
10599           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
10600         {
10601           t1 = build_zero_cst (type);
10602           t1 = fold_unary_loc (loc, BIT_NOT_EXPR, type, t1);
10603           return omit_one_operand_loc (loc, type, t1, arg1);
10604         }
10605
10606       /* X | ~X is -1.  */
10607       if (TREE_CODE (arg1) == BIT_NOT_EXPR
10608           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
10609         {
10610           t1 = build_zero_cst (type);
10611           t1 = fold_unary_loc (loc, BIT_NOT_EXPR, type, t1);
10612           return omit_one_operand_loc (loc, type, t1, arg0);
10613         }
10614
10615       /* Canonicalize (X & C1) | C2.  */
10616       if (TREE_CODE (arg0) == BIT_AND_EXPR
10617           && TREE_CODE (arg1) == INTEGER_CST
10618           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
10619         {
10620           unsigned HOST_WIDE_INT hi1, lo1, hi2, lo2, hi3, lo3, mlo, mhi;
10621           int width = TYPE_PRECISION (type), w;
10622           hi1 = TREE_INT_CST_HIGH (TREE_OPERAND (arg0, 1));
10623           lo1 = TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1));
10624           hi2 = TREE_INT_CST_HIGH (arg1);
10625           lo2 = TREE_INT_CST_LOW (arg1);
10626
10627           /* If (C1&C2) == C1, then (X&C1)|C2 becomes (X,C2).  */
10628           if ((hi1 & hi2) == hi1 && (lo1 & lo2) == lo1)
10629             return omit_one_operand_loc (loc, type, arg1,
10630                                      TREE_OPERAND (arg0, 0));
10631
10632           if (width > HOST_BITS_PER_WIDE_INT)
10633             {
10634               mhi = (unsigned HOST_WIDE_INT) -1
10635                     >> (2 * HOST_BITS_PER_WIDE_INT - width);
10636               mlo = -1;
10637             }
10638           else
10639             {
10640               mhi = 0;
10641               mlo = (unsigned HOST_WIDE_INT) -1
10642                     >> (HOST_BITS_PER_WIDE_INT - width);
10643             }
10644
10645           /* If (C1|C2) == ~0 then (X&C1)|C2 becomes X|C2.  */
10646           if ((~(hi1 | hi2) & mhi) == 0 && (~(lo1 | lo2) & mlo) == 0)
10647             return fold_build2_loc (loc, BIT_IOR_EXPR, type,
10648                                 TREE_OPERAND (arg0, 0), arg1);
10649
10650           /* Minimize the number of bits set in C1, i.e. C1 := C1 & ~C2,
10651              unless (C1 & ~C2) | (C2 & C3) for some C3 is a mask of some
10652              mode which allows further optimizations.  */
10653           hi1 &= mhi;
10654           lo1 &= mlo;
10655           hi2 &= mhi;
10656           lo2 &= mlo;
10657           hi3 = hi1 & ~hi2;
10658           lo3 = lo1 & ~lo2;
10659           for (w = BITS_PER_UNIT;
10660                w <= width && w <= HOST_BITS_PER_WIDE_INT;
10661                w <<= 1)
10662             {
10663               unsigned HOST_WIDE_INT mask
10664                 = (unsigned HOST_WIDE_INT) -1 >> (HOST_BITS_PER_WIDE_INT - w);
10665               if (((lo1 | lo2) & mask) == mask
10666                   && (lo1 & ~mask) == 0 && hi1 == 0)
10667                 {
10668                   hi3 = 0;
10669                   lo3 = mask;
10670                   break;
10671                 }
10672             }
10673           if (hi3 != hi1 || lo3 != lo1)
10674             return fold_build2_loc (loc, BIT_IOR_EXPR, type,
10675                                 fold_build2_loc (loc, BIT_AND_EXPR, type,
10676                                              TREE_OPERAND (arg0, 0),
10677                                              build_int_cst_wide (type,
10678                                                                  lo3, hi3)),
10679                                 arg1);
10680         }
10681
10682       /* (X & Y) | Y is (X, Y).  */
10683       if (TREE_CODE (arg0) == BIT_AND_EXPR
10684           && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
10685         return omit_one_operand_loc (loc, type, arg1, TREE_OPERAND (arg0, 0));
10686       /* (X & Y) | X is (Y, X).  */
10687       if (TREE_CODE (arg0) == BIT_AND_EXPR
10688           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
10689           && reorder_operands_p (TREE_OPERAND (arg0, 1), arg1))
10690         return omit_one_operand_loc (loc, type, arg1, TREE_OPERAND (arg0, 1));
10691       /* X | (X & Y) is (Y, X).  */
10692       if (TREE_CODE (arg1) == BIT_AND_EXPR
10693           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0)
10694           && reorder_operands_p (arg0, TREE_OPERAND (arg1, 1)))
10695         return omit_one_operand_loc (loc, type, arg0, TREE_OPERAND (arg1, 1));
10696       /* X | (Y & X) is (Y, X).  */
10697       if (TREE_CODE (arg1) == BIT_AND_EXPR
10698           && operand_equal_p (arg0, TREE_OPERAND (arg1, 1), 0)
10699           && reorder_operands_p (arg0, TREE_OPERAND (arg1, 0)))
10700         return omit_one_operand_loc (loc, type, arg0, TREE_OPERAND (arg1, 0));
10701
10702       t1 = distribute_bit_expr (loc, code, type, arg0, arg1);
10703       if (t1 != NULL_TREE)
10704         return t1;
10705
10706       /* Convert (or (not arg0) (not arg1)) to (not (and (arg0) (arg1))).
10707
10708          This results in more efficient code for machines without a NAND
10709          instruction.  Combine will canonicalize to the first form
10710          which will allow use of NAND instructions provided by the
10711          backend if they exist.  */
10712       if (TREE_CODE (arg0) == BIT_NOT_EXPR
10713           && TREE_CODE (arg1) == BIT_NOT_EXPR)
10714         {
10715           return
10716             fold_build1_loc (loc, BIT_NOT_EXPR, type,
10717                          build2 (BIT_AND_EXPR, type,
10718                                  fold_convert_loc (loc, type,
10719                                                    TREE_OPERAND (arg0, 0)),
10720                                  fold_convert_loc (loc, type,
10721                                                    TREE_OPERAND (arg1, 0))));
10722         }
10723
10724       /* See if this can be simplified into a rotate first.  If that
10725          is unsuccessful continue in the association code.  */
10726       goto bit_rotate;
10727
10728     case BIT_XOR_EXPR:
10729       if (integer_zerop (arg1))
10730         return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
10731       if (integer_all_onesp (arg1))
10732         return fold_build1_loc (loc, BIT_NOT_EXPR, type, op0);
10733       if (operand_equal_p (arg0, arg1, 0))
10734         return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
10735
10736       /* ~X ^ X is -1.  */
10737       if (TREE_CODE (arg0) == BIT_NOT_EXPR
10738           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
10739         {
10740           t1 = build_zero_cst (type);
10741           t1 = fold_unary_loc (loc, BIT_NOT_EXPR, type, t1);
10742           return omit_one_operand_loc (loc, type, t1, arg1);
10743         }
10744
10745       /* X ^ ~X is -1.  */
10746       if (TREE_CODE (arg1) == BIT_NOT_EXPR
10747           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
10748         {
10749           t1 = build_zero_cst (type);
10750           t1 = fold_unary_loc (loc, BIT_NOT_EXPR, type, t1);
10751           return omit_one_operand_loc (loc, type, t1, arg0);
10752         }
10753
10754       /* If we are XORing two BIT_AND_EXPR's, both of which are and'ing
10755          with a constant, and the two constants have no bits in common,
10756          we should treat this as a BIT_IOR_EXPR since this may produce more
10757          simplifications.  */
10758       if (TREE_CODE (arg0) == BIT_AND_EXPR
10759           && TREE_CODE (arg1) == BIT_AND_EXPR
10760           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
10761           && TREE_CODE (TREE_OPERAND (arg1, 1)) == INTEGER_CST
10762           && integer_zerop (const_binop (BIT_AND_EXPR,
10763                                          TREE_OPERAND (arg0, 1),
10764                                          TREE_OPERAND (arg1, 1))))
10765         {
10766           code = BIT_IOR_EXPR;
10767           goto bit_ior;
10768         }
10769
10770       /* (X | Y) ^ X -> Y & ~ X*/
10771       if (TREE_CODE (arg0) == BIT_IOR_EXPR
10772           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
10773         {
10774           tree t2 = TREE_OPERAND (arg0, 1);
10775           t1 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (arg1),
10776                             arg1);
10777           t1 = fold_build2_loc (loc, BIT_AND_EXPR, type,
10778                             fold_convert_loc (loc, type, t2),
10779                             fold_convert_loc (loc, type, t1));
10780           return t1;
10781         }
10782
10783       /* (Y | X) ^ X -> Y & ~ X*/
10784       if (TREE_CODE (arg0) == BIT_IOR_EXPR
10785           && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
10786         {
10787           tree t2 = TREE_OPERAND (arg0, 0);
10788           t1 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (arg1),
10789                             arg1);
10790           t1 = fold_build2_loc (loc, BIT_AND_EXPR, type,
10791                             fold_convert_loc (loc, type, t2),
10792                             fold_convert_loc (loc, type, t1));
10793           return t1;
10794         }
10795
10796       /* X ^ (X | Y) -> Y & ~ X*/
10797       if (TREE_CODE (arg1) == BIT_IOR_EXPR
10798           && operand_equal_p (TREE_OPERAND (arg1, 0), arg0, 0))
10799         {
10800           tree t2 = TREE_OPERAND (arg1, 1);
10801           t1 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (arg0),
10802                             arg0);
10803           t1 = fold_build2_loc (loc, BIT_AND_EXPR, type,
10804                             fold_convert_loc (loc, type, t2),
10805                             fold_convert_loc (loc, type, t1));
10806           return t1;
10807         }
10808
10809       /* X ^ (Y | X) -> Y & ~ X*/
10810       if (TREE_CODE (arg1) == BIT_IOR_EXPR
10811           && operand_equal_p (TREE_OPERAND (arg1, 1), arg0, 0))
10812         {
10813           tree t2 = TREE_OPERAND (arg1, 0);
10814           t1 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (arg0),
10815                             arg0);
10816           t1 = fold_build2_loc (loc, BIT_AND_EXPR, type,
10817                             fold_convert_loc (loc, type, t2),
10818                             fold_convert_loc (loc, type, t1));
10819           return t1;
10820         }
10821
10822       /* Convert ~X ^ ~Y to X ^ Y.  */
10823       if (TREE_CODE (arg0) == BIT_NOT_EXPR
10824           && TREE_CODE (arg1) == BIT_NOT_EXPR)
10825         return fold_build2_loc (loc, code, type,
10826                             fold_convert_loc (loc, type,
10827                                               TREE_OPERAND (arg0, 0)),
10828                             fold_convert_loc (loc, type,
10829                                               TREE_OPERAND (arg1, 0)));
10830
10831       /* Convert ~X ^ C to X ^ ~C.  */
10832       if (TREE_CODE (arg0) == BIT_NOT_EXPR
10833           && TREE_CODE (arg1) == INTEGER_CST)
10834         return fold_build2_loc (loc, code, type,
10835                             fold_convert_loc (loc, type,
10836                                               TREE_OPERAND (arg0, 0)),
10837                             fold_build1_loc (loc, BIT_NOT_EXPR, type, arg1));
10838
10839       /* Fold (X & 1) ^ 1 as (X & 1) == 0.  */
10840       if (TREE_CODE (arg0) == BIT_AND_EXPR
10841           && integer_onep (TREE_OPERAND (arg0, 1))
10842           && integer_onep (arg1))
10843         return fold_build2_loc (loc, EQ_EXPR, type, arg0,
10844                             build_int_cst (TREE_TYPE (arg0), 0));
10845
10846       /* Fold (X & Y) ^ Y as ~X & Y.  */
10847       if (TREE_CODE (arg0) == BIT_AND_EXPR
10848           && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
10849         {
10850           tem = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
10851           return fold_build2_loc (loc, BIT_AND_EXPR, type,
10852                               fold_build1_loc (loc, BIT_NOT_EXPR, type, tem),
10853                               fold_convert_loc (loc, type, arg1));
10854         }
10855       /* Fold (X & Y) ^ X as ~Y & X.  */
10856       if (TREE_CODE (arg0) == BIT_AND_EXPR
10857           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
10858           && reorder_operands_p (TREE_OPERAND (arg0, 1), arg1))
10859         {
10860           tem = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 1));
10861           return fold_build2_loc (loc, BIT_AND_EXPR, type,
10862                               fold_build1_loc (loc, BIT_NOT_EXPR, type, tem),
10863                               fold_convert_loc (loc, type, arg1));
10864         }
10865       /* Fold X ^ (X & Y) as X & ~Y.  */
10866       if (TREE_CODE (arg1) == BIT_AND_EXPR
10867           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
10868         {
10869           tem = fold_convert_loc (loc, type, TREE_OPERAND (arg1, 1));
10870           return fold_build2_loc (loc, BIT_AND_EXPR, type,
10871                               fold_convert_loc (loc, type, arg0),
10872                               fold_build1_loc (loc, BIT_NOT_EXPR, type, tem));
10873         }
10874       /* Fold X ^ (Y & X) as ~Y & X.  */
10875       if (TREE_CODE (arg1) == BIT_AND_EXPR
10876           && operand_equal_p (arg0, TREE_OPERAND (arg1, 1), 0)
10877           && reorder_operands_p (arg0, TREE_OPERAND (arg1, 0)))
10878         {
10879           tem = fold_convert_loc (loc, type, TREE_OPERAND (arg1, 0));
10880           return fold_build2_loc (loc, BIT_AND_EXPR, type,
10881                               fold_build1_loc (loc, BIT_NOT_EXPR, type, tem),
10882                               fold_convert_loc (loc, type, arg0));
10883         }
10884
10885       /* See if this can be simplified into a rotate first.  If that
10886          is unsuccessful continue in the association code.  */
10887       goto bit_rotate;
10888
10889     case BIT_AND_EXPR:
10890       if (integer_all_onesp (arg1))
10891         return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
10892       if (integer_zerop (arg1))
10893         return omit_one_operand_loc (loc, type, arg1, arg0);
10894       if (operand_equal_p (arg0, arg1, 0))
10895         return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
10896
10897       /* ~X & X is always zero.  */
10898       if (TREE_CODE (arg0) == BIT_NOT_EXPR
10899           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
10900         return omit_one_operand_loc (loc, type, integer_zero_node, arg1);
10901
10902       /* X & ~X is always zero.  */
10903       if (TREE_CODE (arg1) == BIT_NOT_EXPR
10904           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
10905         return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
10906
10907       /* Canonicalize (X | C1) & C2 as (X & C2) | (C1 & C2).  */
10908       if (TREE_CODE (arg0) == BIT_IOR_EXPR
10909           && TREE_CODE (arg1) == INTEGER_CST
10910           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
10911         {
10912           tree tmp1 = fold_convert_loc (loc, type, arg1);
10913           tree tmp2 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
10914           tree tmp3 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 1));
10915           tmp2 = fold_build2_loc (loc, BIT_AND_EXPR, type, tmp2, tmp1);
10916           tmp3 = fold_build2_loc (loc, BIT_AND_EXPR, type, tmp3, tmp1);
10917           return
10918             fold_convert_loc (loc, type,
10919                               fold_build2_loc (loc, BIT_IOR_EXPR,
10920                                            type, tmp2, tmp3));
10921         }
10922
10923       /* (X | Y) & Y is (X, Y).  */
10924       if (TREE_CODE (arg0) == BIT_IOR_EXPR
10925           && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
10926         return omit_one_operand_loc (loc, type, arg1, TREE_OPERAND (arg0, 0));
10927       /* (X | Y) & X is (Y, X).  */
10928       if (TREE_CODE (arg0) == BIT_IOR_EXPR
10929           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
10930           && reorder_operands_p (TREE_OPERAND (arg0, 1), arg1))
10931         return omit_one_operand_loc (loc, type, arg1, TREE_OPERAND (arg0, 1));
10932       /* X & (X | Y) is (Y, X).  */
10933       if (TREE_CODE (arg1) == BIT_IOR_EXPR
10934           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0)
10935           && reorder_operands_p (arg0, TREE_OPERAND (arg1, 1)))
10936         return omit_one_operand_loc (loc, type, arg0, TREE_OPERAND (arg1, 1));
10937       /* X & (Y | X) is (Y, X).  */
10938       if (TREE_CODE (arg1) == BIT_IOR_EXPR
10939           && operand_equal_p (arg0, TREE_OPERAND (arg1, 1), 0)
10940           && reorder_operands_p (arg0, TREE_OPERAND (arg1, 0)))
10941         return omit_one_operand_loc (loc, type, arg0, TREE_OPERAND (arg1, 0));
10942
10943       /* Fold (X ^ 1) & 1 as (X & 1) == 0.  */
10944       if (TREE_CODE (arg0) == BIT_XOR_EXPR
10945           && integer_onep (TREE_OPERAND (arg0, 1))
10946           && integer_onep (arg1))
10947         {
10948           tem = TREE_OPERAND (arg0, 0);
10949           return fold_build2_loc (loc, EQ_EXPR, type,
10950                               fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (tem), tem,
10951                                            build_int_cst (TREE_TYPE (tem), 1)),
10952                               build_int_cst (TREE_TYPE (tem), 0));
10953         }
10954       /* Fold ~X & 1 as (X & 1) == 0.  */
10955       if (TREE_CODE (arg0) == BIT_NOT_EXPR
10956           && integer_onep (arg1))
10957         {
10958           tem = TREE_OPERAND (arg0, 0);
10959           return fold_build2_loc (loc, EQ_EXPR, type,
10960                               fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (tem), tem,
10961                                            build_int_cst (TREE_TYPE (tem), 1)),
10962                               build_int_cst (TREE_TYPE (tem), 0));
10963         }
10964
10965       /* Fold (X ^ Y) & Y as ~X & Y.  */
10966       if (TREE_CODE (arg0) == BIT_XOR_EXPR
10967           && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
10968         {
10969           tem = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
10970           return fold_build2_loc (loc, BIT_AND_EXPR, type,
10971                               fold_build1_loc (loc, BIT_NOT_EXPR, type, tem),
10972                               fold_convert_loc (loc, type, arg1));
10973         }
10974       /* Fold (X ^ Y) & X as ~Y & X.  */
10975       if (TREE_CODE (arg0) == BIT_XOR_EXPR
10976           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
10977           && reorder_operands_p (TREE_OPERAND (arg0, 1), arg1))
10978         {
10979           tem = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 1));
10980           return fold_build2_loc (loc, BIT_AND_EXPR, type,
10981                               fold_build1_loc (loc, BIT_NOT_EXPR, type, tem),
10982                               fold_convert_loc (loc, type, arg1));
10983         }
10984       /* Fold X & (X ^ Y) as X & ~Y.  */
10985       if (TREE_CODE (arg1) == BIT_XOR_EXPR
10986           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
10987         {
10988           tem = fold_convert_loc (loc, type, TREE_OPERAND (arg1, 1));
10989           return fold_build2_loc (loc, BIT_AND_EXPR, type,
10990                               fold_convert_loc (loc, type, arg0),
10991                               fold_build1_loc (loc, BIT_NOT_EXPR, type, tem));
10992         }
10993       /* Fold X & (Y ^ X) as ~Y & X.  */
10994       if (TREE_CODE (arg1) == BIT_XOR_EXPR
10995           && operand_equal_p (arg0, TREE_OPERAND (arg1, 1), 0)
10996           && reorder_operands_p (arg0, TREE_OPERAND (arg1, 0)))
10997         {
10998           tem = fold_convert_loc (loc, type, TREE_OPERAND (arg1, 0));
10999           return fold_build2_loc (loc, BIT_AND_EXPR, type,
11000                               fold_build1_loc (loc, BIT_NOT_EXPR, type, tem),
11001                               fold_convert_loc (loc, type, arg0));
11002         }
11003
11004       /* For constants M and N, if M == (1LL << cst) - 1 && (N & M) == M,
11005          ((A & N) + B) & M -> (A + B) & M
11006          Similarly if (N & M) == 0,
11007          ((A | N) + B) & M -> (A + B) & M
11008          and for - instead of + (or unary - instead of +)
11009          and/or ^ instead of |.
11010          If B is constant and (B & M) == 0, fold into A & M.  */
11011       if (host_integerp (arg1, 1))
11012         {
11013           unsigned HOST_WIDE_INT cst1 = tree_low_cst (arg1, 1);
11014           if (~cst1 && (cst1 & (cst1 + 1)) == 0
11015               && INTEGRAL_TYPE_P (TREE_TYPE (arg0))
11016               && (TREE_CODE (arg0) == PLUS_EXPR
11017                   || TREE_CODE (arg0) == MINUS_EXPR
11018                   || TREE_CODE (arg0) == NEGATE_EXPR)
11019               && (TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg0))
11020                   || TREE_CODE (TREE_TYPE (arg0)) == INTEGER_TYPE))
11021             {
11022               tree pmop[2];
11023               int which = 0;
11024               unsigned HOST_WIDE_INT cst0;
11025
11026               /* Now we know that arg0 is (C + D) or (C - D) or
11027                  -C and arg1 (M) is == (1LL << cst) - 1.
11028                  Store C into PMOP[0] and D into PMOP[1].  */
11029               pmop[0] = TREE_OPERAND (arg0, 0);
11030               pmop[1] = NULL;
11031               if (TREE_CODE (arg0) != NEGATE_EXPR)
11032                 {
11033                   pmop[1] = TREE_OPERAND (arg0, 1);
11034                   which = 1;
11035                 }
11036
11037               if (!host_integerp (TYPE_MAX_VALUE (TREE_TYPE (arg0)), 1)
11038                   || (tree_low_cst (TYPE_MAX_VALUE (TREE_TYPE (arg0)), 1)
11039                       & cst1) != cst1)
11040                 which = -1;
11041
11042               for (; which >= 0; which--)
11043                 switch (TREE_CODE (pmop[which]))
11044                   {
11045                   case BIT_AND_EXPR:
11046                   case BIT_IOR_EXPR:
11047                   case BIT_XOR_EXPR:
11048                     if (TREE_CODE (TREE_OPERAND (pmop[which], 1))
11049                         != INTEGER_CST)
11050                       break;
11051                     /* tree_low_cst not used, because we don't care about
11052                        the upper bits.  */
11053                     cst0 = TREE_INT_CST_LOW (TREE_OPERAND (pmop[which], 1));
11054                     cst0 &= cst1;
11055                     if (TREE_CODE (pmop[which]) == BIT_AND_EXPR)
11056                       {
11057                         if (cst0 != cst1)
11058                           break;
11059                       }
11060                     else if (cst0 != 0)
11061                       break;
11062                     /* If C or D is of the form (A & N) where
11063                        (N & M) == M, or of the form (A | N) or
11064                        (A ^ N) where (N & M) == 0, replace it with A.  */
11065                     pmop[which] = TREE_OPERAND (pmop[which], 0);
11066                     break;
11067                   case INTEGER_CST:
11068                     /* If C or D is a N where (N & M) == 0, it can be
11069                        omitted (assumed 0).  */
11070                     if ((TREE_CODE (arg0) == PLUS_EXPR
11071                          || (TREE_CODE (arg0) == MINUS_EXPR && which == 0))
11072                         && (TREE_INT_CST_LOW (pmop[which]) & cst1) == 0)
11073                       pmop[which] = NULL;
11074                     break;
11075                   default:
11076                     break;
11077                   }
11078
11079               /* Only build anything new if we optimized one or both arguments
11080                  above.  */
11081               if (pmop[0] != TREE_OPERAND (arg0, 0)
11082                   || (TREE_CODE (arg0) != NEGATE_EXPR
11083                       && pmop[1] != TREE_OPERAND (arg0, 1)))
11084                 {
11085                   tree utype = TREE_TYPE (arg0);
11086                   if (! TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg0)))
11087                     {
11088                       /* Perform the operations in a type that has defined
11089                          overflow behavior.  */
11090                       utype = unsigned_type_for (TREE_TYPE (arg0));
11091                       if (pmop[0] != NULL)
11092                         pmop[0] = fold_convert_loc (loc, utype, pmop[0]);
11093                       if (pmop[1] != NULL)
11094                         pmop[1] = fold_convert_loc (loc, utype, pmop[1]);
11095                     }
11096
11097                   if (TREE_CODE (arg0) == NEGATE_EXPR)
11098                     tem = fold_build1_loc (loc, NEGATE_EXPR, utype, pmop[0]);
11099                   else if (TREE_CODE (arg0) == PLUS_EXPR)
11100                     {
11101                       if (pmop[0] != NULL && pmop[1] != NULL)
11102                         tem = fold_build2_loc (loc, PLUS_EXPR, utype,
11103                                                pmop[0], pmop[1]);
11104                       else if (pmop[0] != NULL)
11105                         tem = pmop[0];
11106                       else if (pmop[1] != NULL)
11107                         tem = pmop[1];
11108                       else
11109                         return build_int_cst (type, 0);
11110                     }
11111                   else if (pmop[0] == NULL)
11112                     tem = fold_build1_loc (loc, NEGATE_EXPR, utype, pmop[1]);
11113                   else
11114                     tem = fold_build2_loc (loc, MINUS_EXPR, utype,
11115                                            pmop[0], pmop[1]);
11116                   /* TEM is now the new binary +, - or unary - replacement.  */
11117                   tem = fold_build2_loc (loc, BIT_AND_EXPR, utype, tem,
11118                                          fold_convert_loc (loc, utype, arg1));
11119                   return fold_convert_loc (loc, type, tem);
11120                 }
11121             }
11122         }
11123
11124       t1 = distribute_bit_expr (loc, code, type, arg0, arg1);
11125       if (t1 != NULL_TREE)
11126         return t1;
11127       /* Simplify ((int)c & 0377) into (int)c, if c is unsigned char.  */
11128       if (TREE_CODE (arg1) == INTEGER_CST && TREE_CODE (arg0) == NOP_EXPR
11129           && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg0, 0))))
11130         {
11131           unsigned int prec
11132             = TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0)));
11133
11134           if (prec < BITS_PER_WORD && prec < HOST_BITS_PER_WIDE_INT
11135               && (~TREE_INT_CST_LOW (arg1)
11136                   & (((HOST_WIDE_INT) 1 << prec) - 1)) == 0)
11137             return
11138               fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
11139         }
11140
11141       /* Convert (and (not arg0) (not arg1)) to (not (or (arg0) (arg1))).
11142
11143          This results in more efficient code for machines without a NOR
11144          instruction.  Combine will canonicalize to the first form
11145          which will allow use of NOR instructions provided by the
11146          backend if they exist.  */
11147       if (TREE_CODE (arg0) == BIT_NOT_EXPR
11148           && TREE_CODE (arg1) == BIT_NOT_EXPR)
11149         {
11150           return fold_build1_loc (loc, BIT_NOT_EXPR, type,
11151                               build2 (BIT_IOR_EXPR, type,
11152                                       fold_convert_loc (loc, type,
11153                                                         TREE_OPERAND (arg0, 0)),
11154                                       fold_convert_loc (loc, type,
11155                                                         TREE_OPERAND (arg1, 0))));
11156         }
11157
11158       /* If arg0 is derived from the address of an object or function, we may
11159          be able to fold this expression using the object or function's
11160          alignment.  */
11161       if (POINTER_TYPE_P (TREE_TYPE (arg0)) && host_integerp (arg1, 1))
11162         {
11163           unsigned HOST_WIDE_INT modulus, residue;
11164           unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (arg1);
11165
11166           modulus = get_pointer_modulus_and_residue (arg0, &residue,
11167                                                      integer_onep (arg1));
11168
11169           /* This works because modulus is a power of 2.  If this weren't the
11170              case, we'd have to replace it by its greatest power-of-2
11171              divisor: modulus & -modulus.  */
11172           if (low < modulus)
11173             return build_int_cst (type, residue & low);
11174         }
11175
11176       /* Fold (X << C1) & C2 into (X << C1) & (C2 | ((1 << C1) - 1))
11177               (X >> C1) & C2 into (X >> C1) & (C2 | ~((type) -1 >> C1))
11178          if the new mask might be further optimized.  */
11179       if ((TREE_CODE (arg0) == LSHIFT_EXPR
11180            || TREE_CODE (arg0) == RSHIFT_EXPR)
11181           && host_integerp (TREE_OPERAND (arg0, 1), 1)
11182           && host_integerp (arg1, TYPE_UNSIGNED (TREE_TYPE (arg1)))
11183           && tree_low_cst (TREE_OPERAND (arg0, 1), 1)
11184              < TYPE_PRECISION (TREE_TYPE (arg0))
11185           && TYPE_PRECISION (TREE_TYPE (arg0)) <= HOST_BITS_PER_WIDE_INT
11186           && tree_low_cst (TREE_OPERAND (arg0, 1), 1) > 0)
11187         {
11188           unsigned int shiftc = tree_low_cst (TREE_OPERAND (arg0, 1), 1);
11189           unsigned HOST_WIDE_INT mask
11190             = tree_low_cst (arg1, TYPE_UNSIGNED (TREE_TYPE (arg1)));
11191           unsigned HOST_WIDE_INT newmask, zerobits = 0;
11192           tree shift_type = TREE_TYPE (arg0);
11193
11194           if (TREE_CODE (arg0) == LSHIFT_EXPR)
11195             zerobits = ((((unsigned HOST_WIDE_INT) 1) << shiftc) - 1);
11196           else if (TREE_CODE (arg0) == RSHIFT_EXPR
11197                    && TYPE_PRECISION (TREE_TYPE (arg0))
11198                       == GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (arg0))))
11199             {
11200               unsigned int prec = TYPE_PRECISION (TREE_TYPE (arg0));
11201               tree arg00 = TREE_OPERAND (arg0, 0);
11202               /* See if more bits can be proven as zero because of
11203                  zero extension.  */
11204               if (TREE_CODE (arg00) == NOP_EXPR
11205                   && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg00, 0))))
11206                 {
11207                   tree inner_type = TREE_TYPE (TREE_OPERAND (arg00, 0));
11208                   if (TYPE_PRECISION (inner_type)
11209                       == GET_MODE_BITSIZE (TYPE_MODE (inner_type))
11210                       && TYPE_PRECISION (inner_type) < prec)
11211                     {
11212                       prec = TYPE_PRECISION (inner_type);
11213                       /* See if we can shorten the right shift.  */
11214                       if (shiftc < prec)
11215                         shift_type = inner_type;
11216                     }
11217                 }
11218               zerobits = ~(unsigned HOST_WIDE_INT) 0;
11219               zerobits >>= HOST_BITS_PER_WIDE_INT - shiftc;
11220               zerobits <<= prec - shiftc;
11221               /* For arithmetic shift if sign bit could be set, zerobits
11222                  can contain actually sign bits, so no transformation is
11223                  possible, unless MASK masks them all away.  In that
11224                  case the shift needs to be converted into logical shift.  */
11225               if (!TYPE_UNSIGNED (TREE_TYPE (arg0))
11226                   && prec == TYPE_PRECISION (TREE_TYPE (arg0)))
11227                 {
11228                   if ((mask & zerobits) == 0)
11229                     shift_type = unsigned_type_for (TREE_TYPE (arg0));
11230                   else
11231                     zerobits = 0;
11232                 }
11233             }
11234
11235           /* ((X << 16) & 0xff00) is (X, 0).  */
11236           if ((mask & zerobits) == mask)
11237             return omit_one_operand_loc (loc, type,
11238                                      build_int_cst (type, 0), arg0);
11239
11240           newmask = mask | zerobits;
11241           if (newmask != mask && (newmask & (newmask + 1)) == 0)
11242             {
11243               unsigned int prec;
11244
11245               /* Only do the transformation if NEWMASK is some integer
11246                  mode's mask.  */
11247               for (prec = BITS_PER_UNIT;
11248                    prec < HOST_BITS_PER_WIDE_INT; prec <<= 1)
11249                 if (newmask == (((unsigned HOST_WIDE_INT) 1) << prec) - 1)
11250                   break;
11251               if (prec < HOST_BITS_PER_WIDE_INT
11252                   || newmask == ~(unsigned HOST_WIDE_INT) 0)
11253                 {
11254                   tree newmaskt;
11255
11256                   if (shift_type != TREE_TYPE (arg0))
11257                     {
11258                       tem = fold_build2_loc (loc, TREE_CODE (arg0), shift_type,
11259                                          fold_convert_loc (loc, shift_type,
11260                                                            TREE_OPERAND (arg0, 0)),
11261                                          TREE_OPERAND (arg0, 1));
11262                       tem = fold_convert_loc (loc, type, tem);
11263                     }
11264                   else
11265                     tem = op0;
11266                   newmaskt = build_int_cst_type (TREE_TYPE (op1), newmask);
11267                   if (!tree_int_cst_equal (newmaskt, arg1))
11268                     return fold_build2_loc (loc, BIT_AND_EXPR, type, tem, newmaskt);
11269                 }
11270             }
11271         }
11272
11273       goto associate;
11274
11275     case RDIV_EXPR:
11276       /* Don't touch a floating-point divide by zero unless the mode
11277          of the constant can represent infinity.  */
11278       if (TREE_CODE (arg1) == REAL_CST
11279           && !MODE_HAS_INFINITIES (TYPE_MODE (TREE_TYPE (arg1)))
11280           && real_zerop (arg1))
11281         return NULL_TREE;
11282
11283       /* Optimize A / A to 1.0 if we don't care about
11284          NaNs or Infinities.  Skip the transformation
11285          for non-real operands.  */
11286       if (SCALAR_FLOAT_TYPE_P (TREE_TYPE (arg0))
11287           && ! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0)))
11288           && ! HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg0)))
11289           && operand_equal_p (arg0, arg1, 0))
11290         {
11291           tree r = build_real (TREE_TYPE (arg0), dconst1);
11292
11293           return omit_two_operands_loc (loc, type, r, arg0, arg1);
11294         }
11295
11296       /* The complex version of the above A / A optimization.  */
11297       if (COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0))
11298           && operand_equal_p (arg0, arg1, 0))
11299         {
11300           tree elem_type = TREE_TYPE (TREE_TYPE (arg0));
11301           if (! HONOR_NANS (TYPE_MODE (elem_type))
11302               && ! HONOR_INFINITIES (TYPE_MODE (elem_type)))
11303             {
11304               tree r = build_real (elem_type, dconst1);
11305               /* omit_two_operands will call fold_convert for us.  */
11306               return omit_two_operands_loc (loc, type, r, arg0, arg1);
11307             }
11308         }
11309
11310       /* (-A) / (-B) -> A / B  */
11311       if (TREE_CODE (arg0) == NEGATE_EXPR && negate_expr_p (arg1))
11312         return fold_build2_loc (loc, RDIV_EXPR, type,
11313                             TREE_OPERAND (arg0, 0),
11314                             negate_expr (arg1));
11315       if (TREE_CODE (arg1) == NEGATE_EXPR && negate_expr_p (arg0))
11316         return fold_build2_loc (loc, RDIV_EXPR, type,
11317                             negate_expr (arg0),
11318                             TREE_OPERAND (arg1, 0));
11319
11320       /* In IEEE floating point, x/1 is not equivalent to x for snans.  */
11321       if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
11322           && real_onep (arg1))
11323         return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
11324
11325       /* In IEEE floating point, x/-1 is not equivalent to -x for snans.  */
11326       if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
11327           && real_minus_onep (arg1))
11328         return non_lvalue_loc (loc, fold_convert_loc (loc, type,
11329                                                   negate_expr (arg0)));
11330
11331       /* If ARG1 is a constant, we can convert this to a multiply by the
11332          reciprocal.  This does not have the same rounding properties,
11333          so only do this if -freciprocal-math.  We can actually
11334          always safely do it if ARG1 is a power of two, but it's hard to
11335          tell if it is or not in a portable manner.  */
11336       if (TREE_CODE (arg1) == REAL_CST)
11337         {
11338           if (flag_reciprocal_math
11339               && 0 != (tem = const_binop (code, build_real (type, dconst1),
11340                                           arg1)))
11341             return fold_build2_loc (loc, MULT_EXPR, type, arg0, tem);
11342           /* Find the reciprocal if optimizing and the result is exact.  */
11343           if (optimize)
11344             {
11345               REAL_VALUE_TYPE r;
11346               r = TREE_REAL_CST (arg1);
11347               if (exact_real_inverse (TYPE_MODE(TREE_TYPE(arg0)), &r))
11348                 {
11349                   tem = build_real (type, r);
11350                   return fold_build2_loc (loc, MULT_EXPR, type,
11351                                       fold_convert_loc (loc, type, arg0), tem);
11352                 }
11353             }
11354         }
11355       /* Convert A/B/C to A/(B*C).  */
11356       if (flag_reciprocal_math
11357           && TREE_CODE (arg0) == RDIV_EXPR)
11358         return fold_build2_loc (loc, RDIV_EXPR, type, TREE_OPERAND (arg0, 0),
11359                             fold_build2_loc (loc, MULT_EXPR, type,
11360                                          TREE_OPERAND (arg0, 1), arg1));
11361
11362       /* Convert A/(B/C) to (A/B)*C.  */
11363       if (flag_reciprocal_math
11364           && TREE_CODE (arg1) == RDIV_EXPR)
11365         return fold_build2_loc (loc, MULT_EXPR, type,
11366                             fold_build2_loc (loc, RDIV_EXPR, type, arg0,
11367                                          TREE_OPERAND (arg1, 0)),
11368                             TREE_OPERAND (arg1, 1));
11369
11370       /* Convert C1/(X*C2) into (C1/C2)/X.  */
11371       if (flag_reciprocal_math
11372           && TREE_CODE (arg1) == MULT_EXPR
11373           && TREE_CODE (arg0) == REAL_CST
11374           && TREE_CODE (TREE_OPERAND (arg1, 1)) == REAL_CST)
11375         {
11376           tree tem = const_binop (RDIV_EXPR, arg0,
11377                                   TREE_OPERAND (arg1, 1));
11378           if (tem)
11379             return fold_build2_loc (loc, RDIV_EXPR, type, tem,
11380                                 TREE_OPERAND (arg1, 0));
11381         }
11382
11383       if (flag_unsafe_math_optimizations)
11384         {
11385           enum built_in_function fcode0 = builtin_mathfn_code (arg0);
11386           enum built_in_function fcode1 = builtin_mathfn_code (arg1);
11387
11388           /* Optimize sin(x)/cos(x) as tan(x).  */
11389           if (((fcode0 == BUILT_IN_SIN && fcode1 == BUILT_IN_COS)
11390                || (fcode0 == BUILT_IN_SINF && fcode1 == BUILT_IN_COSF)
11391                || (fcode0 == BUILT_IN_SINL && fcode1 == BUILT_IN_COSL))
11392               && operand_equal_p (CALL_EXPR_ARG (arg0, 0),
11393                                   CALL_EXPR_ARG (arg1, 0), 0))
11394             {
11395               tree tanfn = mathfn_built_in (type, BUILT_IN_TAN);
11396
11397               if (tanfn != NULL_TREE)
11398                 return build_call_expr_loc (loc, tanfn, 1, CALL_EXPR_ARG (arg0, 0));
11399             }
11400
11401           /* Optimize cos(x)/sin(x) as 1.0/tan(x).  */
11402           if (((fcode0 == BUILT_IN_COS && fcode1 == BUILT_IN_SIN)
11403                || (fcode0 == BUILT_IN_COSF && fcode1 == BUILT_IN_SINF)
11404                || (fcode0 == BUILT_IN_COSL && fcode1 == BUILT_IN_SINL))
11405               && operand_equal_p (CALL_EXPR_ARG (arg0, 0),
11406                                   CALL_EXPR_ARG (arg1, 0), 0))
11407             {
11408               tree tanfn = mathfn_built_in (type, BUILT_IN_TAN);
11409
11410               if (tanfn != NULL_TREE)
11411                 {
11412                   tree tmp = build_call_expr_loc (loc, tanfn, 1,
11413                                               CALL_EXPR_ARG (arg0, 0));
11414                   return fold_build2_loc (loc, RDIV_EXPR, type,
11415                                       build_real (type, dconst1), tmp);
11416                 }
11417             }
11418
11419           /* Optimize sin(x)/tan(x) as cos(x) if we don't care about
11420              NaNs or Infinities.  */
11421           if (((fcode0 == BUILT_IN_SIN && fcode1 == BUILT_IN_TAN)
11422                || (fcode0 == BUILT_IN_SINF && fcode1 == BUILT_IN_TANF)
11423                || (fcode0 == BUILT_IN_SINL && fcode1 == BUILT_IN_TANL)))
11424             {
11425               tree arg00 = CALL_EXPR_ARG (arg0, 0);
11426               tree arg01 = CALL_EXPR_ARG (arg1, 0);
11427
11428               if (! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg00)))
11429                   && ! HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg00)))
11430                   && operand_equal_p (arg00, arg01, 0))
11431                 {
11432                   tree cosfn = mathfn_built_in (type, BUILT_IN_COS);
11433
11434                   if (cosfn != NULL_TREE)
11435                     return build_call_expr_loc (loc, cosfn, 1, arg00);
11436                 }
11437             }
11438
11439           /* Optimize tan(x)/sin(x) as 1.0/cos(x) if we don't care about
11440              NaNs or Infinities.  */
11441           if (((fcode0 == BUILT_IN_TAN && fcode1 == BUILT_IN_SIN)
11442                || (fcode0 == BUILT_IN_TANF && fcode1 == BUILT_IN_SINF)
11443                || (fcode0 == BUILT_IN_TANL && fcode1 == BUILT_IN_SINL)))
11444             {
11445               tree arg00 = CALL_EXPR_ARG (arg0, 0);
11446               tree arg01 = CALL_EXPR_ARG (arg1, 0);
11447
11448               if (! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg00)))
11449                   && ! HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg00)))
11450                   && operand_equal_p (arg00, arg01, 0))
11451                 {
11452                   tree cosfn = mathfn_built_in (type, BUILT_IN_COS);
11453
11454                   if (cosfn != NULL_TREE)
11455                     {
11456                       tree tmp = build_call_expr_loc (loc, cosfn, 1, arg00);
11457                       return fold_build2_loc (loc, RDIV_EXPR, type,
11458                                           build_real (type, dconst1),
11459                                           tmp);
11460                     }
11461                 }
11462             }
11463
11464           /* Optimize pow(x,c)/x as pow(x,c-1).  */
11465           if (fcode0 == BUILT_IN_POW
11466               || fcode0 == BUILT_IN_POWF
11467               || fcode0 == BUILT_IN_POWL)
11468             {
11469               tree arg00 = CALL_EXPR_ARG (arg0, 0);
11470               tree arg01 = CALL_EXPR_ARG (arg0, 1);
11471               if (TREE_CODE (arg01) == REAL_CST
11472                   && !TREE_OVERFLOW (arg01)
11473                   && operand_equal_p (arg1, arg00, 0))
11474                 {
11475                   tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg0), 0);
11476                   REAL_VALUE_TYPE c;
11477                   tree arg;
11478
11479                   c = TREE_REAL_CST (arg01);
11480                   real_arithmetic (&c, MINUS_EXPR, &c, &dconst1);
11481                   arg = build_real (type, c);
11482                   return build_call_expr_loc (loc, powfn, 2, arg1, arg);
11483                 }
11484             }
11485
11486           /* Optimize a/root(b/c) into a*root(c/b).  */
11487           if (BUILTIN_ROOT_P (fcode1))
11488             {
11489               tree rootarg = CALL_EXPR_ARG (arg1, 0);
11490
11491               if (TREE_CODE (rootarg) == RDIV_EXPR)
11492                 {
11493                   tree rootfn = TREE_OPERAND (CALL_EXPR_FN (arg1), 0);
11494                   tree b = TREE_OPERAND (rootarg, 0);
11495                   tree c = TREE_OPERAND (rootarg, 1);
11496
11497                   tree tmp = fold_build2_loc (loc, RDIV_EXPR, type, c, b);
11498
11499                   tmp = build_call_expr_loc (loc, rootfn, 1, tmp);
11500                   return fold_build2_loc (loc, MULT_EXPR, type, arg0, tmp);
11501                 }
11502             }
11503
11504           /* Optimize x/expN(y) into x*expN(-y).  */
11505           if (BUILTIN_EXPONENT_P (fcode1))
11506             {
11507               tree expfn = TREE_OPERAND (CALL_EXPR_FN (arg1), 0);
11508               tree arg = negate_expr (CALL_EXPR_ARG (arg1, 0));
11509               arg1 = build_call_expr_loc (loc,
11510                                       expfn, 1,
11511                                       fold_convert_loc (loc, type, arg));
11512               return fold_build2_loc (loc, MULT_EXPR, type, arg0, arg1);
11513             }
11514
11515           /* Optimize x/pow(y,z) into x*pow(y,-z).  */
11516           if (fcode1 == BUILT_IN_POW
11517               || fcode1 == BUILT_IN_POWF
11518               || fcode1 == BUILT_IN_POWL)
11519             {
11520               tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg1), 0);
11521               tree arg10 = CALL_EXPR_ARG (arg1, 0);
11522               tree arg11 = CALL_EXPR_ARG (arg1, 1);
11523               tree neg11 = fold_convert_loc (loc, type,
11524                                              negate_expr (arg11));
11525               arg1 = build_call_expr_loc (loc, powfn, 2, arg10, neg11);
11526               return fold_build2_loc (loc, MULT_EXPR, type, arg0, arg1);
11527             }
11528         }
11529       return NULL_TREE;
11530
11531     case TRUNC_DIV_EXPR:
11532       /* Optimize (X & (-A)) / A where A is a power of 2,
11533          to X >> log2(A) */
11534       if (TREE_CODE (arg0) == BIT_AND_EXPR
11535           && !TYPE_UNSIGNED (type) && TREE_CODE (arg1) == INTEGER_CST
11536           && integer_pow2p (arg1) && tree_int_cst_sgn (arg1) > 0)
11537         {
11538           tree sum = fold_binary_loc (loc, PLUS_EXPR, TREE_TYPE (arg1),
11539                                       arg1, TREE_OPERAND (arg0, 1));
11540           if (sum && integer_zerop (sum)) {
11541             unsigned long pow2;
11542
11543             if (TREE_INT_CST_LOW (arg1))
11544               pow2 = exact_log2 (TREE_INT_CST_LOW (arg1));
11545             else
11546               pow2 = exact_log2 (TREE_INT_CST_HIGH (arg1))
11547                       + HOST_BITS_PER_WIDE_INT;
11548
11549             return fold_build2_loc (loc, RSHIFT_EXPR, type,
11550                           TREE_OPERAND (arg0, 0),
11551                           build_int_cst (NULL_TREE, pow2));
11552           }
11553         }
11554
11555       /* Fall thru */
11556
11557     case FLOOR_DIV_EXPR:
11558       /* Simplify A / (B << N) where A and B are positive and B is
11559          a power of 2, to A >> (N + log2(B)).  */
11560       strict_overflow_p = false;
11561       if (TREE_CODE (arg1) == LSHIFT_EXPR
11562           && (TYPE_UNSIGNED (type)
11563               || tree_expr_nonnegative_warnv_p (op0, &strict_overflow_p)))
11564         {
11565           tree sval = TREE_OPERAND (arg1, 0);
11566           if (integer_pow2p (sval) && tree_int_cst_sgn (sval) > 0)
11567             {
11568               tree sh_cnt = TREE_OPERAND (arg1, 1);
11569               unsigned long pow2;
11570
11571               if (TREE_INT_CST_LOW (sval))
11572                 pow2 = exact_log2 (TREE_INT_CST_LOW (sval));
11573               else
11574                 pow2 = exact_log2 (TREE_INT_CST_HIGH (sval))
11575                        + HOST_BITS_PER_WIDE_INT;
11576
11577               if (strict_overflow_p)
11578                 fold_overflow_warning (("assuming signed overflow does not "
11579                                         "occur when simplifying A / (B << N)"),
11580                                        WARN_STRICT_OVERFLOW_MISC);
11581
11582               sh_cnt = fold_build2_loc (loc, PLUS_EXPR, TREE_TYPE (sh_cnt),
11583                                     sh_cnt, build_int_cst (NULL_TREE, pow2));
11584               return fold_build2_loc (loc, RSHIFT_EXPR, type,
11585                                   fold_convert_loc (loc, type, arg0), sh_cnt);
11586             }
11587         }
11588
11589       /* For unsigned integral types, FLOOR_DIV_EXPR is the same as
11590          TRUNC_DIV_EXPR.  Rewrite into the latter in this case.  */
11591       if (INTEGRAL_TYPE_P (type)
11592           && TYPE_UNSIGNED (type)
11593           && code == FLOOR_DIV_EXPR)
11594         return fold_build2_loc (loc, TRUNC_DIV_EXPR, type, op0, op1);
11595
11596       /* Fall thru */
11597
11598     case ROUND_DIV_EXPR:
11599     case CEIL_DIV_EXPR:
11600     case EXACT_DIV_EXPR:
11601       if (integer_onep (arg1))
11602         return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
11603       if (integer_zerop (arg1))
11604         return NULL_TREE;
11605       /* X / -1 is -X.  */
11606       if (!TYPE_UNSIGNED (type)
11607           && TREE_CODE (arg1) == INTEGER_CST
11608           && TREE_INT_CST_LOW (arg1) == (unsigned HOST_WIDE_INT) -1
11609           && TREE_INT_CST_HIGH (arg1) == -1)
11610         return fold_convert_loc (loc, type, negate_expr (arg0));
11611
11612       /* Convert -A / -B to A / B when the type is signed and overflow is
11613          undefined.  */
11614       if ((!INTEGRAL_TYPE_P (type) || TYPE_OVERFLOW_UNDEFINED (type))
11615           && TREE_CODE (arg0) == NEGATE_EXPR
11616           && negate_expr_p (arg1))
11617         {
11618           if (INTEGRAL_TYPE_P (type))
11619             fold_overflow_warning (("assuming signed overflow does not occur "
11620                                     "when distributing negation across "
11621                                     "division"),
11622                                    WARN_STRICT_OVERFLOW_MISC);
11623           return fold_build2_loc (loc, code, type,
11624                               fold_convert_loc (loc, type,
11625                                                 TREE_OPERAND (arg0, 0)),
11626                               fold_convert_loc (loc, type,
11627                                                 negate_expr (arg1)));
11628         }
11629       if ((!INTEGRAL_TYPE_P (type) || TYPE_OVERFLOW_UNDEFINED (type))
11630           && TREE_CODE (arg1) == NEGATE_EXPR
11631           && negate_expr_p (arg0))
11632         {
11633           if (INTEGRAL_TYPE_P (type))
11634             fold_overflow_warning (("assuming signed overflow does not occur "
11635                                     "when distributing negation across "
11636                                     "division"),
11637                                    WARN_STRICT_OVERFLOW_MISC);
11638           return fold_build2_loc (loc, code, type,
11639                               fold_convert_loc (loc, type,
11640                                                 negate_expr (arg0)),
11641                               fold_convert_loc (loc, type,
11642                                                 TREE_OPERAND (arg1, 0)));
11643         }
11644
11645       /* If arg0 is a multiple of arg1, then rewrite to the fastest div
11646          operation, EXACT_DIV_EXPR.
11647
11648          Note that only CEIL_DIV_EXPR and FLOOR_DIV_EXPR are rewritten now.
11649          At one time others generated faster code, it's not clear if they do
11650          after the last round to changes to the DIV code in expmed.c.  */
11651       if ((code == CEIL_DIV_EXPR || code == FLOOR_DIV_EXPR)
11652           && multiple_of_p (type, arg0, arg1))
11653         return fold_build2_loc (loc, EXACT_DIV_EXPR, type, arg0, arg1);
11654
11655       strict_overflow_p = false;
11656       if (TREE_CODE (arg1) == INTEGER_CST
11657           && 0 != (tem = extract_muldiv (op0, arg1, code, NULL_TREE,
11658                                          &strict_overflow_p)))
11659         {
11660           if (strict_overflow_p)
11661             fold_overflow_warning (("assuming signed overflow does not occur "
11662                                     "when simplifying division"),
11663                                    WARN_STRICT_OVERFLOW_MISC);
11664           return fold_convert_loc (loc, type, tem);
11665         }
11666
11667       return NULL_TREE;
11668
11669     case CEIL_MOD_EXPR:
11670     case FLOOR_MOD_EXPR:
11671     case ROUND_MOD_EXPR:
11672     case TRUNC_MOD_EXPR:
11673       /* X % 1 is always zero, but be sure to preserve any side
11674          effects in X.  */
11675       if (integer_onep (arg1))
11676         return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
11677
11678       /* X % 0, return X % 0 unchanged so that we can get the
11679          proper warnings and errors.  */
11680       if (integer_zerop (arg1))
11681         return NULL_TREE;
11682
11683       /* 0 % X is always zero, but be sure to preserve any side
11684          effects in X.  Place this after checking for X == 0.  */
11685       if (integer_zerop (arg0))
11686         return omit_one_operand_loc (loc, type, integer_zero_node, arg1);
11687
11688       /* X % -1 is zero.  */
11689       if (!TYPE_UNSIGNED (type)
11690           && TREE_CODE (arg1) == INTEGER_CST
11691           && TREE_INT_CST_LOW (arg1) == (unsigned HOST_WIDE_INT) -1
11692           && TREE_INT_CST_HIGH (arg1) == -1)
11693         return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
11694
11695       /* X % -C is the same as X % C.  */
11696       if (code == TRUNC_MOD_EXPR
11697           && !TYPE_UNSIGNED (type)
11698           && TREE_CODE (arg1) == INTEGER_CST
11699           && !TREE_OVERFLOW (arg1)
11700           && TREE_INT_CST_HIGH (arg1) < 0
11701           && !TYPE_OVERFLOW_TRAPS (type)
11702           /* Avoid this transformation if C is INT_MIN, i.e. C == -C.  */
11703           && !sign_bit_p (arg1, arg1))
11704         return fold_build2_loc (loc, code, type,
11705                             fold_convert_loc (loc, type, arg0),
11706                             fold_convert_loc (loc, type,
11707                                               negate_expr (arg1)));
11708
11709       /* X % -Y is the same as X % Y.  */
11710       if (code == TRUNC_MOD_EXPR
11711           && !TYPE_UNSIGNED (type)
11712           && TREE_CODE (arg1) == NEGATE_EXPR
11713           && !TYPE_OVERFLOW_TRAPS (type))
11714         return fold_build2_loc (loc, code, type, fold_convert_loc (loc, type, arg0),
11715                             fold_convert_loc (loc, type,
11716                                               TREE_OPERAND (arg1, 0)));
11717
11718       strict_overflow_p = false;
11719       if (TREE_CODE (arg1) == INTEGER_CST
11720           && 0 != (tem = extract_muldiv (op0, arg1, code, NULL_TREE,
11721                                          &strict_overflow_p)))
11722         {
11723           if (strict_overflow_p)
11724             fold_overflow_warning (("assuming signed overflow does not occur "
11725                                     "when simplifying modulus"),
11726                                    WARN_STRICT_OVERFLOW_MISC);
11727           return fold_convert_loc (loc, type, tem);
11728         }
11729
11730       /* Optimize TRUNC_MOD_EXPR by a power of two into a BIT_AND_EXPR,
11731          i.e. "X % C" into "X & (C - 1)", if X and C are positive.  */
11732       if ((code == TRUNC_MOD_EXPR || code == FLOOR_MOD_EXPR)
11733           && (TYPE_UNSIGNED (type)
11734               || tree_expr_nonnegative_warnv_p (op0, &strict_overflow_p)))
11735         {
11736           tree c = arg1;
11737           /* Also optimize A % (C << N)  where C is a power of 2,
11738              to A & ((C << N) - 1).  */
11739           if (TREE_CODE (arg1) == LSHIFT_EXPR)
11740             c = TREE_OPERAND (arg1, 0);
11741
11742           if (integer_pow2p (c) && tree_int_cst_sgn (c) > 0)
11743             {
11744               tree mask
11745                 = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (arg1), arg1,
11746                                    build_int_cst (TREE_TYPE (arg1), 1));
11747               if (strict_overflow_p)
11748                 fold_overflow_warning (("assuming signed overflow does not "
11749                                         "occur when simplifying "
11750                                         "X % (power of two)"),
11751                                        WARN_STRICT_OVERFLOW_MISC);
11752               return fold_build2_loc (loc, BIT_AND_EXPR, type,
11753                                       fold_convert_loc (loc, type, arg0),
11754                                       fold_convert_loc (loc, type, mask));
11755             }
11756         }
11757
11758       return NULL_TREE;
11759
11760     case LROTATE_EXPR:
11761     case RROTATE_EXPR:
11762       if (integer_all_onesp (arg0))
11763         return omit_one_operand_loc (loc, type, arg0, arg1);
11764       goto shift;
11765
11766     case RSHIFT_EXPR:
11767       /* Optimize -1 >> x for arithmetic right shifts.  */
11768       if (integer_all_onesp (arg0) && !TYPE_UNSIGNED (type)
11769           && tree_expr_nonnegative_p (arg1))
11770         return omit_one_operand_loc (loc, type, arg0, arg1);
11771       /* ... fall through ...  */
11772
11773     case LSHIFT_EXPR:
11774     shift:
11775       if (integer_zerop (arg1))
11776         return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
11777       if (integer_zerop (arg0))
11778         return omit_one_operand_loc (loc, type, arg0, arg1);
11779
11780       /* Since negative shift count is not well-defined,
11781          don't try to compute it in the compiler.  */
11782       if (TREE_CODE (arg1) == INTEGER_CST && tree_int_cst_sgn (arg1) < 0)
11783         return NULL_TREE;
11784
11785       /* Turn (a OP c1) OP c2 into a OP (c1+c2).  */
11786       if (TREE_CODE (op0) == code && host_integerp (arg1, false)
11787           && TREE_INT_CST_LOW (arg1) < TYPE_PRECISION (type)
11788           && host_integerp (TREE_OPERAND (arg0, 1), false)
11789           && TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1)) < TYPE_PRECISION (type))
11790         {
11791           HOST_WIDE_INT low = (TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1))
11792                                + TREE_INT_CST_LOW (arg1));
11793
11794           /* Deal with a OP (c1 + c2) being undefined but (a OP c1) OP c2
11795              being well defined.  */
11796           if (low >= TYPE_PRECISION (type))
11797             {
11798               if (code == LROTATE_EXPR || code == RROTATE_EXPR)
11799                 low = low % TYPE_PRECISION (type);
11800               else if (TYPE_UNSIGNED (type) || code == LSHIFT_EXPR)
11801                 return omit_one_operand_loc (loc, type, build_int_cst (type, 0),
11802                                          TREE_OPERAND (arg0, 0));
11803               else
11804                 low = TYPE_PRECISION (type) - 1;
11805             }
11806
11807           return fold_build2_loc (loc, code, type, TREE_OPERAND (arg0, 0),
11808                               build_int_cst (type, low));
11809         }
11810
11811       /* Transform (x >> c) << c into x & (-1<<c), or transform (x << c) >> c
11812          into x & ((unsigned)-1 >> c) for unsigned types.  */
11813       if (((code == LSHIFT_EXPR && TREE_CODE (arg0) == RSHIFT_EXPR)
11814            || (TYPE_UNSIGNED (type)
11815                && code == RSHIFT_EXPR && TREE_CODE (arg0) == LSHIFT_EXPR))
11816           && host_integerp (arg1, false)
11817           && TREE_INT_CST_LOW (arg1) < TYPE_PRECISION (type)
11818           && host_integerp (TREE_OPERAND (arg0, 1), false)
11819           && TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1)) < TYPE_PRECISION (type))
11820         {
11821           HOST_WIDE_INT low0 = TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1));
11822           HOST_WIDE_INT low1 = TREE_INT_CST_LOW (arg1);
11823           tree lshift;
11824           tree arg00;
11825
11826           if (low0 == low1)
11827             {
11828               arg00 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
11829
11830               lshift = build_int_cst (type, -1);
11831               lshift = int_const_binop (code, lshift, arg1, 0);
11832
11833               return fold_build2_loc (loc, BIT_AND_EXPR, type, arg00, lshift);
11834             }
11835         }
11836
11837       /* Rewrite an LROTATE_EXPR by a constant into an
11838          RROTATE_EXPR by a new constant.  */
11839       if (code == LROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST)
11840         {
11841           tree tem = build_int_cst (TREE_TYPE (arg1),
11842                                     TYPE_PRECISION (type));
11843           tem = const_binop (MINUS_EXPR, tem, arg1);
11844           return fold_build2_loc (loc, RROTATE_EXPR, type, op0, tem);
11845         }
11846
11847       /* If we have a rotate of a bit operation with the rotate count and
11848          the second operand of the bit operation both constant,
11849          permute the two operations.  */
11850       if (code == RROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST
11851           && (TREE_CODE (arg0) == BIT_AND_EXPR
11852               || TREE_CODE (arg0) == BIT_IOR_EXPR
11853               || TREE_CODE (arg0) == BIT_XOR_EXPR)
11854           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
11855         return fold_build2_loc (loc, TREE_CODE (arg0), type,
11856                             fold_build2_loc (loc, code, type,
11857                                          TREE_OPERAND (arg0, 0), arg1),
11858                             fold_build2_loc (loc, code, type,
11859                                          TREE_OPERAND (arg0, 1), arg1));
11860
11861       /* Two consecutive rotates adding up to the precision of the
11862          type can be ignored.  */
11863       if (code == RROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST
11864           && TREE_CODE (arg0) == RROTATE_EXPR
11865           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
11866           && TREE_INT_CST_HIGH (arg1) == 0
11867           && TREE_INT_CST_HIGH (TREE_OPERAND (arg0, 1)) == 0
11868           && ((TREE_INT_CST_LOW (arg1)
11869                + TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1)))
11870               == (unsigned int) TYPE_PRECISION (type)))
11871         return TREE_OPERAND (arg0, 0);
11872
11873       /* Fold (X & C2) << C1 into (X << C1) & (C2 << C1)
11874               (X & C2) >> C1 into (X >> C1) & (C2 >> C1)
11875          if the latter can be further optimized.  */
11876       if ((code == LSHIFT_EXPR || code == RSHIFT_EXPR)
11877           && TREE_CODE (arg0) == BIT_AND_EXPR
11878           && TREE_CODE (arg1) == INTEGER_CST
11879           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
11880         {
11881           tree mask = fold_build2_loc (loc, code, type,
11882                                    fold_convert_loc (loc, type,
11883                                                      TREE_OPERAND (arg0, 1)),
11884                                    arg1);
11885           tree shift = fold_build2_loc (loc, code, type,
11886                                     fold_convert_loc (loc, type,
11887                                                       TREE_OPERAND (arg0, 0)),
11888                                     arg1);
11889           tem = fold_binary_loc (loc, BIT_AND_EXPR, type, shift, mask);
11890           if (tem)
11891             return tem;
11892         }
11893
11894       return NULL_TREE;
11895
11896     case MIN_EXPR:
11897       if (operand_equal_p (arg0, arg1, 0))
11898         return omit_one_operand_loc (loc, type, arg0, arg1);
11899       if (INTEGRAL_TYPE_P (type)
11900           && operand_equal_p (arg1, TYPE_MIN_VALUE (type), OEP_ONLY_CONST))
11901         return omit_one_operand_loc (loc, type, arg1, arg0);
11902       tem = fold_minmax (loc, MIN_EXPR, type, arg0, arg1);
11903       if (tem)
11904         return tem;
11905       goto associate;
11906
11907     case MAX_EXPR:
11908       if (operand_equal_p (arg0, arg1, 0))
11909         return omit_one_operand_loc (loc, type, arg0, arg1);
11910       if (INTEGRAL_TYPE_P (type)
11911           && TYPE_MAX_VALUE (type)
11912           && operand_equal_p (arg1, TYPE_MAX_VALUE (type), OEP_ONLY_CONST))
11913         return omit_one_operand_loc (loc, type, arg1, arg0);
11914       tem = fold_minmax (loc, MAX_EXPR, type, arg0, arg1);
11915       if (tem)
11916         return tem;
11917       goto associate;
11918
11919     case TRUTH_ANDIF_EXPR:
11920       /* Note that the operands of this must be ints
11921          and their values must be 0 or 1.
11922          ("true" is a fixed value perhaps depending on the language.)  */
11923       /* If first arg is constant zero, return it.  */
11924       if (integer_zerop (arg0))
11925         return fold_convert_loc (loc, type, arg0);
11926     case TRUTH_AND_EXPR:
11927       /* If either arg is constant true, drop it.  */
11928       if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
11929         return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg1));
11930       if (TREE_CODE (arg1) == INTEGER_CST && ! integer_zerop (arg1)
11931           /* Preserve sequence points.  */
11932           && (code != TRUTH_ANDIF_EXPR || ! TREE_SIDE_EFFECTS (arg0)))
11933         return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
11934       /* If second arg is constant zero, result is zero, but first arg
11935          must be evaluated.  */
11936       if (integer_zerop (arg1))
11937         return omit_one_operand_loc (loc, type, arg1, arg0);
11938       /* Likewise for first arg, but note that only the TRUTH_AND_EXPR
11939          case will be handled here.  */
11940       if (integer_zerop (arg0))
11941         return omit_one_operand_loc (loc, type, arg0, arg1);
11942
11943       /* !X && X is always false.  */
11944       if (TREE_CODE (arg0) == TRUTH_NOT_EXPR
11945           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
11946         return omit_one_operand_loc (loc, type, integer_zero_node, arg1);
11947       /* X && !X is always false.  */
11948       if (TREE_CODE (arg1) == TRUTH_NOT_EXPR
11949           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
11950         return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
11951
11952       /* A < X && A + 1 > Y ==> A < X && A >= Y.  Normally A + 1 > Y
11953          means A >= Y && A != MAX, but in this case we know that
11954          A < X <= MAX.  */
11955
11956       if (!TREE_SIDE_EFFECTS (arg0)
11957           && !TREE_SIDE_EFFECTS (arg1))
11958         {
11959           tem = fold_to_nonsharp_ineq_using_bound (loc, arg0, arg1);
11960           if (tem && !operand_equal_p (tem, arg0, 0))
11961             return fold_build2_loc (loc, code, type, tem, arg1);
11962
11963           tem = fold_to_nonsharp_ineq_using_bound (loc, arg1, arg0);
11964           if (tem && !operand_equal_p (tem, arg1, 0))
11965             return fold_build2_loc (loc, code, type, arg0, tem);
11966         }
11967
11968     truth_andor:
11969       /* We only do these simplifications if we are optimizing.  */
11970       if (!optimize)
11971         return NULL_TREE;
11972
11973       /* Check for things like (A || B) && (A || C).  We can convert this
11974          to A || (B && C).  Note that either operator can be any of the four
11975          truth and/or operations and the transformation will still be
11976          valid.   Also note that we only care about order for the
11977          ANDIF and ORIF operators.  If B contains side effects, this
11978          might change the truth-value of A.  */
11979       if (TREE_CODE (arg0) == TREE_CODE (arg1)
11980           && (TREE_CODE (arg0) == TRUTH_ANDIF_EXPR
11981               || TREE_CODE (arg0) == TRUTH_ORIF_EXPR
11982               || TREE_CODE (arg0) == TRUTH_AND_EXPR
11983               || TREE_CODE (arg0) == TRUTH_OR_EXPR)
11984           && ! TREE_SIDE_EFFECTS (TREE_OPERAND (arg0, 1)))
11985         {
11986           tree a00 = TREE_OPERAND (arg0, 0);
11987           tree a01 = TREE_OPERAND (arg0, 1);
11988           tree a10 = TREE_OPERAND (arg1, 0);
11989           tree a11 = TREE_OPERAND (arg1, 1);
11990           int commutative = ((TREE_CODE (arg0) == TRUTH_OR_EXPR
11991                               || TREE_CODE (arg0) == TRUTH_AND_EXPR)
11992                              && (code == TRUTH_AND_EXPR
11993                                  || code == TRUTH_OR_EXPR));
11994
11995           if (operand_equal_p (a00, a10, 0))
11996             return fold_build2_loc (loc, TREE_CODE (arg0), type, a00,
11997                                 fold_build2_loc (loc, code, type, a01, a11));
11998           else if (commutative && operand_equal_p (a00, a11, 0))
11999             return fold_build2_loc (loc, TREE_CODE (arg0), type, a00,
12000                                 fold_build2_loc (loc, code, type, a01, a10));
12001           else if (commutative && operand_equal_p (a01, a10, 0))
12002             return fold_build2_loc (loc, TREE_CODE (arg0), type, a01,
12003                                 fold_build2_loc (loc, code, type, a00, a11));
12004
12005           /* This case if tricky because we must either have commutative
12006              operators or else A10 must not have side-effects.  */
12007
12008           else if ((commutative || ! TREE_SIDE_EFFECTS (a10))
12009                    && operand_equal_p (a01, a11, 0))
12010             return fold_build2_loc (loc, TREE_CODE (arg0), type,
12011                                 fold_build2_loc (loc, code, type, a00, a10),
12012                                 a01);
12013         }
12014
12015       /* See if we can build a range comparison.  */
12016       if (0 != (tem = fold_range_test (loc, code, type, op0, op1)))
12017         return tem;
12018
12019       if ((code == TRUTH_ANDIF_EXPR && TREE_CODE (arg0) == TRUTH_ORIF_EXPR)
12020           || (code == TRUTH_ORIF_EXPR && TREE_CODE (arg0) == TRUTH_ANDIF_EXPR))
12021         {
12022           tem = merge_truthop_with_opposite_arm (loc, arg0, arg1, true);
12023           if (tem)
12024             return fold_build2_loc (loc, code, type, tem, arg1);
12025         }
12026
12027       if ((code == TRUTH_ANDIF_EXPR && TREE_CODE (arg1) == TRUTH_ORIF_EXPR)
12028           || (code == TRUTH_ORIF_EXPR && TREE_CODE (arg1) == TRUTH_ANDIF_EXPR))
12029         {
12030           tem = merge_truthop_with_opposite_arm (loc, arg1, arg0, false);
12031           if (tem)
12032             return fold_build2_loc (loc, code, type, arg0, tem);
12033         }
12034
12035       /* Check for the possibility of merging component references.  If our
12036          lhs is another similar operation, try to merge its rhs with our
12037          rhs.  Then try to merge our lhs and rhs.  */
12038       if (TREE_CODE (arg0) == code
12039           && 0 != (tem = fold_truthop (loc, code, type,
12040                                        TREE_OPERAND (arg0, 1), arg1)))
12041         return fold_build2_loc (loc, code, type, TREE_OPERAND (arg0, 0), tem);
12042
12043       if ((tem = fold_truthop (loc, code, type, arg0, arg1)) != 0)
12044         return tem;
12045
12046       return NULL_TREE;
12047
12048     case TRUTH_ORIF_EXPR:
12049       /* Note that the operands of this must be ints
12050          and their values must be 0 or true.
12051          ("true" is a fixed value perhaps depending on the language.)  */
12052       /* If first arg is constant true, return it.  */
12053       if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
12054         return fold_convert_loc (loc, type, arg0);
12055     case TRUTH_OR_EXPR:
12056       /* If either arg is constant zero, drop it.  */
12057       if (TREE_CODE (arg0) == INTEGER_CST && integer_zerop (arg0))
12058         return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg1));
12059       if (TREE_CODE (arg1) == INTEGER_CST && integer_zerop (arg1)
12060           /* Preserve sequence points.  */
12061           && (code != TRUTH_ORIF_EXPR || ! TREE_SIDE_EFFECTS (arg0)))
12062         return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
12063       /* If second arg is constant true, result is true, but we must
12064          evaluate first arg.  */
12065       if (TREE_CODE (arg1) == INTEGER_CST && ! integer_zerop (arg1))
12066         return omit_one_operand_loc (loc, type, arg1, arg0);
12067       /* Likewise for first arg, but note this only occurs here for
12068          TRUTH_OR_EXPR.  */
12069       if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
12070         return omit_one_operand_loc (loc, type, arg0, arg1);
12071
12072       /* !X || X is always true.  */
12073       if (TREE_CODE (arg0) == TRUTH_NOT_EXPR
12074           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
12075         return omit_one_operand_loc (loc, type, integer_one_node, arg1);
12076       /* X || !X is always true.  */
12077       if (TREE_CODE (arg1) == TRUTH_NOT_EXPR
12078           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
12079         return omit_one_operand_loc (loc, type, integer_one_node, arg0);
12080
12081       goto truth_andor;
12082
12083     case TRUTH_XOR_EXPR:
12084       /* If the second arg is constant zero, drop it.  */
12085       if (integer_zerop (arg1))
12086         return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
12087       /* If the second arg is constant true, this is a logical inversion.  */
12088       if (integer_onep (arg1))
12089         {
12090           /* Only call invert_truthvalue if operand is a truth value.  */
12091           if (TREE_CODE (TREE_TYPE (arg0)) != BOOLEAN_TYPE)
12092             tem = fold_build1_loc (loc, TRUTH_NOT_EXPR, TREE_TYPE (arg0), arg0);
12093           else
12094             tem = invert_truthvalue_loc (loc, arg0);
12095           return non_lvalue_loc (loc, fold_convert_loc (loc, type, tem));
12096         }
12097       /* Identical arguments cancel to zero.  */
12098       if (operand_equal_p (arg0, arg1, 0))
12099         return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
12100
12101       /* !X ^ X is always true.  */
12102       if (TREE_CODE (arg0) == TRUTH_NOT_EXPR
12103           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
12104         return omit_one_operand_loc (loc, type, integer_one_node, arg1);
12105
12106       /* X ^ !X is always true.  */
12107       if (TREE_CODE (arg1) == TRUTH_NOT_EXPR
12108           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
12109         return omit_one_operand_loc (loc, type, integer_one_node, arg0);
12110
12111       return NULL_TREE;
12112
12113     case EQ_EXPR:
12114     case NE_EXPR:
12115       STRIP_NOPS (arg0);
12116       STRIP_NOPS (arg1);
12117
12118       tem = fold_comparison (loc, code, type, op0, op1);
12119       if (tem != NULL_TREE)
12120         return tem;
12121
12122       /* bool_var != 0 becomes bool_var. */
12123       if (TREE_CODE (TREE_TYPE (arg0)) == BOOLEAN_TYPE && integer_zerop (arg1)
12124           && code == NE_EXPR)
12125         return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
12126
12127       /* bool_var == 1 becomes bool_var. */
12128       if (TREE_CODE (TREE_TYPE (arg0)) == BOOLEAN_TYPE && integer_onep (arg1)
12129           && code == EQ_EXPR)
12130         return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
12131
12132       /* bool_var != 1 becomes !bool_var. */
12133       if (TREE_CODE (TREE_TYPE (arg0)) == BOOLEAN_TYPE && integer_onep (arg1)
12134           && code == NE_EXPR)
12135         return fold_build1_loc (loc, TRUTH_NOT_EXPR, type,
12136                             fold_convert_loc (loc, type, arg0));
12137
12138       /* bool_var == 0 becomes !bool_var. */
12139       if (TREE_CODE (TREE_TYPE (arg0)) == BOOLEAN_TYPE && integer_zerop (arg1)
12140           && code == EQ_EXPR)
12141         return fold_build1_loc (loc, TRUTH_NOT_EXPR, type,
12142                             fold_convert_loc (loc, type, arg0));
12143
12144       /* !exp != 0 becomes !exp */
12145       if (TREE_CODE (arg0) == TRUTH_NOT_EXPR && integer_zerop (arg1)
12146           && code == NE_EXPR)
12147         return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
12148
12149       /* If this is an equality comparison of the address of two non-weak,
12150          unaliased symbols neither of which are extern (since we do not
12151          have access to attributes for externs), then we know the result.  */
12152       if (TREE_CODE (arg0) == ADDR_EXPR
12153           && VAR_OR_FUNCTION_DECL_P (TREE_OPERAND (arg0, 0))
12154           && ! DECL_WEAK (TREE_OPERAND (arg0, 0))
12155           && ! lookup_attribute ("alias",
12156                                  DECL_ATTRIBUTES (TREE_OPERAND (arg0, 0)))
12157           && ! DECL_EXTERNAL (TREE_OPERAND (arg0, 0))
12158           && TREE_CODE (arg1) == ADDR_EXPR
12159           && VAR_OR_FUNCTION_DECL_P (TREE_OPERAND (arg1, 0))
12160           && ! DECL_WEAK (TREE_OPERAND (arg1, 0))
12161           && ! lookup_attribute ("alias",
12162                                  DECL_ATTRIBUTES (TREE_OPERAND (arg1, 0)))
12163           && ! DECL_EXTERNAL (TREE_OPERAND (arg1, 0)))
12164         {
12165           /* We know that we're looking at the address of two
12166              non-weak, unaliased, static _DECL nodes.
12167
12168              It is both wasteful and incorrect to call operand_equal_p
12169              to compare the two ADDR_EXPR nodes.  It is wasteful in that
12170              all we need to do is test pointer equality for the arguments
12171              to the two ADDR_EXPR nodes.  It is incorrect to use
12172              operand_equal_p as that function is NOT equivalent to a
12173              C equality test.  It can in fact return false for two
12174              objects which would test as equal using the C equality
12175              operator.  */
12176           bool equal = TREE_OPERAND (arg0, 0) == TREE_OPERAND (arg1, 0);
12177           return constant_boolean_node (equal
12178                                         ? code == EQ_EXPR : code != EQ_EXPR,
12179                                         type);
12180         }
12181
12182       /* If this is an EQ or NE comparison of a constant with a PLUS_EXPR or
12183          a MINUS_EXPR of a constant, we can convert it into a comparison with
12184          a revised constant as long as no overflow occurs.  */
12185       if (TREE_CODE (arg1) == INTEGER_CST
12186           && (TREE_CODE (arg0) == PLUS_EXPR
12187               || TREE_CODE (arg0) == MINUS_EXPR)
12188           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
12189           && 0 != (tem = const_binop (TREE_CODE (arg0) == PLUS_EXPR
12190                                       ? MINUS_EXPR : PLUS_EXPR,
12191                                       fold_convert_loc (loc, TREE_TYPE (arg0),
12192                                                         arg1),
12193                                       TREE_OPERAND (arg0, 1)))
12194           && !TREE_OVERFLOW (tem))
12195         return fold_build2_loc (loc, code, type, TREE_OPERAND (arg0, 0), tem);
12196
12197       /* Similarly for a NEGATE_EXPR.  */
12198       if (TREE_CODE (arg0) == NEGATE_EXPR
12199           && TREE_CODE (arg1) == INTEGER_CST
12200           && 0 != (tem = negate_expr (fold_convert_loc (loc, TREE_TYPE (arg0),
12201                                                         arg1)))
12202           && TREE_CODE (tem) == INTEGER_CST
12203           && !TREE_OVERFLOW (tem))
12204         return fold_build2_loc (loc, code, type, TREE_OPERAND (arg0, 0), tem);
12205
12206       /* Similarly for a BIT_XOR_EXPR;  X ^ C1 == C2 is X == (C1 ^ C2).  */
12207       if (TREE_CODE (arg0) == BIT_XOR_EXPR
12208           && TREE_CODE (arg1) == INTEGER_CST
12209           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
12210         return fold_build2_loc (loc, code, type, TREE_OPERAND (arg0, 0),
12211                             fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (arg0),
12212                                          fold_convert_loc (loc,
12213                                                            TREE_TYPE (arg0),
12214                                                            arg1),
12215                                          TREE_OPERAND (arg0, 1)));
12216
12217       /* Transform comparisons of the form X +- Y CMP X to Y CMP 0.  */
12218       if ((TREE_CODE (arg0) == PLUS_EXPR
12219            || TREE_CODE (arg0) == POINTER_PLUS_EXPR
12220            || TREE_CODE (arg0) == MINUS_EXPR)
12221           && operand_equal_p (tree_strip_nop_conversions (TREE_OPERAND (arg0,
12222                                                                         0)),
12223                               arg1, 0)
12224           && (INTEGRAL_TYPE_P (TREE_TYPE (arg0))
12225               || POINTER_TYPE_P (TREE_TYPE (arg0))))
12226         {
12227           tree val = TREE_OPERAND (arg0, 1);
12228           return omit_two_operands_loc (loc, type,
12229                                     fold_build2_loc (loc, code, type,
12230                                                  val,
12231                                                  build_int_cst (TREE_TYPE (val),
12232                                                                 0)),
12233                                     TREE_OPERAND (arg0, 0), arg1);
12234         }
12235
12236       /* Transform comparisons of the form C - X CMP X if C % 2 == 1.  */
12237       if (TREE_CODE (arg0) == MINUS_EXPR
12238           && TREE_CODE (TREE_OPERAND (arg0, 0)) == INTEGER_CST
12239           && operand_equal_p (tree_strip_nop_conversions (TREE_OPERAND (arg0,
12240                                                                         1)),
12241                               arg1, 0)
12242           && (TREE_INT_CST_LOW (TREE_OPERAND (arg0, 0)) & 1) == 1)
12243         {
12244           return omit_two_operands_loc (loc, type,
12245                                     code == NE_EXPR
12246                                     ? boolean_true_node : boolean_false_node,
12247                                     TREE_OPERAND (arg0, 1), arg1);
12248         }
12249
12250       /* If we have X - Y == 0, we can convert that to X == Y and similarly
12251          for !=.  Don't do this for ordered comparisons due to overflow.  */
12252       if (TREE_CODE (arg0) == MINUS_EXPR
12253           && integer_zerop (arg1))
12254         return fold_build2_loc (loc, code, type,
12255                             TREE_OPERAND (arg0, 0), TREE_OPERAND (arg0, 1));
12256
12257       /* Convert ABS_EXPR<x> == 0 or ABS_EXPR<x> != 0 to x == 0 or x != 0.  */
12258       if (TREE_CODE (arg0) == ABS_EXPR
12259           && (integer_zerop (arg1) || real_zerop (arg1)))
12260         return fold_build2_loc (loc, code, type, TREE_OPERAND (arg0, 0), arg1);
12261
12262       /* If this is an EQ or NE comparison with zero and ARG0 is
12263          (1 << foo) & bar, convert it to (bar >> foo) & 1.  Both require
12264          two operations, but the latter can be done in one less insn
12265          on machines that have only two-operand insns or on which a
12266          constant cannot be the first operand.  */
12267       if (TREE_CODE (arg0) == BIT_AND_EXPR
12268           && integer_zerop (arg1))
12269         {
12270           tree arg00 = TREE_OPERAND (arg0, 0);
12271           tree arg01 = TREE_OPERAND (arg0, 1);
12272           if (TREE_CODE (arg00) == LSHIFT_EXPR
12273               && integer_onep (TREE_OPERAND (arg00, 0)))
12274             {
12275               tree tem = fold_build2_loc (loc, RSHIFT_EXPR, TREE_TYPE (arg00),
12276                                       arg01, TREE_OPERAND (arg00, 1));
12277               tem = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (arg0), tem,
12278                                  build_int_cst (TREE_TYPE (arg0), 1));
12279               return fold_build2_loc (loc, code, type,
12280                                   fold_convert_loc (loc, TREE_TYPE (arg1), tem),
12281                                   arg1);
12282             }
12283           else if (TREE_CODE (arg01) == LSHIFT_EXPR
12284                    && integer_onep (TREE_OPERAND (arg01, 0)))
12285             {
12286               tree tem = fold_build2_loc (loc, RSHIFT_EXPR, TREE_TYPE (arg01),
12287                                       arg00, TREE_OPERAND (arg01, 1));
12288               tem = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (arg0), tem,
12289                                  build_int_cst (TREE_TYPE (arg0), 1));
12290               return fold_build2_loc (loc, code, type,
12291                                   fold_convert_loc (loc, TREE_TYPE (arg1), tem),
12292                                   arg1);
12293             }
12294         }
12295
12296       /* If this is an NE or EQ comparison of zero against the result of a
12297          signed MOD operation whose second operand is a power of 2, make
12298          the MOD operation unsigned since it is simpler and equivalent.  */
12299       if (integer_zerop (arg1)
12300           && !TYPE_UNSIGNED (TREE_TYPE (arg0))
12301           && (TREE_CODE (arg0) == TRUNC_MOD_EXPR
12302               || TREE_CODE (arg0) == CEIL_MOD_EXPR
12303               || TREE_CODE (arg0) == FLOOR_MOD_EXPR
12304               || TREE_CODE (arg0) == ROUND_MOD_EXPR)
12305           && integer_pow2p (TREE_OPERAND (arg0, 1)))
12306         {
12307           tree newtype = unsigned_type_for (TREE_TYPE (arg0));
12308           tree newmod = fold_build2_loc (loc, TREE_CODE (arg0), newtype,
12309                                      fold_convert_loc (loc, newtype,
12310                                                        TREE_OPERAND (arg0, 0)),
12311                                      fold_convert_loc (loc, newtype,
12312                                                        TREE_OPERAND (arg0, 1)));
12313
12314           return fold_build2_loc (loc, code, type, newmod,
12315                               fold_convert_loc (loc, newtype, arg1));
12316         }
12317
12318       /* Fold ((X >> C1) & C2) == 0 and ((X >> C1) & C2) != 0 where
12319          C1 is a valid shift constant, and C2 is a power of two, i.e.
12320          a single bit.  */
12321       if (TREE_CODE (arg0) == BIT_AND_EXPR
12322           && TREE_CODE (TREE_OPERAND (arg0, 0)) == RSHIFT_EXPR
12323           && TREE_CODE (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1))
12324              == INTEGER_CST
12325           && integer_pow2p (TREE_OPERAND (arg0, 1))
12326           && integer_zerop (arg1))
12327         {
12328           tree itype = TREE_TYPE (arg0);
12329           unsigned HOST_WIDE_INT prec = TYPE_PRECISION (itype);
12330           tree arg001 = TREE_OPERAND (TREE_OPERAND (arg0, 0), 1);
12331
12332           /* Check for a valid shift count.  */
12333           if (TREE_INT_CST_HIGH (arg001) == 0
12334               && TREE_INT_CST_LOW (arg001) < prec)
12335             {
12336               tree arg01 = TREE_OPERAND (arg0, 1);
12337               tree arg000 = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
12338               unsigned HOST_WIDE_INT log2 = tree_log2 (arg01);
12339               /* If (C2 << C1) doesn't overflow, then ((X >> C1) & C2) != 0
12340                  can be rewritten as (X & (C2 << C1)) != 0.  */
12341               if ((log2 + TREE_INT_CST_LOW (arg001)) < prec)
12342                 {
12343                   tem = fold_build2_loc (loc, LSHIFT_EXPR, itype, arg01, arg001);
12344                   tem = fold_build2_loc (loc, BIT_AND_EXPR, itype, arg000, tem);
12345                   return fold_build2_loc (loc, code, type, tem,
12346                                           fold_convert_loc (loc, itype, arg1));
12347                 }
12348               /* Otherwise, for signed (arithmetic) shifts,
12349                  ((X >> C1) & C2) != 0 is rewritten as X < 0, and
12350                  ((X >> C1) & C2) == 0 is rewritten as X >= 0.  */
12351               else if (!TYPE_UNSIGNED (itype))
12352                 return fold_build2_loc (loc, code == EQ_EXPR ? GE_EXPR : LT_EXPR, type,
12353                                     arg000, build_int_cst (itype, 0));
12354               /* Otherwise, of unsigned (logical) shifts,
12355                  ((X >> C1) & C2) != 0 is rewritten as (X,false), and
12356                  ((X >> C1) & C2) == 0 is rewritten as (X,true).  */
12357               else
12358                 return omit_one_operand_loc (loc, type,
12359                                          code == EQ_EXPR ? integer_one_node
12360                                                          : integer_zero_node,
12361                                          arg000);
12362             }
12363         }
12364
12365       /* If this is an NE comparison of zero with an AND of one, remove the
12366          comparison since the AND will give the correct value.  */
12367       if (code == NE_EXPR
12368           && integer_zerop (arg1)
12369           && TREE_CODE (arg0) == BIT_AND_EXPR
12370           && integer_onep (TREE_OPERAND (arg0, 1)))
12371         return fold_convert_loc (loc, type, arg0);
12372
12373       /* If we have (A & C) == C where C is a power of 2, convert this into
12374          (A & C) != 0.  Similarly for NE_EXPR.  */
12375       if (TREE_CODE (arg0) == BIT_AND_EXPR
12376           && integer_pow2p (TREE_OPERAND (arg0, 1))
12377           && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
12378         return fold_build2_loc (loc, code == EQ_EXPR ? NE_EXPR : EQ_EXPR, type,
12379                             arg0, fold_convert_loc (loc, TREE_TYPE (arg0),
12380                                                     integer_zero_node));
12381
12382       /* If we have (A & C) != 0 or (A & C) == 0 and C is the sign
12383          bit, then fold the expression into A < 0 or A >= 0.  */
12384       tem = fold_single_bit_test_into_sign_test (loc, code, arg0, arg1, type);
12385       if (tem)
12386         return tem;
12387
12388       /* If we have (A & C) == D where D & ~C != 0, convert this into 0.
12389          Similarly for NE_EXPR.  */
12390       if (TREE_CODE (arg0) == BIT_AND_EXPR
12391           && TREE_CODE (arg1) == INTEGER_CST
12392           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
12393         {
12394           tree notc = fold_build1_loc (loc, BIT_NOT_EXPR,
12395                                    TREE_TYPE (TREE_OPERAND (arg0, 1)),
12396                                    TREE_OPERAND (arg0, 1));
12397           tree dandnotc
12398             = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (arg0),
12399                                fold_convert_loc (loc, TREE_TYPE (arg0), arg1),
12400                                notc);
12401           tree rslt = code == EQ_EXPR ? integer_zero_node : integer_one_node;
12402           if (integer_nonzerop (dandnotc))
12403             return omit_one_operand_loc (loc, type, rslt, arg0);
12404         }
12405
12406       /* If we have (A | C) == D where C & ~D != 0, convert this into 0.
12407          Similarly for NE_EXPR.  */
12408       if (TREE_CODE (arg0) == BIT_IOR_EXPR
12409           && TREE_CODE (arg1) == INTEGER_CST
12410           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
12411         {
12412           tree notd = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (arg1), arg1);
12413           tree candnotd
12414             = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (arg0),
12415                                TREE_OPERAND (arg0, 1),
12416                                fold_convert_loc (loc, TREE_TYPE (arg0), notd));
12417           tree rslt = code == EQ_EXPR ? integer_zero_node : integer_one_node;
12418           if (integer_nonzerop (candnotd))
12419             return omit_one_operand_loc (loc, type, rslt, arg0);
12420         }
12421
12422       /* If this is a comparison of a field, we may be able to simplify it.  */
12423       if ((TREE_CODE (arg0) == COMPONENT_REF
12424            || TREE_CODE (arg0) == BIT_FIELD_REF)
12425           /* Handle the constant case even without -O
12426              to make sure the warnings are given.  */
12427           && (optimize || TREE_CODE (arg1) == INTEGER_CST))
12428         {
12429           t1 = optimize_bit_field_compare (loc, code, type, arg0, arg1);
12430           if (t1)
12431             return t1;
12432         }
12433
12434       /* Optimize comparisons of strlen vs zero to a compare of the
12435          first character of the string vs zero.  To wit,
12436                 strlen(ptr) == 0   =>  *ptr == 0
12437                 strlen(ptr) != 0   =>  *ptr != 0
12438          Other cases should reduce to one of these two (or a constant)
12439          due to the return value of strlen being unsigned.  */
12440       if (TREE_CODE (arg0) == CALL_EXPR
12441           && integer_zerop (arg1))
12442         {
12443           tree fndecl = get_callee_fndecl (arg0);
12444
12445           if (fndecl
12446               && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
12447               && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_STRLEN
12448               && call_expr_nargs (arg0) == 1
12449               && TREE_CODE (TREE_TYPE (CALL_EXPR_ARG (arg0, 0))) == POINTER_TYPE)
12450             {
12451               tree iref = build_fold_indirect_ref_loc (loc,
12452                                                    CALL_EXPR_ARG (arg0, 0));
12453               return fold_build2_loc (loc, code, type, iref,
12454                                   build_int_cst (TREE_TYPE (iref), 0));
12455             }
12456         }
12457
12458       /* Fold (X >> C) != 0 into X < 0 if C is one less than the width
12459          of X.  Similarly fold (X >> C) == 0 into X >= 0.  */
12460       if (TREE_CODE (arg0) == RSHIFT_EXPR
12461           && integer_zerop (arg1)
12462           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
12463         {
12464           tree arg00 = TREE_OPERAND (arg0, 0);
12465           tree arg01 = TREE_OPERAND (arg0, 1);
12466           tree itype = TREE_TYPE (arg00);
12467           if (TREE_INT_CST_HIGH (arg01) == 0
12468               && TREE_INT_CST_LOW (arg01)
12469                  == (unsigned HOST_WIDE_INT) (TYPE_PRECISION (itype) - 1))
12470             {
12471               if (TYPE_UNSIGNED (itype))
12472                 {
12473                   itype = signed_type_for (itype);
12474                   arg00 = fold_convert_loc (loc, itype, arg00);
12475                 }
12476               return fold_build2_loc (loc, code == EQ_EXPR ? GE_EXPR : LT_EXPR,
12477                                   type, arg00, build_int_cst (itype, 0));
12478             }
12479         }
12480
12481       /* (X ^ Y) == 0 becomes X == Y, and (X ^ Y) != 0 becomes X != Y.  */
12482       if (integer_zerop (arg1)
12483           && TREE_CODE (arg0) == BIT_XOR_EXPR)
12484         return fold_build2_loc (loc, code, type, TREE_OPERAND (arg0, 0),
12485                             TREE_OPERAND (arg0, 1));
12486
12487       /* (X ^ Y) == Y becomes X == 0.  We know that Y has no side-effects.  */
12488       if (TREE_CODE (arg0) == BIT_XOR_EXPR
12489           && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
12490         return fold_build2_loc (loc, code, type, TREE_OPERAND (arg0, 0),
12491                                 build_int_cst (TREE_TYPE (arg0), 0));
12492       /* Likewise (X ^ Y) == X becomes Y == 0.  X has no side-effects.  */
12493       if (TREE_CODE (arg0) == BIT_XOR_EXPR
12494           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
12495           && reorder_operands_p (TREE_OPERAND (arg0, 1), arg1))
12496         return fold_build2_loc (loc, code, type, TREE_OPERAND (arg0, 1),
12497                                 build_int_cst (TREE_TYPE (arg0), 0));
12498
12499       /* (X ^ C1) op C2 can be rewritten as X op (C1 ^ C2).  */
12500       if (TREE_CODE (arg0) == BIT_XOR_EXPR
12501           && TREE_CODE (arg1) == INTEGER_CST
12502           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
12503         return fold_build2_loc (loc, code, type, TREE_OPERAND (arg0, 0),
12504                             fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (arg1),
12505                                          TREE_OPERAND (arg0, 1), arg1));
12506
12507       /* Fold (~X & C) == 0 into (X & C) != 0 and (~X & C) != 0 into
12508          (X & C) == 0 when C is a single bit.  */
12509       if (TREE_CODE (arg0) == BIT_AND_EXPR
12510           && TREE_CODE (TREE_OPERAND (arg0, 0)) == BIT_NOT_EXPR
12511           && integer_zerop (arg1)
12512           && integer_pow2p (TREE_OPERAND (arg0, 1)))
12513         {
12514           tem = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (arg0),
12515                                  TREE_OPERAND (TREE_OPERAND (arg0, 0), 0),
12516                                  TREE_OPERAND (arg0, 1));
12517           return fold_build2_loc (loc, code == EQ_EXPR ? NE_EXPR : EQ_EXPR,
12518                                   type, tem,
12519                                   fold_convert_loc (loc, TREE_TYPE (arg0),
12520                                                     arg1));
12521         }
12522
12523       /* Fold ((X & C) ^ C) eq/ne 0 into (X & C) ne/eq 0, when the
12524          constant C is a power of two, i.e. a single bit.  */
12525       if (TREE_CODE (arg0) == BIT_XOR_EXPR
12526           && TREE_CODE (TREE_OPERAND (arg0, 0)) == BIT_AND_EXPR
12527           && integer_zerop (arg1)
12528           && integer_pow2p (TREE_OPERAND (arg0, 1))
12529           && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1),
12530                               TREE_OPERAND (arg0, 1), OEP_ONLY_CONST))
12531         {
12532           tree arg00 = TREE_OPERAND (arg0, 0);
12533           return fold_build2_loc (loc, code == EQ_EXPR ? NE_EXPR : EQ_EXPR, type,
12534                               arg00, build_int_cst (TREE_TYPE (arg00), 0));
12535         }
12536
12537       /* Likewise, fold ((X ^ C) & C) eq/ne 0 into (X & C) ne/eq 0,
12538          when is C is a power of two, i.e. a single bit.  */
12539       if (TREE_CODE (arg0) == BIT_AND_EXPR
12540           && TREE_CODE (TREE_OPERAND (arg0, 0)) == BIT_XOR_EXPR
12541           && integer_zerop (arg1)
12542           && integer_pow2p (TREE_OPERAND (arg0, 1))
12543           && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1),
12544                               TREE_OPERAND (arg0, 1), OEP_ONLY_CONST))
12545         {
12546           tree arg000 = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
12547           tem = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (arg000),
12548                              arg000, TREE_OPERAND (arg0, 1));
12549           return fold_build2_loc (loc, code == EQ_EXPR ? NE_EXPR : EQ_EXPR, type,
12550                               tem, build_int_cst (TREE_TYPE (tem), 0));
12551         }
12552
12553       if (integer_zerop (arg1)
12554           && tree_expr_nonzero_p (arg0))
12555         {
12556           tree res = constant_boolean_node (code==NE_EXPR, type);
12557           return omit_one_operand_loc (loc, type, res, arg0);
12558         }
12559
12560       /* Fold -X op -Y as X op Y, where op is eq/ne.  */
12561       if (TREE_CODE (arg0) == NEGATE_EXPR
12562           && TREE_CODE (arg1) == NEGATE_EXPR)
12563         return fold_build2_loc (loc, code, type,
12564                                 TREE_OPERAND (arg0, 0),
12565                                 fold_convert_loc (loc, TREE_TYPE (arg0),
12566                                                   TREE_OPERAND (arg1, 0)));
12567
12568       /* Fold (X & C) op (Y & C) as (X ^ Y) & C op 0", and symmetries.  */
12569       if (TREE_CODE (arg0) == BIT_AND_EXPR
12570           && TREE_CODE (arg1) == BIT_AND_EXPR)
12571         {
12572           tree arg00 = TREE_OPERAND (arg0, 0);
12573           tree arg01 = TREE_OPERAND (arg0, 1);
12574           tree arg10 = TREE_OPERAND (arg1, 0);
12575           tree arg11 = TREE_OPERAND (arg1, 1);
12576           tree itype = TREE_TYPE (arg0);
12577
12578           if (operand_equal_p (arg01, arg11, 0))
12579             return fold_build2_loc (loc, code, type,
12580                                 fold_build2_loc (loc, BIT_AND_EXPR, itype,
12581                                              fold_build2_loc (loc,
12582                                                           BIT_XOR_EXPR, itype,
12583                                                           arg00, arg10),
12584                                              arg01),
12585                                 build_int_cst (itype, 0));
12586
12587           if (operand_equal_p (arg01, arg10, 0))
12588             return fold_build2_loc (loc, code, type,
12589                                 fold_build2_loc (loc, BIT_AND_EXPR, itype,
12590                                              fold_build2_loc (loc,
12591                                                           BIT_XOR_EXPR, itype,
12592                                                           arg00, arg11),
12593                                              arg01),
12594                                 build_int_cst (itype, 0));
12595
12596           if (operand_equal_p (arg00, arg11, 0))
12597             return fold_build2_loc (loc, code, type,
12598                                 fold_build2_loc (loc, BIT_AND_EXPR, itype,
12599                                              fold_build2_loc (loc,
12600                                                           BIT_XOR_EXPR, itype,
12601                                                           arg01, arg10),
12602                                              arg00),
12603                                 build_int_cst (itype, 0));
12604
12605           if (operand_equal_p (arg00, arg10, 0))
12606             return fold_build2_loc (loc, code, type,
12607                                 fold_build2_loc (loc, BIT_AND_EXPR, itype,
12608                                              fold_build2_loc (loc,
12609                                                           BIT_XOR_EXPR, itype,
12610                                                           arg01, arg11),
12611                                              arg00),
12612                                 build_int_cst (itype, 0));
12613         }
12614
12615       if (TREE_CODE (arg0) == BIT_XOR_EXPR
12616           && TREE_CODE (arg1) == BIT_XOR_EXPR)
12617         {
12618           tree arg00 = TREE_OPERAND (arg0, 0);
12619           tree arg01 = TREE_OPERAND (arg0, 1);
12620           tree arg10 = TREE_OPERAND (arg1, 0);
12621           tree arg11 = TREE_OPERAND (arg1, 1);
12622           tree itype = TREE_TYPE (arg0);
12623
12624           /* Optimize (X ^ Z) op (Y ^ Z) as X op Y, and symmetries.
12625              operand_equal_p guarantees no side-effects so we don't need
12626              to use omit_one_operand on Z.  */
12627           if (operand_equal_p (arg01, arg11, 0))
12628             return fold_build2_loc (loc, code, type, arg00, arg10);
12629           if (operand_equal_p (arg01, arg10, 0))
12630             return fold_build2_loc (loc, code, type, arg00, arg11);
12631           if (operand_equal_p (arg00, arg11, 0))
12632             return fold_build2_loc (loc, code, type, arg01, arg10);
12633           if (operand_equal_p (arg00, arg10, 0))
12634             return fold_build2_loc (loc, code, type, arg01, arg11);
12635
12636           /* Optimize (X ^ C1) op (Y ^ C2) as (X ^ (C1 ^ C2)) op Y.  */
12637           if (TREE_CODE (arg01) == INTEGER_CST
12638               && TREE_CODE (arg11) == INTEGER_CST)
12639             {
12640               tem = fold_build2_loc (loc, BIT_XOR_EXPR, itype, arg01,
12641                                      fold_convert_loc (loc, itype, arg11));
12642               tem = fold_build2_loc (loc, BIT_XOR_EXPR, itype, arg00, tem);
12643               return fold_build2_loc (loc, code, type, tem,
12644                                       fold_convert_loc (loc, itype, arg10));
12645             }
12646         }
12647
12648       /* Attempt to simplify equality/inequality comparisons of complex
12649          values.  Only lower the comparison if the result is known or
12650          can be simplified to a single scalar comparison.  */
12651       if ((TREE_CODE (arg0) == COMPLEX_EXPR
12652            || TREE_CODE (arg0) == COMPLEX_CST)
12653           && (TREE_CODE (arg1) == COMPLEX_EXPR
12654               || TREE_CODE (arg1) == COMPLEX_CST))
12655         {
12656           tree real0, imag0, real1, imag1;
12657           tree rcond, icond;
12658
12659           if (TREE_CODE (arg0) == COMPLEX_EXPR)
12660             {
12661               real0 = TREE_OPERAND (arg0, 0);
12662               imag0 = TREE_OPERAND (arg0, 1);
12663             }
12664           else
12665             {
12666               real0 = TREE_REALPART (arg0);
12667               imag0 = TREE_IMAGPART (arg0);
12668             }
12669
12670           if (TREE_CODE (arg1) == COMPLEX_EXPR)
12671             {
12672               real1 = TREE_OPERAND (arg1, 0);
12673               imag1 = TREE_OPERAND (arg1, 1);
12674             }
12675           else
12676             {
12677               real1 = TREE_REALPART (arg1);
12678               imag1 = TREE_IMAGPART (arg1);
12679             }
12680
12681           rcond = fold_binary_loc (loc, code, type, real0, real1);
12682           if (rcond && TREE_CODE (rcond) == INTEGER_CST)
12683             {
12684               if (integer_zerop (rcond))
12685                 {
12686                   if (code == EQ_EXPR)
12687                     return omit_two_operands_loc (loc, type, boolean_false_node,
12688                                               imag0, imag1);
12689                   return fold_build2_loc (loc, NE_EXPR, type, imag0, imag1);
12690                 }
12691               else
12692                 {
12693                   if (code == NE_EXPR)
12694                     return omit_two_operands_loc (loc, type, boolean_true_node,
12695                                               imag0, imag1);
12696                   return fold_build2_loc (loc, EQ_EXPR, type, imag0, imag1);
12697                 }
12698             }
12699
12700           icond = fold_binary_loc (loc, code, type, imag0, imag1);
12701           if (icond && TREE_CODE (icond) == INTEGER_CST)
12702             {
12703               if (integer_zerop (icond))
12704                 {
12705                   if (code == EQ_EXPR)
12706                     return omit_two_operands_loc (loc, type, boolean_false_node,
12707                                               real0, real1);
12708                   return fold_build2_loc (loc, NE_EXPR, type, real0, real1);
12709                 }
12710               else
12711                 {
12712                   if (code == NE_EXPR)
12713                     return omit_two_operands_loc (loc, type, boolean_true_node,
12714                                               real0, real1);
12715                   return fold_build2_loc (loc, EQ_EXPR, type, real0, real1);
12716                 }
12717             }
12718         }
12719
12720       return NULL_TREE;
12721
12722     case LT_EXPR:
12723     case GT_EXPR:
12724     case LE_EXPR:
12725     case GE_EXPR:
12726       tem = fold_comparison (loc, code, type, op0, op1);
12727       if (tem != NULL_TREE)
12728         return tem;
12729
12730       /* Transform comparisons of the form X +- C CMP X.  */
12731       if ((TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
12732           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
12733           && ((TREE_CODE (TREE_OPERAND (arg0, 1)) == REAL_CST
12734                && !HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0))))
12735               || (TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
12736                   && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))))
12737         {
12738           tree arg01 = TREE_OPERAND (arg0, 1);
12739           enum tree_code code0 = TREE_CODE (arg0);
12740           int is_positive;
12741
12742           if (TREE_CODE (arg01) == REAL_CST)
12743             is_positive = REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg01)) ? -1 : 1;
12744           else
12745             is_positive = tree_int_cst_sgn (arg01);
12746
12747           /* (X - c) > X becomes false.  */
12748           if (code == GT_EXPR
12749               && ((code0 == MINUS_EXPR && is_positive >= 0)
12750                   || (code0 == PLUS_EXPR && is_positive <= 0)))
12751             {
12752               if (TREE_CODE (arg01) == INTEGER_CST
12753                   && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
12754                 fold_overflow_warning (("assuming signed overflow does not "
12755                                         "occur when assuming that (X - c) > X "
12756                                         "is always false"),
12757                                        WARN_STRICT_OVERFLOW_ALL);
12758               return constant_boolean_node (0, type);
12759             }
12760
12761           /* Likewise (X + c) < X becomes false.  */
12762           if (code == LT_EXPR
12763               && ((code0 == PLUS_EXPR && is_positive >= 0)
12764                   || (code0 == MINUS_EXPR && is_positive <= 0)))
12765             {
12766               if (TREE_CODE (arg01) == INTEGER_CST
12767                   && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
12768                 fold_overflow_warning (("assuming signed overflow does not "
12769                                         "occur when assuming that "
12770                                         "(X + c) < X is always false"),
12771                                        WARN_STRICT_OVERFLOW_ALL);
12772               return constant_boolean_node (0, type);
12773             }
12774
12775           /* Convert (X - c) <= X to true.  */
12776           if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1)))
12777               && code == LE_EXPR
12778               && ((code0 == MINUS_EXPR && is_positive >= 0)
12779                   || (code0 == PLUS_EXPR && is_positive <= 0)))
12780             {
12781               if (TREE_CODE (arg01) == INTEGER_CST
12782                   && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
12783                 fold_overflow_warning (("assuming signed overflow does not "
12784                                         "occur when assuming that "
12785                                         "(X - c) <= X is always true"),
12786                                        WARN_STRICT_OVERFLOW_ALL);
12787               return constant_boolean_node (1, type);
12788             }
12789
12790           /* Convert (X + c) >= X to true.  */
12791           if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1)))
12792               && code == GE_EXPR
12793               && ((code0 == PLUS_EXPR && is_positive >= 0)
12794                   || (code0 == MINUS_EXPR && is_positive <= 0)))
12795             {
12796               if (TREE_CODE (arg01) == INTEGER_CST
12797                   && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
12798                 fold_overflow_warning (("assuming signed overflow does not "
12799                                         "occur when assuming that "
12800                                         "(X + c) >= X is always true"),
12801                                        WARN_STRICT_OVERFLOW_ALL);
12802               return constant_boolean_node (1, type);
12803             }
12804
12805           if (TREE_CODE (arg01) == INTEGER_CST)
12806             {
12807               /* Convert X + c > X and X - c < X to true for integers.  */
12808               if (code == GT_EXPR
12809                   && ((code0 == PLUS_EXPR && is_positive > 0)
12810                       || (code0 == MINUS_EXPR && is_positive < 0)))
12811                 {
12812                   if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
12813                     fold_overflow_warning (("assuming signed overflow does "
12814                                             "not occur when assuming that "
12815                                             "(X + c) > X is always true"),
12816                                            WARN_STRICT_OVERFLOW_ALL);
12817                   return constant_boolean_node (1, type);
12818                 }
12819
12820               if (code == LT_EXPR
12821                   && ((code0 == MINUS_EXPR && is_positive > 0)
12822                       || (code0 == PLUS_EXPR && is_positive < 0)))
12823                 {
12824                   if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
12825                     fold_overflow_warning (("assuming signed overflow does "
12826                                             "not occur when assuming that "
12827                                             "(X - c) < X is always true"),
12828                                            WARN_STRICT_OVERFLOW_ALL);
12829                   return constant_boolean_node (1, type);
12830                 }
12831
12832               /* Convert X + c <= X and X - c >= X to false for integers.  */
12833               if (code == LE_EXPR
12834                   && ((code0 == PLUS_EXPR && is_positive > 0)
12835                       || (code0 == MINUS_EXPR && is_positive < 0)))
12836                 {
12837                   if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
12838                     fold_overflow_warning (("assuming signed overflow does "
12839                                             "not occur when assuming that "
12840                                             "(X + c) <= X is always false"),
12841                                            WARN_STRICT_OVERFLOW_ALL);
12842                   return constant_boolean_node (0, type);
12843                 }
12844
12845               if (code == GE_EXPR
12846                   && ((code0 == MINUS_EXPR && is_positive > 0)
12847                       || (code0 == PLUS_EXPR && is_positive < 0)))
12848                 {
12849                   if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
12850                     fold_overflow_warning (("assuming signed overflow does "
12851                                             "not occur when assuming that "
12852                                             "(X - c) >= X is always false"),
12853                                            WARN_STRICT_OVERFLOW_ALL);
12854                   return constant_boolean_node (0, type);
12855                 }
12856             }
12857         }
12858
12859       /* Comparisons with the highest or lowest possible integer of
12860          the specified precision will have known values.  */
12861       {
12862         tree arg1_type = TREE_TYPE (arg1);
12863         unsigned int width = TYPE_PRECISION (arg1_type);
12864
12865         if (TREE_CODE (arg1) == INTEGER_CST
12866             && width <= 2 * HOST_BITS_PER_WIDE_INT
12867             && (INTEGRAL_TYPE_P (arg1_type) || POINTER_TYPE_P (arg1_type)))
12868           {
12869             HOST_WIDE_INT signed_max_hi;
12870             unsigned HOST_WIDE_INT signed_max_lo;
12871             unsigned HOST_WIDE_INT max_hi, max_lo, min_hi, min_lo;
12872
12873             if (width <= HOST_BITS_PER_WIDE_INT)
12874               {
12875                 signed_max_lo = ((unsigned HOST_WIDE_INT) 1 << (width - 1))
12876                                 - 1;
12877                 signed_max_hi = 0;
12878                 max_hi = 0;
12879
12880                 if (TYPE_UNSIGNED (arg1_type))
12881                   {
12882                     max_lo = ((unsigned HOST_WIDE_INT) 2 << (width - 1)) - 1;
12883                     min_lo = 0;
12884                     min_hi = 0;
12885                   }
12886                 else
12887                   {
12888                     max_lo = signed_max_lo;
12889                     min_lo = ((unsigned HOST_WIDE_INT) -1 << (width - 1));
12890                     min_hi = -1;
12891                   }
12892               }
12893             else
12894               {
12895                 width -= HOST_BITS_PER_WIDE_INT;
12896                 signed_max_lo = -1;
12897                 signed_max_hi = ((unsigned HOST_WIDE_INT) 1 << (width - 1))
12898                                 - 1;
12899                 max_lo = -1;
12900                 min_lo = 0;
12901
12902                 if (TYPE_UNSIGNED (arg1_type))
12903                   {
12904                     max_hi = ((unsigned HOST_WIDE_INT) 2 << (width - 1)) - 1;
12905                     min_hi = 0;
12906                   }
12907                 else
12908                   {
12909                     max_hi = signed_max_hi;
12910                     min_hi = ((unsigned HOST_WIDE_INT) -1 << (width - 1));
12911                   }
12912               }
12913
12914             if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (arg1) == max_hi
12915                 && TREE_INT_CST_LOW (arg1) == max_lo)
12916               switch (code)
12917                 {
12918                 case GT_EXPR:
12919                   return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
12920
12921                 case GE_EXPR:
12922                   return fold_build2_loc (loc, EQ_EXPR, type, op0, op1);
12923
12924                 case LE_EXPR:
12925                   return omit_one_operand_loc (loc, type, integer_one_node, arg0);
12926
12927                 case LT_EXPR:
12928                   return fold_build2_loc (loc, NE_EXPR, type, op0, op1);
12929
12930                 /* The GE_EXPR and LT_EXPR cases above are not normally
12931                    reached because of previous transformations.  */
12932
12933                 default:
12934                   break;
12935                 }
12936             else if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (arg1)
12937                      == max_hi
12938                      && TREE_INT_CST_LOW (arg1) == max_lo - 1)
12939               switch (code)
12940                 {
12941                 case GT_EXPR:
12942                   arg1 = const_binop (PLUS_EXPR, arg1,
12943                                       build_int_cst (TREE_TYPE (arg1), 1));
12944                   return fold_build2_loc (loc, EQ_EXPR, type,
12945                                       fold_convert_loc (loc,
12946                                                         TREE_TYPE (arg1), arg0),
12947                                       arg1);
12948                 case LE_EXPR:
12949                   arg1 = const_binop (PLUS_EXPR, arg1,
12950                                       build_int_cst (TREE_TYPE (arg1), 1));
12951                   return fold_build2_loc (loc, NE_EXPR, type,
12952                                       fold_convert_loc (loc, TREE_TYPE (arg1),
12953                                                         arg0),
12954                                       arg1);
12955                 default:
12956                   break;
12957                 }
12958             else if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (arg1)
12959                      == min_hi
12960                      && TREE_INT_CST_LOW (arg1) == min_lo)
12961               switch (code)
12962                 {
12963                 case LT_EXPR:
12964                   return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
12965
12966                 case LE_EXPR:
12967                   return fold_build2_loc (loc, EQ_EXPR, type, op0, op1);
12968
12969                 case GE_EXPR:
12970                   return omit_one_operand_loc (loc, type, integer_one_node, arg0);
12971
12972                 case GT_EXPR:
12973                   return fold_build2_loc (loc, NE_EXPR, type, op0, op1);
12974
12975                 default:
12976                   break;
12977                 }
12978             else if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (arg1)
12979                      == min_hi
12980                      && TREE_INT_CST_LOW (arg1) == min_lo + 1)
12981               switch (code)
12982                 {
12983                 case GE_EXPR:
12984                   arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node);
12985                   return fold_build2_loc (loc, NE_EXPR, type,
12986                                       fold_convert_loc (loc,
12987                                                         TREE_TYPE (arg1), arg0),
12988                                       arg1);
12989                 case LT_EXPR:
12990                   arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node);
12991                   return fold_build2_loc (loc, EQ_EXPR, type,
12992                                       fold_convert_loc (loc, TREE_TYPE (arg1),
12993                                                         arg0),
12994                                       arg1);
12995                 default:
12996                   break;
12997                 }
12998
12999             else if (TREE_INT_CST_HIGH (arg1) == signed_max_hi
13000                      && TREE_INT_CST_LOW (arg1) == signed_max_lo
13001                      && TYPE_UNSIGNED (arg1_type)
13002                      /* We will flip the signedness of the comparison operator
13003                         associated with the mode of arg1, so the sign bit is
13004                         specified by this mode.  Check that arg1 is the signed
13005                         max associated with this sign bit.  */
13006                      && width == GET_MODE_BITSIZE (TYPE_MODE (arg1_type))
13007                      /* signed_type does not work on pointer types.  */
13008                      && INTEGRAL_TYPE_P (arg1_type))
13009               {
13010                 /* The following case also applies to X < signed_max+1
13011                    and X >= signed_max+1 because previous transformations.  */
13012                 if (code == LE_EXPR || code == GT_EXPR)
13013                   {
13014                     tree st;
13015                     st = signed_type_for (TREE_TYPE (arg1));
13016                     return fold_build2_loc (loc,
13017                                         code == LE_EXPR ? GE_EXPR : LT_EXPR,
13018                                         type, fold_convert_loc (loc, st, arg0),
13019                                         build_int_cst (st, 0));
13020                   }
13021               }
13022           }
13023       }
13024
13025       /* If we are comparing an ABS_EXPR with a constant, we can
13026          convert all the cases into explicit comparisons, but they may
13027          well not be faster than doing the ABS and one comparison.
13028          But ABS (X) <= C is a range comparison, which becomes a subtraction
13029          and a comparison, and is probably faster.  */
13030       if (code == LE_EXPR
13031           && TREE_CODE (arg1) == INTEGER_CST
13032           && TREE_CODE (arg0) == ABS_EXPR
13033           && ! TREE_SIDE_EFFECTS (arg0)
13034           && (0 != (tem = negate_expr (arg1)))
13035           && TREE_CODE (tem) == INTEGER_CST
13036           && !TREE_OVERFLOW (tem))
13037         return fold_build2_loc (loc, TRUTH_ANDIF_EXPR, type,
13038                             build2 (GE_EXPR, type,
13039                                     TREE_OPERAND (arg0, 0), tem),
13040                             build2 (LE_EXPR, type,
13041                                     TREE_OPERAND (arg0, 0), arg1));
13042
13043       /* Convert ABS_EXPR<x> >= 0 to true.  */
13044       strict_overflow_p = false;
13045       if (code == GE_EXPR
13046           && (integer_zerop (arg1)
13047               || (! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0)))
13048                   && real_zerop (arg1)))
13049           && tree_expr_nonnegative_warnv_p (arg0, &strict_overflow_p))
13050         {
13051           if (strict_overflow_p)
13052             fold_overflow_warning (("assuming signed overflow does not occur "
13053                                     "when simplifying comparison of "
13054                                     "absolute value and zero"),
13055                                    WARN_STRICT_OVERFLOW_CONDITIONAL);
13056           return omit_one_operand_loc (loc, type, integer_one_node, arg0);
13057         }
13058
13059       /* Convert ABS_EXPR<x> < 0 to false.  */
13060       strict_overflow_p = false;
13061       if (code == LT_EXPR
13062           && (integer_zerop (arg1) || real_zerop (arg1))
13063           && tree_expr_nonnegative_warnv_p (arg0, &strict_overflow_p))
13064         {
13065           if (strict_overflow_p)
13066             fold_overflow_warning (("assuming signed overflow does not occur "
13067                                     "when simplifying comparison of "
13068                                     "absolute value and zero"),
13069                                    WARN_STRICT_OVERFLOW_CONDITIONAL);
13070           return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
13071         }
13072
13073       /* If X is unsigned, convert X < (1 << Y) into X >> Y == 0
13074          and similarly for >= into !=.  */
13075       if ((code == LT_EXPR || code == GE_EXPR)
13076           && TYPE_UNSIGNED (TREE_TYPE (arg0))
13077           && TREE_CODE (arg1) == LSHIFT_EXPR
13078           && integer_onep (TREE_OPERAND (arg1, 0)))
13079         return build2_loc (loc, code == LT_EXPR ? EQ_EXPR : NE_EXPR, type,
13080                            build2 (RSHIFT_EXPR, TREE_TYPE (arg0), arg0,
13081                                    TREE_OPERAND (arg1, 1)),
13082                            build_int_cst (TREE_TYPE (arg0), 0));
13083
13084       if ((code == LT_EXPR || code == GE_EXPR)
13085           && TYPE_UNSIGNED (TREE_TYPE (arg0))
13086           && CONVERT_EXPR_P (arg1)
13087           && TREE_CODE (TREE_OPERAND (arg1, 0)) == LSHIFT_EXPR
13088           && integer_onep (TREE_OPERAND (TREE_OPERAND (arg1, 0), 0)))
13089         {
13090           tem = build2 (RSHIFT_EXPR, TREE_TYPE (arg0), arg0,
13091                         TREE_OPERAND (TREE_OPERAND (arg1, 0), 1));
13092           return build2_loc (loc, code == LT_EXPR ? EQ_EXPR : NE_EXPR, type,
13093                              fold_convert_loc (loc, TREE_TYPE (arg0), tem),
13094                              build_int_cst (TREE_TYPE (arg0), 0));
13095         }
13096
13097       return NULL_TREE;
13098
13099     case UNORDERED_EXPR:
13100     case ORDERED_EXPR:
13101     case UNLT_EXPR:
13102     case UNLE_EXPR:
13103     case UNGT_EXPR:
13104     case UNGE_EXPR:
13105     case UNEQ_EXPR:
13106     case LTGT_EXPR:
13107       if (TREE_CODE (arg0) == REAL_CST && TREE_CODE (arg1) == REAL_CST)
13108         {
13109           t1 = fold_relational_const (code, type, arg0, arg1);
13110           if (t1 != NULL_TREE)
13111             return t1;
13112         }
13113
13114       /* If the first operand is NaN, the result is constant.  */
13115       if (TREE_CODE (arg0) == REAL_CST
13116           && REAL_VALUE_ISNAN (TREE_REAL_CST (arg0))
13117           && (code != LTGT_EXPR || ! flag_trapping_math))
13118         {
13119           t1 = (code == ORDERED_EXPR || code == LTGT_EXPR)
13120                ? integer_zero_node
13121                : integer_one_node;
13122           return omit_one_operand_loc (loc, type, t1, arg1);
13123         }
13124
13125       /* If the second operand is NaN, the result is constant.  */
13126       if (TREE_CODE (arg1) == REAL_CST
13127           && REAL_VALUE_ISNAN (TREE_REAL_CST (arg1))
13128           && (code != LTGT_EXPR || ! flag_trapping_math))
13129         {
13130           t1 = (code == ORDERED_EXPR || code == LTGT_EXPR)
13131                ? integer_zero_node
13132                : integer_one_node;
13133           return omit_one_operand_loc (loc, type, t1, arg0);
13134         }
13135
13136       /* Simplify unordered comparison of something with itself.  */
13137       if ((code == UNLE_EXPR || code == UNGE_EXPR || code == UNEQ_EXPR)
13138           && operand_equal_p (arg0, arg1, 0))
13139         return constant_boolean_node (1, type);
13140
13141       if (code == LTGT_EXPR
13142           && !flag_trapping_math
13143           && operand_equal_p (arg0, arg1, 0))
13144         return constant_boolean_node (0, type);
13145
13146       /* Fold (double)float1 CMP (double)float2 into float1 CMP float2.  */
13147       {
13148         tree targ0 = strip_float_extensions (arg0);
13149         tree targ1 = strip_float_extensions (arg1);
13150         tree newtype = TREE_TYPE (targ0);
13151
13152         if (TYPE_PRECISION (TREE_TYPE (targ1)) > TYPE_PRECISION (newtype))
13153           newtype = TREE_TYPE (targ1);
13154
13155         if (TYPE_PRECISION (newtype) < TYPE_PRECISION (TREE_TYPE (arg0)))
13156           return fold_build2_loc (loc, code, type,
13157                               fold_convert_loc (loc, newtype, targ0),
13158                               fold_convert_loc (loc, newtype, targ1));
13159       }
13160
13161       return NULL_TREE;
13162
13163     case COMPOUND_EXPR:
13164       /* When pedantic, a compound expression can be neither an lvalue
13165          nor an integer constant expression.  */
13166       if (TREE_SIDE_EFFECTS (arg0) || TREE_CONSTANT (arg1))
13167         return NULL_TREE;
13168       /* Don't let (0, 0) be null pointer constant.  */
13169       tem = integer_zerop (arg1) ? build1 (NOP_EXPR, type, arg1)
13170                                  : fold_convert_loc (loc, type, arg1);
13171       return pedantic_non_lvalue_loc (loc, tem);
13172
13173     case COMPLEX_EXPR:
13174       if ((TREE_CODE (arg0) == REAL_CST
13175            && TREE_CODE (arg1) == REAL_CST)
13176           || (TREE_CODE (arg0) == INTEGER_CST
13177               && TREE_CODE (arg1) == INTEGER_CST))
13178         return build_complex (type, arg0, arg1);
13179       if (TREE_CODE (arg0) == REALPART_EXPR
13180           && TREE_CODE (arg1) == IMAGPART_EXPR
13181           && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (arg0, 0)))
13182               == TYPE_MAIN_VARIANT (type))
13183           && operand_equal_p (TREE_OPERAND (arg0, 0),
13184                               TREE_OPERAND (arg1, 0), 0))
13185         return omit_one_operand_loc (loc, type, TREE_OPERAND (arg0, 0),
13186                                      TREE_OPERAND (arg1, 0));
13187       return NULL_TREE;
13188
13189     case ASSERT_EXPR:
13190       /* An ASSERT_EXPR should never be passed to fold_binary.  */
13191       gcc_unreachable ();
13192
13193     default:
13194       return NULL_TREE;
13195     } /* switch (code) */
13196 }
13197
13198 /* Callback for walk_tree, looking for LABEL_EXPR.  Return *TP if it is
13199    a LABEL_EXPR; otherwise return NULL_TREE.  Do not check the subtrees
13200    of GOTO_EXPR.  */
13201
13202 static tree
13203 contains_label_1 (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
13204 {
13205   switch (TREE_CODE (*tp))
13206     {
13207     case LABEL_EXPR:
13208       return *tp;
13209
13210     case GOTO_EXPR:
13211       *walk_subtrees = 0;
13212
13213       /* ... fall through ...  */
13214
13215     default:
13216       return NULL_TREE;
13217     }
13218 }
13219
13220 /* Return whether the sub-tree ST contains a label which is accessible from
13221    outside the sub-tree.  */
13222
13223 static bool
13224 contains_label_p (tree st)
13225 {
13226   return
13227    (walk_tree_without_duplicates (&st, contains_label_1 , NULL) != NULL_TREE);
13228 }
13229
13230 /* Fold a ternary expression of code CODE and type TYPE with operands
13231    OP0, OP1, and OP2.  Return the folded expression if folding is
13232    successful.  Otherwise, return NULL_TREE.  */
13233
13234 tree
13235 fold_ternary_loc (location_t loc, enum tree_code code, tree type,
13236                   tree op0, tree op1, tree op2)
13237 {
13238   tree tem;
13239   tree arg0 = NULL_TREE, arg1 = NULL_TREE, arg2 = NULL_TREE;
13240   enum tree_code_class kind = TREE_CODE_CLASS (code);
13241
13242   gcc_assert (IS_EXPR_CODE_CLASS (kind)
13243               && TREE_CODE_LENGTH (code) == 3);
13244
13245   /* Strip any conversions that don't change the mode.  This is safe
13246      for every expression, except for a comparison expression because
13247      its signedness is derived from its operands.  So, in the latter
13248      case, only strip conversions that don't change the signedness.
13249
13250      Note that this is done as an internal manipulation within the
13251      constant folder, in order to find the simplest representation of
13252      the arguments so that their form can be studied.  In any cases,
13253      the appropriate type conversions should be put back in the tree
13254      that will get out of the constant folder.  */
13255   if (op0)
13256     {
13257       arg0 = op0;
13258       STRIP_NOPS (arg0);
13259     }
13260
13261   if (op1)
13262     {
13263       arg1 = op1;
13264       STRIP_NOPS (arg1);
13265     }
13266
13267   if (op2)
13268     {
13269       arg2 = op2;
13270       STRIP_NOPS (arg2);
13271     }
13272
13273   switch (code)
13274     {
13275     case COMPONENT_REF:
13276       if (TREE_CODE (arg0) == CONSTRUCTOR
13277           && ! type_contains_placeholder_p (TREE_TYPE (arg0)))
13278         {
13279           unsigned HOST_WIDE_INT idx;
13280           tree field, value;
13281           FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (arg0), idx, field, value)
13282             if (field == arg1)
13283               return value;
13284         }
13285       return NULL_TREE;
13286
13287     case COND_EXPR:
13288       /* Pedantic ANSI C says that a conditional expression is never an lvalue,
13289          so all simple results must be passed through pedantic_non_lvalue.  */
13290       if (TREE_CODE (arg0) == INTEGER_CST)
13291         {
13292           tree unused_op = integer_zerop (arg0) ? op1 : op2;
13293           tem = integer_zerop (arg0) ? op2 : op1;
13294           /* Only optimize constant conditions when the selected branch
13295              has the same type as the COND_EXPR.  This avoids optimizing
13296              away "c ? x : throw", where the throw has a void type.
13297              Avoid throwing away that operand which contains label.  */
13298           if ((!TREE_SIDE_EFFECTS (unused_op)
13299                || !contains_label_p (unused_op))
13300               && (! VOID_TYPE_P (TREE_TYPE (tem))
13301                   || VOID_TYPE_P (type)))
13302             return pedantic_non_lvalue_loc (loc, tem);
13303           return NULL_TREE;
13304         }
13305       if (operand_equal_p (arg1, op2, 0))
13306         return pedantic_omit_one_operand_loc (loc, type, arg1, arg0);
13307
13308       /* If we have A op B ? A : C, we may be able to convert this to a
13309          simpler expression, depending on the operation and the values
13310          of B and C.  Signed zeros prevent all of these transformations,
13311          for reasons given above each one.
13312
13313          Also try swapping the arguments and inverting the conditional.  */
13314       if (COMPARISON_CLASS_P (arg0)
13315           && operand_equal_for_comparison_p (TREE_OPERAND (arg0, 0),
13316                                              arg1, TREE_OPERAND (arg0, 1))
13317           && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg1))))
13318         {
13319           tem = fold_cond_expr_with_comparison (loc, type, arg0, op1, op2);
13320           if (tem)
13321             return tem;
13322         }
13323
13324       if (COMPARISON_CLASS_P (arg0)
13325           && operand_equal_for_comparison_p (TREE_OPERAND (arg0, 0),
13326                                              op2,
13327                                              TREE_OPERAND (arg0, 1))
13328           && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (op2))))
13329         {
13330           tem = fold_truth_not_expr (loc, arg0);
13331           if (tem && COMPARISON_CLASS_P (tem))
13332             {
13333               tem = fold_cond_expr_with_comparison (loc, type, tem, op2, op1);
13334               if (tem)
13335                 return tem;
13336             }
13337         }
13338
13339       /* If the second operand is simpler than the third, swap them
13340          since that produces better jump optimization results.  */
13341       if (truth_value_p (TREE_CODE (arg0))
13342           && tree_swap_operands_p (op1, op2, false))
13343         {
13344           /* See if this can be inverted.  If it can't, possibly because
13345              it was a floating-point inequality comparison, don't do
13346              anything.  */
13347           tem = fold_truth_not_expr (loc, arg0);
13348           if (tem)
13349             return fold_build3_loc (loc, code, type, tem, op2, op1);
13350         }
13351
13352       /* Convert A ? 1 : 0 to simply A.  */
13353       if (integer_onep (op1)
13354           && integer_zerop (op2)
13355           /* If we try to convert OP0 to our type, the
13356              call to fold will try to move the conversion inside
13357              a COND, which will recurse.  In that case, the COND_EXPR
13358              is probably the best choice, so leave it alone.  */
13359           && type == TREE_TYPE (arg0))
13360         return pedantic_non_lvalue_loc (loc, arg0);
13361
13362       /* Convert A ? 0 : 1 to !A.  This prefers the use of NOT_EXPR
13363          over COND_EXPR in cases such as floating point comparisons.  */
13364       if (integer_zerop (op1)
13365           && integer_onep (op2)
13366           && truth_value_p (TREE_CODE (arg0)))
13367         return pedantic_non_lvalue_loc (loc,
13368                                     fold_convert_loc (loc, type,
13369                                               invert_truthvalue_loc (loc,
13370                                                                      arg0)));
13371
13372       /* A < 0 ? <sign bit of A> : 0 is simply (A & <sign bit of A>).  */
13373       if (TREE_CODE (arg0) == LT_EXPR
13374           && integer_zerop (TREE_OPERAND (arg0, 1))
13375           && integer_zerop (op2)
13376           && (tem = sign_bit_p (TREE_OPERAND (arg0, 0), arg1)))
13377         {
13378           /* sign_bit_p only checks ARG1 bits within A's precision.
13379              If <sign bit of A> has wider type than A, bits outside
13380              of A's precision in <sign bit of A> need to be checked.
13381              If they are all 0, this optimization needs to be done
13382              in unsigned A's type, if they are all 1 in signed A's type,
13383              otherwise this can't be done.  */
13384           if (TYPE_PRECISION (TREE_TYPE (tem))
13385               < TYPE_PRECISION (TREE_TYPE (arg1))
13386               && TYPE_PRECISION (TREE_TYPE (tem))
13387                  < TYPE_PRECISION (type))
13388             {
13389               unsigned HOST_WIDE_INT mask_lo;
13390               HOST_WIDE_INT mask_hi;
13391               int inner_width, outer_width;
13392               tree tem_type;
13393
13394               inner_width = TYPE_PRECISION (TREE_TYPE (tem));
13395               outer_width = TYPE_PRECISION (TREE_TYPE (arg1));
13396               if (outer_width > TYPE_PRECISION (type))
13397                 outer_width = TYPE_PRECISION (type);
13398
13399               if (outer_width > HOST_BITS_PER_WIDE_INT)
13400                 {
13401                   mask_hi = ((unsigned HOST_WIDE_INT) -1
13402                              >> (2 * HOST_BITS_PER_WIDE_INT - outer_width));
13403                   mask_lo = -1;
13404                 }
13405               else
13406                 {
13407                   mask_hi = 0;
13408                   mask_lo = ((unsigned HOST_WIDE_INT) -1
13409                              >> (HOST_BITS_PER_WIDE_INT - outer_width));
13410                 }
13411               if (inner_width > HOST_BITS_PER_WIDE_INT)
13412                 {
13413                   mask_hi &= ~((unsigned HOST_WIDE_INT) -1
13414                                >> (HOST_BITS_PER_WIDE_INT - inner_width));
13415                   mask_lo = 0;
13416                 }
13417               else
13418                 mask_lo &= ~((unsigned HOST_WIDE_INT) -1
13419                              >> (HOST_BITS_PER_WIDE_INT - inner_width));
13420
13421               if ((TREE_INT_CST_HIGH (arg1) & mask_hi) == mask_hi
13422                   && (TREE_INT_CST_LOW (arg1) & mask_lo) == mask_lo)
13423                 {
13424                   tem_type = signed_type_for (TREE_TYPE (tem));
13425                   tem = fold_convert_loc (loc, tem_type, tem);
13426                 }
13427               else if ((TREE_INT_CST_HIGH (arg1) & mask_hi) == 0
13428                        && (TREE_INT_CST_LOW (arg1) & mask_lo) == 0)
13429                 {
13430                   tem_type = unsigned_type_for (TREE_TYPE (tem));
13431                   tem = fold_convert_loc (loc, tem_type, tem);
13432                 }
13433               else
13434                 tem = NULL;
13435             }
13436
13437           if (tem)
13438             return
13439               fold_convert_loc (loc, type,
13440                                 fold_build2_loc (loc, BIT_AND_EXPR,
13441                                              TREE_TYPE (tem), tem,
13442                                              fold_convert_loc (loc,
13443                                                                TREE_TYPE (tem),
13444                                                                arg1)));
13445         }
13446
13447       /* (A >> N) & 1 ? (1 << N) : 0 is simply A & (1 << N).  A & 1 was
13448          already handled above.  */
13449       if (TREE_CODE (arg0) == BIT_AND_EXPR
13450           && integer_onep (TREE_OPERAND (arg0, 1))
13451           && integer_zerop (op2)
13452           && integer_pow2p (arg1))
13453         {
13454           tree tem = TREE_OPERAND (arg0, 0);
13455           STRIP_NOPS (tem);
13456           if (TREE_CODE (tem) == RSHIFT_EXPR
13457               && TREE_CODE (TREE_OPERAND (tem, 1)) == INTEGER_CST
13458               && (unsigned HOST_WIDE_INT) tree_log2 (arg1) ==
13459                  TREE_INT_CST_LOW (TREE_OPERAND (tem, 1)))
13460             return fold_build2_loc (loc, BIT_AND_EXPR, type,
13461                                 TREE_OPERAND (tem, 0), arg1);
13462         }
13463
13464       /* A & N ? N : 0 is simply A & N if N is a power of two.  This
13465          is probably obsolete because the first operand should be a
13466          truth value (that's why we have the two cases above), but let's
13467          leave it in until we can confirm this for all front-ends.  */
13468       if (integer_zerop (op2)
13469           && TREE_CODE (arg0) == NE_EXPR
13470           && integer_zerop (TREE_OPERAND (arg0, 1))
13471           && integer_pow2p (arg1)
13472           && TREE_CODE (TREE_OPERAND (arg0, 0)) == BIT_AND_EXPR
13473           && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1),
13474                               arg1, OEP_ONLY_CONST))
13475         return pedantic_non_lvalue_loc (loc,
13476                                     fold_convert_loc (loc, type,
13477                                                       TREE_OPERAND (arg0, 0)));
13478
13479       /* Convert A ? B : 0 into A && B if A and B are truth values.  */
13480       if (integer_zerop (op2)
13481           && truth_value_p (TREE_CODE (arg0))
13482           && truth_value_p (TREE_CODE (arg1)))
13483         return fold_build2_loc (loc, TRUTH_ANDIF_EXPR, type,
13484                             fold_convert_loc (loc, type, arg0),
13485                             arg1);
13486
13487       /* Convert A ? B : 1 into !A || B if A and B are truth values.  */
13488       if (integer_onep (op2)
13489           && truth_value_p (TREE_CODE (arg0))
13490           && truth_value_p (TREE_CODE (arg1)))
13491         {
13492           /* Only perform transformation if ARG0 is easily inverted.  */
13493           tem = fold_truth_not_expr (loc, arg0);
13494           if (tem)
13495             return fold_build2_loc (loc, TRUTH_ORIF_EXPR, type,
13496                                 fold_convert_loc (loc, type, tem),
13497                                 arg1);
13498         }
13499
13500       /* Convert A ? 0 : B into !A && B if A and B are truth values.  */
13501       if (integer_zerop (arg1)
13502           && truth_value_p (TREE_CODE (arg0))
13503           && truth_value_p (TREE_CODE (op2)))
13504         {
13505           /* Only perform transformation if ARG0 is easily inverted.  */
13506           tem = fold_truth_not_expr (loc, arg0);
13507           if (tem)
13508             return fold_build2_loc (loc, TRUTH_ANDIF_EXPR, type,
13509                                 fold_convert_loc (loc, type, tem),
13510                                 op2);
13511         }
13512
13513       /* Convert A ? 1 : B into A || B if A and B are truth values.  */
13514       if (integer_onep (arg1)
13515           && truth_value_p (TREE_CODE (arg0))
13516           && truth_value_p (TREE_CODE (op2)))
13517         return fold_build2_loc (loc, TRUTH_ORIF_EXPR, type,
13518                             fold_convert_loc (loc, type, arg0),
13519                             op2);
13520
13521       return NULL_TREE;
13522
13523     case CALL_EXPR:
13524       /* CALL_EXPRs used to be ternary exprs.  Catch any mistaken uses
13525          of fold_ternary on them.  */
13526       gcc_unreachable ();
13527
13528     case BIT_FIELD_REF:
13529       if ((TREE_CODE (arg0) == VECTOR_CST
13530            || (TREE_CODE (arg0) == CONSTRUCTOR && TREE_CONSTANT (arg0)))
13531           && type == TREE_TYPE (TREE_TYPE (arg0)))
13532         {
13533           unsigned HOST_WIDE_INT width = tree_low_cst (arg1, 1);
13534           unsigned HOST_WIDE_INT idx = tree_low_cst (op2, 1);
13535
13536           if (width != 0
13537               && simple_cst_equal (arg1, TYPE_SIZE (type)) == 1
13538               && (idx % width) == 0
13539               && (idx = idx / width)
13540                  < TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0)))
13541             {
13542               tree elements = NULL_TREE;
13543
13544               if (TREE_CODE (arg0) == VECTOR_CST)
13545                 elements = TREE_VECTOR_CST_ELTS (arg0);
13546               else
13547                 {
13548                   unsigned HOST_WIDE_INT idx;
13549                   tree value;
13550
13551                   FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (arg0), idx, value)
13552                     elements = tree_cons (NULL_TREE, value, elements);
13553                 }
13554               while (idx-- > 0 && elements)
13555                 elements = TREE_CHAIN (elements);
13556               if (elements)
13557                 return TREE_VALUE (elements);
13558               else
13559                 return build_zero_cst (type);
13560             }
13561         }
13562
13563       /* A bit-field-ref that referenced the full argument can be stripped.  */
13564       if (INTEGRAL_TYPE_P (TREE_TYPE (arg0))
13565           && TYPE_PRECISION (TREE_TYPE (arg0)) == tree_low_cst (arg1, 1)
13566           && integer_zerop (op2))
13567         return fold_convert_loc (loc, type, arg0);
13568
13569       return NULL_TREE;
13570
13571     case FMA_EXPR:
13572       /* For integers we can decompose the FMA if possible.  */
13573       if (TREE_CODE (arg0) == INTEGER_CST
13574           && TREE_CODE (arg1) == INTEGER_CST)
13575         return fold_build2_loc (loc, PLUS_EXPR, type,
13576                                 const_binop (MULT_EXPR, arg0, arg1), arg2);
13577       if (integer_zerop (arg2))
13578         return fold_build2_loc (loc, MULT_EXPR, type, arg0, arg1);
13579
13580       return fold_fma (loc, type, arg0, arg1, arg2);
13581
13582     default:
13583       return NULL_TREE;
13584     } /* switch (code) */
13585 }
13586
13587 /* Perform constant folding and related simplification of EXPR.
13588    The related simplifications include x*1 => x, x*0 => 0, etc.,
13589    and application of the associative law.
13590    NOP_EXPR conversions may be removed freely (as long as we
13591    are careful not to change the type of the overall expression).
13592    We cannot simplify through a CONVERT_EXPR, FIX_EXPR or FLOAT_EXPR,
13593    but we can constant-fold them if they have constant operands.  */
13594
13595 #ifdef ENABLE_FOLD_CHECKING
13596 # define fold(x) fold_1 (x)
13597 static tree fold_1 (tree);
13598 static
13599 #endif
13600 tree
13601 fold (tree expr)
13602 {
13603   const tree t = expr;
13604   enum tree_code code = TREE_CODE (t);
13605   enum tree_code_class kind = TREE_CODE_CLASS (code);
13606   tree tem;
13607   location_t loc = EXPR_LOCATION (expr);
13608
13609   /* Return right away if a constant.  */
13610   if (kind == tcc_constant)
13611     return t;
13612
13613   /* CALL_EXPR-like objects with variable numbers of operands are
13614      treated specially.  */
13615   if (kind == tcc_vl_exp)
13616     {
13617       if (code == CALL_EXPR)
13618         {
13619           tem = fold_call_expr (loc, expr, false);
13620           return tem ? tem : expr;
13621         }
13622       return expr;
13623     }
13624
13625   if (IS_EXPR_CODE_CLASS (kind))
13626     {
13627       tree type = TREE_TYPE (t);
13628       tree op0, op1, op2;
13629
13630       switch (TREE_CODE_LENGTH (code))
13631         {
13632         case 1:
13633           op0 = TREE_OPERAND (t, 0);
13634           tem = fold_unary_loc (loc, code, type, op0);
13635           return tem ? tem : expr;
13636         case 2:
13637           op0 = TREE_OPERAND (t, 0);
13638           op1 = TREE_OPERAND (t, 1);
13639           tem = fold_binary_loc (loc, code, type, op0, op1);
13640           return tem ? tem : expr;
13641         case 3:
13642           op0 = TREE_OPERAND (t, 0);
13643           op1 = TREE_OPERAND (t, 1);
13644           op2 = TREE_OPERAND (t, 2);
13645           tem = fold_ternary_loc (loc, code, type, op0, op1, op2);
13646           return tem ? tem : expr;
13647         default:
13648           break;
13649         }
13650     }
13651
13652   switch (code)
13653     {
13654     case ARRAY_REF:
13655       {
13656         tree op0 = TREE_OPERAND (t, 0);
13657         tree op1 = TREE_OPERAND (t, 1);
13658
13659         if (TREE_CODE (op1) == INTEGER_CST
13660             && TREE_CODE (op0) == CONSTRUCTOR
13661             && ! type_contains_placeholder_p (TREE_TYPE (op0)))
13662           {
13663             VEC(constructor_elt,gc) *elts = CONSTRUCTOR_ELTS (op0);
13664             unsigned HOST_WIDE_INT end = VEC_length (constructor_elt, elts);
13665             unsigned HOST_WIDE_INT begin = 0;
13666
13667             /* Find a matching index by means of a binary search.  */
13668             while (begin != end)
13669               {
13670                 unsigned HOST_WIDE_INT middle = (begin + end) / 2;
13671                 tree index = VEC_index (constructor_elt, elts, middle)->index;
13672
13673                 if (TREE_CODE (index) == INTEGER_CST
13674                     && tree_int_cst_lt (index, op1))
13675                   begin = middle + 1;
13676                 else if (TREE_CODE (index) == INTEGER_CST
13677                          && tree_int_cst_lt (op1, index))
13678                   end = middle;
13679                 else if (TREE_CODE (index) == RANGE_EXPR
13680                          && tree_int_cst_lt (TREE_OPERAND (index, 1), op1))
13681                   begin = middle + 1;
13682                 else if (TREE_CODE (index) == RANGE_EXPR
13683                          && tree_int_cst_lt (op1, TREE_OPERAND (index, 0)))
13684                   end = middle;
13685                 else
13686                   return VEC_index (constructor_elt, elts, middle)->value;
13687               }
13688           }
13689
13690         return t;
13691       }
13692
13693     case CONST_DECL:
13694       return fold (DECL_INITIAL (t));
13695
13696     default:
13697       return t;
13698     } /* switch (code) */
13699 }
13700
13701 #ifdef ENABLE_FOLD_CHECKING
13702 #undef fold
13703
13704 static void fold_checksum_tree (const_tree, struct md5_ctx *, htab_t);
13705 static void fold_check_failed (const_tree, const_tree);
13706 void print_fold_checksum (const_tree);
13707
13708 /* When --enable-checking=fold, compute a digest of expr before
13709    and after actual fold call to see if fold did not accidentally
13710    change original expr.  */
13711
13712 tree
13713 fold (tree expr)
13714 {
13715   tree ret;
13716   struct md5_ctx ctx;
13717   unsigned char checksum_before[16], checksum_after[16];
13718   htab_t ht;
13719
13720   ht = htab_create (32, htab_hash_pointer, htab_eq_pointer, NULL);
13721   md5_init_ctx (&ctx);
13722   fold_checksum_tree (expr, &ctx, ht);
13723   md5_finish_ctx (&ctx, checksum_before);
13724   htab_empty (ht);
13725
13726   ret = fold_1 (expr);
13727
13728   md5_init_ctx (&ctx);
13729   fold_checksum_tree (expr, &ctx, ht);
13730   md5_finish_ctx (&ctx, checksum_after);
13731   htab_delete (ht);
13732
13733   if (memcmp (checksum_before, checksum_after, 16))
13734     fold_check_failed (expr, ret);
13735
13736   return ret;
13737 }
13738
13739 void
13740 print_fold_checksum (const_tree expr)
13741 {
13742   struct md5_ctx ctx;
13743   unsigned char checksum[16], cnt;
13744   htab_t ht;
13745
13746   ht = htab_create (32, htab_hash_pointer, htab_eq_pointer, NULL);
13747   md5_init_ctx (&ctx);
13748   fold_checksum_tree (expr, &ctx, ht);
13749   md5_finish_ctx (&ctx, checksum);
13750   htab_delete (ht);
13751   for (cnt = 0; cnt < 16; ++cnt)
13752     fprintf (stderr, "%02x", checksum[cnt]);
13753   putc ('\n', stderr);
13754 }
13755
13756 static void
13757 fold_check_failed (const_tree expr ATTRIBUTE_UNUSED, const_tree ret ATTRIBUTE_UNUSED)
13758 {
13759   internal_error ("fold check: original tree changed by fold");
13760 }
13761
13762 static void
13763 fold_checksum_tree (const_tree expr, struct md5_ctx *ctx, htab_t ht)
13764 {
13765   void **slot;
13766   enum tree_code code;
13767   union tree_node buf;
13768   int i, len;
13769
13770 recursive_label:
13771
13772   gcc_assert ((sizeof (struct tree_exp) + 5 * sizeof (tree)
13773                <= sizeof (struct tree_function_decl))
13774               && sizeof (struct tree_type) <= sizeof (struct tree_function_decl));
13775   if (expr == NULL)
13776     return;
13777   slot = (void **) htab_find_slot (ht, expr, INSERT);
13778   if (*slot != NULL)
13779     return;
13780   *slot = CONST_CAST_TREE (expr);
13781   code = TREE_CODE (expr);
13782   if (TREE_CODE_CLASS (code) == tcc_declaration
13783       && DECL_ASSEMBLER_NAME_SET_P (expr))
13784     {
13785       /* Allow DECL_ASSEMBLER_NAME to be modified.  */
13786       memcpy ((char *) &buf, expr, tree_size (expr));
13787       SET_DECL_ASSEMBLER_NAME ((tree)&buf, NULL);
13788       expr = (tree) &buf;
13789     }
13790   else if (TREE_CODE_CLASS (code) == tcc_type
13791            && (TYPE_POINTER_TO (expr)
13792                || TYPE_REFERENCE_TO (expr)
13793                || TYPE_CACHED_VALUES_P (expr)
13794                || TYPE_CONTAINS_PLACEHOLDER_INTERNAL (expr)
13795                || TYPE_NEXT_VARIANT (expr)))
13796     {
13797       /* Allow these fields to be modified.  */
13798       tree tmp;
13799       memcpy ((char *) &buf, expr, tree_size (expr));
13800       expr = tmp = (tree) &buf;
13801       TYPE_CONTAINS_PLACEHOLDER_INTERNAL (tmp) = 0;
13802       TYPE_POINTER_TO (tmp) = NULL;
13803       TYPE_REFERENCE_TO (tmp) = NULL;
13804       TYPE_NEXT_VARIANT (tmp) = NULL;
13805       if (TYPE_CACHED_VALUES_P (tmp))
13806         {
13807           TYPE_CACHED_VALUES_P (tmp) = 0;
13808           TYPE_CACHED_VALUES (tmp) = NULL;
13809         }
13810     }
13811   md5_process_bytes (expr, tree_size (expr), ctx);
13812   fold_checksum_tree (TREE_TYPE (expr), ctx, ht);
13813   if (TREE_CODE_CLASS (code) != tcc_type
13814       && TREE_CODE_CLASS (code) != tcc_declaration
13815       && code != TREE_LIST
13816       && code != SSA_NAME)
13817     fold_checksum_tree (TREE_CHAIN (expr), ctx, ht);
13818   switch (TREE_CODE_CLASS (code))
13819     {
13820     case tcc_constant:
13821       switch (code)
13822         {
13823         case STRING_CST:
13824           md5_process_bytes (TREE_STRING_POINTER (expr),
13825                              TREE_STRING_LENGTH (expr), ctx);
13826           break;
13827         case COMPLEX_CST:
13828           fold_checksum_tree (TREE_REALPART (expr), ctx, ht);
13829           fold_checksum_tree (TREE_IMAGPART (expr), ctx, ht);
13830           break;
13831         case VECTOR_CST:
13832           fold_checksum_tree (TREE_VECTOR_CST_ELTS (expr), ctx, ht);
13833           break;
13834         default:
13835           break;
13836         }
13837       break;
13838     case tcc_exceptional:
13839       switch (code)
13840         {
13841         case TREE_LIST:
13842           fold_checksum_tree (TREE_PURPOSE (expr), ctx, ht);
13843           fold_checksum_tree (TREE_VALUE (expr), ctx, ht);
13844           expr = TREE_CHAIN (expr);
13845           goto recursive_label;
13846           break;
13847         case TREE_VEC:
13848           for (i = 0; i < TREE_VEC_LENGTH (expr); ++i)
13849             fold_checksum_tree (TREE_VEC_ELT (expr, i), ctx, ht);
13850           break;
13851         default:
13852           break;
13853         }
13854       break;
13855     case tcc_expression:
13856     case tcc_reference:
13857     case tcc_comparison:
13858     case tcc_unary:
13859     case tcc_binary:
13860     case tcc_statement:
13861     case tcc_vl_exp:
13862       len = TREE_OPERAND_LENGTH (expr);
13863       for (i = 0; i < len; ++i)
13864         fold_checksum_tree (TREE_OPERAND (expr, i), ctx, ht);
13865       break;
13866     case tcc_declaration:
13867       fold_checksum_tree (DECL_NAME (expr), ctx, ht);
13868       fold_checksum_tree (DECL_CONTEXT (expr), ctx, ht);
13869       if (CODE_CONTAINS_STRUCT (TREE_CODE (expr), TS_DECL_COMMON))
13870         {
13871           fold_checksum_tree (DECL_SIZE (expr), ctx, ht);
13872           fold_checksum_tree (DECL_SIZE_UNIT (expr), ctx, ht);
13873           fold_checksum_tree (DECL_INITIAL (expr), ctx, ht);
13874           fold_checksum_tree (DECL_ABSTRACT_ORIGIN (expr), ctx, ht);
13875           fold_checksum_tree (DECL_ATTRIBUTES (expr), ctx, ht);
13876         }
13877       if (CODE_CONTAINS_STRUCT (TREE_CODE (expr), TS_DECL_WITH_VIS))
13878         fold_checksum_tree (DECL_SECTION_NAME (expr), ctx, ht);
13879
13880       if (CODE_CONTAINS_STRUCT (TREE_CODE (expr), TS_DECL_NON_COMMON))
13881         {
13882           fold_checksum_tree (DECL_VINDEX (expr), ctx, ht);
13883           fold_checksum_tree (DECL_RESULT_FLD (expr), ctx, ht);
13884           fold_checksum_tree (DECL_ARGUMENT_FLD (expr), ctx, ht);
13885         }
13886       break;
13887     case tcc_type:
13888       if (TREE_CODE (expr) == ENUMERAL_TYPE)
13889         fold_checksum_tree (TYPE_VALUES (expr), ctx, ht);
13890       fold_checksum_tree (TYPE_SIZE (expr), ctx, ht);
13891       fold_checksum_tree (TYPE_SIZE_UNIT (expr), ctx, ht);
13892       fold_checksum_tree (TYPE_ATTRIBUTES (expr), ctx, ht);
13893       fold_checksum_tree (TYPE_NAME (expr), ctx, ht);
13894       if (INTEGRAL_TYPE_P (expr)
13895           || SCALAR_FLOAT_TYPE_P (expr))
13896         {
13897           fold_checksum_tree (TYPE_MIN_VALUE (expr), ctx, ht);
13898           fold_checksum_tree (TYPE_MAX_VALUE (expr), ctx, ht);
13899         }
13900       fold_checksum_tree (TYPE_MAIN_VARIANT (expr), ctx, ht);
13901       if (TREE_CODE (expr) == RECORD_TYPE
13902           || TREE_CODE (expr) == UNION_TYPE
13903           || TREE_CODE (expr) == QUAL_UNION_TYPE)
13904         fold_checksum_tree (TYPE_BINFO (expr), ctx, ht);
13905       fold_checksum_tree (TYPE_CONTEXT (expr), ctx, ht);
13906       break;
13907     default:
13908       break;
13909     }
13910 }
13911
13912 /* Helper function for outputting the checksum of a tree T.  When
13913    debugging with gdb, you can "define mynext" to be "next" followed
13914    by "call debug_fold_checksum (op0)", then just trace down till the
13915    outputs differ.  */
13916
13917 DEBUG_FUNCTION void
13918 debug_fold_checksum (const_tree t)
13919 {
13920   int i;
13921   unsigned char checksum[16];
13922   struct md5_ctx ctx;
13923   htab_t ht = htab_create (32, htab_hash_pointer, htab_eq_pointer, NULL);
13924
13925   md5_init_ctx (&ctx);
13926   fold_checksum_tree (t, &ctx, ht);
13927   md5_finish_ctx (&ctx, checksum);
13928   htab_empty (ht);
13929
13930   for (i = 0; i < 16; i++)
13931     fprintf (stderr, "%d ", checksum[i]);
13932
13933   fprintf (stderr, "\n");
13934 }
13935
13936 #endif
13937
13938 /* Fold a unary tree expression with code CODE of type TYPE with an
13939    operand OP0.  LOC is the location of the resulting expression.
13940    Return a folded expression if successful.  Otherwise, return a tree
13941    expression with code CODE of type TYPE with an operand OP0.  */
13942
13943 tree
13944 fold_build1_stat_loc (location_t loc,
13945                       enum tree_code code, tree type, tree op0 MEM_STAT_DECL)
13946 {
13947   tree tem;
13948 #ifdef ENABLE_FOLD_CHECKING
13949   unsigned char checksum_before[16], checksum_after[16];
13950   struct md5_ctx ctx;
13951   htab_t ht;
13952
13953   ht = htab_create (32, htab_hash_pointer, htab_eq_pointer, NULL);
13954   md5_init_ctx (&ctx);
13955   fold_checksum_tree (op0, &ctx, ht);
13956   md5_finish_ctx (&ctx, checksum_before);
13957   htab_empty (ht);
13958 #endif
13959
13960   tem = fold_unary_loc (loc, code, type, op0);
13961   if (!tem)
13962     tem = build1_stat_loc (loc, code, type, op0 PASS_MEM_STAT);
13963
13964 #ifdef ENABLE_FOLD_CHECKING
13965   md5_init_ctx (&ctx);
13966   fold_checksum_tree (op0, &ctx, ht);
13967   md5_finish_ctx (&ctx, checksum_after);
13968   htab_delete (ht);
13969
13970   if (memcmp (checksum_before, checksum_after, 16))
13971     fold_check_failed (op0, tem);
13972 #endif
13973   return tem;
13974 }
13975
13976 /* Fold a binary tree expression with code CODE of type TYPE with
13977    operands OP0 and OP1.  LOC is the location of the resulting
13978    expression.  Return a folded expression if successful.  Otherwise,
13979    return a tree expression with code CODE of type TYPE with operands
13980    OP0 and OP1.  */
13981
13982 tree
13983 fold_build2_stat_loc (location_t loc,
13984                       enum tree_code code, tree type, tree op0, tree op1
13985                       MEM_STAT_DECL)
13986 {
13987   tree tem;
13988 #ifdef ENABLE_FOLD_CHECKING
13989   unsigned char checksum_before_op0[16],
13990                 checksum_before_op1[16],
13991                 checksum_after_op0[16],
13992                 checksum_after_op1[16];
13993   struct md5_ctx ctx;
13994   htab_t ht;
13995
13996   ht = htab_create (32, htab_hash_pointer, htab_eq_pointer, NULL);
13997   md5_init_ctx (&ctx);
13998   fold_checksum_tree (op0, &ctx, ht);
13999   md5_finish_ctx (&ctx, checksum_before_op0);
14000   htab_empty (ht);
14001
14002   md5_init_ctx (&ctx);
14003   fold_checksum_tree (op1, &ctx, ht);
14004   md5_finish_ctx (&ctx, checksum_before_op1);
14005   htab_empty (ht);
14006 #endif
14007
14008   tem = fold_binary_loc (loc, code, type, op0, op1);
14009   if (!tem)
14010     tem = build2_stat_loc (loc, code, type, op0, op1 PASS_MEM_STAT);
14011
14012 #ifdef ENABLE_FOLD_CHECKING
14013   md5_init_ctx (&ctx);
14014   fold_checksum_tree (op0, &ctx, ht);
14015   md5_finish_ctx (&ctx, checksum_after_op0);
14016   htab_empty (ht);
14017
14018   if (memcmp (checksum_before_op0, checksum_after_op0, 16))
14019     fold_check_failed (op0, tem);
14020
14021   md5_init_ctx (&ctx);
14022   fold_checksum_tree (op1, &ctx, ht);
14023   md5_finish_ctx (&ctx, checksum_after_op1);
14024   htab_delete (ht);
14025
14026   if (memcmp (checksum_before_op1, checksum_after_op1, 16))
14027     fold_check_failed (op1, tem);
14028 #endif
14029   return tem;
14030 }
14031
14032 /* Fold a ternary tree expression with code CODE of type TYPE with
14033    operands OP0, OP1, and OP2.  Return a folded expression if
14034    successful.  Otherwise, return a tree expression with code CODE of
14035    type TYPE with operands OP0, OP1, and OP2.  */
14036
14037 tree
14038 fold_build3_stat_loc (location_t loc, enum tree_code code, tree type,
14039                       tree op0, tree op1, tree op2 MEM_STAT_DECL)
14040 {
14041   tree tem;
14042 #ifdef ENABLE_FOLD_CHECKING
14043   unsigned char checksum_before_op0[16],
14044                 checksum_before_op1[16],
14045                 checksum_before_op2[16],
14046                 checksum_after_op0[16],
14047                 checksum_after_op1[16],
14048                 checksum_after_op2[16];
14049   struct md5_ctx ctx;
14050   htab_t ht;
14051
14052   ht = htab_create (32, htab_hash_pointer, htab_eq_pointer, NULL);
14053   md5_init_ctx (&ctx);
14054   fold_checksum_tree (op0, &ctx, ht);
14055   md5_finish_ctx (&ctx, checksum_before_op0);
14056   htab_empty (ht);
14057
14058   md5_init_ctx (&ctx);
14059   fold_checksum_tree (op1, &ctx, ht);
14060   md5_finish_ctx (&ctx, checksum_before_op1);
14061   htab_empty (ht);
14062
14063   md5_init_ctx (&ctx);
14064   fold_checksum_tree (op2, &ctx, ht);
14065   md5_finish_ctx (&ctx, checksum_before_op2);
14066   htab_empty (ht);
14067 #endif
14068
14069   gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
14070   tem = fold_ternary_loc (loc, code, type, op0, op1, op2);
14071   if (!tem)
14072     tem = build3_stat_loc (loc, code, type, op0, op1, op2 PASS_MEM_STAT);
14073
14074 #ifdef ENABLE_FOLD_CHECKING
14075   md5_init_ctx (&ctx);
14076   fold_checksum_tree (op0, &ctx, ht);
14077   md5_finish_ctx (&ctx, checksum_after_op0);
14078   htab_empty (ht);
14079
14080   if (memcmp (checksum_before_op0, checksum_after_op0, 16))
14081     fold_check_failed (op0, tem);
14082
14083   md5_init_ctx (&ctx);
14084   fold_checksum_tree (op1, &ctx, ht);
14085   md5_finish_ctx (&ctx, checksum_after_op1);
14086   htab_empty (ht);
14087
14088   if (memcmp (checksum_before_op1, checksum_after_op1, 16))
14089     fold_check_failed (op1, tem);
14090
14091   md5_init_ctx (&ctx);
14092   fold_checksum_tree (op2, &ctx, ht);
14093   md5_finish_ctx (&ctx, checksum_after_op2);
14094   htab_delete (ht);
14095
14096   if (memcmp (checksum_before_op2, checksum_after_op2, 16))
14097     fold_check_failed (op2, tem);
14098 #endif
14099   return tem;
14100 }
14101
14102 /* Fold a CALL_EXPR expression of type TYPE with operands FN and NARGS
14103    arguments in ARGARRAY, and a null static chain.
14104    Return a folded expression if successful.  Otherwise, return a CALL_EXPR
14105    of type TYPE from the given operands as constructed by build_call_array.  */
14106
14107 tree
14108 fold_build_call_array_loc (location_t loc, tree type, tree fn,
14109                            int nargs, tree *argarray)
14110 {
14111   tree tem;
14112 #ifdef ENABLE_FOLD_CHECKING
14113   unsigned char checksum_before_fn[16],
14114                 checksum_before_arglist[16],
14115                 checksum_after_fn[16],
14116                 checksum_after_arglist[16];
14117   struct md5_ctx ctx;
14118   htab_t ht;
14119   int i;
14120
14121   ht = htab_create (32, htab_hash_pointer, htab_eq_pointer, NULL);
14122   md5_init_ctx (&ctx);
14123   fold_checksum_tree (fn, &ctx, ht);
14124   md5_finish_ctx (&ctx, checksum_before_fn);
14125   htab_empty (ht);
14126
14127   md5_init_ctx (&ctx);
14128   for (i = 0; i < nargs; i++)
14129     fold_checksum_tree (argarray[i], &ctx, ht);
14130   md5_finish_ctx (&ctx, checksum_before_arglist);
14131   htab_empty (ht);
14132 #endif
14133
14134   tem = fold_builtin_call_array (loc, type, fn, nargs, argarray);
14135
14136 #ifdef ENABLE_FOLD_CHECKING
14137   md5_init_ctx (&ctx);
14138   fold_checksum_tree (fn, &ctx, ht);
14139   md5_finish_ctx (&ctx, checksum_after_fn);
14140   htab_empty (ht);
14141
14142   if (memcmp (checksum_before_fn, checksum_after_fn, 16))
14143     fold_check_failed (fn, tem);
14144
14145   md5_init_ctx (&ctx);
14146   for (i = 0; i < nargs; i++)
14147     fold_checksum_tree (argarray[i], &ctx, ht);
14148   md5_finish_ctx (&ctx, checksum_after_arglist);
14149   htab_delete (ht);
14150
14151   if (memcmp (checksum_before_arglist, checksum_after_arglist, 16))
14152     fold_check_failed (NULL_TREE, tem);
14153 #endif
14154   return tem;
14155 }
14156
14157 /* Perform constant folding and related simplification of initializer
14158    expression EXPR.  These behave identically to "fold_buildN" but ignore
14159    potential run-time traps and exceptions that fold must preserve.  */
14160
14161 #define START_FOLD_INIT \
14162   int saved_signaling_nans = flag_signaling_nans;\
14163   int saved_trapping_math = flag_trapping_math;\
14164   int saved_rounding_math = flag_rounding_math;\
14165   int saved_trapv = flag_trapv;\
14166   int saved_folding_initializer = folding_initializer;\
14167   flag_signaling_nans = 0;\
14168   flag_trapping_math = 0;\
14169   flag_rounding_math = 0;\
14170   flag_trapv = 0;\
14171   folding_initializer = 1;
14172
14173 #define END_FOLD_INIT \
14174   flag_signaling_nans = saved_signaling_nans;\
14175   flag_trapping_math = saved_trapping_math;\
14176   flag_rounding_math = saved_rounding_math;\
14177   flag_trapv = saved_trapv;\
14178   folding_initializer = saved_folding_initializer;
14179
14180 tree
14181 fold_build1_initializer_loc (location_t loc, enum tree_code code,
14182                              tree type, tree op)
14183 {
14184   tree result;
14185   START_FOLD_INIT;
14186
14187   result = fold_build1_loc (loc, code, type, op);
14188
14189   END_FOLD_INIT;
14190   return result;
14191 }
14192
14193 tree
14194 fold_build2_initializer_loc (location_t loc, enum tree_code code,
14195                              tree type, tree op0, tree op1)
14196 {
14197   tree result;
14198   START_FOLD_INIT;
14199
14200   result = fold_build2_loc (loc, code, type, op0, op1);
14201
14202   END_FOLD_INIT;
14203   return result;
14204 }
14205
14206 tree
14207 fold_build3_initializer_loc (location_t loc, enum tree_code code,
14208                              tree type, tree op0, tree op1, tree op2)
14209 {
14210   tree result;
14211   START_FOLD_INIT;
14212
14213   result = fold_build3_loc (loc, code, type, op0, op1, op2);
14214
14215   END_FOLD_INIT;
14216   return result;
14217 }
14218
14219 tree
14220 fold_build_call_array_initializer_loc (location_t loc, tree type, tree fn,
14221                                        int nargs, tree *argarray)
14222 {
14223   tree result;
14224   START_FOLD_INIT;
14225
14226   result = fold_build_call_array_loc (loc, type, fn, nargs, argarray);
14227
14228   END_FOLD_INIT;
14229   return result;
14230 }
14231
14232 #undef START_FOLD_INIT
14233 #undef END_FOLD_INIT
14234
14235 /* Determine if first argument is a multiple of second argument.  Return 0 if
14236    it is not, or we cannot easily determined it to be.
14237
14238    An example of the sort of thing we care about (at this point; this routine
14239    could surely be made more general, and expanded to do what the *_DIV_EXPR's
14240    fold cases do now) is discovering that
14241
14242      SAVE_EXPR (I) * SAVE_EXPR (J * 8)
14243
14244    is a multiple of
14245
14246      SAVE_EXPR (J * 8)
14247
14248    when we know that the two SAVE_EXPR (J * 8) nodes are the same node.
14249
14250    This code also handles discovering that
14251
14252      SAVE_EXPR (I) * SAVE_EXPR (J * 8)
14253
14254    is a multiple of 8 so we don't have to worry about dealing with a
14255    possible remainder.
14256
14257    Note that we *look* inside a SAVE_EXPR only to determine how it was
14258    calculated; it is not safe for fold to do much of anything else with the
14259    internals of a SAVE_EXPR, since it cannot know when it will be evaluated
14260    at run time.  For example, the latter example above *cannot* be implemented
14261    as SAVE_EXPR (I) * J or any variant thereof, since the value of J at
14262    evaluation time of the original SAVE_EXPR is not necessarily the same at
14263    the time the new expression is evaluated.  The only optimization of this
14264    sort that would be valid is changing
14265
14266      SAVE_EXPR (I) * SAVE_EXPR (SAVE_EXPR (J) * 8)
14267
14268    divided by 8 to
14269
14270      SAVE_EXPR (I) * SAVE_EXPR (J)
14271
14272    (where the same SAVE_EXPR (J) is used in the original and the
14273    transformed version).  */
14274
14275 int
14276 multiple_of_p (tree type, const_tree top, const_tree bottom)
14277 {
14278   if (operand_equal_p (top, bottom, 0))
14279     return 1;
14280
14281   if (TREE_CODE (type) != INTEGER_TYPE)
14282     return 0;
14283
14284   switch (TREE_CODE (top))
14285     {
14286     case BIT_AND_EXPR:
14287       /* Bitwise and provides a power of two multiple.  If the mask is
14288          a multiple of BOTTOM then TOP is a multiple of BOTTOM.  */
14289       if (!integer_pow2p (bottom))
14290         return 0;
14291       /* FALLTHRU */
14292
14293     case MULT_EXPR:
14294       return (multiple_of_p (type, TREE_OPERAND (top, 0), bottom)
14295               || multiple_of_p (type, TREE_OPERAND (top, 1), bottom));
14296
14297     case PLUS_EXPR:
14298     case MINUS_EXPR:
14299       return (multiple_of_p (type, TREE_OPERAND (top, 0), bottom)
14300               && multiple_of_p (type, TREE_OPERAND (top, 1), bottom));
14301
14302     case LSHIFT_EXPR:
14303       if (TREE_CODE (TREE_OPERAND (top, 1)) == INTEGER_CST)
14304         {
14305           tree op1, t1;
14306
14307           op1 = TREE_OPERAND (top, 1);
14308           /* const_binop may not detect overflow correctly,
14309              so check for it explicitly here.  */
14310           if (TYPE_PRECISION (TREE_TYPE (size_one_node))
14311               > TREE_INT_CST_LOW (op1)
14312               && TREE_INT_CST_HIGH (op1) == 0
14313               && 0 != (t1 = fold_convert (type,
14314                                           const_binop (LSHIFT_EXPR,
14315                                                        size_one_node,
14316                                                        op1)))
14317               && !TREE_OVERFLOW (t1))
14318             return multiple_of_p (type, t1, bottom);
14319         }
14320       return 0;
14321
14322     case NOP_EXPR:
14323       /* Can't handle conversions from non-integral or wider integral type.  */
14324       if ((TREE_CODE (TREE_TYPE (TREE_OPERAND (top, 0))) != INTEGER_TYPE)
14325           || (TYPE_PRECISION (type)
14326               < TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (top, 0)))))
14327         return 0;
14328
14329       /* .. fall through ...  */
14330
14331     case SAVE_EXPR:
14332       return multiple_of_p (type, TREE_OPERAND (top, 0), bottom);
14333
14334     case COND_EXPR:
14335       return (multiple_of_p (type, TREE_OPERAND (top, 1), bottom)
14336               && multiple_of_p (type, TREE_OPERAND (top, 2), bottom));
14337
14338     case INTEGER_CST:
14339       if (TREE_CODE (bottom) != INTEGER_CST
14340           || integer_zerop (bottom)
14341           || (TYPE_UNSIGNED (type)
14342               && (tree_int_cst_sgn (top) < 0
14343                   || tree_int_cst_sgn (bottom) < 0)))
14344         return 0;
14345       return integer_zerop (int_const_binop (TRUNC_MOD_EXPR,
14346                                              top, bottom, 0));
14347
14348     default:
14349       return 0;
14350     }
14351 }
14352
14353 /* Return true if CODE or TYPE is known to be non-negative. */
14354
14355 static bool
14356 tree_simple_nonnegative_warnv_p (enum tree_code code, tree type)
14357 {
14358   if ((TYPE_PRECISION (type) != 1 || TYPE_UNSIGNED (type))
14359       && truth_value_p (code))
14360     /* Truth values evaluate to 0 or 1, which is nonnegative unless we
14361        have a signed:1 type (where the value is -1 and 0).  */
14362     return true;
14363   return false;
14364 }
14365
14366 /* Return true if (CODE OP0) is known to be non-negative.  If the return
14367    value is based on the assumption that signed overflow is undefined,
14368    set *STRICT_OVERFLOW_P to true; otherwise, don't change
14369    *STRICT_OVERFLOW_P.  */
14370
14371 bool
14372 tree_unary_nonnegative_warnv_p (enum tree_code code, tree type, tree op0,
14373                                 bool *strict_overflow_p)
14374 {
14375   if (TYPE_UNSIGNED (type))
14376     return true;
14377
14378   switch (code)
14379     {
14380     case ABS_EXPR:
14381       /* We can't return 1 if flag_wrapv is set because
14382          ABS_EXPR<INT_MIN> = INT_MIN.  */
14383       if (!INTEGRAL_TYPE_P (type))
14384         return true;
14385       if (TYPE_OVERFLOW_UNDEFINED (type))
14386         {
14387           *strict_overflow_p = true;
14388           return true;
14389         }
14390       break;
14391
14392     case NON_LVALUE_EXPR:
14393     case FLOAT_EXPR:
14394     case FIX_TRUNC_EXPR:
14395       return tree_expr_nonnegative_warnv_p (op0,
14396                                             strict_overflow_p);
14397
14398     case NOP_EXPR:
14399       {
14400         tree inner_type = TREE_TYPE (op0);
14401         tree outer_type = type;
14402
14403         if (TREE_CODE (outer_type) == REAL_TYPE)
14404           {
14405             if (TREE_CODE (inner_type) == REAL_TYPE)
14406               return tree_expr_nonnegative_warnv_p (op0,
14407                                                     strict_overflow_p);
14408             if (TREE_CODE (inner_type) == INTEGER_TYPE)
14409               {
14410                 if (TYPE_UNSIGNED (inner_type))
14411                   return true;
14412                 return tree_expr_nonnegative_warnv_p (op0,
14413                                                       strict_overflow_p);
14414               }
14415           }
14416         else if (TREE_CODE (outer_type) == INTEGER_TYPE)
14417           {
14418             if (TREE_CODE (inner_type) == REAL_TYPE)
14419               return tree_expr_nonnegative_warnv_p (op0,
14420                                                     strict_overflow_p);
14421             if (TREE_CODE (inner_type) == INTEGER_TYPE)
14422               return TYPE_PRECISION (inner_type) < TYPE_PRECISION (outer_type)
14423                       && TYPE_UNSIGNED (inner_type);
14424           }
14425       }
14426       break;
14427
14428     default:
14429       return tree_simple_nonnegative_warnv_p (code, type);
14430     }
14431
14432   /* We don't know sign of `t', so be conservative and return false.  */
14433   return false;
14434 }
14435
14436 /* Return true if (CODE OP0 OP1) is known to be non-negative.  If the return
14437    value is based on the assumption that signed overflow is undefined,
14438    set *STRICT_OVERFLOW_P to true; otherwise, don't change
14439    *STRICT_OVERFLOW_P.  */
14440
14441 bool
14442 tree_binary_nonnegative_warnv_p (enum tree_code code, tree type, tree op0,
14443                                       tree op1, bool *strict_overflow_p)
14444 {
14445   if (TYPE_UNSIGNED (type))
14446     return true;
14447
14448   switch (code)
14449     {
14450     case POINTER_PLUS_EXPR:
14451     case PLUS_EXPR:
14452       if (FLOAT_TYPE_P (type))
14453         return (tree_expr_nonnegative_warnv_p (op0,
14454                                                strict_overflow_p)
14455                 && tree_expr_nonnegative_warnv_p (op1,
14456                                                   strict_overflow_p));
14457
14458       /* zero_extend(x) + zero_extend(y) is non-negative if x and y are
14459          both unsigned and at least 2 bits shorter than the result.  */
14460       if (TREE_CODE (type) == INTEGER_TYPE
14461           && TREE_CODE (op0) == NOP_EXPR
14462           && TREE_CODE (op1) == NOP_EXPR)
14463         {
14464           tree inner1 = TREE_TYPE (TREE_OPERAND (op0, 0));
14465           tree inner2 = TREE_TYPE (TREE_OPERAND (op1, 0));
14466           if (TREE_CODE (inner1) == INTEGER_TYPE && TYPE_UNSIGNED (inner1)
14467               && TREE_CODE (inner2) == INTEGER_TYPE && TYPE_UNSIGNED (inner2))
14468             {
14469               unsigned int prec = MAX (TYPE_PRECISION (inner1),
14470                                        TYPE_PRECISION (inner2)) + 1;
14471               return prec < TYPE_PRECISION (type);
14472             }
14473         }
14474       break;
14475
14476     case MULT_EXPR:
14477       if (FLOAT_TYPE_P (type))
14478         {
14479           /* x * x for floating point x is always non-negative.  */
14480           if (operand_equal_p (op0, op1, 0))
14481             return true;
14482           return (tree_expr_nonnegative_warnv_p (op0,
14483                                                  strict_overflow_p)
14484                   && tree_expr_nonnegative_warnv_p (op1,
14485                                                     strict_overflow_p));
14486         }
14487
14488       /* zero_extend(x) * zero_extend(y) is non-negative if x and y are
14489          both unsigned and their total bits is shorter than the result.  */
14490       if (TREE_CODE (type) == INTEGER_TYPE
14491           && (TREE_CODE (op0) == NOP_EXPR || TREE_CODE (op0) == INTEGER_CST)
14492           && (TREE_CODE (op1) == NOP_EXPR || TREE_CODE (op1) == INTEGER_CST))
14493         {
14494           tree inner0 = (TREE_CODE (op0) == NOP_EXPR)
14495             ? TREE_TYPE (TREE_OPERAND (op0, 0))
14496             : TREE_TYPE (op0);
14497           tree inner1 = (TREE_CODE (op1) == NOP_EXPR)
14498             ? TREE_TYPE (TREE_OPERAND (op1, 0))
14499             : TREE_TYPE (op1);
14500
14501           bool unsigned0 = TYPE_UNSIGNED (inner0);
14502           bool unsigned1 = TYPE_UNSIGNED (inner1);
14503
14504           if (TREE_CODE (op0) == INTEGER_CST)
14505             unsigned0 = unsigned0 || tree_int_cst_sgn (op0) >= 0;
14506
14507           if (TREE_CODE (op1) == INTEGER_CST)
14508             unsigned1 = unsigned1 || tree_int_cst_sgn (op1) >= 0;
14509
14510           if (TREE_CODE (inner0) == INTEGER_TYPE && unsigned0
14511               && TREE_CODE (inner1) == INTEGER_TYPE && unsigned1)
14512             {
14513               unsigned int precision0 = (TREE_CODE (op0) == INTEGER_CST)
14514                 ? tree_int_cst_min_precision (op0, /*unsignedp=*/true)
14515                 : TYPE_PRECISION (inner0);
14516
14517               unsigned int precision1 = (TREE_CODE (op1) == INTEGER_CST)
14518                 ? tree_int_cst_min_precision (op1, /*unsignedp=*/true)
14519                 : TYPE_PRECISION (inner1);
14520
14521               return precision0 + precision1 < TYPE_PRECISION (type);
14522             }
14523         }
14524       return false;
14525
14526     case BIT_AND_EXPR:
14527     case MAX_EXPR:
14528       return (tree_expr_nonnegative_warnv_p (op0,
14529                                              strict_overflow_p)
14530               || tree_expr_nonnegative_warnv_p (op1,
14531                                                 strict_overflow_p));
14532
14533     case BIT_IOR_EXPR:
14534     case BIT_XOR_EXPR:
14535     case MIN_EXPR:
14536     case RDIV_EXPR:
14537     case TRUNC_DIV_EXPR:
14538     case CEIL_DIV_EXPR:
14539     case FLOOR_DIV_EXPR:
14540     case ROUND_DIV_EXPR:
14541       return (tree_expr_nonnegative_warnv_p (op0,
14542                                              strict_overflow_p)
14543               && tree_expr_nonnegative_warnv_p (op1,
14544                                                 strict_overflow_p));
14545
14546     case TRUNC_MOD_EXPR:
14547     case CEIL_MOD_EXPR:
14548     case FLOOR_MOD_EXPR:
14549     case ROUND_MOD_EXPR:
14550       return tree_expr_nonnegative_warnv_p (op0,
14551                                             strict_overflow_p);
14552     default:
14553       return tree_simple_nonnegative_warnv_p (code, type);
14554     }
14555
14556   /* We don't know sign of `t', so be conservative and return false.  */
14557   return false;
14558 }
14559
14560 /* Return true if T is known to be non-negative.  If the return
14561    value is based on the assumption that signed overflow is undefined,
14562    set *STRICT_OVERFLOW_P to true; otherwise, don't change
14563    *STRICT_OVERFLOW_P.  */
14564
14565 bool
14566 tree_single_nonnegative_warnv_p (tree t, bool *strict_overflow_p)
14567 {
14568   if (TYPE_UNSIGNED (TREE_TYPE (t)))
14569     return true;
14570
14571   switch (TREE_CODE (t))
14572     {
14573     case INTEGER_CST:
14574       return tree_int_cst_sgn (t) >= 0;
14575
14576     case REAL_CST:
14577       return ! REAL_VALUE_NEGATIVE (TREE_REAL_CST (t));
14578
14579     case FIXED_CST:
14580       return ! FIXED_VALUE_NEGATIVE (TREE_FIXED_CST (t));
14581
14582     case COND_EXPR:
14583       return (tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 1),
14584                                              strict_overflow_p)
14585               && tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 2),
14586                                                 strict_overflow_p));
14587     default:
14588       return tree_simple_nonnegative_warnv_p (TREE_CODE (t),
14589                                                    TREE_TYPE (t));
14590     }
14591   /* We don't know sign of `t', so be conservative and return false.  */
14592   return false;
14593 }
14594
14595 /* Return true if T is known to be non-negative.  If the return
14596    value is based on the assumption that signed overflow is undefined,
14597    set *STRICT_OVERFLOW_P to true; otherwise, don't change
14598    *STRICT_OVERFLOW_P.  */
14599
14600 bool
14601 tree_call_nonnegative_warnv_p (tree type, tree fndecl,
14602                                tree arg0, tree arg1, bool *strict_overflow_p)
14603 {
14604   if (fndecl && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL)
14605     switch (DECL_FUNCTION_CODE (fndecl))
14606       {
14607         CASE_FLT_FN (BUILT_IN_ACOS):
14608         CASE_FLT_FN (BUILT_IN_ACOSH):
14609         CASE_FLT_FN (BUILT_IN_CABS):
14610         CASE_FLT_FN (BUILT_IN_COSH):
14611         CASE_FLT_FN (BUILT_IN_ERFC):
14612         CASE_FLT_FN (BUILT_IN_EXP):
14613         CASE_FLT_FN (BUILT_IN_EXP10):
14614         CASE_FLT_FN (BUILT_IN_EXP2):
14615         CASE_FLT_FN (BUILT_IN_FABS):
14616         CASE_FLT_FN (BUILT_IN_FDIM):
14617         CASE_FLT_FN (BUILT_IN_HYPOT):
14618         CASE_FLT_FN (BUILT_IN_POW10):
14619         CASE_INT_FN (BUILT_IN_FFS):
14620         CASE_INT_FN (BUILT_IN_PARITY):
14621         CASE_INT_FN (BUILT_IN_POPCOUNT):
14622       case BUILT_IN_BSWAP32:
14623       case BUILT_IN_BSWAP64:
14624         /* Always true.  */
14625         return true;
14626
14627         CASE_FLT_FN (BUILT_IN_SQRT):
14628         /* sqrt(-0.0) is -0.0.  */
14629         if (!HONOR_SIGNED_ZEROS (TYPE_MODE (type)))
14630           return true;
14631         return tree_expr_nonnegative_warnv_p (arg0,
14632                                               strict_overflow_p);
14633
14634         CASE_FLT_FN (BUILT_IN_ASINH):
14635         CASE_FLT_FN (BUILT_IN_ATAN):
14636         CASE_FLT_FN (BUILT_IN_ATANH):
14637         CASE_FLT_FN (BUILT_IN_CBRT):
14638         CASE_FLT_FN (BUILT_IN_CEIL):
14639         CASE_FLT_FN (BUILT_IN_ERF):
14640         CASE_FLT_FN (BUILT_IN_EXPM1):
14641         CASE_FLT_FN (BUILT_IN_FLOOR):
14642         CASE_FLT_FN (BUILT_IN_FMOD):
14643         CASE_FLT_FN (BUILT_IN_FREXP):
14644         CASE_FLT_FN (BUILT_IN_LCEIL):
14645         CASE_FLT_FN (BUILT_IN_LDEXP):
14646         CASE_FLT_FN (BUILT_IN_LFLOOR):
14647         CASE_FLT_FN (BUILT_IN_LLCEIL):
14648         CASE_FLT_FN (BUILT_IN_LLFLOOR):
14649         CASE_FLT_FN (BUILT_IN_LLRINT):
14650         CASE_FLT_FN (BUILT_IN_LLROUND):
14651         CASE_FLT_FN (BUILT_IN_LRINT):
14652         CASE_FLT_FN (BUILT_IN_LROUND):
14653         CASE_FLT_FN (BUILT_IN_MODF):
14654         CASE_FLT_FN (BUILT_IN_NEARBYINT):
14655         CASE_FLT_FN (BUILT_IN_RINT):
14656         CASE_FLT_FN (BUILT_IN_ROUND):
14657         CASE_FLT_FN (BUILT_IN_SCALB):
14658         CASE_FLT_FN (BUILT_IN_SCALBLN):
14659         CASE_FLT_FN (BUILT_IN_SCALBN):
14660         CASE_FLT_FN (BUILT_IN_SIGNBIT):
14661         CASE_FLT_FN (BUILT_IN_SIGNIFICAND):
14662         CASE_FLT_FN (BUILT_IN_SINH):
14663         CASE_FLT_FN (BUILT_IN_TANH):
14664         CASE_FLT_FN (BUILT_IN_TRUNC):
14665         /* True if the 1st argument is nonnegative.  */
14666         return tree_expr_nonnegative_warnv_p (arg0,
14667                                               strict_overflow_p);
14668
14669         CASE_FLT_FN (BUILT_IN_FMAX):
14670         /* True if the 1st OR 2nd arguments are nonnegative.  */
14671         return (tree_expr_nonnegative_warnv_p (arg0,
14672                                                strict_overflow_p)
14673                 || (tree_expr_nonnegative_warnv_p (arg1,
14674                                                    strict_overflow_p)));
14675
14676         CASE_FLT_FN (BUILT_IN_FMIN):
14677         /* True if the 1st AND 2nd arguments are nonnegative.  */
14678         return (tree_expr_nonnegative_warnv_p (arg0,
14679                                                strict_overflow_p)
14680                 && (tree_expr_nonnegative_warnv_p (arg1,
14681                                                    strict_overflow_p)));
14682
14683         CASE_FLT_FN (BUILT_IN_COPYSIGN):
14684         /* True if the 2nd argument is nonnegative.  */
14685         return tree_expr_nonnegative_warnv_p (arg1,
14686                                               strict_overflow_p);
14687
14688         CASE_FLT_FN (BUILT_IN_POWI):
14689         /* True if the 1st argument is nonnegative or the second
14690            argument is an even integer.  */
14691         if (TREE_CODE (arg1) == INTEGER_CST
14692             && (TREE_INT_CST_LOW (arg1) & 1) == 0)
14693           return true;
14694         return tree_expr_nonnegative_warnv_p (arg0,
14695                                               strict_overflow_p);
14696
14697         CASE_FLT_FN (BUILT_IN_POW):
14698         /* True if the 1st argument is nonnegative or the second
14699            argument is an even integer valued real.  */
14700         if (TREE_CODE (arg1) == REAL_CST)
14701           {
14702             REAL_VALUE_TYPE c;
14703             HOST_WIDE_INT n;
14704
14705             c = TREE_REAL_CST (arg1);
14706             n = real_to_integer (&c);
14707             if ((n & 1) == 0)
14708               {
14709                 REAL_VALUE_TYPE cint;
14710                 real_from_integer (&cint, VOIDmode, n,
14711                                    n < 0 ? -1 : 0, 0);
14712                 if (real_identical (&c, &cint))
14713                   return true;
14714               }
14715           }
14716         return tree_expr_nonnegative_warnv_p (arg0,
14717                                               strict_overflow_p);
14718
14719       default:
14720         break;
14721       }
14722   return tree_simple_nonnegative_warnv_p (CALL_EXPR,
14723                                           type);
14724 }
14725
14726 /* Return true if T is known to be non-negative.  If the return
14727    value is based on the assumption that signed overflow is undefined,
14728    set *STRICT_OVERFLOW_P to true; otherwise, don't change
14729    *STRICT_OVERFLOW_P.  */
14730
14731 bool
14732 tree_invalid_nonnegative_warnv_p (tree t, bool *strict_overflow_p)
14733 {
14734   enum tree_code code = TREE_CODE (t);
14735   if (TYPE_UNSIGNED (TREE_TYPE (t)))
14736     return true;
14737
14738   switch (code)
14739     {
14740     case TARGET_EXPR:
14741       {
14742         tree temp = TARGET_EXPR_SLOT (t);
14743         t = TARGET_EXPR_INITIAL (t);
14744
14745         /* If the initializer is non-void, then it's a normal expression
14746            that will be assigned to the slot.  */
14747         if (!VOID_TYPE_P (t))
14748           return tree_expr_nonnegative_warnv_p (t, strict_overflow_p);
14749
14750         /* Otherwise, the initializer sets the slot in some way.  One common
14751            way is an assignment statement at the end of the initializer.  */
14752         while (1)
14753           {
14754             if (TREE_CODE (t) == BIND_EXPR)
14755               t = expr_last (BIND_EXPR_BODY (t));
14756             else if (TREE_CODE (t) == TRY_FINALLY_EXPR
14757                      || TREE_CODE (t) == TRY_CATCH_EXPR)
14758               t = expr_last (TREE_OPERAND (t, 0));
14759             else if (TREE_CODE (t) == STATEMENT_LIST)
14760               t = expr_last (t);
14761             else
14762               break;
14763           }
14764         if (TREE_CODE (t) == MODIFY_EXPR
14765             && TREE_OPERAND (t, 0) == temp)
14766           return tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 1),
14767                                                 strict_overflow_p);
14768
14769         return false;
14770       }
14771
14772     case CALL_EXPR:
14773       {
14774         tree arg0 = call_expr_nargs (t) > 0 ?  CALL_EXPR_ARG (t, 0) : NULL_TREE;
14775         tree arg1 = call_expr_nargs (t) > 1 ?  CALL_EXPR_ARG (t, 1) : NULL_TREE;
14776
14777         return tree_call_nonnegative_warnv_p (TREE_TYPE (t),
14778                                               get_callee_fndecl (t),
14779                                               arg0,
14780                                               arg1,
14781                                               strict_overflow_p);
14782       }
14783     case COMPOUND_EXPR:
14784     case MODIFY_EXPR:
14785       return tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 1),
14786                                             strict_overflow_p);
14787     case BIND_EXPR:
14788       return tree_expr_nonnegative_warnv_p (expr_last (TREE_OPERAND (t, 1)),
14789                                             strict_overflow_p);
14790     case SAVE_EXPR:
14791       return tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 0),
14792                                             strict_overflow_p);
14793
14794     default:
14795       return tree_simple_nonnegative_warnv_p (TREE_CODE (t),
14796                                                    TREE_TYPE (t));
14797     }
14798
14799   /* We don't know sign of `t', so be conservative and return false.  */
14800   return false;
14801 }
14802
14803 /* Return true if T is known to be non-negative.  If the return
14804    value is based on the assumption that signed overflow is undefined,
14805    set *STRICT_OVERFLOW_P to true; otherwise, don't change
14806    *STRICT_OVERFLOW_P.  */
14807
14808 bool
14809 tree_expr_nonnegative_warnv_p (tree t, bool *strict_overflow_p)
14810 {
14811   enum tree_code code;
14812   if (t == error_mark_node)
14813     return false;
14814
14815   code = TREE_CODE (t);
14816   switch (TREE_CODE_CLASS (code))
14817     {
14818     case tcc_binary:
14819     case tcc_comparison:
14820       return tree_binary_nonnegative_warnv_p (TREE_CODE (t),
14821                                               TREE_TYPE (t),
14822                                               TREE_OPERAND (t, 0),
14823                                               TREE_OPERAND (t, 1),
14824                                               strict_overflow_p);
14825
14826     case tcc_unary:
14827       return tree_unary_nonnegative_warnv_p (TREE_CODE (t),
14828                                              TREE_TYPE (t),
14829                                              TREE_OPERAND (t, 0),
14830                                              strict_overflow_p);
14831
14832     case tcc_constant:
14833     case tcc_declaration:
14834     case tcc_reference:
14835       return tree_single_nonnegative_warnv_p (t, strict_overflow_p);
14836
14837     default:
14838       break;
14839     }
14840
14841   switch (code)
14842     {
14843     case TRUTH_AND_EXPR:
14844     case TRUTH_OR_EXPR:
14845     case TRUTH_XOR_EXPR:
14846       return tree_binary_nonnegative_warnv_p (TREE_CODE (t),
14847                                               TREE_TYPE (t),
14848                                               TREE_OPERAND (t, 0),
14849                                               TREE_OPERAND (t, 1),
14850                                               strict_overflow_p);
14851     case TRUTH_NOT_EXPR:
14852       return tree_unary_nonnegative_warnv_p (TREE_CODE (t),
14853                                              TREE_TYPE (t),
14854                                              TREE_OPERAND (t, 0),
14855                                              strict_overflow_p);
14856
14857     case COND_EXPR:
14858     case CONSTRUCTOR:
14859     case OBJ_TYPE_REF:
14860     case ASSERT_EXPR:
14861     case ADDR_EXPR:
14862     case WITH_SIZE_EXPR:
14863     case SSA_NAME:
14864       return tree_single_nonnegative_warnv_p (t, strict_overflow_p);
14865
14866     default:
14867       return tree_invalid_nonnegative_warnv_p (t, strict_overflow_p);
14868     }
14869 }
14870
14871 /* Return true if `t' is known to be non-negative.  Handle warnings
14872    about undefined signed overflow.  */
14873
14874 bool
14875 tree_expr_nonnegative_p (tree t)
14876 {
14877   bool ret, strict_overflow_p;
14878
14879   strict_overflow_p = false;
14880   ret = tree_expr_nonnegative_warnv_p (t, &strict_overflow_p);
14881   if (strict_overflow_p)
14882     fold_overflow_warning (("assuming signed overflow does not occur when "
14883                             "determining that expression is always "
14884                             "non-negative"),
14885                            WARN_STRICT_OVERFLOW_MISC);
14886   return ret;
14887 }
14888
14889
14890 /* Return true when (CODE OP0) is an address and is known to be nonzero.
14891    For floating point we further ensure that T is not denormal.
14892    Similar logic is present in nonzero_address in rtlanal.h.
14893
14894    If the return value is based on the assumption that signed overflow
14895    is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
14896    change *STRICT_OVERFLOW_P.  */
14897
14898 bool
14899 tree_unary_nonzero_warnv_p (enum tree_code code, tree type, tree op0,
14900                                  bool *strict_overflow_p)
14901 {
14902   switch (code)
14903     {
14904     case ABS_EXPR:
14905       return tree_expr_nonzero_warnv_p (op0,
14906                                         strict_overflow_p);
14907
14908     case NOP_EXPR:
14909       {
14910         tree inner_type = TREE_TYPE (op0);
14911         tree outer_type = type;
14912
14913         return (TYPE_PRECISION (outer_type) >= TYPE_PRECISION (inner_type)
14914                 && tree_expr_nonzero_warnv_p (op0,
14915                                               strict_overflow_p));
14916       }
14917       break;
14918
14919     case NON_LVALUE_EXPR:
14920       return tree_expr_nonzero_warnv_p (op0,
14921                                         strict_overflow_p);
14922
14923     default:
14924       break;
14925   }
14926
14927   return false;
14928 }
14929
14930 /* Return true when (CODE OP0 OP1) is an address and is known to be nonzero.
14931    For floating point we further ensure that T is not denormal.
14932    Similar logic is present in nonzero_address in rtlanal.h.
14933
14934    If the return value is based on the assumption that signed overflow
14935    is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
14936    change *STRICT_OVERFLOW_P.  */
14937
14938 bool
14939 tree_binary_nonzero_warnv_p (enum tree_code code,
14940                              tree type,
14941                              tree op0,
14942                              tree op1, bool *strict_overflow_p)
14943 {
14944   bool sub_strict_overflow_p;
14945   switch (code)
14946     {
14947     case POINTER_PLUS_EXPR:
14948     case PLUS_EXPR:
14949       if (TYPE_OVERFLOW_UNDEFINED (type))
14950         {
14951           /* With the presence of negative values it is hard
14952              to say something.  */
14953           sub_strict_overflow_p = false;
14954           if (!tree_expr_nonnegative_warnv_p (op0,
14955                                               &sub_strict_overflow_p)
14956               || !tree_expr_nonnegative_warnv_p (op1,
14957                                                  &sub_strict_overflow_p))
14958             return false;
14959           /* One of operands must be positive and the other non-negative.  */
14960           /* We don't set *STRICT_OVERFLOW_P here: even if this value
14961              overflows, on a twos-complement machine the sum of two
14962              nonnegative numbers can never be zero.  */
14963           return (tree_expr_nonzero_warnv_p (op0,
14964                                              strict_overflow_p)
14965                   || tree_expr_nonzero_warnv_p (op1,
14966                                                 strict_overflow_p));
14967         }
14968       break;
14969
14970     case MULT_EXPR:
14971       if (TYPE_OVERFLOW_UNDEFINED (type))
14972         {
14973           if (tree_expr_nonzero_warnv_p (op0,
14974                                          strict_overflow_p)
14975               && tree_expr_nonzero_warnv_p (op1,
14976                                             strict_overflow_p))
14977             {
14978               *strict_overflow_p = true;
14979               return true;
14980             }
14981         }
14982       break;
14983
14984     case MIN_EXPR:
14985       sub_strict_overflow_p = false;
14986       if (tree_expr_nonzero_warnv_p (op0,
14987                                      &sub_strict_overflow_p)
14988           && tree_expr_nonzero_warnv_p (op1,
14989                                         &sub_strict_overflow_p))
14990         {
14991           if (sub_strict_overflow_p)
14992             *strict_overflow_p = true;
14993         }
14994       break;
14995
14996     case MAX_EXPR:
14997       sub_strict_overflow_p = false;
14998       if (tree_expr_nonzero_warnv_p (op0,
14999                                      &sub_strict_overflow_p))
15000         {
15001           if (sub_strict_overflow_p)
15002             *strict_overflow_p = true;
15003
15004           /* When both operands are nonzero, then MAX must be too.  */
15005           if (tree_expr_nonzero_warnv_p (op1,
15006                                          strict_overflow_p))
15007             return true;
15008
15009           /* MAX where operand 0 is positive is positive.  */
15010           return tree_expr_nonnegative_warnv_p (op0,
15011                                                strict_overflow_p);
15012         }
15013       /* MAX where operand 1 is positive is positive.  */
15014       else if (tree_expr_nonzero_warnv_p (op1,
15015                                           &sub_strict_overflow_p)
15016                && tree_expr_nonnegative_warnv_p (op1,
15017                                                  &sub_strict_overflow_p))
15018         {
15019           if (sub_strict_overflow_p)
15020             *strict_overflow_p = true;
15021           return true;
15022         }
15023       break;
15024
15025     case BIT_IOR_EXPR:
15026       return (tree_expr_nonzero_warnv_p (op1,
15027                                          strict_overflow_p)
15028               || tree_expr_nonzero_warnv_p (op0,
15029                                             strict_overflow_p));
15030
15031     default:
15032       break;
15033   }
15034
15035   return false;
15036 }
15037
15038 /* Return true when T is an address and is known to be nonzero.
15039    For floating point we further ensure that T is not denormal.
15040    Similar logic is present in nonzero_address in rtlanal.h.
15041
15042    If the return value is based on the assumption that signed overflow
15043    is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
15044    change *STRICT_OVERFLOW_P.  */
15045
15046 bool
15047 tree_single_nonzero_warnv_p (tree t, bool *strict_overflow_p)
15048 {
15049   bool sub_strict_overflow_p;
15050   switch (TREE_CODE (t))
15051     {
15052     case INTEGER_CST:
15053       return !integer_zerop (t);
15054
15055     case ADDR_EXPR:
15056       {
15057         tree base = TREE_OPERAND (t, 0);
15058         if (!DECL_P (base))
15059           base = get_base_address (base);
15060
15061         if (!base)
15062           return false;
15063
15064         /* Weak declarations may link to NULL.  Other things may also be NULL
15065            so protect with -fdelete-null-pointer-checks; but not variables
15066            allocated on the stack.  */
15067         if (DECL_P (base)
15068             && (flag_delete_null_pointer_checks
15069                 || (DECL_CONTEXT (base)
15070                     && TREE_CODE (DECL_CONTEXT (base)) == FUNCTION_DECL
15071                     && auto_var_in_fn_p (base, DECL_CONTEXT (base)))))
15072           return !VAR_OR_FUNCTION_DECL_P (base) || !DECL_WEAK (base);
15073
15074         /* Constants are never weak.  */
15075         if (CONSTANT_CLASS_P (base))
15076           return true;
15077
15078         return false;
15079       }
15080
15081     case COND_EXPR:
15082       sub_strict_overflow_p = false;
15083       if (tree_expr_nonzero_warnv_p (TREE_OPERAND (t, 1),
15084                                      &sub_strict_overflow_p)
15085           && tree_expr_nonzero_warnv_p (TREE_OPERAND (t, 2),
15086                                         &sub_strict_overflow_p))
15087         {
15088           if (sub_strict_overflow_p)
15089             *strict_overflow_p = true;
15090           return true;
15091         }
15092       break;
15093
15094     default:
15095       break;
15096     }
15097   return false;
15098 }
15099
15100 /* Return true when T is an address and is known to be nonzero.
15101    For floating point we further ensure that T is not denormal.
15102    Similar logic is present in nonzero_address in rtlanal.h.
15103
15104    If the return value is based on the assumption that signed overflow
15105    is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
15106    change *STRICT_OVERFLOW_P.  */
15107
15108 bool
15109 tree_expr_nonzero_warnv_p (tree t, bool *strict_overflow_p)
15110 {
15111   tree type = TREE_TYPE (t);
15112   enum tree_code code;
15113
15114   /* Doing something useful for floating point would need more work.  */
15115   if (!INTEGRAL_TYPE_P (type) && !POINTER_TYPE_P (type))
15116     return false;
15117
15118   code = TREE_CODE (t);
15119   switch (TREE_CODE_CLASS (code))
15120     {
15121     case tcc_unary:
15122       return tree_unary_nonzero_warnv_p (code, type, TREE_OPERAND (t, 0),
15123                                               strict_overflow_p);
15124     case tcc_binary:
15125     case tcc_comparison:
15126       return tree_binary_nonzero_warnv_p (code, type,
15127                                                TREE_OPERAND (t, 0),
15128                                                TREE_OPERAND (t, 1),
15129                                                strict_overflow_p);
15130     case tcc_constant:
15131     case tcc_declaration:
15132     case tcc_reference:
15133       return tree_single_nonzero_warnv_p (t, strict_overflow_p);
15134
15135     default:
15136       break;
15137     }
15138
15139   switch (code)
15140     {
15141     case TRUTH_NOT_EXPR:
15142       return tree_unary_nonzero_warnv_p (code, type, TREE_OPERAND (t, 0),
15143                                               strict_overflow_p);
15144
15145     case TRUTH_AND_EXPR:
15146     case TRUTH_OR_EXPR:
15147     case TRUTH_XOR_EXPR:
15148       return tree_binary_nonzero_warnv_p (code, type,
15149                                                TREE_OPERAND (t, 0),
15150                                                TREE_OPERAND (t, 1),
15151                                                strict_overflow_p);
15152
15153     case COND_EXPR:
15154     case CONSTRUCTOR:
15155     case OBJ_TYPE_REF:
15156     case ASSERT_EXPR:
15157     case ADDR_EXPR:
15158     case WITH_SIZE_EXPR:
15159     case SSA_NAME:
15160       return tree_single_nonzero_warnv_p (t, strict_overflow_p);
15161
15162     case COMPOUND_EXPR:
15163     case MODIFY_EXPR:
15164     case BIND_EXPR:
15165       return tree_expr_nonzero_warnv_p (TREE_OPERAND (t, 1),
15166                                         strict_overflow_p);
15167
15168     case SAVE_EXPR:
15169       return tree_expr_nonzero_warnv_p (TREE_OPERAND (t, 0),
15170                                         strict_overflow_p);
15171
15172     case CALL_EXPR:
15173       return alloca_call_p (t);
15174
15175     default:
15176       break;
15177     }
15178   return false;
15179 }
15180
15181 /* Return true when T is an address and is known to be nonzero.
15182    Handle warnings about undefined signed overflow.  */
15183
15184 bool
15185 tree_expr_nonzero_p (tree t)
15186 {
15187   bool ret, strict_overflow_p;
15188
15189   strict_overflow_p = false;
15190   ret = tree_expr_nonzero_warnv_p (t, &strict_overflow_p);
15191   if (strict_overflow_p)
15192     fold_overflow_warning (("assuming signed overflow does not occur when "
15193                             "determining that expression is always "
15194                             "non-zero"),
15195                            WARN_STRICT_OVERFLOW_MISC);
15196   return ret;
15197 }
15198
15199 /* Given the components of a binary expression CODE, TYPE, OP0 and OP1,
15200    attempt to fold the expression to a constant without modifying TYPE,
15201    OP0 or OP1.
15202
15203    If the expression could be simplified to a constant, then return
15204    the constant.  If the expression would not be simplified to a
15205    constant, then return NULL_TREE.  */
15206
15207 tree
15208 fold_binary_to_constant (enum tree_code code, tree type, tree op0, tree op1)
15209 {
15210   tree tem = fold_binary (code, type, op0, op1);
15211   return (tem && TREE_CONSTANT (tem)) ? tem : NULL_TREE;
15212 }
15213
15214 /* Given the components of a unary expression CODE, TYPE and OP0,
15215    attempt to fold the expression to a constant without modifying
15216    TYPE or OP0.
15217
15218    If the expression could be simplified to a constant, then return
15219    the constant.  If the expression would not be simplified to a
15220    constant, then return NULL_TREE.  */
15221
15222 tree
15223 fold_unary_to_constant (enum tree_code code, tree type, tree op0)
15224 {
15225   tree tem = fold_unary (code, type, op0);
15226   return (tem && TREE_CONSTANT (tem)) ? tem : NULL_TREE;
15227 }
15228
15229 /* If EXP represents referencing an element in a constant string
15230    (either via pointer arithmetic or array indexing), return the
15231    tree representing the value accessed, otherwise return NULL.  */
15232
15233 tree
15234 fold_read_from_constant_string (tree exp)
15235 {
15236   if ((TREE_CODE (exp) == INDIRECT_REF
15237        || TREE_CODE (exp) == ARRAY_REF)
15238       && TREE_CODE (TREE_TYPE (exp)) == INTEGER_TYPE)
15239     {
15240       tree exp1 = TREE_OPERAND (exp, 0);
15241       tree index;
15242       tree string;
15243       location_t loc = EXPR_LOCATION (exp);
15244
15245       if (TREE_CODE (exp) == INDIRECT_REF)
15246         string = string_constant (exp1, &index);
15247       else
15248         {
15249           tree low_bound = array_ref_low_bound (exp);
15250           index = fold_convert_loc (loc, sizetype, TREE_OPERAND (exp, 1));
15251
15252           /* Optimize the special-case of a zero lower bound.
15253
15254              We convert the low_bound to sizetype to avoid some problems
15255              with constant folding.  (E.g. suppose the lower bound is 1,
15256              and its mode is QI.  Without the conversion,l (ARRAY
15257              +(INDEX-(unsigned char)1)) becomes ((ARRAY+(-(unsigned char)1))
15258              +INDEX), which becomes (ARRAY+255+INDEX).  Oops!)  */
15259           if (! integer_zerop (low_bound))
15260             index = size_diffop_loc (loc, index,
15261                                  fold_convert_loc (loc, sizetype, low_bound));
15262
15263           string = exp1;
15264         }
15265
15266       if (string
15267           && TYPE_MODE (TREE_TYPE (exp)) == TYPE_MODE (TREE_TYPE (TREE_TYPE (string)))
15268           && TREE_CODE (string) == STRING_CST
15269           && TREE_CODE (index) == INTEGER_CST
15270           && compare_tree_int (index, TREE_STRING_LENGTH (string)) < 0
15271           && (GET_MODE_CLASS (TYPE_MODE (TREE_TYPE (TREE_TYPE (string))))
15272               == MODE_INT)
15273           && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (TREE_TYPE (string)))) == 1))
15274         return build_int_cst_type (TREE_TYPE (exp),
15275                                    (TREE_STRING_POINTER (string)
15276                                     [TREE_INT_CST_LOW (index)]));
15277     }
15278   return NULL;
15279 }
15280
15281 /* Return the tree for neg (ARG0) when ARG0 is known to be either
15282    an integer constant, real, or fixed-point constant.
15283
15284    TYPE is the type of the result.  */
15285
15286 static tree
15287 fold_negate_const (tree arg0, tree type)
15288 {
15289   tree t = NULL_TREE;
15290
15291   switch (TREE_CODE (arg0))
15292     {
15293     case INTEGER_CST:
15294       {
15295         double_int val = tree_to_double_int (arg0);
15296         int overflow = neg_double (val.low, val.high, &val.low, &val.high);
15297
15298         t = force_fit_type_double (type, val, 1,
15299                                    (overflow | TREE_OVERFLOW (arg0))
15300                                    && !TYPE_UNSIGNED (type));
15301         break;
15302       }
15303
15304     case REAL_CST:
15305       t = build_real (type, real_value_negate (&TREE_REAL_CST (arg0)));
15306       break;
15307
15308     case FIXED_CST:
15309       {
15310         FIXED_VALUE_TYPE f;
15311         bool overflow_p = fixed_arithmetic (&f, NEGATE_EXPR,
15312                                             &(TREE_FIXED_CST (arg0)), NULL,
15313                                             TYPE_SATURATING (type));
15314         t = build_fixed (type, f);
15315         /* Propagate overflow flags.  */
15316         if (overflow_p | TREE_OVERFLOW (arg0))
15317           TREE_OVERFLOW (t) = 1;
15318         break;
15319       }
15320
15321     default:
15322       gcc_unreachable ();
15323     }
15324
15325   return t;
15326 }
15327
15328 /* Return the tree for abs (ARG0) when ARG0 is known to be either
15329    an integer constant or real constant.
15330
15331    TYPE is the type of the result.  */
15332
15333 tree
15334 fold_abs_const (tree arg0, tree type)
15335 {
15336   tree t = NULL_TREE;
15337
15338   switch (TREE_CODE (arg0))
15339     {
15340     case INTEGER_CST:
15341       {
15342         double_int val = tree_to_double_int (arg0);
15343
15344         /* If the value is unsigned or non-negative, then the absolute value
15345            is the same as the ordinary value.  */
15346         if (TYPE_UNSIGNED (type)
15347             || !double_int_negative_p (val))
15348           t = arg0;
15349
15350         /* If the value is negative, then the absolute value is
15351            its negation.  */
15352         else
15353           {
15354             int overflow;
15355
15356             overflow = neg_double (val.low, val.high, &val.low, &val.high);
15357             t = force_fit_type_double (type, val, -1,
15358                                        overflow | TREE_OVERFLOW (arg0));
15359           }
15360       }
15361       break;
15362
15363     case REAL_CST:
15364       if (REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg0)))
15365         t = build_real (type, real_value_negate (&TREE_REAL_CST (arg0)));
15366       else
15367         t =  arg0;
15368       break;
15369
15370     default:
15371       gcc_unreachable ();
15372     }
15373
15374   return t;
15375 }
15376
15377 /* Return the tree for not (ARG0) when ARG0 is known to be an integer
15378    constant.  TYPE is the type of the result.  */
15379
15380 static tree
15381 fold_not_const (const_tree arg0, tree type)
15382 {
15383   double_int val;
15384
15385   gcc_assert (TREE_CODE (arg0) == INTEGER_CST);
15386
15387   val = double_int_not (tree_to_double_int (arg0));
15388   return force_fit_type_double (type, val, 0, TREE_OVERFLOW (arg0));
15389 }
15390
15391 /* Given CODE, a relational operator, the target type, TYPE and two
15392    constant operands OP0 and OP1, return the result of the
15393    relational operation.  If the result is not a compile time
15394    constant, then return NULL_TREE.  */
15395
15396 static tree
15397 fold_relational_const (enum tree_code code, tree type, tree op0, tree op1)
15398 {
15399   int result, invert;
15400
15401   /* From here on, the only cases we handle are when the result is
15402      known to be a constant.  */
15403
15404   if (TREE_CODE (op0) == REAL_CST && TREE_CODE (op1) == REAL_CST)
15405     {
15406       const REAL_VALUE_TYPE *c0 = TREE_REAL_CST_PTR (op0);
15407       const REAL_VALUE_TYPE *c1 = TREE_REAL_CST_PTR (op1);
15408
15409       /* Handle the cases where either operand is a NaN.  */
15410       if (real_isnan (c0) || real_isnan (c1))
15411         {
15412           switch (code)
15413             {
15414             case EQ_EXPR:
15415             case ORDERED_EXPR:
15416               result = 0;
15417               break;
15418
15419             case NE_EXPR:
15420             case UNORDERED_EXPR:
15421             case UNLT_EXPR:
15422             case UNLE_EXPR:
15423             case UNGT_EXPR:
15424             case UNGE_EXPR:
15425             case UNEQ_EXPR:
15426               result = 1;
15427               break;
15428
15429             case LT_EXPR:
15430             case LE_EXPR:
15431             case GT_EXPR:
15432             case GE_EXPR:
15433             case LTGT_EXPR:
15434               if (flag_trapping_math)
15435                 return NULL_TREE;
15436               result = 0;
15437               break;
15438
15439             default:
15440               gcc_unreachable ();
15441             }
15442
15443           return constant_boolean_node (result, type);
15444         }
15445
15446       return constant_boolean_node (real_compare (code, c0, c1), type);
15447     }
15448
15449   if (TREE_CODE (op0) == FIXED_CST && TREE_CODE (op1) == FIXED_CST)
15450     {
15451       const FIXED_VALUE_TYPE *c0 = TREE_FIXED_CST_PTR (op0);
15452       const FIXED_VALUE_TYPE *c1 = TREE_FIXED_CST_PTR (op1);
15453       return constant_boolean_node (fixed_compare (code, c0, c1), type);
15454     }
15455
15456   /* Handle equality/inequality of complex constants.  */
15457   if (TREE_CODE (op0) == COMPLEX_CST && TREE_CODE (op1) == COMPLEX_CST)
15458     {
15459       tree rcond = fold_relational_const (code, type,
15460                                           TREE_REALPART (op0),
15461                                           TREE_REALPART (op1));
15462       tree icond = fold_relational_const (code, type,
15463                                           TREE_IMAGPART (op0),
15464                                           TREE_IMAGPART (op1));
15465       if (code == EQ_EXPR)
15466         return fold_build2 (TRUTH_ANDIF_EXPR, type, rcond, icond);
15467       else if (code == NE_EXPR)
15468         return fold_build2 (TRUTH_ORIF_EXPR, type, rcond, icond);
15469       else
15470         return NULL_TREE;
15471     }
15472
15473   /* From here on we only handle LT, LE, GT, GE, EQ and NE.
15474
15475      To compute GT, swap the arguments and do LT.
15476      To compute GE, do LT and invert the result.
15477      To compute LE, swap the arguments, do LT and invert the result.
15478      To compute NE, do EQ and invert the result.
15479
15480      Therefore, the code below must handle only EQ and LT.  */
15481
15482   if (code == LE_EXPR || code == GT_EXPR)
15483     {
15484       tree tem = op0;
15485       op0 = op1;
15486       op1 = tem;
15487       code = swap_tree_comparison (code);
15488     }
15489
15490   /* Note that it is safe to invert for real values here because we
15491      have already handled the one case that it matters.  */
15492
15493   invert = 0;
15494   if (code == NE_EXPR || code == GE_EXPR)
15495     {
15496       invert = 1;
15497       code = invert_tree_comparison (code, false);
15498     }
15499
15500   /* Compute a result for LT or EQ if args permit;
15501      Otherwise return T.  */
15502   if (TREE_CODE (op0) == INTEGER_CST && TREE_CODE (op1) == INTEGER_CST)
15503     {
15504       if (code == EQ_EXPR)
15505         result = tree_int_cst_equal (op0, op1);
15506       else if (TYPE_UNSIGNED (TREE_TYPE (op0)))
15507         result = INT_CST_LT_UNSIGNED (op0, op1);
15508       else
15509         result = INT_CST_LT (op0, op1);
15510     }
15511   else
15512     return NULL_TREE;
15513
15514   if (invert)
15515     result ^= 1;
15516   return constant_boolean_node (result, type);
15517 }
15518
15519 /* If necessary, return a CLEANUP_POINT_EXPR for EXPR with the
15520    indicated TYPE.  If no CLEANUP_POINT_EXPR is necessary, return EXPR
15521    itself.  */
15522
15523 tree
15524 fold_build_cleanup_point_expr (tree type, tree expr)
15525 {
15526   /* If the expression does not have side effects then we don't have to wrap
15527      it with a cleanup point expression.  */
15528   if (!TREE_SIDE_EFFECTS (expr))
15529     return expr;
15530
15531   /* If the expression is a return, check to see if the expression inside the
15532      return has no side effects or the right hand side of the modify expression
15533      inside the return. If either don't have side effects set we don't need to
15534      wrap the expression in a cleanup point expression.  Note we don't check the
15535      left hand side of the modify because it should always be a return decl.  */
15536   if (TREE_CODE (expr) == RETURN_EXPR)
15537     {
15538       tree op = TREE_OPERAND (expr, 0);
15539       if (!op || !TREE_SIDE_EFFECTS (op))
15540         return expr;
15541       op = TREE_OPERAND (op, 1);
15542       if (!TREE_SIDE_EFFECTS (op))
15543         return expr;
15544     }
15545
15546   return build1 (CLEANUP_POINT_EXPR, type, expr);
15547 }
15548
15549 /* Given a pointer value OP0 and a type TYPE, return a simplified version
15550    of an indirection through OP0, or NULL_TREE if no simplification is
15551    possible.  */
15552
15553 tree
15554 fold_indirect_ref_1 (location_t loc, tree type, tree op0)
15555 {
15556   tree sub = op0;
15557   tree subtype;
15558
15559   STRIP_NOPS (sub);
15560   subtype = TREE_TYPE (sub);
15561   if (!POINTER_TYPE_P (subtype))
15562     return NULL_TREE;
15563
15564   if (TREE_CODE (sub) == ADDR_EXPR)
15565     {
15566       tree op = TREE_OPERAND (sub, 0);
15567       tree optype = TREE_TYPE (op);
15568       /* *&CONST_DECL -> to the value of the const decl.  */
15569       if (TREE_CODE (op) == CONST_DECL)
15570         return DECL_INITIAL (op);
15571       /* *&p => p;  make sure to handle *&"str"[cst] here.  */
15572       if (type == optype)
15573         {
15574           tree fop = fold_read_from_constant_string (op);
15575           if (fop)
15576             return fop;
15577           else
15578             return op;
15579         }
15580       /* *(foo *)&fooarray => fooarray[0] */
15581       else if (TREE_CODE (optype) == ARRAY_TYPE
15582                && type == TREE_TYPE (optype)
15583                && (!in_gimple_form
15584                    || TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST))
15585         {
15586           tree type_domain = TYPE_DOMAIN (optype);
15587           tree min_val = size_zero_node;
15588           if (type_domain && TYPE_MIN_VALUE (type_domain))
15589             min_val = TYPE_MIN_VALUE (type_domain);
15590           if (in_gimple_form
15591               && TREE_CODE (min_val) != INTEGER_CST)
15592             return NULL_TREE;
15593           return build4_loc (loc, ARRAY_REF, type, op, min_val,
15594                              NULL_TREE, NULL_TREE);
15595         }
15596       /* *(foo *)&complexfoo => __real__ complexfoo */
15597       else if (TREE_CODE (optype) == COMPLEX_TYPE
15598                && type == TREE_TYPE (optype))
15599         return fold_build1_loc (loc, REALPART_EXPR, type, op);
15600       /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
15601       else if (TREE_CODE (optype) == VECTOR_TYPE
15602                && type == TREE_TYPE (optype))
15603         {
15604           tree part_width = TYPE_SIZE (type);
15605           tree index = bitsize_int (0);
15606           return fold_build3_loc (loc, BIT_FIELD_REF, type, op, part_width, index);
15607         }
15608     }
15609
15610   if (TREE_CODE (sub) == POINTER_PLUS_EXPR
15611       && TREE_CODE (TREE_OPERAND (sub, 1)) == INTEGER_CST)
15612     {
15613       tree op00 = TREE_OPERAND (sub, 0);
15614       tree op01 = TREE_OPERAND (sub, 1);
15615
15616       STRIP_NOPS (op00);
15617       if (TREE_CODE (op00) == ADDR_EXPR)
15618         {
15619           tree op00type;
15620           op00 = TREE_OPERAND (op00, 0);
15621           op00type = TREE_TYPE (op00);
15622
15623           /* ((foo*)&vectorfoo)[1] => BIT_FIELD_REF<vectorfoo,...> */
15624           if (TREE_CODE (op00type) == VECTOR_TYPE
15625               && type == TREE_TYPE (op00type))
15626             {
15627               HOST_WIDE_INT offset = tree_low_cst (op01, 0);
15628               tree part_width = TYPE_SIZE (type);
15629               unsigned HOST_WIDE_INT part_widthi = tree_low_cst (part_width, 0)/BITS_PER_UNIT;
15630               unsigned HOST_WIDE_INT indexi = offset * BITS_PER_UNIT;
15631               tree index = bitsize_int (indexi);
15632
15633               if (offset/part_widthi <= TYPE_VECTOR_SUBPARTS (op00type))
15634                 return fold_build3_loc (loc,
15635                                         BIT_FIELD_REF, type, op00,
15636                                         part_width, index);
15637
15638             }
15639           /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */
15640           else if (TREE_CODE (op00type) == COMPLEX_TYPE
15641                    && type == TREE_TYPE (op00type))
15642             {
15643               tree size = TYPE_SIZE_UNIT (type);
15644               if (tree_int_cst_equal (size, op01))
15645                 return fold_build1_loc (loc, IMAGPART_EXPR, type, op00);
15646             }
15647           /* ((foo *)&fooarray)[1] => fooarray[1] */
15648           else if (TREE_CODE (op00type) == ARRAY_TYPE
15649                    && type == TREE_TYPE (op00type))
15650             {
15651               tree type_domain = TYPE_DOMAIN (op00type);
15652               tree min_val = size_zero_node;
15653               if (type_domain && TYPE_MIN_VALUE (type_domain))
15654                 min_val = TYPE_MIN_VALUE (type_domain);
15655               op01 = size_binop_loc (loc, EXACT_DIV_EXPR, op01,
15656                                      TYPE_SIZE_UNIT (type));
15657               op01 = size_binop_loc (loc, PLUS_EXPR, op01, min_val);
15658               return build4_loc (loc, ARRAY_REF, type, op00, op01,
15659                                  NULL_TREE, NULL_TREE);
15660             }
15661         }
15662     }
15663
15664   /* *(foo *)fooarrptr => (*fooarrptr)[0] */
15665   if (TREE_CODE (TREE_TYPE (subtype)) == ARRAY_TYPE
15666       && type == TREE_TYPE (TREE_TYPE (subtype))
15667       && (!in_gimple_form
15668           || TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST))
15669     {
15670       tree type_domain;
15671       tree min_val = size_zero_node;
15672       sub = build_fold_indirect_ref_loc (loc, sub);
15673       type_domain = TYPE_DOMAIN (TREE_TYPE (sub));
15674       if (type_domain && TYPE_MIN_VALUE (type_domain))
15675         min_val = TYPE_MIN_VALUE (type_domain);
15676       if (in_gimple_form
15677           && TREE_CODE (min_val) != INTEGER_CST)
15678         return NULL_TREE;
15679       return build4_loc (loc, ARRAY_REF, type, sub, min_val, NULL_TREE,
15680                          NULL_TREE);
15681     }
15682
15683   return NULL_TREE;
15684 }
15685
15686 /* Builds an expression for an indirection through T, simplifying some
15687    cases.  */
15688
15689 tree
15690 build_fold_indirect_ref_loc (location_t loc, tree t)
15691 {
15692   tree type = TREE_TYPE (TREE_TYPE (t));
15693   tree sub = fold_indirect_ref_1 (loc, type, t);
15694
15695   if (sub)
15696     return sub;
15697
15698   return build1_loc (loc, INDIRECT_REF, type, t);
15699 }
15700
15701 /* Given an INDIRECT_REF T, return either T or a simplified version.  */
15702
15703 tree
15704 fold_indirect_ref_loc (location_t loc, tree t)
15705 {
15706   tree sub = fold_indirect_ref_1 (loc, TREE_TYPE (t), TREE_OPERAND (t, 0));
15707
15708   if (sub)
15709     return sub;
15710   else
15711     return t;
15712 }
15713
15714 /* Strip non-trapping, non-side-effecting tree nodes from an expression
15715    whose result is ignored.  The type of the returned tree need not be
15716    the same as the original expression.  */
15717
15718 tree
15719 fold_ignored_result (tree t)
15720 {
15721   if (!TREE_SIDE_EFFECTS (t))
15722     return integer_zero_node;
15723
15724   for (;;)
15725     switch (TREE_CODE_CLASS (TREE_CODE (t)))
15726       {
15727       case tcc_unary:
15728         t = TREE_OPERAND (t, 0);
15729         break;
15730
15731       case tcc_binary:
15732       case tcc_comparison:
15733         if (!TREE_SIDE_EFFECTS (TREE_OPERAND (t, 1)))
15734           t = TREE_OPERAND (t, 0);
15735         else if (!TREE_SIDE_EFFECTS (TREE_OPERAND (t, 0)))
15736           t = TREE_OPERAND (t, 1);
15737         else
15738           return t;
15739         break;
15740
15741       case tcc_expression:
15742         switch (TREE_CODE (t))
15743           {
15744           case COMPOUND_EXPR:
15745             if (TREE_SIDE_EFFECTS (TREE_OPERAND (t, 1)))
15746               return t;
15747             t = TREE_OPERAND (t, 0);
15748             break;
15749
15750           case COND_EXPR:
15751             if (TREE_SIDE_EFFECTS (TREE_OPERAND (t, 1))
15752                 || TREE_SIDE_EFFECTS (TREE_OPERAND (t, 2)))
15753               return t;
15754             t = TREE_OPERAND (t, 0);
15755             break;
15756
15757           default:
15758             return t;
15759           }
15760         break;
15761
15762       default:
15763         return t;
15764       }
15765 }
15766
15767 /* Return the value of VALUE, rounded up to a multiple of DIVISOR.
15768    This can only be applied to objects of a sizetype.  */
15769
15770 tree
15771 round_up_loc (location_t loc, tree value, int divisor)
15772 {
15773   tree div = NULL_TREE;
15774
15775   gcc_assert (divisor > 0);
15776   if (divisor == 1)
15777     return value;
15778
15779   /* See if VALUE is already a multiple of DIVISOR.  If so, we don't
15780      have to do anything.  Only do this when we are not given a const,
15781      because in that case, this check is more expensive than just
15782      doing it.  */
15783   if (TREE_CODE (value) != INTEGER_CST)
15784     {
15785       div = build_int_cst (TREE_TYPE (value), divisor);
15786
15787       if (multiple_of_p (TREE_TYPE (value), value, div))
15788         return value;
15789     }
15790
15791   /* If divisor is a power of two, simplify this to bit manipulation.  */
15792   if (divisor == (divisor & -divisor))
15793     {
15794       if (TREE_CODE (value) == INTEGER_CST)
15795         {
15796           double_int val = tree_to_double_int (value);
15797           bool overflow_p;
15798
15799           if ((val.low & (divisor - 1)) == 0)
15800             return value;
15801
15802           overflow_p = TREE_OVERFLOW (value);
15803           val.low &= ~(divisor - 1);
15804           val.low += divisor;
15805           if (val.low == 0)
15806             {
15807               val.high++;
15808               if (val.high == 0)
15809                 overflow_p = true;
15810             }
15811
15812           return force_fit_type_double (TREE_TYPE (value), val,
15813                                         -1, overflow_p);
15814         }
15815       else
15816         {
15817           tree t;
15818
15819           t = build_int_cst (TREE_TYPE (value), divisor - 1);
15820           value = size_binop_loc (loc, PLUS_EXPR, value, t);
15821           t = build_int_cst (TREE_TYPE (value), -divisor);
15822           value = size_binop_loc (loc, BIT_AND_EXPR, value, t);
15823         }
15824     }
15825   else
15826     {
15827       if (!div)
15828         div = build_int_cst (TREE_TYPE (value), divisor);
15829       value = size_binop_loc (loc, CEIL_DIV_EXPR, value, div);
15830       value = size_binop_loc (loc, MULT_EXPR, value, div);
15831     }
15832
15833   return value;
15834 }
15835
15836 /* Likewise, but round down.  */
15837
15838 tree
15839 round_down_loc (location_t loc, tree value, int divisor)
15840 {
15841   tree div = NULL_TREE;
15842
15843   gcc_assert (divisor > 0);
15844   if (divisor == 1)
15845     return value;
15846
15847   /* See if VALUE is already a multiple of DIVISOR.  If so, we don't
15848      have to do anything.  Only do this when we are not given a const,
15849      because in that case, this check is more expensive than just
15850      doing it.  */
15851   if (TREE_CODE (value) != INTEGER_CST)
15852     {
15853       div = build_int_cst (TREE_TYPE (value), divisor);
15854
15855       if (multiple_of_p (TREE_TYPE (value), value, div))
15856         return value;
15857     }
15858
15859   /* If divisor is a power of two, simplify this to bit manipulation.  */
15860   if (divisor == (divisor & -divisor))
15861     {
15862       tree t;
15863
15864       t = build_int_cst (TREE_TYPE (value), -divisor);
15865       value = size_binop_loc (loc, BIT_AND_EXPR, value, t);
15866     }
15867   else
15868     {
15869       if (!div)
15870         div = build_int_cst (TREE_TYPE (value), divisor);
15871       value = size_binop_loc (loc, FLOOR_DIV_EXPR, value, div);
15872       value = size_binop_loc (loc, MULT_EXPR, value, div);
15873     }
15874
15875   return value;
15876 }
15877
15878 /* Returns the pointer to the base of the object addressed by EXP and
15879    extracts the information about the offset of the access, storing it
15880    to PBITPOS and POFFSET.  */
15881
15882 static tree
15883 split_address_to_core_and_offset (tree exp,
15884                                   HOST_WIDE_INT *pbitpos, tree *poffset)
15885 {
15886   tree core;
15887   enum machine_mode mode;
15888   int unsignedp, volatilep;
15889   HOST_WIDE_INT bitsize;
15890   location_t loc = EXPR_LOCATION (exp);
15891
15892   if (TREE_CODE (exp) == ADDR_EXPR)
15893     {
15894       core = get_inner_reference (TREE_OPERAND (exp, 0), &bitsize, pbitpos,
15895                                   poffset, &mode, &unsignedp, &volatilep,
15896                                   false);
15897       core = build_fold_addr_expr_loc (loc, core);
15898     }
15899   else
15900     {
15901       core = exp;
15902       *pbitpos = 0;
15903       *poffset = NULL_TREE;
15904     }
15905
15906   return core;
15907 }
15908
15909 /* Returns true if addresses of E1 and E2 differ by a constant, false
15910    otherwise.  If they do, E1 - E2 is stored in *DIFF.  */
15911
15912 bool
15913 ptr_difference_const (tree e1, tree e2, HOST_WIDE_INT *diff)
15914 {
15915   tree core1, core2;
15916   HOST_WIDE_INT bitpos1, bitpos2;
15917   tree toffset1, toffset2, tdiff, type;
15918
15919   core1 = split_address_to_core_and_offset (e1, &bitpos1, &toffset1);
15920   core2 = split_address_to_core_and_offset (e2, &bitpos2, &toffset2);
15921
15922   if (bitpos1 % BITS_PER_UNIT != 0
15923       || bitpos2 % BITS_PER_UNIT != 0
15924       || !operand_equal_p (core1, core2, 0))
15925     return false;
15926
15927   if (toffset1 && toffset2)
15928     {
15929       type = TREE_TYPE (toffset1);
15930       if (type != TREE_TYPE (toffset2))
15931         toffset2 = fold_convert (type, toffset2);
15932
15933       tdiff = fold_build2 (MINUS_EXPR, type, toffset1, toffset2);
15934       if (!cst_and_fits_in_hwi (tdiff))
15935         return false;
15936
15937       *diff = int_cst_value (tdiff);
15938     }
15939   else if (toffset1 || toffset2)
15940     {
15941       /* If only one of the offsets is non-constant, the difference cannot
15942          be a constant.  */
15943       return false;
15944     }
15945   else
15946     *diff = 0;
15947
15948   *diff += (bitpos1 - bitpos2) / BITS_PER_UNIT;
15949   return true;
15950 }
15951
15952 /* Simplify the floating point expression EXP when the sign of the
15953    result is not significant.  Return NULL_TREE if no simplification
15954    is possible.  */
15955
15956 tree
15957 fold_strip_sign_ops (tree exp)
15958 {
15959   tree arg0, arg1;
15960   location_t loc = EXPR_LOCATION (exp);
15961
15962   switch (TREE_CODE (exp))
15963     {
15964     case ABS_EXPR:
15965     case NEGATE_EXPR:
15966       arg0 = fold_strip_sign_ops (TREE_OPERAND (exp, 0));
15967       return arg0 ? arg0 : TREE_OPERAND (exp, 0);
15968
15969     case MULT_EXPR:
15970     case RDIV_EXPR:
15971       if (HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (TREE_TYPE (exp))))
15972         return NULL_TREE;
15973       arg0 = fold_strip_sign_ops (TREE_OPERAND (exp, 0));
15974       arg1 = fold_strip_sign_ops (TREE_OPERAND (exp, 1));
15975       if (arg0 != NULL_TREE || arg1 != NULL_TREE)
15976         return fold_build2_loc (loc, TREE_CODE (exp), TREE_TYPE (exp),
15977                             arg0 ? arg0 : TREE_OPERAND (exp, 0),
15978                             arg1 ? arg1 : TREE_OPERAND (exp, 1));
15979       break;
15980
15981     case COMPOUND_EXPR:
15982       arg0 = TREE_OPERAND (exp, 0);
15983       arg1 = fold_strip_sign_ops (TREE_OPERAND (exp, 1));
15984       if (arg1)
15985         return fold_build2_loc (loc, COMPOUND_EXPR, TREE_TYPE (exp), arg0, arg1);
15986       break;
15987
15988     case COND_EXPR:
15989       arg0 = fold_strip_sign_ops (TREE_OPERAND (exp, 1));
15990       arg1 = fold_strip_sign_ops (TREE_OPERAND (exp, 2));
15991       if (arg0 || arg1)
15992         return fold_build3_loc (loc,
15993                             COND_EXPR, TREE_TYPE (exp), TREE_OPERAND (exp, 0),
15994                             arg0 ? arg0 : TREE_OPERAND (exp, 1),
15995                             arg1 ? arg1 : TREE_OPERAND (exp, 2));
15996       break;
15997
15998     case CALL_EXPR:
15999       {
16000         const enum built_in_function fcode = builtin_mathfn_code (exp);
16001         switch (fcode)
16002         {
16003         CASE_FLT_FN (BUILT_IN_COPYSIGN):
16004           /* Strip copysign function call, return the 1st argument. */
16005           arg0 = CALL_EXPR_ARG (exp, 0);
16006           arg1 = CALL_EXPR_ARG (exp, 1);
16007           return omit_one_operand_loc (loc, TREE_TYPE (exp), arg0, arg1);
16008
16009         default:
16010           /* Strip sign ops from the argument of "odd" math functions.  */
16011           if (negate_mathfn_p (fcode))
16012             {
16013               arg0 = fold_strip_sign_ops (CALL_EXPR_ARG (exp, 0));
16014               if (arg0)
16015                 return build_call_expr_loc (loc, get_callee_fndecl (exp), 1, arg0);
16016             }
16017           break;
16018         }
16019       }
16020       break;
16021
16022     default:
16023       break;
16024     }
16025   return NULL_TREE;
16026 }