gcc/simplify-rtx.c

   1 /* RTL simplification functions for GNU compiler.
   2    Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
   3    1999, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 2, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING.  If not, write to the Free
  19 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
  20 02110-1301, USA.  */
  21
  22
  23 #include "config.h"
  24 #include "system.h"
  25 #include "coretypes.h"
  26 #include "tm.h"
  27 #include "rtl.h"
  28 #include "tree.h"
  29 #include "tm_p.h"
  30 #include "regs.h"
  31 #include "hard-reg-set.h"
  32 #include "flags.h"
  33 #include "real.h"
  34 #include "insn-config.h"
  35 #include "recog.h"
  36 #include "function.h"
  37 #include "expr.h"
  38 #include "toplev.h"
  39 #include "output.h"
  40 #include "ggc.h"
  41 #include "target.h"
  42
  43 /* Simplification and canonicalization of RTL.  */
  44
  45 /* Much code operates on (low, high) pairs; the low value is an
  46    unsigned wide int, the high value a signed wide int.  We
  47    occasionally need to sign extend from low to high as if low were a
  48    signed wide int.  */
  49 #define HWI_SIGN_EXTEND(low) \
  50  ((((HOST_WIDE_INT) low) < 0) ? ((HOST_WIDE_INT) -1) : ((HOST_WIDE_INT) 0))
  51
  52 static rtx neg_const_int (enum machine_mode, rtx);
  53 static bool plus_minus_operand_p (rtx);
  54 static int simplify_plus_minus_op_data_cmp (const void *, const void *);
  55 static rtx simplify_plus_minus (enum rtx_code, enum machine_mode, rtx, rtx);
  56 static rtx simplify_immed_subreg (enum machine_mode, rtx, enum machine_mode,
  57                                   unsigned int);
  58 static rtx simplify_associative_operation (enum rtx_code, enum machine_mode,
  59                                            rtx, rtx);
  60 static rtx simplify_relational_operation_1 (enum rtx_code, enum machine_mode,
  61                                             enum machine_mode, rtx, rtx);
  62 static rtx simplify_unary_operation_1 (enum rtx_code, enum machine_mode, rtx);
  63 static rtx simplify_binary_operation_1 (enum rtx_code, enum machine_mode,
  64                                         rtx, rtx, rtx, rtx);
  65 \f
  66 /* Negate a CONST_INT rtx, truncating (because a conversion from a
  67    maximally negative number can overflow).  */
  68 static rtx
  69 neg_const_int (enum machine_mode mode, rtx i)
  70 {
  71   return gen_int_mode (- INTVAL (i), mode);
  72 }
  73
  74 /* Test whether expression, X, is an immediate constant that represents
  75    the most significant bit of machine mode MODE.  */
  76
  77 bool
  78 mode_signbit_p (enum machine_mode mode, rtx x)
  79 {
  80   unsigned HOST_WIDE_INT val;
  81   unsigned int width;
  82
  83   if (GET_MODE_CLASS (mode) != MODE_INT)
  84     return false;
  85
  86   width = GET_MODE_BITSIZE (mode);
  87   if (width == 0)
  88     return false;
  89
  90   if (width <= HOST_BITS_PER_WIDE_INT
  91       && GET_CODE (x) == CONST_INT)
  92     val = INTVAL (x);
  93   else if (width <= 2 * HOST_BITS_PER_WIDE_INT
  94            && GET_CODE (x) == CONST_DOUBLE
  95            && CONST_DOUBLE_LOW (x) == 0)
  96     {
  97       val = CONST_DOUBLE_HIGH (x);
  98       width -= HOST_BITS_PER_WIDE_INT;
  99     }
 100   else
 101     return false;
 102
 103   if (width < HOST_BITS_PER_WIDE_INT)
 104     val &= ((unsigned HOST_WIDE_INT) 1 << width) - 1;
 105   return val == ((unsigned HOST_WIDE_INT) 1 << (width - 1));
 106 }
 107 \f
 108 /* Make a binary operation by properly ordering the operands and
 109    seeing if the expression folds.  */
 110
 111 rtx
 112 simplify_gen_binary (enum rtx_code code, enum machine_mode mode, rtx op0,
 113                      rtx op1)
 114 {
 115   rtx tem;
 116
 117   /* Put complex operands first and constants second if commutative.  */
 118   if (GET_RTX_CLASS (code) == RTX_COMM_ARITH
 119       && swap_commutative_operands_p (op0, op1))
 120     tem = op0, op0 = op1, op1 = tem;
 121
 122   /* If this simplifies, do it.  */
 123   tem = simplify_binary_operation (code, mode, op0, op1);
 124   if (tem)
 125     return tem;
 126
 127   return gen_rtx_fmt_ee (code, mode, op0, op1);
 128 }
 129 \f
 130 /* If X is a MEM referencing the constant pool, return the real value.
 131    Otherwise return X.  */
 132 rtx
 133 avoid_constant_pool_reference (rtx x)
 134 {
 135   rtx c, tmp, addr;
 136   enum machine_mode cmode;
 137   HOST_WIDE_INT offset = 0;
 138
 139   switch (GET_CODE (x))
 140     {
 141     case MEM:
 142       break;
 143
 144     case FLOAT_EXTEND:
 145       /* Handle float extensions of constant pool references.  */
 146       tmp = XEXP (x, 0);
 147       c = avoid_constant_pool_reference (tmp);
 148       if (c != tmp && GET_CODE (c) == CONST_DOUBLE)
 149         {
 150           REAL_VALUE_TYPE d;
 151
 152           REAL_VALUE_FROM_CONST_DOUBLE (d, c);
 153           return CONST_DOUBLE_FROM_REAL_VALUE (d, GET_MODE (x));
 154         }
 155       return x;
 156
 157     default:
 158       return x;
 159     }
 160
 161   addr = XEXP (x, 0);
 162
 163   /* Call target hook to avoid the effects of -fpic etc....  */
 164   addr = targetm.delegitimize_address (addr);
 165
 166   /* Split the address into a base and integer offset.  */
 167   if (GET_CODE (addr) == CONST
 168       && GET_CODE (XEXP (addr, 0)) == PLUS
 169       && GET_CODE (XEXP (XEXP (addr, 0), 1)) == CONST_INT)
 170     {
 171       offset = INTVAL (XEXP (XEXP (addr, 0), 1));
 172       addr = XEXP (XEXP (addr, 0), 0);
 173     }
 174
 175   if (GET_CODE (addr) == LO_SUM)
 176     addr = XEXP (addr, 1);
 177
 178   /* If this is a constant pool reference, we can turn it into its
 179      constant and hope that simplifications happen.  */
 180   if (GET_CODE (addr) == SYMBOL_REF
 181       && CONSTANT_POOL_ADDRESS_P (addr))
 182     {
 183       c = get_pool_constant (addr);
 184       cmode = get_pool_mode (addr);
 185
 186       /* If we're accessing the constant in a different mode than it was
 187          originally stored, attempt to fix that up via subreg simplifications.
 188          If that fails we have no choice but to return the original memory.  */
 189       if (offset != 0 || cmode != GET_MODE (x))
 190         {
 191           rtx tem = simplify_subreg (GET_MODE (x), c, cmode, offset);
 192           if (tem && CONSTANT_P (tem))
 193             return tem;
 194         }
 195       else
 196         return c;
 197     }
 198
 199   return x;
 200 }
 201
 202 /* Return true if X is a MEM referencing the constant pool.  */
 203
 204 bool
 205 constant_pool_reference_p (rtx x)
 206 {
 207   return avoid_constant_pool_reference (x) != x;
 208 }
 209 \f
 210 /* Make a unary operation by first seeing if it folds and otherwise making
 211    the specified operation.  */
 212
 213 rtx
 214 simplify_gen_unary (enum rtx_code code, enum machine_mode mode, rtx op,
 215                     enum machine_mode op_mode)
 216 {
 217   rtx tem;
 218
 219   /* If this simplifies, use it.  */
 220   if ((tem = simplify_unary_operation (code, mode, op, op_mode)) != 0)
 221     return tem;
 222
 223   return gen_rtx_fmt_e (code, mode, op);
 224 }
 225
 226 /* Likewise for ternary operations.  */
 227
 228 rtx
 229 simplify_gen_ternary (enum rtx_code code, enum machine_mode mode,
 230                       enum machine_mode op0_mode, rtx op0, rtx op1, rtx op2)
 231 {
 232   rtx tem;
 233
 234   /* If this simplifies, use it.  */
 235   if (0 != (tem = simplify_ternary_operation (code, mode, op0_mode,
 236                                               op0, op1, op2)))
 237     return tem;
 238
 239   return gen_rtx_fmt_eee (code, mode, op0, op1, op2);
 240 }
 241
 242 /* Likewise, for relational operations.
 243    CMP_MODE specifies mode comparison is done in.  */
 244
 245 rtx
 246 simplify_gen_relational (enum rtx_code code, enum machine_mode mode,
 247                          enum machine_mode cmp_mode, rtx op0, rtx op1)
 248 {
 249   rtx tem;
 250
 251   if (0 != (tem = simplify_relational_operation (code, mode, cmp_mode,
 252                                                  op0, op1)))
 253     return tem;
 254
 255   return gen_rtx_fmt_ee (code, mode, op0, op1);
 256 }
 257 \f
 258 /* Replace all occurrences of OLD_RTX in X with NEW_RTX and try to simplify the
 259    resulting RTX.  Return a new RTX which is as simplified as possible.  */
 260
 261 rtx
 262 simplify_replace_rtx (rtx x, rtx old_rtx, rtx new_rtx)
 263 {
 264   enum rtx_code code = GET_CODE (x);
 265   enum machine_mode mode = GET_MODE (x);
 266   enum machine_mode op_mode;
 267   rtx op0, op1, op2;
 268
 269   /* If X is OLD_RTX, return NEW_RTX.  Otherwise, if this is an expression, try
 270      to build a new expression substituting recursively.  If we can't do
 271      anything, return our input.  */
 272
 273   if (x == old_rtx)
 274     return new_rtx;
 275
 276   switch (GET_RTX_CLASS (code))
 277     {
 278     case RTX_UNARY:
 279       op0 = XEXP (x, 0);
 280       op_mode = GET_MODE (op0);
 281       op0 = simplify_replace_rtx (op0, old_rtx, new_rtx);
 282       if (op0 == XEXP (x, 0))
 283         return x;
 284       return simplify_gen_unary (code, mode, op0, op_mode);
 285
 286     case RTX_BIN_ARITH:
 287     case RTX_COMM_ARITH:
 288       op0 = simplify_replace_rtx (XEXP (x, 0), old_rtx, new_rtx);
 289       op1 = simplify_replace_rtx (XEXP (x, 1), old_rtx, new_rtx);
 290       if (op0 == XEXP (x, 0) && op1 == XEXP (x, 1))
 291         return x;
 292       return simplify_gen_binary (code, mode, op0, op1);
 293
 294     case RTX_COMPARE:
 295     case RTX_COMM_COMPARE:
 296       op0 = XEXP (x, 0);
 297       op1 = XEXP (x, 1);
 298       op_mode = GET_MODE (op0) != VOIDmode ? GET_MODE (op0) : GET_MODE (op1);
 299       op0 = simplify_replace_rtx (op0, old_rtx, new_rtx);
 300       op1 = simplify_replace_rtx (op1, old_rtx, new_rtx);
 301       if (op0 == XEXP (x, 0) && op1 == XEXP (x, 1))
 302         return x;
 303       return simplify_gen_relational (code, mode, op_mode, op0, op1);
 304
 305     case RTX_TERNARY:
 306     case RTX_BITFIELD_OPS:
 307       op0 = XEXP (x, 0);
 308       op_mode = GET_MODE (op0);
 309       op0 = simplify_replace_rtx (op0, old_rtx, new_rtx);
 310       op1 = simplify_replace_rtx (XEXP (x, 1), old_rtx, new_rtx);
 311       op2 = simplify_replace_rtx (XEXP (x, 2), old_rtx, new_rtx);
 312       if (op0 == XEXP (x, 0) && op1 == XEXP (x, 1) && op2 == XEXP (x, 2))
 313         return x;
 314       if (op_mode == VOIDmode)
 315         op_mode = GET_MODE (op0);
 316       return simplify_gen_ternary (code, mode, op_mode, op0, op1, op2);
 317
 318     case RTX_EXTRA:
 319       /* The only case we try to handle is a SUBREG.  */
 320       if (code == SUBREG)
 321         {
 322           op0 = simplify_replace_rtx (SUBREG_REG (x), old_rtx, new_rtx);
 323           if (op0 == SUBREG_REG (x))
 324             return x;
 325           op0 = simplify_gen_subreg (GET_MODE (x), op0,
 326                                      GET_MODE (SUBREG_REG (x)),
 327                                      SUBREG_BYTE (x));
 328           return op0 ? op0 : x;
 329         }
 330       break;
 331
 332     case RTX_OBJ:
 333       if (code == MEM)
 334         {
 335           op0 = simplify_replace_rtx (XEXP (x, 0), old_rtx, new_rtx);
 336           if (op0 == XEXP (x, 0))
 337             return x;
 338           return replace_equiv_address_nv (x, op0);
 339         }
 340       else if (code == LO_SUM)
 341         {
 342           op0 = simplify_replace_rtx (XEXP (x, 0), old_rtx, new_rtx);
 343           op1 = simplify_replace_rtx (XEXP (x, 1), old_rtx, new_rtx);
 344
 345           /* (lo_sum (high x) x) -> x  */
 346           if (GET_CODE (op0) == HIGH && rtx_equal_p (XEXP (op0, 0), op1))
 347             return op1;
 348
 349           if (op0 == XEXP (x, 0) && op1 == XEXP (x, 1))
 350             return x;
 351           return gen_rtx_LO_SUM (mode, op0, op1);
 352         }
 353       else if (code == REG)
 354         {
 355           if (rtx_equal_p (x, old_rtx))
 356             return new_rtx;
 357         }
 358       break;
 359
 360     default:
 361       break;
 362     }
 363   return x;
 364 }
 365 \f
 366 /* Try to simplify a unary operation CODE whose output mode is to be
 367    MODE with input operand OP whose mode was originally OP_MODE.
 368    Return zero if no simplification can be made.  */
 369 rtx
 370 simplify_unary_operation (enum rtx_code code, enum machine_mode mode,
 371                           rtx op, enum machine_mode op_mode)
 372 {
 373   rtx trueop, tem;
 374
 375   if (GET_CODE (op) == CONST)
 376     op = XEXP (op, 0);
 377
 378   trueop = avoid_constant_pool_reference (op);
 379
 380   tem = simplify_const_unary_operation (code, mode, trueop, op_mode);
 381   if (tem)
 382     return tem;
 383
 384   return simplify_unary_operation_1 (code, mode, op);
 385 }
 386
 387 /* Perform some simplifications we can do even if the operands
 388    aren't constant.  */
 389 static rtx
 390 simplify_unary_operation_1 (enum rtx_code code, enum machine_mode mode, rtx op)
 391 {
 392   enum rtx_code reversed;
 393   rtx temp;
 394
 395   switch (code)
 396     {
 397     case NOT:
 398       /* (not (not X)) == X.  */
 399       if (GET_CODE (op) == NOT)
 400         return XEXP (op, 0);
 401
 402       /* (not (eq X Y)) == (ne X Y), etc.  */
 403       if (COMPARISON_P (op)
 404           && (mode == BImode || STORE_FLAG_VALUE == -1)
 405           && ((reversed = reversed_comparison_code (op, NULL_RTX)) != UNKNOWN))
 406         return simplify_gen_relational (reversed, mode, VOIDmode,
 407                                         XEXP (op, 0), XEXP (op, 1));
 408
 409       /* (not (plus X -1)) can become (neg X).  */
 410       if (GET_CODE (op) == PLUS
 411           && XEXP (op, 1) == constm1_rtx)
 412         return simplify_gen_unary (NEG, mode, XEXP (op, 0), mode);
 413
 414       /* Similarly, (not (neg X)) is (plus X -1).  */
 415       if (GET_CODE (op) == NEG)
 416         return plus_constant (XEXP (op, 0), -1);
 417
 418       /* (not (xor X C)) for C constant is (xor X D) with D = ~C.  */
 419       if (GET_CODE (op) == XOR
 420           && GET_CODE (XEXP (op, 1)) == CONST_INT
 421           && (temp = simplify_unary_operation (NOT, mode,
 422                                                XEXP (op, 1), mode)) != 0)
 423         return simplify_gen_binary (XOR, mode, XEXP (op, 0), temp);
 424
 425       /* (not (plus X C)) for signbit C is (xor X D) with D = ~C.  */
 426       if (GET_CODE (op) == PLUS
 427           && GET_CODE (XEXP (op, 1)) == CONST_INT
 428           && mode_signbit_p (mode, XEXP (op, 1))
 429           && (temp = simplify_unary_operation (NOT, mode,
 430                                                XEXP (op, 1), mode)) != 0)
 431         return simplify_gen_binary (XOR, mode, XEXP (op, 0), temp);
 432
 433
 434       /* (not (ashift 1 X)) is (rotate ~1 X).  We used to do this for
 435          operands other than 1, but that is not valid.  We could do a
 436          similar simplification for (not (lshiftrt C X)) where C is
 437          just the sign bit, but this doesn't seem common enough to
 438          bother with.  */
 439       if (GET_CODE (op) == ASHIFT
 440           && XEXP (op, 0) == const1_rtx)
 441         {
 442           temp = simplify_gen_unary (NOT, mode, const1_rtx, mode);
 443           return simplify_gen_binary (ROTATE, mode, temp, XEXP (op, 1));
 444         }
 445
 446       /* If STORE_FLAG_VALUE is -1, (not (comparison X Y)) can be done
 447          by reversing the comparison code if valid.  */
 448       if (STORE_FLAG_VALUE == -1
 449           && COMPARISON_P (op)
 450           && (reversed = reversed_comparison_code (op, NULL_RTX)) != UNKNOWN)
 451         return simplify_gen_relational (reversed, mode, VOIDmode,
 452                                         XEXP (op, 0), XEXP (op, 1));
 453
 454       /* (not (ashiftrt foo C)) where C is the number of bits in FOO
 455          minus 1 is (ge foo (const_int 0)) if STORE_FLAG_VALUE is -1,
 456          so we can perform the above simplification.  */
 457
 458       if (STORE_FLAG_VALUE == -1
 459           && GET_CODE (op) == ASHIFTRT
 460           && GET_CODE (XEXP (op, 1)) == CONST_INT
 461           && INTVAL (XEXP (op, 1)) == GET_MODE_BITSIZE (mode) - 1)
 462         return simplify_gen_relational (GE, mode, VOIDmode,
 463                                         XEXP (op, 0), const0_rtx);
 464
 465       break;
 466
 467     case NEG:
 468       /* (neg (neg X)) == X.  */
 469       if (GET_CODE (op) == NEG)
 470         return XEXP (op, 0);
 471
 472       /* (neg (plus X 1)) can become (not X).  */
 473       if (GET_CODE (op) == PLUS
 474           && XEXP (op, 1) == const1_rtx)
 475         return simplify_gen_unary (NOT, mode, XEXP (op, 0), mode);
 476
 477       /* Similarly, (neg (not X)) is (plus X 1).  */
 478       if (GET_CODE (op) == NOT)
 479         return plus_constant (XEXP (op, 0), 1);
 480
 481       /* (neg (minus X Y)) can become (minus Y X).  This transformation
 482          isn't safe for modes with signed zeros, since if X and Y are
 483          both +0, (minus Y X) is the same as (minus X Y).  If the
 484          rounding mode is towards +infinity (or -infinity) then the two
 485          expressions will be rounded differently.  */
 486       if (GET_CODE (op) == MINUS
 487           && !HONOR_SIGNED_ZEROS (mode)
 488           && !HONOR_SIGN_DEPENDENT_ROUNDING (mode))
 489         return simplify_gen_binary (MINUS, mode, XEXP (op, 1), XEXP (op, 0));
 490
 491       if (GET_CODE (op) == PLUS
 492           && !HONOR_SIGNED_ZEROS (mode)
 493           && !HONOR_SIGN_DEPENDENT_ROUNDING (mode))
 494         {
 495           /* (neg (plus A C)) is simplified to (minus -C A).  */
 496           if (GET_CODE (XEXP (op, 1)) == CONST_INT
 497               || GET_CODE (XEXP (op, 1)) == CONST_DOUBLE)
 498             {
 499               temp = simplify_unary_operation (NEG, mode, XEXP (op, 1), mode);
 500               if (temp)
 501                 return simplify_gen_binary (MINUS, mode, temp, XEXP (op, 0));
 502             }
 503
 504           /* (neg (plus A B)) is canonicalized to (minus (neg A) B).  */
 505           temp = simplify_gen_unary (NEG, mode, XEXP (op, 0), mode);
 506           return simplify_gen_binary (MINUS, mode, temp, XEXP (op, 1));
 507         }
 508
 509       /* (neg (mult A B)) becomes (mult (neg A) B).
 510          This works even for floating-point values.  */
 511       if (GET_CODE (op) == MULT
 512           && !HONOR_SIGN_DEPENDENT_ROUNDING (mode))
 513         {
 514           temp = simplify_gen_unary (NEG, mode, XEXP (op, 0), mode);
 515           return simplify_gen_binary (MULT, mode, temp, XEXP (op, 1));
 516         }
 517
 518       /* NEG commutes with ASHIFT since it is multiplication.  Only do
 519          this if we can then eliminate the NEG (e.g., if the operand
 520          is a constant).  */
 521       if (GET_CODE (op) == ASHIFT)
 522         {
 523           temp = simplify_unary_operation (NEG, mode, XEXP (op, 0), mode);
 524           if (temp)
 525             return simplify_gen_binary (ASHIFT, mode, temp, XEXP (op, 1));
 526         }
 527
 528       /* (neg (ashiftrt X C)) can be replaced by (lshiftrt X C) when
 529          C is equal to the width of MODE minus 1.  */
 530       if (GET_CODE (op) == ASHIFTRT
 531           && GET_CODE (XEXP (op, 1)) == CONST_INT
 532           && INTVAL (XEXP (op, 1)) == GET_MODE_BITSIZE (mode) - 1)
 533         return simplify_gen_binary (LSHIFTRT, mode,
 534                                     XEXP (op, 0), XEXP (op, 1));
 535
 536       /* (neg (lshiftrt X C)) can be replaced by (ashiftrt X C) when
 537          C is equal to the width of MODE minus 1.  */
 538       if (GET_CODE (op) == LSHIFTRT
 539           && GET_CODE (XEXP (op, 1)) == CONST_INT
 540           && INTVAL (XEXP (op, 1)) == GET_MODE_BITSIZE (mode) - 1)
 541         return simplify_gen_binary (ASHIFTRT, mode,
 542                                     XEXP (op, 0), XEXP (op, 1));
 543
 544       break;
 545
 546     case SIGN_EXTEND:
 547       /* (sign_extend (truncate (minus (label_ref L1) (label_ref L2))))
 548          becomes just the MINUS if its mode is MODE.  This allows
 549          folding switch statements on machines using casesi (such as
 550          the VAX).  */
 551       if (GET_CODE (op) == TRUNCATE
 552           && GET_MODE (XEXP (op, 0)) == mode
 553           && GET_CODE (XEXP (op, 0)) == MINUS
 554           && GET_CODE (XEXP (XEXP (op, 0), 0)) == LABEL_REF
 555           && GET_CODE (XEXP (XEXP (op, 0), 1)) == LABEL_REF)
 556         return XEXP (op, 0);
 557
 558       /* Check for a sign extension of a subreg of a promoted
 559          variable, where the promotion is sign-extended, and the
 560          target mode is the same as the variable's promotion.  */
 561       if (GET_CODE (op) == SUBREG
 562           && SUBREG_PROMOTED_VAR_P (op)
 563           && ! SUBREG_PROMOTED_UNSIGNED_P (op)
 564           && GET_MODE (XEXP (op, 0)) == mode)
 565         return XEXP (op, 0);
 566
 567 #if defined(POINTERS_EXTEND_UNSIGNED) && !defined(HAVE_ptr_extend)
 568       if (! POINTERS_EXTEND_UNSIGNED
 569           && mode == Pmode && GET_MODE (op) == ptr_mode
 570           && (CONSTANT_P (op)
 571               || (GET_CODE (op) == SUBREG
 572                   && REG_P (SUBREG_REG (op))
 573                   && REG_POINTER (SUBREG_REG (op))
 574                   && GET_MODE (SUBREG_REG (op)) == Pmode)))
 575         return convert_memory_address (Pmode, op);
 576 #endif
 577       break;
 578
 579     case ZERO_EXTEND:
 580       /* Check for a zero extension of a subreg of a promoted
 581          variable, where the promotion is zero-extended, and the
 582          target mode is the same as the variable's promotion.  */
 583       if (GET_CODE (op) == SUBREG
 584           && SUBREG_PROMOTED_VAR_P (op)
 585           && SUBREG_PROMOTED_UNSIGNED_P (op) > 0
 586           && GET_MODE (XEXP (op, 0)) == mode)
 587         return XEXP (op, 0);
 588
 589 #if defined(POINTERS_EXTEND_UNSIGNED) && !defined(HAVE_ptr_extend)
 590       if (POINTERS_EXTEND_UNSIGNED > 0
 591           && mode == Pmode && GET_MODE (op) == ptr_mode
 592           && (CONSTANT_P (op)
 593               || (GET_CODE (op) == SUBREG
 594                   && REG_P (SUBREG_REG (op))
 595                   && REG_POINTER (SUBREG_REG (op))
 596                   && GET_MODE (SUBREG_REG (op)) == Pmode)))
 597         return convert_memory_address (Pmode, op);
 598 #endif
 599       break;
 600
 601     default:
 602       break;
 603     }
 604
 605   return 0;
 606 }
 607
 608 /* Try to compute the value of a unary operation CODE whose output mode is to
 609    be MODE with input operand OP whose mode was originally OP_MODE.
 610    Return zero if the value cannot be computed.  */
 611 rtx
 612 simplify_const_unary_operation (enum rtx_code code, enum machine_mode mode,
 613                                 rtx op, enum machine_mode op_mode)
 614 {
 615   unsigned int width = GET_MODE_BITSIZE (mode);
 616
 617   if (code == VEC_DUPLICATE)
 618     {
 619       gcc_assert (VECTOR_MODE_P (mode));
 620       if (GET_MODE (op) != VOIDmode)
 621       {
 622         if (!VECTOR_MODE_P (GET_MODE (op)))
 623           gcc_assert (GET_MODE_INNER (mode) == GET_MODE (op));
 624         else
 625           gcc_assert (GET_MODE_INNER (mode) == GET_MODE_INNER
 626                                                 (GET_MODE (op)));
 627       }
 628       if (GET_CODE (op) == CONST_INT || GET_CODE (op) == CONST_DOUBLE
 629           || GET_CODE (op) == CONST_VECTOR)
 630         {
 631           int elt_size = GET_MODE_SIZE (GET_MODE_INNER (mode));
 632           unsigned n_elts = (GET_MODE_SIZE (mode) / elt_size);
 633           rtvec v = rtvec_alloc (n_elts);
 634           unsigned int i;
 635
 636           if (GET_CODE (op) != CONST_VECTOR)
 637             for (i = 0; i < n_elts; i++)
 638               RTVEC_ELT (v, i) = op;
 639           else
 640             {
 641               enum machine_mode inmode = GET_MODE (op);
 642               int in_elt_size = GET_MODE_SIZE (GET_MODE_INNER (inmode));
 643               unsigned in_n_elts = (GET_MODE_SIZE (inmode) / in_elt_size);
 644
 645               gcc_assert (in_n_elts < n_elts);
 646               gcc_assert ((n_elts % in_n_elts) == 0);
 647               for (i = 0; i < n_elts; i++)
 648                 RTVEC_ELT (v, i) = CONST_VECTOR_ELT (op, i % in_n_elts);
 649             }
 650           return gen_rtx_CONST_VECTOR (mode, v);
 651         }
 652     }
 653
 654   if (VECTOR_MODE_P (mode) && GET_CODE (op) == CONST_VECTOR)
 655     {
 656       int elt_size = GET_MODE_SIZE (GET_MODE_INNER (mode));
 657       unsigned n_elts = (GET_MODE_SIZE (mode) / elt_size);
 658       enum machine_mode opmode = GET_MODE (op);
 659       int op_elt_size = GET_MODE_SIZE (GET_MODE_INNER (opmode));
 660       unsigned op_n_elts = (GET_MODE_SIZE (opmode) / op_elt_size);
 661       rtvec v = rtvec_alloc (n_elts);
 662       unsigned int i;
 663
 664       gcc_assert (op_n_elts == n_elts);
 665       for (i = 0; i < n_elts; i++)
 666         {
 667           rtx x = simplify_unary_operation (code, GET_MODE_INNER (mode),
 668                                             CONST_VECTOR_ELT (op, i),
 669                                             GET_MODE_INNER (opmode));
 670           if (!x)
 671             return 0;
 672           RTVEC_ELT (v, i) = x;
 673         }
 674       return gen_rtx_CONST_VECTOR (mode, v);
 675     }
 676
 677   /* The order of these tests is critical so that, for example, we don't
 678      check the wrong mode (input vs. output) for a conversion operation,
 679      such as FIX.  At some point, this should be simplified.  */
 680
 681   if (code == FLOAT && GET_MODE (op) == VOIDmode
 682       && (GET_CODE (op) == CONST_DOUBLE || GET_CODE (op) == CONST_INT))
 683     {
 684       HOST_WIDE_INT hv, lv;
 685       REAL_VALUE_TYPE d;
 686
 687       if (GET_CODE (op) == CONST_INT)
 688         lv = INTVAL (op), hv = HWI_SIGN_EXTEND (lv);
 689       else
 690         lv = CONST_DOUBLE_LOW (op),  hv = CONST_DOUBLE_HIGH (op);
 691
 692       REAL_VALUE_FROM_INT (d, lv, hv, mode);
 693       d = real_value_truncate (mode, d);
 694       return CONST_DOUBLE_FROM_REAL_VALUE (d, mode);
 695     }
 696   else if (code == UNSIGNED_FLOAT && GET_MODE (op) == VOIDmode
 697            && (GET_CODE (op) == CONST_DOUBLE
 698                || GET_CODE (op) == CONST_INT))
 699     {
 700       HOST_WIDE_INT hv, lv;
 701       REAL_VALUE_TYPE d;
 702
 703       if (GET_CODE (op) == CONST_INT)
 704         lv = INTVAL (op), hv = HWI_SIGN_EXTEND (lv);
 705       else
 706         lv = CONST_DOUBLE_LOW (op),  hv = CONST_DOUBLE_HIGH (op);
 707
 708       if (op_mode == VOIDmode)
 709         {
 710           /* We don't know how to interpret negative-looking numbers in
 711              this case, so don't try to fold those.  */
 712           if (hv < 0)
 713             return 0;
 714         }
 715       else if (GET_MODE_BITSIZE (op_mode) >= HOST_BITS_PER_WIDE_INT * 2)
 716         ;
 717       else
 718         hv = 0, lv &= GET_MODE_MASK (op_mode);
 719
 720       REAL_VALUE_FROM_UNSIGNED_INT (d, lv, hv, mode);
 721       d = real_value_truncate (mode, d);
 722       return CONST_DOUBLE_FROM_REAL_VALUE (d, mode);
 723     }
 724
 725   if (GET_CODE (op) == CONST_INT
 726       && width <= HOST_BITS_PER_WIDE_INT && width > 0)
 727     {
 728       HOST_WIDE_INT arg0 = INTVAL (op);
 729       HOST_WIDE_INT val;
 730
 731       switch (code)
 732         {
 733         case NOT:
 734           val = ~ arg0;
 735           break;
 736
 737         case NEG:
 738           val = - arg0;
 739           break;
 740
 741         case ABS:
 742           val = (arg0 >= 0 ? arg0 : - arg0);
 743           break;
 744
 745         case FFS:
 746           /* Don't use ffs here.  Instead, get low order bit and then its
 747              number.  If arg0 is zero, this will return 0, as desired.  */
 748           arg0 &= GET_MODE_MASK (mode);
 749           val = exact_log2 (arg0 & (- arg0)) + 1;
 750           break;
 751
 752         case CLZ:
 753           arg0 &= GET_MODE_MASK (mode);
 754           if (arg0 == 0 && CLZ_DEFINED_VALUE_AT_ZERO (mode, val))
 755             ;
 756           else
 757             val = GET_MODE_BITSIZE (mode) - floor_log2 (arg0) - 1;
 758           break;
 759
 760         case CTZ:
 761           arg0 &= GET_MODE_MASK (mode);
 762           if (arg0 == 0)
 763             {
 764               /* Even if the value at zero is undefined, we have to come
 765                  up with some replacement.  Seems good enough.  */
 766               if (! CTZ_DEFINED_VALUE_AT_ZERO (mode, val))
 767                 val = GET_MODE_BITSIZE (mode);
 768             }
 769           else
 770             val = exact_log2 (arg0 & -arg0);
 771           break;
 772
 773         case POPCOUNT:
 774           arg0 &= GET_MODE_MASK (mode);
 775           val = 0;
 776           while (arg0)
 777             val++, arg0 &= arg0 - 1;
 778           break;
 779
 780         case PARITY:
 781           arg0 &= GET_MODE_MASK (mode);
 782           val = 0;
 783           while (arg0)
 784             val++, arg0 &= arg0 - 1;
 785           val &= 1;
 786           break;
 787
 788         case TRUNCATE:
 789           val = arg0;
 790           break;
 791
 792         case ZERO_EXTEND:
 793           /* When zero-extending a CONST_INT, we need to know its
 794              original mode.  */
 795           gcc_assert (op_mode != VOIDmode);
 796           if (GET_MODE_BITSIZE (op_mode) == HOST_BITS_PER_WIDE_INT)
 797             {
 798               /* If we were really extending the mode,
 799                  we would have to distinguish between zero-extension
 800                  and sign-extension.  */
 801               gcc_assert (width == GET_MODE_BITSIZE (op_mode));
 802               val = arg0;
 803             }
 804           else if (GET_MODE_BITSIZE (op_mode) < HOST_BITS_PER_WIDE_INT)
 805             val = arg0 & ~((HOST_WIDE_INT) (-1) << GET_MODE_BITSIZE (op_mode));
 806           else
 807             return 0;
 808           break;
 809
 810         case SIGN_EXTEND:
 811           if (op_mode == VOIDmode)
 812             op_mode = mode;
 813           if (GET_MODE_BITSIZE (op_mode) == HOST_BITS_PER_WIDE_INT)
 814             {
 815               /* If we were really extending the mode,
 816                  we would have to distinguish between zero-extension
 817                  and sign-extension.  */
 818               gcc_assert (width == GET_MODE_BITSIZE (op_mode));
 819               val = arg0;
 820             }
 821           else if (GET_MODE_BITSIZE (op_mode) < HOST_BITS_PER_WIDE_INT)
 822             {
 823               val
 824                 = arg0 & ~((HOST_WIDE_INT) (-1) << GET_MODE_BITSIZE (op_mode));
 825               if (val
 826                   & ((HOST_WIDE_INT) 1 << (GET_MODE_BITSIZE (op_mode) - 1)))
 827                 val -= (HOST_WIDE_INT) 1 << GET_MODE_BITSIZE (op_mode);
 828             }
 829           else
 830             return 0;
 831           break;
 832
 833         case SQRT:
 834         case FLOAT_EXTEND:
 835         case FLOAT_TRUNCATE:
 836         case SS_TRUNCATE:
 837         case US_TRUNCATE:
 838           return 0;
 839
 840         default:
 841           gcc_unreachable ();
 842         }
 843
 844       return gen_int_mode (val, mode);
 845     }
 846
 847   /* We can do some operations on integer CONST_DOUBLEs.  Also allow
 848      for a DImode operation on a CONST_INT.  */
 849   else if (GET_MODE (op) == VOIDmode
 850            && width <= HOST_BITS_PER_WIDE_INT * 2
 851            && (GET_CODE (op) == CONST_DOUBLE
 852                || GET_CODE (op) == CONST_INT))
 853     {
 854       unsigned HOST_WIDE_INT l1, lv;
 855       HOST_WIDE_INT h1, hv;
 856
 857       if (GET_CODE (op) == CONST_DOUBLE)
 858         l1 = CONST_DOUBLE_LOW (op), h1 = CONST_DOUBLE_HIGH (op);
 859       else
 860         l1 = INTVAL (op), h1 = HWI_SIGN_EXTEND (l1);
 861
 862       switch (code)
 863         {
 864         case NOT:
 865           lv = ~ l1;
 866           hv = ~ h1;
 867           break;
 868
 869         case NEG:
 870           neg_double (l1, h1, &lv, &hv);
 871           break;
 872
 873         case ABS:
 874           if (h1 < 0)
 875             neg_double (l1, h1, &lv, &hv);
 876           else
 877             lv = l1, hv = h1;
 878           break;
 879
 880         case FFS:
 881           hv = 0;
 882           if (l1 == 0)
 883             {
 884               if (h1 == 0)
 885                 lv = 0;
 886               else
 887                 lv = HOST_BITS_PER_WIDE_INT + exact_log2 (h1 & -h1) + 1;
 888             }
 889           else
 890             lv = exact_log2 (l1 & -l1) + 1;
 891           break;
 892
 893         case CLZ:
 894           hv = 0;
 895           if (h1 != 0)
 896             lv = GET_MODE_BITSIZE (mode) - floor_log2 (h1) - 1
 897               - HOST_BITS_PER_WIDE_INT;
 898           else if (l1 != 0)
 899             lv = GET_MODE_BITSIZE (mode) - floor_log2 (l1) - 1;
 900           else if (! CLZ_DEFINED_VALUE_AT_ZERO (mode, lv))
 901             lv = GET_MODE_BITSIZE (mode);
 902           break;
 903
 904         case CTZ:
 905           hv = 0;
 906           if (l1 != 0)
 907             lv = exact_log2 (l1 & -l1);
 908           else if (h1 != 0)
 909             lv = HOST_BITS_PER_WIDE_INT + exact_log2 (h1 & -h1);
 910           else if (! CTZ_DEFINED_VALUE_AT_ZERO (mode, lv))
 911             lv = GET_MODE_BITSIZE (mode);
 912           break;
 913
 914         case POPCOUNT:
 915           hv = 0;
 916           lv = 0;
 917           while (l1)
 918             lv++, l1 &= l1 - 1;
 919           while (h1)
 920             lv++, h1 &= h1 - 1;
 921           break;
 922
 923         case PARITY:
 924           hv = 0;
 925           lv = 0;
 926           while (l1)
 927             lv++, l1 &= l1 - 1;
 928           while (h1)
 929             lv++, h1 &= h1 - 1;
 930           lv &= 1;
 931           break;
 932
 933         case TRUNCATE:
 934           /* This is just a change-of-mode, so do nothing.  */
 935           lv = l1, hv = h1;
 936           break;
 937
 938         case ZERO_EXTEND:
 939           gcc_assert (op_mode != VOIDmode);
 940
 941           if (GET_MODE_BITSIZE (op_mode) > HOST_BITS_PER_WIDE_INT)
 942             return 0;
 943
 944           hv = 0;
 945           lv = l1 & GET_MODE_MASK (op_mode);
 946           break;
 947
 948         case SIGN_EXTEND:
 949           if (op_mode == VOIDmode
 950               || GET_MODE_BITSIZE (op_mode) > HOST_BITS_PER_WIDE_INT)
 951             return 0;
 952           else
 953             {
 954               lv = l1 & GET_MODE_MASK (op_mode);
 955               if (GET_MODE_BITSIZE (op_mode) < HOST_BITS_PER_WIDE_INT
 956                   && (lv & ((HOST_WIDE_INT) 1
 957                             << (GET_MODE_BITSIZE (op_mode) - 1))) != 0)
 958                 lv -= (HOST_WIDE_INT) 1 << GET_MODE_BITSIZE (op_mode);
 959
 960               hv = HWI_SIGN_EXTEND (lv);
 961             }
 962           break;
 963
 964         case SQRT:
 965           return 0;
 966
 967         default:
 968           return 0;
 969         }
 970
 971       return immed_double_const (lv, hv, mode);
 972     }
 973
 974   else if (GET_CODE (op) == CONST_DOUBLE
 975            && SCALAR_FLOAT_MODE_P (mode))
 976     {
 977       REAL_VALUE_TYPE d, t;
 978       REAL_VALUE_FROM_CONST_DOUBLE (d, op);
 979
 980       switch (code)
 981         {
 982         case SQRT:
 983           if (HONOR_SNANS (mode) && real_isnan (&d))
 984             return 0;
 985           real_sqrt (&t, mode, &d);
 986           d = t;
 987           break;
 988         case ABS:
 989           d = REAL_VALUE_ABS (d);
 990           break;
 991         case NEG:
 992           d = REAL_VALUE_NEGATE (d);
 993           break;
 994         case FLOAT_TRUNCATE:
 995           d = real_value_truncate (mode, d);
 996           break;
 997         case FLOAT_EXTEND:
 998           /* All this does is change the mode.  */
 999           break;
1000         case FIX:
1001           real_arithmetic (&d, FIX_TRUNC_EXPR, &d, NULL);
1002           break;
1003         case NOT:
1004           {
1005             long tmp[4];
1006             int i;
1007
1008             real_to_target (tmp, &d, GET_MODE (op));
1009             for (i = 0; i < 4; i++)
1010               tmp[i] = ~tmp[i];
1011             real_from_target (&d, tmp, mode);
1012             break;
1013           }
1014         default:
1015           gcc_unreachable ();
1016         }
1017       return CONST_DOUBLE_FROM_REAL_VALUE (d, mode);
1018     }
1019
1020   else if (GET_CODE (op) == CONST_DOUBLE
1021            && SCALAR_FLOAT_MODE_P (GET_MODE (op))
1022            && GET_MODE_CLASS (mode) == MODE_INT
1023            && width <= 2*HOST_BITS_PER_WIDE_INT && width > 0)
1024     {
1025       /* Although the overflow semantics of RTL's FIX and UNSIGNED_FIX
1026          operators are intentionally left unspecified (to ease implementation
1027          by target backends), for consistency, this routine implements the
1028          same semantics for constant folding as used by the middle-end.  */
1029
1030       /* This was formerly used only for non-IEEE float.
1031          eggert@twinsun.com says it is safe for IEEE also.  */
1032       HOST_WIDE_INT xh, xl, th, tl;
1033       REAL_VALUE_TYPE x, t;
1034       REAL_VALUE_FROM_CONST_DOUBLE (x, op);
1035       switch (code)
1036         {
1037         case FIX:
1038           if (REAL_VALUE_ISNAN (x))
1039             return const0_rtx;
1040
1041           /* Test against the signed upper bound.  */
1042           if (width > HOST_BITS_PER_WIDE_INT)
1043             {
1044               th = ((unsigned HOST_WIDE_INT) 1
1045                     << (width - HOST_BITS_PER_WIDE_INT - 1)) - 1;
1046               tl = -1;
1047             }
1048           else
1049             {
1050               th = 0;
1051               tl = ((unsigned HOST_WIDE_INT) 1 << (width - 1)) - 1;
1052             }
1053           real_from_integer (&t, VOIDmode, tl, th, 0);
1054           if (REAL_VALUES_LESS (t, x))
1055             {
1056               xh = th;
1057               xl = tl;
1058               break;
1059             }
1060
1061           /* Test against the signed lower bound.  */
1062           if (width > HOST_BITS_PER_WIDE_INT)
1063             {
1064               th = (HOST_WIDE_INT) -1 << (width - HOST_BITS_PER_WIDE_INT - 1);
1065               tl = 0;
1066             }
1067           else
1068             {
1069               th = -1;
1070               tl = (HOST_WIDE_INT) -1 << (width - 1);
1071             }
1072           real_from_integer (&t, VOIDmode, tl, th, 0);
1073           if (REAL_VALUES_LESS (x, t))
1074             {
1075               xh = th;
1076               xl = tl;
1077               break;
1078             }
1079           REAL_VALUE_TO_INT (&xl, &xh, x);
1080           break;
1081
1082         case UNSIGNED_FIX:
1083           if (REAL_VALUE_ISNAN (x) || REAL_VALUE_NEGATIVE (x))
1084             return const0_rtx;
1085
1086           /* Test against the unsigned upper bound.  */
1087           if (width == 2*HOST_BITS_PER_WIDE_INT)
1088             {
1089               th = -1;
1090               tl = -1;
1091             }
1092           else if (width >= HOST_BITS_PER_WIDE_INT)
1093             {
1094               th = ((unsigned HOST_WIDE_INT) 1
1095                     << (width - HOST_BITS_PER_WIDE_INT)) - 1;
1096               tl = -1;
1097             }
1098           else
1099             {
1100               th = 0;
1101               tl = ((unsigned HOST_WIDE_INT) 1 << width) - 1;
1102             }
1103           real_from_integer (&t, VOIDmode, tl, th, 1);
1104           if (REAL_VALUES_LESS (t, x))
1105             {
1106               xh = th;
1107               xl = tl;
1108               break;
1109             }
1110
1111           REAL_VALUE_TO_INT (&xl, &xh, x);
1112           break;
1113
1114         default:
1115           gcc_unreachable ();
1116         }
1117       return immed_double_const (xl, xh, mode);
1118     }
1119
1120   return NULL_RTX;
1121 }
1122 \f
1123 /* Subroutine of simplify_binary_operation to simplify a commutative,
1124    associative binary operation CODE with result mode MODE, operating
1125    on OP0 and OP1.  CODE is currently one of PLUS, MULT, AND, IOR, XOR,
1126    SMIN, SMAX, UMIN or UMAX.  Return zero if no simplification or
1127    canonicalization is possible.  */
1128
1129 static rtx
1130 simplify_associative_operation (enum rtx_code code, enum machine_mode mode,
1131                                 rtx op0, rtx op1)
1132 {
1133   rtx tem;
1134
1135   /* Linearize the operator to the left.  */
1136   if (GET_CODE (op1) == code)
1137     {
1138       /* "(a op b) op (c op d)" becomes "((a op b) op c) op d)".  */
1139       if (GET_CODE (op0) == code)
1140         {
1141           tem = simplify_gen_binary (code, mode, op0, XEXP (op1, 0));
1142           return simplify_gen_binary (code, mode, tem, XEXP (op1, 1));
1143         }
1144
1145       /* "a op (b op c)" becomes "(b op c) op a".  */
1146       if (! swap_commutative_operands_p (op1, op0))
1147         return simplify_gen_binary (code, mode, op1, op0);
1148
1149       tem = op0;
1150       op0 = op1;
1151       op1 = tem;
1152     }
1153
1154   if (GET_CODE (op0) == code)
1155     {
1156       /* Canonicalize "(x op c) op y" as "(x op y) op c".  */
1157       if (swap_commutative_operands_p (XEXP (op0, 1), op1))
1158         {
1159           tem = simplify_gen_binary (code, mode, XEXP (op0, 0), op1);
1160           return simplify_gen_binary (code, mode, tem, XEXP (op0, 1));
1161         }
1162
1163       /* Attempt to simplify "(a op b) op c" as "a op (b op c)".  */
1164       tem = swap_commutative_operands_p (XEXP (op0, 1), op1)
1165             ? simplify_binary_operation (code, mode, op1, XEXP (op0, 1))
1166             : simplify_binary_operation (code, mode, XEXP (op0, 1), op1);
1167       if (tem != 0)
1168         return simplify_gen_binary (code, mode, XEXP (op0, 0), tem);
1169
1170       /* Attempt to simplify "(a op b) op c" as "(a op c) op b".  */
1171       tem = swap_commutative_operands_p (XEXP (op0, 0), op1)
1172             ? simplify_binary_operation (code, mode, op1, XEXP (op0, 0))
1173             : simplify_binary_operation (code, mode, XEXP (op0, 0), op1);
1174       if (tem != 0)
1175         return simplify_gen_binary (code, mode, tem, XEXP (op0, 1));
1176     }
1177
1178   return 0;
1179 }
1180
1181
1182 /* Simplify a binary operation CODE with result mode MODE, operating on OP0
1183    and OP1.  Return 0 if no simplification is possible.
1184
1185    Don't use this for relational operations such as EQ or LT.
1186    Use simplify_relational_operation instead.  */
1187 rtx
1188 simplify_binary_operation (enum rtx_code code, enum machine_mode mode,
1189                            rtx op0, rtx op1)
1190 {
1191   rtx trueop0, trueop1;
1192   rtx tem;
1193
1194   /* Relational operations don't work here.  We must know the mode
1195      of the operands in order to do the comparison correctly.
1196      Assuming a full word can give incorrect results.
1197      Consider comparing 128 with -128 in QImode.  */
1198   gcc_assert (GET_RTX_CLASS (code) != RTX_COMPARE);
1199   gcc_assert (GET_RTX_CLASS (code) != RTX_COMM_COMPARE);
1200
1201   /* Make sure the constant is second.  */
1202   if (GET_RTX_CLASS (code) == RTX_COMM_ARITH
1203       && swap_commutative_operands_p (op0, op1))
1204     {
1205       tem = op0, op0 = op1, op1 = tem;
1206     }
1207
1208   trueop0 = avoid_constant_pool_reference (op0);
1209   trueop1 = avoid_constant_pool_reference (op1);
1210
1211   tem = simplify_const_binary_operation (code, mode, trueop0, trueop1);
1212   if (tem)
1213     return tem;
1214   return simplify_binary_operation_1 (code, mode, op0, op1, trueop0, trueop1);
1215 }
1216
1217 static rtx
1218 simplify_binary_operation_1 (enum rtx_code code, enum machine_mode mode,
1219                              rtx op0, rtx op1, rtx trueop0, rtx trueop1)
1220 {
1221   rtx tem;
1222   HOST_WIDE_INT val;
1223   unsigned int width = GET_MODE_BITSIZE (mode);
1224
1225   /* Even if we can't compute a constant result,
1226      there are some cases worth simplifying.  */
1227
1228   switch (code)
1229     {
1230     case PLUS:
1231       /* Maybe simplify x + 0 to x.  The two expressions are equivalent
1232          when x is NaN, infinite, or finite and nonzero.  They aren't
1233          when x is -0 and the rounding mode is not towards -infinity,
1234          since (-0) + 0 is then 0.  */
1235       if (!HONOR_SIGNED_ZEROS (mode) && trueop1 == CONST0_RTX (mode))
1236         return op0;
1237
1238       /* ((-a) + b) -> (b - a) and similarly for (a + (-b)).  These
1239          transformations are safe even for IEEE.  */
1240       if (GET_CODE (op0) == NEG)
1241         return simplify_gen_binary (MINUS, mode, op1, XEXP (op0, 0));
1242       else if (GET_CODE (op1) == NEG)
1243         return simplify_gen_binary (MINUS, mode, op0, XEXP (op1, 0));
1244
1245       /* (~a) + 1 -> -a */
1246       if (INTEGRAL_MODE_P (mode)
1247           && GET_CODE (op0) == NOT
1248           && trueop1 == const1_rtx)
1249         return simplify_gen_unary (NEG, mode, XEXP (op0, 0), mode);
1250
1251       /* Handle both-operands-constant cases.  We can only add
1252          CONST_INTs to constants since the sum of relocatable symbols
1253          can't be handled by most assemblers.  Don't add CONST_INT
1254          to CONST_INT since overflow won't be computed properly if wider
1255          than HOST_BITS_PER_WIDE_INT.  */
1256
1257       if (CONSTANT_P (op0) && GET_MODE (op0) != VOIDmode
1258           && GET_CODE (op1) == CONST_INT)
1259         return plus_constant (op0, INTVAL (op1));
1260       else if (CONSTANT_P (op1) && GET_MODE (op1) != VOIDmode
1261                && GET_CODE (op0) == CONST_INT)
1262         return plus_constant (op1, INTVAL (op0));
1263
1264       /* See if this is something like X * C - X or vice versa or
1265          if the multiplication is written as a shift.  If so, we can
1266          distribute and make a new multiply, shift, or maybe just
1267          have X (if C is 2 in the example above).  But don't make
1268          something more expensive than we had before.  */
1269
1270       if (SCALAR_INT_MODE_P (mode))
1271         {
1272           HOST_WIDE_INT coeff0h = 0, coeff1h = 0;
1273           unsigned HOST_WIDE_INT coeff0l = 1, coeff1l = 1;
1274           rtx lhs = op0, rhs = op1;
1275
1276           if (GET_CODE (lhs) == NEG)
1277             {
1278               coeff0l = -1;
1279               coeff0h = -1;
1280               lhs = XEXP (lhs, 0);
1281             }
1282           else if (GET_CODE (lhs) == MULT
1283                    && GET_CODE (XEXP (lhs, 1)) == CONST_INT)
1284             {
1285               coeff0l = INTVAL (XEXP (lhs, 1));
1286               coeff0h = INTVAL (XEXP (lhs, 1)) < 0 ? -1 : 0;
1287               lhs = XEXP (lhs, 0);
1288             }
1289           else if (GET_CODE (lhs) == ASHIFT
1290                    && GET_CODE (XEXP (lhs, 1)) == CONST_INT
1291                    && INTVAL (XEXP (lhs, 1)) >= 0
1292                    && INTVAL (XEXP (lhs, 1)) < HOST_BITS_PER_WIDE_INT)
1293             {
1294               coeff0l = ((HOST_WIDE_INT) 1) << INTVAL (XEXP (lhs, 1));
1295               coeff0h = 0;
1296               lhs = XEXP (lhs, 0);
1297             }
1298
1299           if (GET_CODE (rhs) == NEG)
1300             {
1301               coeff1l = -1;
1302               coeff1h = -1;
1303               rhs = XEXP (rhs, 0);
1304             }
1305           else if (GET_CODE (rhs) == MULT
1306                    && GET_CODE (XEXP (rhs, 1)) == CONST_INT)
1307             {
1308               coeff1l = INTVAL (XEXP (rhs, 1));
1309               coeff1h = INTVAL (XEXP (rhs, 1)) < 0 ? -1 : 0;
1310               rhs = XEXP (rhs, 0);
1311             }
1312           else if (GET_CODE (rhs) == ASHIFT
1313                    && GET_CODE (XEXP (rhs, 1)) == CONST_INT
1314                    && INTVAL (XEXP (rhs, 1)) >= 0
1315                    && INTVAL (XEXP (rhs, 1)) < HOST_BITS_PER_WIDE_INT)
1316             {
1317               coeff1l = ((HOST_WIDE_INT) 1) << INTVAL (XEXP (rhs, 1));
1318               coeff1h = 0;
1319               rhs = XEXP (rhs, 0);
1320             }
1321
1322           if (rtx_equal_p (lhs, rhs))
1323             {
1324               rtx orig = gen_rtx_PLUS (mode, op0, op1);
1325               rtx coeff;
1326               unsigned HOST_WIDE_INT l;
1327               HOST_WIDE_INT h;
1328
1329               add_double (coeff0l, coeff0h, coeff1l, coeff1h, &l, &h);
1330               coeff = immed_double_const (l, h, mode);
1331
1332               tem = simplify_gen_binary (MULT, mode, lhs, coeff);
1333               return rtx_cost (tem, SET) <= rtx_cost (orig, SET)
1334                 ? tem : 0;
1335             }
1336         }
1337
1338       /* (plus (xor X C1) C2) is (xor X (C1^C2)) if C2 is signbit.  */
1339       if ((GET_CODE (op1) == CONST_INT
1340            || GET_CODE (op1) == CONST_DOUBLE)
1341           && GET_CODE (op0) == XOR
1342           && (GET_CODE (XEXP (op0, 1)) == CONST_INT
1343               || GET_CODE (XEXP (op0, 1)) == CONST_DOUBLE)
1344           && mode_signbit_p (mode, op1))
1345         return simplify_gen_binary (XOR, mode, XEXP (op0, 0),
1346                                     simplify_gen_binary (XOR, mode, op1,
1347                                                          XEXP (op0, 1)));
1348
1349       /* If one of the operands is a PLUS or a MINUS, see if we can
1350          simplify this by the associative law.
1351          Don't use the associative law for floating point.
1352          The inaccuracy makes it nonassociative,
1353          and subtle programs can break if operations are associated.  */
1354
1355       if (INTEGRAL_MODE_P (mode)
1356           && (plus_minus_operand_p (op0)
1357               || plus_minus_operand_p (op1))
1358           && (tem = simplify_plus_minus (code, mode, op0, op1)) != 0)
1359         return tem;
1360
1361       /* Reassociate floating point addition only when the user
1362          specifies unsafe math optimizations.  */
1363       if (FLOAT_MODE_P (mode)
1364           && flag_unsafe_math_optimizations)
1365         {
1366           tem = simplify_associative_operation (code, mode, op0, op1);
1367           if (tem)
1368             return tem;
1369         }
1370       break;
1371
1372     case COMPARE:
1373 #ifdef HAVE_cc0
1374       /* Convert (compare FOO (const_int 0)) to FOO unless we aren't
1375          using cc0, in which case we want to leave it as a COMPARE
1376          so we can distinguish it from a register-register-copy.
1377
1378          In IEEE floating point, x-0 is not the same as x.  */
1379
1380       if ((TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT
1381            || ! FLOAT_MODE_P (mode) || flag_unsafe_math_optimizations)
1382           && trueop1 == CONST0_RTX (mode))
1383         return op0;
1384 #endif
1385
1386       /* Convert (compare (gt (flags) 0) (lt (flags) 0)) to (flags).  */
1387       if (((GET_CODE (op0) == GT && GET_CODE (op1) == LT)
1388            || (GET_CODE (op0) == GTU && GET_CODE (op1) == LTU))
1389           && XEXP (op0, 1) == const0_rtx && XEXP (op1, 1) == const0_rtx)
1390         {
1391           rtx xop00 = XEXP (op0, 0);
1392           rtx xop10 = XEXP (op1, 0);
1393
1394 #ifdef HAVE_cc0
1395           if (GET_CODE (xop00) == CC0 && GET_CODE (xop10) == CC0)
1396 #else
1397             if (REG_P (xop00) && REG_P (xop10)
1398                 && GET_MODE (xop00) == GET_MODE (xop10)
1399                 && REGNO (xop00) == REGNO (xop10)
1400                 && GET_MODE_CLASS (GET_MODE (xop00)) == MODE_CC
1401                 && GET_MODE_CLASS (GET_MODE (xop10)) == MODE_CC)
1402 #endif
1403               return xop00;
1404         }
1405       break;
1406
1407     case MINUS:
1408       /* We can't assume x-x is 0 even with non-IEEE floating point,
1409          but since it is zero except in very strange circumstances, we
1410          will treat it as zero with -funsafe-math-optimizations.  */
1411       if (rtx_equal_p (trueop0, trueop1)
1412           && ! side_effects_p (op0)
1413           && (! FLOAT_MODE_P (mode) || flag_unsafe_math_optimizations))
1414         return CONST0_RTX (mode);
1415
1416       /* Change subtraction from zero into negation.  (0 - x) is the
1417          same as -x when x is NaN, infinite, or finite and nonzero.
1418          But if the mode has signed zeros, and does not round towards
1419          -infinity, then 0 - 0 is 0, not -0.  */
1420       if (!HONOR_SIGNED_ZEROS (mode) && trueop0 == CONST0_RTX (mode))
1421         return simplify_gen_unary (NEG, mode, op1, mode);
1422
1423       /* (-1 - a) is ~a.  */
1424       if (trueop0 == constm1_rtx)
1425         return simplify_gen_unary (NOT, mode, op1, mode);
1426
1427       /* Subtracting 0 has no effect unless the mode has signed zeros
1428          and supports rounding towards -infinity.  In such a case,
1429          0 - 0 is -0.  */
1430       if (!(HONOR_SIGNED_ZEROS (mode)
1431             && HONOR_SIGN_DEPENDENT_ROUNDING (mode))
1432           && trueop1 == CONST0_RTX (mode))
1433         return op0;
1434
1435       /* See if this is something like X * C - X or vice versa or
1436          if the multiplication is written as a shift.  If so, we can
1437          distribute and make a new multiply, shift, or maybe just
1438          have X (if C is 2 in the example above).  But don't make
1439          something more expensive than we had before.  */
1440
1441       if (SCALAR_INT_MODE_P (mode))
1442         {
1443           HOST_WIDE_INT coeff0h = 0, negcoeff1h = -1;
1444           unsigned HOST_WIDE_INT coeff0l = 1, negcoeff1l = -1;
1445           rtx lhs = op0, rhs = op1;
1446
1447           if (GET_CODE (lhs) == NEG)
1448             {
1449               coeff0l = -1;
1450               coeff0h = -1;
1451               lhs = XEXP (lhs, 0);
1452             }
1453           else if (GET_CODE (lhs) == MULT
1454                    && GET_CODE (XEXP (lhs, 1)) == CONST_INT)
1455             {
1456               coeff0l = INTVAL (XEXP (lhs, 1));
1457               coeff0h = INTVAL (XEXP (lhs, 1)) < 0 ? -1 : 0;
1458               lhs = XEXP (lhs, 0);
1459             }
1460           else if (GET_CODE (lhs) == ASHIFT
1461                    && GET_CODE (XEXP (lhs, 1)) == CONST_INT
1462                    && INTVAL (XEXP (lhs, 1)) >= 0
1463                    && INTVAL (XEXP (lhs, 1)) < HOST_BITS_PER_WIDE_INT)
1464             {
1465               coeff0l = ((HOST_WIDE_INT) 1) << INTVAL (XEXP (lhs, 1));
1466               coeff0h = 0;
1467               lhs = XEXP (lhs, 0);
1468             }
1469
1470           if (GET_CODE (rhs) == NEG)
1471             {
1472               negcoeff1l = 1;
1473               negcoeff1h = 0;
1474               rhs = XEXP (rhs, 0);
1475             }
1476           else if (GET_CODE (rhs) == MULT
1477                    && GET_CODE (XEXP (rhs, 1)) == CONST_INT)
1478             {
1479               negcoeff1l = -INTVAL (XEXP (rhs, 1));
1480               negcoeff1h = INTVAL (XEXP (rhs, 1)) <= 0 ? 0 : -1;
1481               rhs = XEXP (rhs, 0);
1482             }
1483           else if (GET_CODE (rhs) == ASHIFT
1484                    && GET_CODE (XEXP (rhs, 1)) == CONST_INT
1485                    && INTVAL (XEXP (rhs, 1)) >= 0
1486                    && INTVAL (XEXP (rhs, 1)) < HOST_BITS_PER_WIDE_INT)
1487             {
1488               negcoeff1l = -(((HOST_WIDE_INT) 1) << INTVAL (XEXP (rhs, 1)));
1489               negcoeff1h = -1;
1490               rhs = XEXP (rhs, 0);
1491             }
1492
1493           if (rtx_equal_p (lhs, rhs))
1494             {
1495               rtx orig = gen_rtx_MINUS (mode, op0, op1);
1496               rtx coeff;
1497               unsigned HOST_WIDE_INT l;
1498               HOST_WIDE_INT h;
1499
1500               add_double (coeff0l, coeff0h, negcoeff1l, negcoeff1h, &l, &h);
1501               coeff = immed_double_const (l, h, mode);
1502
1503               tem = simplify_gen_binary (MULT, mode, lhs, coeff);
1504               return rtx_cost (tem, SET) <= rtx_cost (orig, SET)
1505                 ? tem : 0;
1506             }
1507         }
1508
1509       /* (a - (-b)) -> (a + b).  True even for IEEE.  */
1510       if (GET_CODE (op1) == NEG)
1511         return simplify_gen_binary (PLUS, mode, op0, XEXP (op1, 0));
1512
1513       /* (-x - c) may be simplified as (-c - x).  */
1514       if (GET_CODE (op0) == NEG
1515           && (GET_CODE (op1) == CONST_INT
1516               || GET_CODE (op1) == CONST_DOUBLE))
1517         {
1518           tem = simplify_unary_operation (NEG, mode, op1, mode);
1519           if (tem)
1520             return simplify_gen_binary (MINUS, mode, tem, XEXP (op0, 0));
1521         }
1522
1523       /* Don't let a relocatable value get a negative coeff.  */
1524       if (GET_CODE (op1) == CONST_INT && GET_MODE (op0) != VOIDmode)
1525         return simplify_gen_binary (PLUS, mode,
1526                                     op0,
1527                                     neg_const_int (mode, op1));
1528
1529       /* (x - (x & y)) -> (x & ~y) */
1530       if (GET_CODE (op1) == AND)
1531         {
1532           if (rtx_equal_p (op0, XEXP (op1, 0)))
1533             {
1534               tem = simplify_gen_unary (NOT, mode, XEXP (op1, 1),
1535                                         GET_MODE (XEXP (op1, 1)));
1536               return simplify_gen_binary (AND, mode, op0, tem);
1537             }
1538           if (rtx_equal_p (op0, XEXP (op1, 1)))
1539             {
1540               tem = simplify_gen_unary (NOT, mode, XEXP (op1, 0),
1541                                         GET_MODE (XEXP (op1, 0)));
1542               return simplify_gen_binary (AND, mode, op0, tem);
1543             }
1544         }
1545
1546       /* If one of the operands is a PLUS or a MINUS, see if we can
1547          simplify this by the associative law.  This will, for example,
1548          canonicalize (minus A (plus B C)) to (minus (minus A B) C).
1549          Don't use the associative law for floating point.
1550          The inaccuracy makes it nonassociative,
1551          and subtle programs can break if operations are associated.  */
1552
1553       if (INTEGRAL_MODE_P (mode)
1554           && (plus_minus_operand_p (op0)
1555               || plus_minus_operand_p (op1))
1556           && (tem = simplify_plus_minus (code, mode, op0, op1)) != 0)
1557         return tem;
1558       break;
1559
1560     case MULT:
1561       if (trueop1 == constm1_rtx)
1562         return simplify_gen_unary (NEG, mode, op0, mode);
1563
1564       /* Maybe simplify x * 0 to 0.  The reduction is not valid if
1565          x is NaN, since x * 0 is then also NaN.  Nor is it valid
1566          when the mode has signed zeros, since multiplying a negative
1567          number by 0 will give -0, not 0.  */
1568       if (!HONOR_NANS (mode)
1569           && !HONOR_SIGNED_ZEROS (mode)
1570           && trueop1 == CONST0_RTX (mode)
1571           && ! side_effects_p (op0))
1572         return op1;
1573
1574       /* In IEEE floating point, x*1 is not equivalent to x for
1575          signalling NaNs.  */
1576       if (!HONOR_SNANS (mode)
1577           && trueop1 == CONST1_RTX (mode))
1578         return op0;
1579
1580       /* Convert multiply by constant power of two into shift unless
1581          we are still generating RTL.  This test is a kludge.  */
1582       if (GET_CODE (trueop1) == CONST_INT
1583           && (val = exact_log2 (INTVAL (trueop1))) >= 0
1584           /* If the mode is larger than the host word size, and the
1585              uppermost bit is set, then this isn't a power of two due
1586              to implicit sign extension.  */
1587           && (width <= HOST_BITS_PER_WIDE_INT
1588               || val != HOST_BITS_PER_WIDE_INT - 1))
1589         return simplify_gen_binary (ASHIFT, mode, op0, GEN_INT (val));
1590
1591       /* Likewise for multipliers wider than a word.  */
1592       else if (GET_CODE (trueop1) == CONST_DOUBLE
1593                && (GET_MODE (trueop1) == VOIDmode
1594                    || GET_MODE_CLASS (GET_MODE (trueop1)) == MODE_INT)
1595                && GET_MODE (op0) == mode
1596                && CONST_DOUBLE_LOW (trueop1) == 0
1597                && (val = exact_log2 (CONST_DOUBLE_HIGH (trueop1))) >= 0)
1598         return simplify_gen_binary (ASHIFT, mode, op0,
1599                                     GEN_INT (val + HOST_BITS_PER_WIDE_INT));
1600
1601       /* x*2 is x+x and x*(-1) is -x */
1602       if (GET_CODE (trueop1) == CONST_DOUBLE
1603           && SCALAR_FLOAT_MODE_P (GET_MODE (trueop1))
1604           && GET_MODE (op0) == mode)
1605         {
1606           REAL_VALUE_TYPE d;
1607           REAL_VALUE_FROM_CONST_DOUBLE (d, trueop1);
1608
1609           if (REAL_VALUES_EQUAL (d, dconst2))
1610             return simplify_gen_binary (PLUS, mode, op0, copy_rtx (op0));
1611
1612           if (REAL_VALUES_EQUAL (d, dconstm1))
1613             return simplify_gen_unary (NEG, mode, op0, mode);
1614         }
1615
1616       /* Reassociate multiplication, but for floating point MULTs
1617          only when the user specifies unsafe math optimizations.  */
1618       if (! FLOAT_MODE_P (mode)
1619           || flag_unsafe_math_optimizations)
1620         {
1621           tem = simplify_associative_operation (code, mode, op0, op1);
1622           if (tem)
1623             return tem;
1624         }
1625       break;
1626
1627     case IOR:
1628       if (trueop1 == const0_rtx)
1629         return op0;
1630       if (GET_CODE (trueop1) == CONST_INT
1631           && ((INTVAL (trueop1) & GET_MODE_MASK (mode))
1632               == GET_MODE_MASK (mode)))
1633         return op1;
1634       if (rtx_equal_p (trueop0, trueop1) && ! side_effects_p (op0))
1635         return op0;
1636       /* A | (~A) -> -1 */
1637       if (((GET_CODE (op0) == NOT && rtx_equal_p (XEXP (op0, 0), op1))
1638            || (GET_CODE (op1) == NOT && rtx_equal_p (XEXP (op1, 0), op0)))
1639           && ! side_effects_p (op0)
1640           && SCALAR_INT_MODE_P (mode))
1641         return constm1_rtx;
1642       tem = simplify_associative_operation (code, mode, op0, op1);
1643       if (tem)
1644         return tem;
1645       break;
1646
1647     case XOR:
1648       if (trueop1 == const0_rtx)
1649         return op0;
1650       if (GET_CODE (trueop1) == CONST_INT
1651           && ((INTVAL (trueop1) & GET_MODE_MASK (mode))
1652               == GET_MODE_MASK (mode)))
1653         return simplify_gen_unary (NOT, mode, op0, mode);
1654       if (rtx_equal_p (trueop0, trueop1)
1655           && ! side_effects_p (op0)
1656           && GET_MODE_CLASS (mode) != MODE_CC)
1657          return CONST0_RTX (mode);
1658
1659       /* Canonicalize XOR of the most significant bit to PLUS.  */
1660       if ((GET_CODE (op1) == CONST_INT
1661            || GET_CODE (op1) == CONST_DOUBLE)
1662           && mode_signbit_p (mode, op1))
1663         return simplify_gen_binary (PLUS, mode, op0, op1);
1664       /* (xor (plus X C1) C2) is (xor X (C1^C2)) if C1 is signbit.  */
1665       if ((GET_CODE (op1) == CONST_INT
1666            || GET_CODE (op1) == CONST_DOUBLE)
1667           && GET_CODE (op0) == PLUS
1668           && (GET_CODE (XEXP (op0, 1)) == CONST_INT
1669               || GET_CODE (XEXP (op0, 1)) == CONST_DOUBLE)
1670           && mode_signbit_p (mode, XEXP (op0, 1)))
1671         return simplify_gen_binary (XOR, mode, XEXP (op0, 0),
1672                                     simplify_gen_binary (XOR, mode, op1,
1673                                                          XEXP (op0, 1)));
1674
1675       tem = simplify_associative_operation (code, mode, op0, op1);
1676       if (tem)
1677         return tem;
1678       break;
1679
1680     case AND:
1681       if (trueop1 == CONST0_RTX (mode) && ! side_effects_p (op0))
1682         return trueop1;
1683       /* If we are turning off bits already known off in OP0, we need
1684          not do an AND.  */
1685       if (GET_CODE (trueop1) == CONST_INT
1686           && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
1687           && (nonzero_bits (trueop0, mode) & ~INTVAL (trueop1)) == 0)
1688         return op0;
1689       if (rtx_equal_p (trueop0, trueop1) && ! side_effects_p (op0)
1690           && GET_MODE_CLASS (mode) != MODE_CC)
1691         return op0;
1692       /* A & (~A) -> 0 */
1693       if (((GET_CODE (op0) == NOT && rtx_equal_p (XEXP (op0, 0), op1))
1694            || (GET_CODE (op1) == NOT && rtx_equal_p (XEXP (op1, 0), op0)))
1695           && ! side_effects_p (op0)
1696           && GET_MODE_CLASS (mode) != MODE_CC)
1697         return CONST0_RTX (mode);
1698
1699       /* Transform (and (extend X) C) into (zero_extend (and X C)) if
1700          there are no nonzero bits of C outside of X's mode.  */
1701       if ((GET_CODE (op0) == SIGN_EXTEND
1702            || GET_CODE (op0) == ZERO_EXTEND)
1703           && GET_CODE (trueop1) == CONST_INT
1704           && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
1705           && (~GET_MODE_MASK (GET_MODE (XEXP (op0, 0)))
1706               & INTVAL (trueop1)) == 0)
1707         {
1708           enum machine_mode imode = GET_MODE (XEXP (op0, 0));
1709           tem = simplify_gen_binary (AND, imode, XEXP (op0, 0),
1710                                      gen_int_mode (INTVAL (trueop1),
1711                                                    imode));
1712           return simplify_gen_unary (ZERO_EXTEND, mode, tem, imode);
1713         }
1714
1715       /* For constants M and N, if M == (1LL << cst) - 1 && (N & M) == M,
1716          ((A & N) + B) & M -> (A + B) & M
1717          Similarly if (N & M) == 0,
1718          ((A | N) + B) & M -> (A + B) & M
1719          and for - instead of + and/or ^ instead of |.  */
1720       if (GET_CODE (trueop1) == CONST_INT
1721           && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
1722           && ~INTVAL (trueop1)
1723           && (INTVAL (trueop1) & (INTVAL (trueop1) + 1)) == 0
1724           && (GET_CODE (op0) == PLUS || GET_CODE (op0) == MINUS))
1725         {
1726           rtx pmop[2];
1727           int which;
1728
1729           pmop[0] = XEXP (op0, 0);
1730           pmop[1] = XEXP (op0, 1);
1731
1732           for (which = 0; which < 2; which++)
1733             {
1734               tem = pmop[which];
1735               switch (GET_CODE (tem))
1736                 {
1737                 case AND:
1738                   if (GET_CODE (XEXP (tem, 1)) == CONST_INT
1739                       && (INTVAL (XEXP (tem, 1)) & INTVAL (trueop1))
1740                       == INTVAL (trueop1))
1741                     pmop[which] = XEXP (tem, 0);
1742                   break;
1743                 case IOR:
1744                 case XOR:
1745                   if (GET_CODE (XEXP (tem, 1)) == CONST_INT
1746                       && (INTVAL (XEXP (tem, 1)) & INTVAL (trueop1)) == 0)
1747                     pmop[which] = XEXP (tem, 0);
1748                   break;
1749                 default:
1750                   break;
1751                 }
1752             }
1753
1754           if (pmop[0] != XEXP (op0, 0) || pmop[1] != XEXP (op0, 1))
1755             {
1756               tem = simplify_gen_binary (GET_CODE (op0), mode,
1757                                          pmop[0], pmop[1]);
1758               return simplify_gen_binary (code, mode, tem, op1);
1759             }
1760         }
1761       tem = simplify_associative_operation (code, mode, op0, op1);
1762       if (tem)
1763         return tem;
1764       break;
1765
1766     case UDIV:
1767       /* 0/x is 0 (or x&0 if x has side-effects).  */
1768       if (trueop0 == CONST0_RTX (mode))
1769         {
1770           if (side_effects_p (op1))
1771             return simplify_gen_binary (AND, mode, op1, trueop0);
1772           return trueop0;
1773         }
1774       /* x/1 is x.  */
1775       if (trueop1 == CONST1_RTX (mode))
1776         return rtl_hooks.gen_lowpart_no_emit (mode, op0);
1777       /* Convert divide by power of two into shift.  */
1778       if (GET_CODE (trueop1) == CONST_INT
1779           && (val = exact_log2 (INTVAL (trueop1))) > 0)
1780         return simplify_gen_binary (LSHIFTRT, mode, op0, GEN_INT (val));
1781       break;
1782
1783     case DIV:
1784       /* Handle floating point and integers separately.  */
1785       if (SCALAR_FLOAT_MODE_P (mode))
1786         {
1787           /* Maybe change 0.0 / x to 0.0.  This transformation isn't
1788              safe for modes with NaNs, since 0.0 / 0.0 will then be
1789              NaN rather than 0.0.  Nor is it safe for modes with signed
1790              zeros, since dividing 0 by a negative number gives -0.0  */
1791           if (trueop0 == CONST0_RTX (mode)
1792               && !HONOR_NANS (mode)
1793               && !HONOR_SIGNED_ZEROS (mode)
1794               && ! side_effects_p (op1))
1795             return op0;
1796           /* x/1.0 is x.  */
1797           if (trueop1 == CONST1_RTX (mode)
1798               && !HONOR_SNANS (mode))
1799             return op0;
1800
1801           if (GET_CODE (trueop1) == CONST_DOUBLE
1802               && trueop1 != CONST0_RTX (mode))
1803             {
1804               REAL_VALUE_TYPE d;
1805               REAL_VALUE_FROM_CONST_DOUBLE (d, trueop1);
1806
1807               /* x/-1.0 is -x.  */
1808               if (REAL_VALUES_EQUAL (d, dconstm1)
1809                   && !HONOR_SNANS (mode))
1810                 return simplify_gen_unary (NEG, mode, op0, mode);
1811
1812               /* Change FP division by a constant into multiplication.
1813                  Only do this with -funsafe-math-optimizations.  */
1814               if (flag_unsafe_math_optimizations
1815                   && !REAL_VALUES_EQUAL (d, dconst0))
1816                 {
1817                   REAL_ARITHMETIC (d, RDIV_EXPR, dconst1, d);
1818                   tem = CONST_DOUBLE_FROM_REAL_VALUE (d, mode);
1819                   return simplify_gen_binary (MULT, mode, op0, tem);
1820                 }
1821             }
1822         }
1823       else
1824         {
1825           /* 0/x is 0 (or x&0 if x has side-effects).  */
1826           if (trueop0 == CONST0_RTX (mode))
1827             {
1828               if (side_effects_p (op1))
1829                 return simplify_gen_binary (AND, mode, op1, trueop0);
1830               return trueop0;
1831             }
1832           /* x/1 is x.  */
1833           if (trueop1 == CONST1_RTX (mode))
1834             return rtl_hooks.gen_lowpart_no_emit (mode, op0);
1835           /* x/-1 is -x.  */
1836           if (trueop1 == constm1_rtx)
1837             {
1838               rtx x = rtl_hooks.gen_lowpart_no_emit (mode, op0);
1839               return simplify_gen_unary (NEG, mode, x, mode);
1840             }
1841         }
1842       break;
1843
1844     case UMOD:
1845       /* 0%x is 0 (or x&0 if x has side-effects).  */
1846       if (trueop0 == CONST0_RTX (mode))
1847         {
1848           if (side_effects_p (op1))
1849             return simplify_gen_binary (AND, mode, op1, trueop0);
1850           return trueop0;
1851         }
1852       /* x%1 is 0 (of x&0 if x has side-effects).  */
1853       if (trueop1 == CONST1_RTX (mode))
1854         {
1855           if (side_effects_p (op0))
1856             return simplify_gen_binary (AND, mode, op0, CONST0_RTX (mode));
1857           return CONST0_RTX (mode);
1858         }
1859       /* Implement modulus by power of two as AND.  */
1860       if (GET_CODE (trueop1) == CONST_INT
1861           && exact_log2 (INTVAL (trueop1)) > 0)
1862         return simplify_gen_binary (AND, mode, op0,
1863                                     GEN_INT (INTVAL (op1) - 1));
1864       break;
1865
1866     case MOD:
1867       /* 0%x is 0 (or x&0 if x has side-effects).  */
1868       if (trueop0 == CONST0_RTX (mode))
1869         {
1870           if (side_effects_p (op1))
1871             return simplify_gen_binary (AND, mode, op1, trueop0);
1872           return trueop0;
1873         }
1874       /* x%1 and x%-1 is 0 (or x&0 if x has side-effects).  */
1875       if (trueop1 == CONST1_RTX (mode) || trueop1 == constm1_rtx)
1876         {
1877           if (side_effects_p (op0))
1878             return simplify_gen_binary (AND, mode, op0, CONST0_RTX (mode));
1879           return CONST0_RTX (mode);
1880         }
1881       break;
1882
1883     case ROTATERT:
1884     case ROTATE:
1885     case ASHIFTRT:
1886       /* Rotating ~0 always results in ~0.  */
1887       if (GET_CODE (trueop0) == CONST_INT && width <= HOST_BITS_PER_WIDE_INT
1888           && (unsigned HOST_WIDE_INT) INTVAL (trueop0) == GET_MODE_MASK (mode)
1889           && ! side_effects_p (op1))
1890         return op0;
1891
1892       /* Fall through....  */
1893
1894     case ASHIFT:
1895     case LSHIFTRT:
1896       if (trueop1 == CONST0_RTX (mode))
1897         return op0;
1898       if (trueop0 == CONST0_RTX (mode) && ! side_effects_p (op1))
1899         return op0;
1900       break;
1901
1902     case SMIN:
1903       if (width <= HOST_BITS_PER_WIDE_INT
1904           && GET_CODE (trueop1) == CONST_INT
1905           && INTVAL (trueop1) == (HOST_WIDE_INT) 1 << (width -1)
1906           && ! side_effects_p (op0))
1907         return op1;
1908       if (rtx_equal_p (trueop0, trueop1) && ! side_effects_p (op0))
1909         return op0;
1910       tem = simplify_associative_operation (code, mode, op0, op1);
1911       if (tem)
1912         return tem;
1913       break;
1914
1915     case SMAX:
1916       if (width <= HOST_BITS_PER_WIDE_INT
1917           && GET_CODE (trueop1) == CONST_INT
1918           && ((unsigned HOST_WIDE_INT) INTVAL (trueop1)
1919               == (unsigned HOST_WIDE_INT) GET_MODE_MASK (mode) >> 1)
1920           && ! side_effects_p (op0))
1921         return op1;
1922       if (rtx_equal_p (trueop0, trueop1) && ! side_effects_p (op0))
1923         return op0;
1924       tem = simplify_associative_operation (code, mode, op0, op1);
1925       if (tem)
1926         return tem;
1927       break;
1928
1929     case UMIN:
1930       if (trueop1 == CONST0_RTX (mode) && ! side_effects_p (op0))
1931         return op1;
1932       if (rtx_equal_p (trueop0, trueop1) && ! side_effects_p (op0))
1933         return op0;
1934       tem = simplify_associative_operation (code, mode, op0, op1);
1935       if (tem)
1936         return tem;
1937       break;
1938
1939     case UMAX:
1940       if (trueop1 == constm1_rtx && ! side_effects_p (op0))
1941         return op1;
1942       if (rtx_equal_p (trueop0, trueop1) && ! side_effects_p (op0))
1943         return op0;
1944       tem = simplify_associative_operation (code, mode, op0, op1);
1945       if (tem)
1946         return tem;
1947       break;
1948
1949     case SS_PLUS:
1950     case US_PLUS:
1951     case SS_MINUS:
1952     case US_MINUS:
1953       /* ??? There are simplifications that can be done.  */
1954       return 0;
1955
1956     case VEC_SELECT:
1957       if (!VECTOR_MODE_P (mode))
1958         {
1959           gcc_assert (VECTOR_MODE_P (GET_MODE (trueop0)));
1960           gcc_assert (mode == GET_MODE_INNER (GET_MODE (trueop0)));
1961           gcc_assert (GET_CODE (trueop1) == PARALLEL);
1962           gcc_assert (XVECLEN (trueop1, 0) == 1);
1963           gcc_assert (GET_CODE (XVECEXP (trueop1, 0, 0)) == CONST_INT);
1964
1965           if (GET_CODE (trueop0) == CONST_VECTOR)
1966             return CONST_VECTOR_ELT (trueop0, INTVAL (XVECEXP
1967                                                       (trueop1, 0, 0)));
1968         }
1969       else
1970         {
1971           gcc_assert (VECTOR_MODE_P (GET_MODE (trueop0)));
1972           gcc_assert (GET_MODE_INNER (mode)
1973                       == GET_MODE_INNER (GET_MODE (trueop0)));
1974           gcc_assert (GET_CODE (trueop1) == PARALLEL);
1975
1976           if (GET_CODE (trueop0) == CONST_VECTOR)
1977             {
1978               int elt_size = GET_MODE_SIZE (GET_MODE_INNER (mode));
1979               unsigned n_elts = (GET_MODE_SIZE (mode) / elt_size);
1980               rtvec v = rtvec_alloc (n_elts);
1981               unsigned int i;
1982
1983               gcc_assert (XVECLEN (trueop1, 0) == (int) n_elts);
1984               for (i = 0; i < n_elts; i++)
1985                 {
1986                   rtx x = XVECEXP (trueop1, 0, i);
1987
1988                   gcc_assert (GET_CODE (x) == CONST_INT);
1989                   RTVEC_ELT (v, i) = CONST_VECTOR_ELT (trueop0,
1990                                                        INTVAL (x));
1991                 }
1992
1993               return gen_rtx_CONST_VECTOR (mode, v);
1994             }
1995         }
1996       return 0;
1997     case VEC_CONCAT:
1998       {
1999         enum machine_mode op0_mode = (GET_MODE (trueop0) != VOIDmode
2000                                       ? GET_MODE (trueop0)
2001                                       : GET_MODE_INNER (mode));
2002         enum machine_mode op1_mode = (GET_MODE (trueop1) != VOIDmode
2003                                       ? GET_MODE (trueop1)
2004                                       : GET_MODE_INNER (mode));
2005
2006         gcc_assert (VECTOR_MODE_P (mode));
2007         gcc_assert (GET_MODE_SIZE (op0_mode) + GET_MODE_SIZE (op1_mode)
2008                     == GET_MODE_SIZE (mode));
2009
2010         if (VECTOR_MODE_P (op0_mode))
2011           gcc_assert (GET_MODE_INNER (mode)
2012                       == GET_MODE_INNER (op0_mode));
2013         else
2014           gcc_assert (GET_MODE_INNER (mode) == op0_mode);
2015
2016         if (VECTOR_MODE_P (op1_mode))
2017           gcc_assert (GET_MODE_INNER (mode)
2018                       == GET_MODE_INNER (op1_mode));
2019         else
2020           gcc_assert (GET_MODE_INNER (mode) == op1_mode);
2021
2022         if ((GET_CODE (trueop0) == CONST_VECTOR
2023              || GET_CODE (trueop0) == CONST_INT
2024              || GET_CODE (trueop0) == CONST_DOUBLE)
2025             && (GET_CODE (trueop1) == CONST_VECTOR
2026                 || GET_CODE (trueop1) == CONST_INT
2027                 || GET_CODE (trueop1) == CONST_DOUBLE))
2028           {
2029             int elt_size = GET_MODE_SIZE (GET_MODE_INNER (mode));
2030             unsigned n_elts = (GET_MODE_SIZE (mode) / elt_size);
2031             rtvec v = rtvec_alloc (n_elts);
2032             unsigned int i;
2033             unsigned in_n_elts = 1;
2034
2035             if (VECTOR_MODE_P (op0_mode))
2036               in_n_elts = (GET_MODE_SIZE (op0_mode) / elt_size);
2037             for (i = 0; i < n_elts; i++)
2038               {
2039                 if (i < in_n_elts)
2040                   {
2041                     if (!VECTOR_MODE_P (op0_mode))
2042                       RTVEC_ELT (v, i) = trueop0;
2043                     else
2044                       RTVEC_ELT (v, i) = CONST_VECTOR_ELT (trueop0, i);
2045                   }
2046                 else
2047                   {
2048                     if (!VECTOR_MODE_P (op1_mode))
2049                       RTVEC_ELT (v, i) = trueop1;
2050                     else
2051                       RTVEC_ELT (v, i) = CONST_VECTOR_ELT (trueop1,
2052                                                            i - in_n_elts);
2053                   }
2054               }
2055
2056             return gen_rtx_CONST_VECTOR (mode, v);
2057           }
2058       }
2059       return 0;
2060
2061     default:
2062       gcc_unreachable ();
2063     }
2064
2065   return 0;
2066 }
2067
2068 rtx
2069 simplify_const_binary_operation (enum rtx_code code, enum machine_mode mode,
2070                                  rtx op0, rtx op1)
2071 {
2072   HOST_WIDE_INT arg0, arg1, arg0s, arg1s;
2073   HOST_WIDE_INT val;
2074   unsigned int width = GET_MODE_BITSIZE (mode);
2075
2076   if (VECTOR_MODE_P (mode)
2077       && code != VEC_CONCAT
2078       && GET_CODE (op0) == CONST_VECTOR
2079       && GET_CODE (op1) == CONST_VECTOR)
2080     {
2081       unsigned n_elts = GET_MODE_NUNITS (mode);
2082       enum machine_mode op0mode = GET_MODE (op0);
2083       unsigned op0_n_elts = GET_MODE_NUNITS (op0mode);
2084       enum machine_mode op1mode = GET_MODE (op1);
2085       unsigned op1_n_elts = GET_MODE_NUNITS (op1mode);
2086       rtvec v = rtvec_alloc (n_elts);
2087       unsigned int i;
2088
2089       gcc_assert (op0_n_elts == n_elts);
2090       gcc_assert (op1_n_elts == n_elts);
2091       for (i = 0; i < n_elts; i++)
2092         {
2093           rtx x = simplify_binary_operation (code, GET_MODE_INNER (mode),
2094                                              CONST_VECTOR_ELT (op0, i),
2095                                              CONST_VECTOR_ELT (op1, i));
2096           if (!x)
2097             return 0;
2098           RTVEC_ELT (v, i) = x;
2099         }
2100
2101       return gen_rtx_CONST_VECTOR (mode, v);
2102     }
2103
2104   if (VECTOR_MODE_P (mode)
2105       && code == VEC_CONCAT
2106       && CONSTANT_P (op0) && CONSTANT_P (op1))
2107     {
2108       unsigned n_elts = GET_MODE_NUNITS (mode);
2109       rtvec v = rtvec_alloc (n_elts);
2110
2111       gcc_assert (n_elts >= 2);
2112       if (n_elts == 2)
2113         {
2114           gcc_assert (GET_CODE (op0) != CONST_VECTOR);
2115           gcc_assert (GET_CODE (op1) != CONST_VECTOR);
2116
2117           RTVEC_ELT (v, 0) = op0;
2118           RTVEC_ELT (v, 1) = op1;
2119         }
2120       else
2121         {
2122           unsigned op0_n_elts = GET_MODE_NUNITS (GET_MODE (op0));
2123           unsigned op1_n_elts = GET_MODE_NUNITS (GET_MODE (op1));
2124           unsigned i;
2125
2126           gcc_assert (GET_CODE (op0) == CONST_VECTOR);
2127           gcc_assert (GET_CODE (op1) == CONST_VECTOR);
2128           gcc_assert (op0_n_elts + op1_n_elts == n_elts);
2129
2130           for (i = 0; i < op0_n_elts; ++i)
2131             RTVEC_ELT (v, i) = XVECEXP (op0, 0, i);
2132           for (i = 0; i < op1_n_elts; ++i)
2133             RTVEC_ELT (v, op0_n_elts+i) = XVECEXP (op1, 0, i);
2134         }
2135
2136       return gen_rtx_CONST_VECTOR (mode, v);
2137     }
2138
2139   if (SCALAR_FLOAT_MODE_P (mode)
2140       && GET_CODE (op0) == CONST_DOUBLE
2141       && GET_CODE (op1) == CONST_DOUBLE
2142       && mode == GET_MODE (op0) && mode == GET_MODE (op1))
2143     {
2144       if (code == AND
2145           || code == IOR
2146           || code == XOR)
2147         {
2148           long tmp0[4];
2149           long tmp1[4];
2150           REAL_VALUE_TYPE r;
2151           int i;
2152
2153           real_to_target (tmp0, CONST_DOUBLE_REAL_VALUE (op0),
2154                           GET_MODE (op0));
2155           real_to_target (tmp1, CONST_DOUBLE_REAL_VALUE (op1),
2156                           GET_MODE (op1));
2157           for (i = 0; i < 4; i++)
2158             {
2159               switch (code)
2160               {
2161               case AND:
2162                 tmp0[i] &= tmp1[i];
2163                 break;
2164               case IOR:
2165                 tmp0[i] |= tmp1[i];
2166                 break;
2167               case XOR:
2168                 tmp0[i] ^= tmp1[i];
2169                 break;
2170               default:
2171                 gcc_unreachable ();
2172               }
2173             }
2174            real_from_target (&r, tmp0, mode);
2175            return CONST_DOUBLE_FROM_REAL_VALUE (r, mode);
2176         }
2177       else
2178         {
2179           REAL_VALUE_TYPE f0, f1, value, result;
2180           bool inexact;
2181
2182           REAL_VALUE_FROM_CONST_DOUBLE (f0, op0);
2183           REAL_VALUE_FROM_CONST_DOUBLE (f1, op1);
2184           real_convert (&f0, mode, &f0);
2185           real_convert (&f1, mode, &f1);
2186
2187           if (HONOR_SNANS (mode)
2188               && (REAL_VALUE_ISNAN (f0) || REAL_VALUE_ISNAN (f1)))
2189             return 0;
2190
2191           if (code == DIV
2192               && REAL_VALUES_EQUAL (f1, dconst0)
2193               && (flag_trapping_math || ! MODE_HAS_INFINITIES (mode)))
2194             return 0;
2195
2196           if (MODE_HAS_INFINITIES (mode) && HONOR_NANS (mode)
2197               && flag_trapping_math
2198               && REAL_VALUE_ISINF (f0) && REAL_VALUE_ISINF (f1))
2199             {
2200               int s0 = REAL_VALUE_NEGATIVE (f0);
2201               int s1 = REAL_VALUE_NEGATIVE (f1);
2202
2203               switch (code)
2204                 {
2205                 case PLUS:
2206                   /* Inf + -Inf = NaN plus exception.  */
2207                   if (s0 != s1)
2208                     return 0;
2209                   break;
2210                 case MINUS:
2211                   /* Inf - Inf = NaN plus exception.  */
2212                   if (s0 == s1)
2213                     return 0;
2214                   break;
2215                 case DIV:
2216                   /* Inf / Inf = NaN plus exception.  */
2217                   return 0;
2218                 default:
2219                   break;
2220                 }
2221             }
2222
2223           if (code == MULT && MODE_HAS_INFINITIES (mode) && HONOR_NANS (mode)
2224               && flag_trapping_math
2225               && ((REAL_VALUE_ISINF (f0) && REAL_VALUES_EQUAL (f1, dconst0))
2226                   || (REAL_VALUE_ISINF (f1)
2227                       && REAL_VALUES_EQUAL (f0, dconst0))))
2228             /* Inf * 0 = NaN plus exception.  */
2229             return 0;
2230
2231           inexact = real_arithmetic (&value, rtx_to_tree_code (code),
2232                                      &f0, &f1);
2233           real_convert (&result, mode, &value);
2234
2235           /* Don't constant fold this floating point operation if
2236              the result has overflowed and flag_trapping_math.  */
2237
2238           if (flag_trapping_math
2239               && MODE_HAS_INFINITIES (mode)
2240               && REAL_VALUE_ISINF (result)
2241               && !REAL_VALUE_ISINF (f0)
2242               && !REAL_VALUE_ISINF (f1))
2243             /* Overflow plus exception.  */
2244             return 0;
2245
2246           /* Don't constant fold this floating point operation if the
2247              result may dependent upon the run-time rounding mode and
2248              flag_rounding_math is set, or if GCC's software emulation
2249              is unable to accurately represent the result.  */
2250
2251           if ((flag_rounding_math
2252                || (REAL_MODE_FORMAT_COMPOSITE_P (mode)
2253                    && !flag_unsafe_math_optimizations))
2254               && (inexact || !real_identical (&result, &value)))
2255             return NULL_RTX;
2256
2257           return CONST_DOUBLE_FROM_REAL_VALUE (result, mode);
2258         }
2259     }
2260
2261   /* We can fold some multi-word operations.  */
2262   if (GET_MODE_CLASS (mode) == MODE_INT
2263       && width == HOST_BITS_PER_WIDE_INT * 2
2264       && (GET_CODE (op0) == CONST_DOUBLE || GET_CODE (op0) == CONST_INT)
2265       && (GET_CODE (op1) == CONST_DOUBLE || GET_CODE (op1) == CONST_INT))
2266     {
2267       unsigned HOST_WIDE_INT l1, l2, lv, lt;
2268       HOST_WIDE_INT h1, h2, hv, ht;
2269
2270       if (GET_CODE (op0) == CONST_DOUBLE)
2271         l1 = CONST_DOUBLE_LOW (op0), h1 = CONST_DOUBLE_HIGH (op0);
2272       else
2273         l1 = INTVAL (op0), h1 = HWI_SIGN_EXTEND (l1);
2274
2275       if (GET_CODE (op1) == CONST_DOUBLE)
2276         l2 = CONST_DOUBLE_LOW (op1), h2 = CONST_DOUBLE_HIGH (op1);
2277       else
2278         l2 = INTVAL (op1), h2 = HWI_SIGN_EXTEND (l2);
2279
2280       switch (code)
2281         {
2282         case MINUS:
2283           /* A - B == A + (-B).  */
2284           neg_double (l2, h2, &lv, &hv);
2285           l2 = lv, h2 = hv;
2286
2287           /* Fall through....  */
2288
2289         case PLUS:
2290           add_double (l1, h1, l2, h2, &lv, &hv);
2291           break;
2292
2293         case MULT:
2294           mul_double (l1, h1, l2, h2, &lv, &hv);
2295           break;
2296
2297         case DIV:
2298           if (div_and_round_double (TRUNC_DIV_EXPR, 0, l1, h1, l2, h2,
2299                                     &lv, &hv, &lt, &ht))
2300             return 0;
2301           break;
2302
2303         case MOD:
2304           if (div_and_round_double (TRUNC_DIV_EXPR, 0, l1, h1, l2, h2,
2305                                     &lt, &ht, &lv, &hv))
2306             return 0;
2307           break;
2308
2309         case UDIV:
2310           if (div_and_round_double (TRUNC_DIV_EXPR, 1, l1, h1, l2, h2,
2311                                     &lv, &hv, &lt, &ht))
2312             return 0;
2313           break;
2314
2315         case UMOD:
2316           if (div_and_round_double (TRUNC_DIV_EXPR, 1, l1, h1, l2, h2,
2317                                     &lt, &ht, &lv, &hv))
2318             return 0;
2319           break;
2320
2321         case AND:
2322           lv = l1 & l2, hv = h1 & h2;
2323           break;
2324
2325         case IOR:
2326           lv = l1 | l2, hv = h1 | h2;
2327           break;
2328
2329         case XOR:
2330           lv = l1 ^ l2, hv = h1 ^ h2;
2331           break;
2332
2333         case SMIN:
2334           if (h1 < h2
2335               || (h1 == h2
2336                   && ((unsigned HOST_WIDE_INT) l1
2337                       < (unsigned HOST_WIDE_INT) l2)))
2338             lv = l1, hv = h1;
2339           else
2340             lv = l2, hv = h2;
2341           break;
2342
2343         case SMAX:
2344           if (h1 > h2
2345               || (h1 == h2
2346                   && ((unsigned HOST_WIDE_INT) l1
2347                       > (unsigned HOST_WIDE_INT) l2)))
2348             lv = l1, hv = h1;
2349           else
2350             lv = l2, hv = h2;
2351           break;
2352
2353         case UMIN:
2354           if ((unsigned HOST_WIDE_INT) h1 < (unsigned HOST_WIDE_INT) h2
2355               || (h1 == h2
2356                   && ((unsigned HOST_WIDE_INT) l1
2357                       < (unsigned HOST_WIDE_INT) l2)))
2358             lv = l1, hv = h1;
2359           else
2360             lv = l2, hv = h2;
2361           break;
2362
2363         case UMAX:
2364           if ((unsigned HOST_WIDE_INT) h1 > (unsigned HOST_WIDE_INT) h2
2365               || (h1 == h2
2366                   && ((unsigned HOST_WIDE_INT) l1
2367                       > (unsigned HOST_WIDE_INT) l2)))
2368             lv = l1, hv = h1;
2369           else
2370             lv = l2, hv = h2;
2371           break;
2372
2373         case LSHIFTRT:   case ASHIFTRT:
2374         case ASHIFT:
2375         case ROTATE:     case ROTATERT:
2376           if (SHIFT_COUNT_TRUNCATED)
2377             l2 &= (GET_MODE_BITSIZE (mode) - 1), h2 = 0;
2378
2379           if (h2 != 0 || l2 >= GET_MODE_BITSIZE (mode))
2380             return 0;
2381
2382           if (code == LSHIFTRT || code == ASHIFTRT)
2383             rshift_double (l1, h1, l2, GET_MODE_BITSIZE (mode), &lv, &hv,
2384                            code == ASHIFTRT);
2385           else if (code == ASHIFT)
2386             lshift_double (l1, h1, l2, GET_MODE_BITSIZE (mode), &lv, &hv, 1);
2387           else if (code == ROTATE)
2388             lrotate_double (l1, h1, l2, GET_MODE_BITSIZE (mode), &lv, &hv);
2389           else /* code == ROTATERT */
2390             rrotate_double (l1, h1, l2, GET_MODE_BITSIZE (mode), &lv, &hv);
2391           break;
2392
2393         default:
2394           return 0;
2395         }
2396
2397       return immed_double_const (lv, hv, mode);
2398     }
2399
2400   if (GET_CODE (op0) == CONST_INT && GET_CODE (op1) == CONST_INT
2401       && width <= HOST_BITS_PER_WIDE_INT && width != 0)
2402     {
2403       /* Get the integer argument values in two forms:
2404          zero-extended in ARG0, ARG1 and sign-extended in ARG0S, ARG1S.  */
2405
2406       arg0 = INTVAL (op0);
2407       arg1 = INTVAL (op1);
2408
2409       if (width < HOST_BITS_PER_WIDE_INT)
2410         {
2411           arg0 &= ((HOST_WIDE_INT) 1 << width) - 1;
2412           arg1 &= ((HOST_WIDE_INT) 1 << width) - 1;
2413
2414           arg0s = arg0;
2415           if (arg0s & ((HOST_WIDE_INT) 1 << (width - 1)))
2416             arg0s |= ((HOST_WIDE_INT) (-1) << width);
2417
2418           arg1s = arg1;
2419           if (arg1s & ((HOST_WIDE_INT) 1 << (width - 1)))
2420             arg1s |= ((HOST_WIDE_INT) (-1) << width);
2421         }
2422       else
2423         {
2424           arg0s = arg0;
2425           arg1s = arg1;
2426         }
2427
2428       /* Compute the value of the arithmetic.  */
2429
2430       switch (code)
2431         {
2432         case PLUS:
2433           val = arg0s + arg1s;
2434           break;
2435
2436         case MINUS:
2437           val = arg0s - arg1s;
2438           break;
2439
2440         case MULT:
2441           val = arg0s * arg1s;
2442           break;
2443
2444         case DIV:
2445           if (arg1s == 0
2446               || (arg0s == (HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT - 1)
2447                   && arg1s == -1))
2448             return 0;
2449           val = arg0s / arg1s;
2450           break;
2451
2452         case MOD:
2453           if (arg1s == 0
2454               || (arg0s == (HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT - 1)
2455                   && arg1s == -1))
2456             return 0;
2457           val = arg0s % arg1s;
2458           break;
2459
2460         case UDIV:
2461           if (arg1 == 0
2462               || (arg0s == (HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT - 1)
2463                   && arg1s == -1))
2464             return 0;
2465           val = (unsigned HOST_WIDE_INT) arg0 / arg1;
2466           break;
2467
2468         case UMOD:
2469           if (arg1 == 0
2470               || (arg0s == (HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT - 1)
2471                   && arg1s == -1))
2472             return 0;
2473           val = (unsigned HOST_WIDE_INT) arg0 % arg1;
2474           break;
2475
2476         case AND:
2477           val = arg0 & arg1;
2478           break;
2479
2480         case IOR:
2481           val = arg0 | arg1;
2482           break;
2483
2484         case XOR:
2485           val = arg0 ^ arg1;
2486           break;
2487
2488         case LSHIFTRT:
2489         case ASHIFT:
2490         case ASHIFTRT:
2491           /* Truncate the shift if SHIFT_COUNT_TRUNCATED, otherwise make sure
2492              the value is in range.  We can't return any old value for
2493              out-of-range arguments because either the middle-end (via
2494              shift_truncation_mask) or the back-end might be relying on
2495              target-specific knowledge.  Nor can we rely on
2496              shift_truncation_mask, since the shift might not be part of an
2497              ashlM3, lshrM3 or ashrM3 instruction.  */
2498           if (SHIFT_COUNT_TRUNCATED)
2499             arg1 = (unsigned HOST_WIDE_INT) arg1 % width;
2500           else if (arg1 < 0 || arg1 >= GET_MODE_BITSIZE (mode))
2501             return 0;
2502
2503           val = (code == ASHIFT
2504                  ? ((unsigned HOST_WIDE_INT) arg0) << arg1
2505                  : ((unsigned HOST_WIDE_INT) arg0) >> arg1);
2506
2507           /* Sign-extend the result for arithmetic right shifts.  */
2508           if (code == ASHIFTRT && arg0s < 0 && arg1 > 0)
2509             val |= ((HOST_WIDE_INT) -1) << (width - arg1);
2510           break;
2511
2512         case ROTATERT:
2513           if (arg1 < 0)
2514             return 0;
2515
2516           arg1 %= width;
2517           val = ((((unsigned HOST_WIDE_INT) arg0) << (width - arg1))
2518                  | (((unsigned HOST_WIDE_INT) arg0) >> arg1));
2519           break;
2520
2521         case ROTATE:
2522           if (arg1 < 0)
2523             return 0;
2524
2525           arg1 %= width;
2526           val = ((((unsigned HOST_WIDE_INT) arg0) << arg1)
2527                  | (((unsigned HOST_WIDE_INT) arg0) >> (width - arg1)));
2528           break;
2529
2530         case COMPARE:
2531           /* Do nothing here.  */
2532           return 0;
2533
2534         case SMIN:
2535           val = arg0s <= arg1s ? arg0s : arg1s;
2536           break;
2537
2538         case UMIN:
2539           val = ((unsigned HOST_WIDE_INT) arg0
2540                  <= (unsigned HOST_WIDE_INT) arg1 ? arg0 : arg1);
2541           break;
2542
2543         case SMAX:
2544           val = arg0s > arg1s ? arg0s : arg1s;
2545           break;
2546
2547         case UMAX:
2548           val = ((unsigned HOST_WIDE_INT) arg0
2549                  > (unsigned HOST_WIDE_INT) arg1 ? arg0 : arg1);
2550           break;
2551
2552         case SS_PLUS:
2553         case US_PLUS:
2554         case SS_MINUS:
2555         case US_MINUS:
2556           /* ??? There are simplifications that can be done.  */
2557           return 0;
2558
2559         default:
2560           gcc_unreachable ();
2561         }
2562
2563       return gen_int_mode (val, mode);
2564     }
2565
2566   return NULL_RTX;
2567 }
2568
2569
2570 \f
2571 /* Simplify a PLUS or MINUS, at least one of whose operands may be another
2572    PLUS or MINUS.
2573
2574    Rather than test for specific case, we do this by a brute-force method
2575    and do all possible simplifications until no more changes occur.  Then
2576    we rebuild the operation.  */
2577
2578 struct simplify_plus_minus_op_data
2579 {
2580   rtx op;
2581   short neg;
2582   short ix;
2583 };
2584
2585 static int
2586 simplify_plus_minus_op_data_cmp (const void *p1, const void *p2)
2587 {
2588   const struct simplify_plus_minus_op_data *d1 = p1;
2589   const struct simplify_plus_minus_op_data *d2 = p2;
2590   int result;
2591
2592   result = (commutative_operand_precedence (d2->op)
2593             - commutative_operand_precedence (d1->op));
2594   if (result)
2595     return result;
2596   return d1->ix - d2->ix;
2597 }
2598
2599 static rtx
2600 simplify_plus_minus (enum rtx_code code, enum machine_mode mode, rtx op0,
2601                      rtx op1)
2602 {
2603   struct simplify_plus_minus_op_data ops[8];
2604   rtx result, tem;
2605   int n_ops = 2, input_ops = 2;
2606   int first, changed, canonicalized = 0;
2607   int i, j;
2608
2609   memset (ops, 0, sizeof ops);
2610
2611   /* Set up the two operands and then expand them until nothing has been
2612      changed.  If we run out of room in our array, give up; this should
2613      almost never happen.  */
2614
2615   ops[0].op = op0;
2616   ops[0].neg = 0;
2617   ops[1].op = op1;
2618   ops[1].neg = (code == MINUS);
2619
2620   do
2621     {
2622       changed = 0;
2623
2624       for (i = 0; i < n_ops; i++)
2625         {
2626           rtx this_op = ops[i].op;
2627           int this_neg = ops[i].neg;
2628           enum rtx_code this_code = GET_CODE (this_op);
2629
2630           switch (this_code)
2631             {
2632             case PLUS:
2633             case MINUS:
2634               if (n_ops == 7)
2635                 return NULL_RTX;
2636
2637               ops[n_ops].op = XEXP (this_op, 1);
2638               ops[n_ops].neg = (this_code == MINUS) ^ this_neg;
2639               n_ops++;
2640
2641               ops[i].op = XEXP (this_op, 0);
2642               input_ops++;
2643               changed = 1;
2644               canonicalized |= this_neg;
2645               break;
2646
2647             case NEG:
2648               ops[i].op = XEXP (this_op, 0);
2649               ops[i].neg = ! this_neg;
2650               changed = 1;
2651               canonicalized = 1;
2652               break;
2653
2654             case CONST:
2655               if (n_ops < 7
2656                   && GET_CODE (XEXP (this_op, 0)) == PLUS
2657                   && CONSTANT_P (XEXP (XEXP (this_op, 0), 0))
2658                   && CONSTANT_P (XEXP (XEXP (this_op, 0), 1)))
2659                 {
2660                   ops[i].op = XEXP (XEXP (this_op, 0), 0);
2661                   ops[n_ops].op = XEXP (XEXP (this_op, 0), 1);
2662                   ops[n_ops].neg = this_neg;
2663                   n_ops++;
2664                   changed = 1;
2665                   canonicalized = 1;
2666                 }
2667               break;
2668
2669             case NOT:
2670               /* ~a -> (-a - 1) */
2671               if (n_ops != 7)
2672                 {
2673                   ops[n_ops].op = constm1_rtx;
2674                   ops[n_ops++].neg = this_neg;
2675                   ops[i].op = XEXP (this_op, 0);
2676                   ops[i].neg = !this_neg;
2677                   changed = 1;
2678                   canonicalized = 1;
2679                 }
2680               break;
2681
2682             case CONST_INT:
2683               if (this_neg)
2684                 {
2685                   ops[i].op = neg_const_int (mode, this_op);
2686                   ops[i].neg = 0;
2687                   changed = 1;
2688                   canonicalized = 1;
2689                 }
2690               break;
2691
2692             default:
2693               break;
2694             }
2695         }
2696     }
2697   while (changed);
2698
2699   gcc_assert (n_ops >= 2);
2700   if (!canonicalized)
2701     {
2702       int n_constants = 0;
2703
2704       for (i = 0; i < n_ops; i++)
2705         if (GET_CODE (ops[i].op) == CONST_INT)
2706           n_constants++;
2707
2708       if (n_constants <= 1)
2709         return NULL_RTX;
2710     }
2711
2712   /* If we only have two operands, we can avoid the loops.  */
2713   if (n_ops == 2)
2714     {
2715       enum rtx_code code = ops[0].neg || ops[1].neg ? MINUS : PLUS;
2716       rtx lhs, rhs;
2717
2718       /* Get the two operands.  Be careful with the order, especially for
2719          the cases where code == MINUS.  */
2720       if (ops[0].neg && ops[1].neg)
2721         {
2722           lhs = gen_rtx_NEG (mode, ops[0].op);
2723           rhs = ops[1].op;
2724         }
2725       else if (ops[0].neg)
2726         {
2727           lhs = ops[1].op;
2728           rhs = ops[0].op;
2729         }
2730       else
2731         {
2732           lhs = ops[0].op;
2733           rhs = ops[1].op;
2734         }
2735
2736       return simplify_const_binary_operation (code, mode, lhs, rhs);
2737     }
2738
2739   /* Now simplify each pair of operands until nothing changes.  The first
2740      time through just simplify constants against each other.  */
2741
2742   first = 1;
2743   do
2744     {
2745       changed = first;
2746
2747       for (i = 0; i < n_ops - 1; i++)
2748         for (j = i + 1; j < n_ops; j++)
2749           {
2750             rtx lhs = ops[i].op, rhs = ops[j].op;
2751             int lneg = ops[i].neg, rneg = ops[j].neg;
2752
2753             if (lhs != 0 && rhs != 0
2754                 && (! first || (CONSTANT_P (lhs) && CONSTANT_P (rhs))))
2755               {
2756                 enum rtx_code ncode = PLUS;
2757
2758                 if (lneg != rneg)
2759                   {
2760                     ncode = MINUS;
2761                     if (lneg)
2762                       tem = lhs, lhs = rhs, rhs = tem;
2763                   }
2764                 else if (swap_commutative_operands_p (lhs, rhs))
2765                   tem = lhs, lhs = rhs, rhs = tem;
2766
2767                 tem = simplify_binary_operation (ncode, mode, lhs, rhs);
2768
2769                 /* Reject "simplifications" that just wrap the two
2770                    arguments in a CONST.  Failure to do so can result
2771                    in infinite recursion with simplify_binary_operation
2772                    when it calls us to simplify CONST operations.  */
2773                 if (tem
2774                     && ! (GET_CODE (tem) == CONST
2775                           && GET_CODE (XEXP (tem, 0)) == ncode
2776                           && XEXP (XEXP (tem, 0), 0) == lhs
2777                           && XEXP (XEXP (tem, 0), 1) == rhs)
2778                     /* Don't allow -x + -1 -> ~x simplifications in the
2779                        first pass.  This allows us the chance to combine
2780                        the -1 with other constants.  */
2781                     && ! (first
2782                           && GET_CODE (tem) == NOT
2783                           && XEXP (tem, 0) == rhs))
2784                   {
2785                     lneg &= rneg;
2786                     if (GET_CODE (tem) == NEG)
2787                       tem = XEXP (tem, 0), lneg = !lneg;
2788                     if (GET_CODE (tem) == CONST_INT && lneg)
2789                       tem = neg_const_int (mode, tem), lneg = 0;
2790
2791                     ops[i].op = tem;
2792                     ops[i].neg = lneg;
2793                     ops[j].op = NULL_RTX;
2794                     changed = 1;
2795                   }
2796               }
2797           }
2798
2799       first = 0;
2800     }
2801   while (changed);
2802
2803   /* Pack all the operands to the lower-numbered entries.  */
2804   for (i = 0, j = 0; j < n_ops; j++)
2805     if (ops[j].op)
2806       {
2807         ops[i] = ops[j];
2808         /* Stabilize sort.  */
2809         ops[i].ix = i;
2810         i++;
2811       }
2812   n_ops = i;
2813
2814   /* Sort the operations based on swap_commutative_operands_p.  */
2815   qsort (ops, n_ops, sizeof (*ops), simplify_plus_minus_op_data_cmp);
2816
2817   /* Create (minus -C X) instead of (neg (const (plus X C))).  */
2818   if (n_ops == 2
2819       && GET_CODE (ops[1].op) == CONST_INT
2820       && CONSTANT_P (ops[0].op)
2821       && ops[0].neg)
2822     return gen_rtx_fmt_ee (MINUS, mode, ops[1].op, ops[0].op);
2823
2824   /* We suppressed creation of trivial CONST expressions in the
2825      combination loop to avoid recursion.  Create one manually now.
2826      The combination loop should have ensured that there is exactly
2827      one CONST_INT, and the sort will have ensured that it is last
2828      in the array and that any other constant will be next-to-last.  */
2829
2830   if (n_ops > 1
2831       && GET_CODE (ops[n_ops - 1].op) == CONST_INT
2832       && CONSTANT_P (ops[n_ops - 2].op))
2833     {
2834       rtx value = ops[n_ops - 1].op;
2835       if (ops[n_ops - 1].neg ^ ops[n_ops - 2].neg)
2836         value = neg_const_int (mode, value);
2837       ops[n_ops - 2].op = plus_constant (ops[n_ops - 2].op, INTVAL (value));
2838       n_ops--;
2839     }
2840
2841   /* Put a non-negated operand first, if possible.  */
2842
2843   for (i = 0; i < n_ops && ops[i].neg; i++)
2844     continue;
2845   if (i == n_ops)
2846     ops[0].op = gen_rtx_NEG (mode, ops[0].op);
2847   else if (i != 0)
2848     {
2849       tem = ops[0].op;
2850       ops[0] = ops[i];
2851       ops[i].op = tem;
2852       ops[i].neg = 1;
2853     }
2854
2855   /* Now make the result by performing the requested operations.  */
2856   result = ops[0].op;
2857   for (i = 1; i < n_ops; i++)
2858     result = gen_rtx_fmt_ee (ops[i].neg ? MINUS : PLUS,
2859                              mode, result, ops[i].op);
2860
2861   return result;
2862 }
2863
2864 /* Check whether an operand is suitable for calling simplify_plus_minus.  */
2865 static bool
2866 plus_minus_operand_p (rtx x)
2867 {
2868   return GET_CODE (x) == PLUS
2869          || GET_CODE (x) == MINUS
2870          || (GET_CODE (x) == CONST
2871              && GET_CODE (XEXP (x, 0)) == PLUS
2872              && CONSTANT_P (XEXP (XEXP (x, 0), 0))
2873              && CONSTANT_P (XEXP (XEXP (x, 0), 1)));
2874 }
2875
2876 /* Like simplify_binary_operation except used for relational operators.
2877    MODE is the mode of the result. If MODE is VOIDmode, both operands must
2878    not also be VOIDmode.
2879
2880    CMP_MODE specifies in which mode the comparison is done in, so it is
2881    the mode of the operands.  If CMP_MODE is VOIDmode, it is taken from
2882    the operands or, if both are VOIDmode, the operands are compared in
2883    "infinite precision".  */
2884 rtx
2885 simplify_relational_operation (enum rtx_code code, enum machine_mode mode,
2886                                enum machine_mode cmp_mode, rtx op0, rtx op1)
2887 {
2888   rtx tem, trueop0, trueop1;
2889
2890   if (cmp_mode == VOIDmode)
2891     cmp_mode = GET_MODE (op0);
2892   if (cmp_mode == VOIDmode)
2893     cmp_mode = GET_MODE (op1);
2894
2895   tem = simplify_const_relational_operation (code, cmp_mode, op0, op1);
2896   if (tem)
2897     {
2898       if (SCALAR_FLOAT_MODE_P (mode))
2899         {
2900           if (tem == const0_rtx)
2901             return CONST0_RTX (mode);
2902 #ifdef FLOAT_STORE_FLAG_VALUE
2903           {
2904             REAL_VALUE_TYPE val;
2905             val = FLOAT_STORE_FLAG_VALUE (mode);
2906             return CONST_DOUBLE_FROM_REAL_VALUE (val, mode);
2907           }
2908 #else
2909           return NULL_RTX;
2910 #endif
2911         }
2912       if (VECTOR_MODE_P (mode))
2913         {
2914           if (tem == const0_rtx)
2915             return CONST0_RTX (mode);
2916 #ifdef VECTOR_STORE_FLAG_VALUE
2917           {
2918             int i, units;
2919             rtvec v;
2920
2921             rtx val = VECTOR_STORE_FLAG_VALUE (mode);
2922             if (val == NULL_RTX)
2923               return NULL_RTX;
2924             if (val == const1_rtx)
2925               return CONST1_RTX (mode);
2926
2927             units = GET_MODE_NUNITS (mode);
2928             v = rtvec_alloc (units);
2929             for (i = 0; i < units; i++)
2930               RTVEC_ELT (v, i) = val;
2931             return gen_rtx_raw_CONST_VECTOR (mode, v);
2932           }
2933 #else
2934           return NULL_RTX;
2935 #endif
2936         }
2937
2938       return tem;
2939     }
2940
2941   /* For the following tests, ensure const0_rtx is op1.  */
2942   if (swap_commutative_operands_p (op0, op1)
2943       || (op0 == const0_rtx && op1 != const0_rtx))
2944     tem = op0, op0 = op1, op1 = tem, code = swap_condition (code);
2945
2946   /* If op0 is a compare, extract the comparison arguments from it.  */
2947   if (GET_CODE (op0) == COMPARE && op1 == const0_rtx)
2948     return simplify_relational_operation (code, mode, VOIDmode,
2949                                           XEXP (op0, 0), XEXP (op0, 1));
2950
2951   if (mode == VOIDmode
2952       || GET_MODE_CLASS (cmp_mode) == MODE_CC
2953       || CC0_P (op0))
2954     return NULL_RTX;
2955
2956   trueop0 = avoid_constant_pool_reference (op0);
2957   trueop1 = avoid_constant_pool_reference (op1);
2958   return simplify_relational_operation_1 (code, mode, cmp_mode,
2959                                           trueop0, trueop1);
2960 }
2961
2962 /* This part of simplify_relational_operation is only used when CMP_MODE
2963    is not in class MODE_CC (i.e. it is a real comparison).
2964
2965    MODE is the mode of the result, while CMP_MODE specifies in which
2966    mode the comparison is done in, so it is the mode of the operands.  */
2967
2968 static rtx
2969 simplify_relational_operation_1 (enum rtx_code code, enum machine_mode mode,
2970                                  enum machine_mode cmp_mode, rtx op0, rtx op1)
2971 {
2972   enum rtx_code op0code = GET_CODE (op0);
2973
2974   if (GET_CODE (op1) == CONST_INT)
2975     {
2976       if (INTVAL (op1) == 0 && COMPARISON_P (op0))
2977         {
2978           /* If op0 is a comparison, extract the comparison arguments form it.  */
2979           if (code == NE)
2980             {
2981               if (GET_MODE (op0) == mode)
2982                 return simplify_rtx (op0);
2983               else
2984                 return simplify_gen_relational (GET_CODE (op0), mode, VOIDmode,
2985                                                 XEXP (op0, 0), XEXP (op0, 1));
2986             }
2987           else if (code == EQ)
2988             {
2989               enum rtx_code new_code = reversed_comparison_code (op0, NULL_RTX);
2990               if (new_code != UNKNOWN)
2991                 return simplify_gen_relational (new_code, mode, VOIDmode,
2992                                                 XEXP (op0, 0), XEXP (op0, 1));
2993             }
2994         }
2995     }
2996
2997   /* (eq/ne (plus x cst1) cst2) simplifies to (eq/ne x (cst2 - cst1))  */
2998   if ((code == EQ || code == NE)
2999       && (op0code == PLUS || op0code == MINUS)
3000       && CONSTANT_P (op1)
3001       && CONSTANT_P (XEXP (op0, 1))
3002       && (INTEGRAL_MODE_P (cmp_mode) || flag_unsafe_math_optimizations))
3003     {
3004       rtx x = XEXP (op0, 0);
3005       rtx c = XEXP (op0, 1);
3006
3007       c = simplify_gen_binary (op0code == PLUS ? MINUS : PLUS,
3008                                cmp_mode, op1, c);
3009       return simplify_gen_relational (code, mode, cmp_mode, x, c);
3010     }
3011
3012   /* (ne:SI (zero_extract:SI FOO (const_int 1) BAR) (const_int 0))) is
3013      the same as (zero_extract:SI FOO (const_int 1) BAR).  */
3014   if (code == NE
3015       && op1 == const0_rtx
3016       && GET_MODE_CLASS (mode) == MODE_INT
3017       && cmp_mode != VOIDmode
3018       /* ??? Work-around BImode bugs in the ia64 backend.  */
3019       && mode != BImode
3020       && cmp_mode != BImode
3021       && nonzero_bits (op0, cmp_mode) == 1
3022       && STORE_FLAG_VALUE == 1)
3023     return GET_MODE_SIZE (mode) > GET_MODE_SIZE (cmp_mode)
3024            ? simplify_gen_unary (ZERO_EXTEND, mode, op0, cmp_mode)
3025            : lowpart_subreg (mode, op0, cmp_mode);
3026
3027   return NULL_RTX;
3028 }
3029
3030 /* Check if the given comparison (done in the given MODE) is actually a
3031    tautology or a contradiction.
3032    If no simplification is possible, this function returns zero.
3033    Otherwise, it returns either const_true_rtx or const0_rtx.  */
3034
3035 rtx
3036 simplify_const_relational_operation (enum rtx_code code,
3037                                      enum machine_mode mode,
3038                                      rtx op0, rtx op1)
3039 {
3040   int equal, op0lt, op0ltu, op1lt, op1ltu;
3041   rtx tem;
3042   rtx trueop0;
3043   rtx trueop1;
3044
3045   gcc_assert (mode != VOIDmode
3046               || (GET_MODE (op0) == VOIDmode
3047                   && GET_MODE (op1) == VOIDmode));
3048
3049   /* If op0 is a compare, extract the comparison arguments from it.  */
3050   if (GET_CODE (op0) == COMPARE && op1 == const0_rtx)
3051     {
3052       op1 = XEXP (op0, 1);
3053       op0 = XEXP (op0, 0);
3054
3055       if (GET_MODE (op0) != VOIDmode)
3056         mode = GET_MODE (op0);
3057       else if (GET_MODE (op1) != VOIDmode)
3058         mode = GET_MODE (op1);
3059       else
3060         return 0;
3061     }
3062
3063   /* We can't simplify MODE_CC values since we don't know what the
3064      actual comparison is.  */
3065   if (GET_MODE_CLASS (GET_MODE (op0)) == MODE_CC || CC0_P (op0))
3066     return 0;
3067
3068   /* Make sure the constant is second.  */
3069   if (swap_commutative_operands_p (op0, op1))
3070     {
3071       tem = op0, op0 = op1, op1 = tem;
3072       code = swap_condition (code);
3073     }
3074
3075   trueop0 = avoid_constant_pool_reference (op0);
3076   trueop1 = avoid_constant_pool_reference (op1);
3077
3078   /* For integer comparisons of A and B maybe we can simplify A - B and can
3079      then simplify a comparison of that with zero.  If A and B are both either
3080      a register or a CONST_INT, this can't help; testing for these cases will
3081      prevent infinite recursion here and speed things up.
3082
3083      If CODE is an unsigned comparison, then we can never do this optimization,
3084      because it gives an incorrect result if the subtraction wraps around zero.
3085      ANSI C defines unsigned operations such that they never overflow, and
3086      thus such cases can not be ignored; but we cannot do it even for
3087      signed comparisons for languages such as Java, so test flag_wrapv.  */
3088
3089   if (!flag_wrapv && INTEGRAL_MODE_P (mode) && trueop1 != const0_rtx
3090       && ! ((REG_P (op0) || GET_CODE (trueop0) == CONST_INT)
3091             && (REG_P (op1) || GET_CODE (trueop1) == CONST_INT))
3092       && 0 != (tem = simplify_binary_operation (MINUS, mode, op0, op1))
3093       /* We cannot do this for == or != if tem is a nonzero address.  */
3094       && ((code != EQ && code != NE) || ! nonzero_address_p (tem))
3095       && code != GTU && code != GEU && code != LTU && code != LEU)
3096     return simplify_const_relational_operation (signed_condition (code),
3097                                                 mode, tem, const0_rtx);
3098
3099   if (flag_unsafe_math_optimizations && code == ORDERED)
3100     return const_true_rtx;
3101
3102   if (flag_unsafe_math_optimizations && code == UNORDERED)
3103     return const0_rtx;
3104
3105   /* For modes without NaNs, if the two operands are equal, we know the
3106      result except if they have side-effects.  */
3107   if (! HONOR_NANS (GET_MODE (trueop0))
3108       && rtx_equal_p (trueop0, trueop1)
3109       && ! side_effects_p (trueop0))
3110     equal = 1, op0lt = 0, op0ltu = 0, op1lt = 0, op1ltu = 0;
3111
3112   /* If the operands are floating-point constants, see if we can fold
3113      the result.  */
3114   else if (GET_CODE (trueop0) == CONST_DOUBLE
3115            && GET_CODE (trueop1) == CONST_DOUBLE
3116            && SCALAR_FLOAT_MODE_P (GET_MODE (trueop0)))
3117     {
3118       REAL_VALUE_TYPE d0, d1;
3119
3120       REAL_VALUE_FROM_CONST_DOUBLE (d0, trueop0);
3121       REAL_VALUE_FROM_CONST_DOUBLE (d1, trueop1);
3122
3123       /* Comparisons are unordered iff at least one of the values is NaN.  */
3124       if (REAL_VALUE_ISNAN (d0) || REAL_VALUE_ISNAN (d1))
3125         switch (code)
3126           {
3127           case UNEQ:
3128           case UNLT:
3129           case UNGT:
3130           case UNLE:
3131           case UNGE:
3132           case NE:
3133           case UNORDERED:
3134             return const_true_rtx;
3135           case EQ:
3136           case LT:
3137           case GT:
3138           case LE:
3139           case GE:
3140           case LTGT:
3141           case ORDERED:
3142             return const0_rtx;
3143           default:
3144             return 0;
3145           }
3146
3147       equal = REAL_VALUES_EQUAL (d0, d1);
3148       op0lt = op0ltu = REAL_VALUES_LESS (d0, d1);
3149       op1lt = op1ltu = REAL_VALUES_LESS (d1, d0);
3150     }
3151
3152   /* Otherwise, see if the operands are both integers.  */
3153   else if ((GET_MODE_CLASS (mode) == MODE_INT || mode == VOIDmode)
3154            && (GET_CODE (trueop0) == CONST_DOUBLE
3155                || GET_CODE (trueop0) == CONST_INT)
3156            && (GET_CODE (trueop1) == CONST_DOUBLE
3157                || GET_CODE (trueop1) == CONST_INT))
3158     {
3159       int width = GET_MODE_BITSIZE (mode);
3160       HOST_WIDE_INT l0s, h0s, l1s, h1s;
3161       unsigned HOST_WIDE_INT l0u, h0u, l1u, h1u;
3162
3163       /* Get the two words comprising each integer constant.  */
3164       if (GET_CODE (trueop0) == CONST_DOUBLE)
3165         {
3166           l0u = l0s = CONST_DOUBLE_LOW (trueop0);
3167           h0u = h0s = CONST_DOUBLE_HIGH (trueop0);
3168         }
3169       else
3170         {
3171           l0u = l0s = INTVAL (trueop0);
3172           h0u = h0s = HWI_SIGN_EXTEND (l0s);
3173         }
3174
3175       if (GET_CODE (trueop1) == CONST_DOUBLE)
3176         {
3177           l1u = l1s = CONST_DOUBLE_LOW (trueop1);
3178           h1u = h1s = CONST_DOUBLE_HIGH (trueop1);
3179         }
3180       else
3181         {
3182           l1u = l1s = INTVAL (trueop1);
3183           h1u = h1s = HWI_SIGN_EXTEND (l1s);
3184         }
3185
3186       /* If WIDTH is nonzero and smaller than HOST_BITS_PER_WIDE_INT,
3187          we have to sign or zero-extend the values.  */
3188       if (width != 0 && width < HOST_BITS_PER_WIDE_INT)
3189         {
3190           l0u &= ((HOST_WIDE_INT) 1 << width) - 1;
3191           l1u &= ((HOST_WIDE_INT) 1 << width) - 1;
3192
3193           if (l0s & ((HOST_WIDE_INT) 1 << (width - 1)))
3194             l0s |= ((HOST_WIDE_INT) (-1) << width);
3195
3196           if (l1s & ((HOST_WIDE_INT) 1 << (width - 1)))
3197             l1s |= ((HOST_WIDE_INT) (-1) << width);
3198         }
3199       if (width != 0 && width <= HOST_BITS_PER_WIDE_INT)
3200         h0u = h1u = 0, h0s = HWI_SIGN_EXTEND (l0s), h1s = HWI_SIGN_EXTEND (l1s);
3201
3202       equal = (h0u == h1u && l0u == l1u);
3203       op0lt = (h0s < h1s || (h0s == h1s && l0u < l1u));
3204       op1lt = (h1s < h0s || (h1s == h0s && l1u < l0u));
3205       op0ltu = (h0u < h1u || (h0u == h1u && l0u < l1u));
3206       op1ltu = (h1u < h0u || (h1u == h0u && l1u < l0u));
3207     }
3208
3209   /* Otherwise, there are some code-specific tests we can make.  */
3210   else
3211     {
3212       /* Optimize comparisons with upper and lower bounds.  */
3213       if (SCALAR_INT_MODE_P (mode)
3214           && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
3215         {
3216           rtx mmin, mmax;
3217           int sign;
3218
3219           if (code == GEU
3220               || code == LEU
3221               || code == GTU
3222               || code == LTU)
3223             sign = 0;
3224           else
3225             sign = 1;
3226
3227           get_mode_bounds (mode, sign, mode, &mmin, &mmax);
3228
3229           tem = NULL_RTX;
3230           switch (code)
3231             {
3232             case GEU:
3233             case GE:
3234               /* x >= min is always true.  */
3235               if (rtx_equal_p (trueop1, mmin))
3236                 tem = const_true_rtx;
3237               else
3238               break;
3239
3240             case LEU:
3241             case LE:
3242               /* x <= max is always true.  */
3243               if (rtx_equal_p (trueop1, mmax))
3244                 tem = const_true_rtx;
3245               break;
3246
3247             case GTU:
3248             case GT:
3249               /* x > max is always false.  */
3250               if (rtx_equal_p (trueop1, mmax))
3251                 tem = const0_rtx;
3252               break;
3253
3254             case LTU:
3255             case LT:
3256               /* x < min is always false.  */
3257               if (rtx_equal_p (trueop1, mmin))
3258                 tem = const0_rtx;
3259               break;
3260
3261             default:
3262               break;
3263             }
3264           if (tem == const0_rtx
3265               || tem == const_true_rtx)
3266             return tem;
3267         }
3268
3269       switch (code)
3270         {
3271         case EQ:
3272           if (trueop1 == const0_rtx && nonzero_address_p (op0))
3273             return const0_rtx;
3274           break;
3275
3276         case NE:
3277           if (trueop1 == const0_rtx && nonzero_address_p (op0))
3278             return const_true_rtx;
3279           break;
3280
3281         case LT:
3282           /* Optimize abs(x) < 0.0.  */
3283           if (trueop1 == CONST0_RTX (mode)
3284               && !HONOR_SNANS (mode)
3285               && !(flag_wrapv && INTEGRAL_MODE_P (mode)))
3286             {
3287               tem = GET_CODE (trueop0) == FLOAT_EXTEND ? XEXP (trueop0, 0)
3288                                                        : trueop0;
3289               if (GET_CODE (tem) == ABS)
3290                 return const0_rtx;
3291             }
3292           break;
3293
3294         case GE:
3295           /* Optimize abs(x) >= 0.0.  */
3296           if (trueop1 == CONST0_RTX (mode)
3297               && !HONOR_NANS (mode)
3298               && !(flag_wrapv && INTEGRAL_MODE_P (mode)))
3299             {
3300               tem = GET_CODE (trueop0) == FLOAT_EXTEND ? XEXP (trueop0, 0)
3301                                                        : trueop0;
3302               if (GET_CODE (tem) == ABS)
3303                 return const_true_rtx;
3304             }
3305           break;
3306
3307         case UNGE:
3308           /* Optimize ! (abs(x) < 0.0).  */
3309           if (trueop1 == CONST0_RTX (mode))
3310             {
3311               tem = GET_CODE (trueop0) == FLOAT_EXTEND ? XEXP (trueop0, 0)
3312                                                        : trueop0;
3313               if (GET_CODE (tem) == ABS)
3314                 return const_true_rtx;
3315             }
3316           break;
3317
3318         default:
3319           break;
3320         }
3321
3322       return 0;
3323     }
3324
3325   /* If we reach here, EQUAL, OP0LT, OP0LTU, OP1LT, and OP1LTU are set
3326      as appropriate.  */
3327   switch (code)
3328     {
3329     case EQ:
3330     case UNEQ:
3331       return equal ? const_true_rtx : const0_rtx;
3332     case NE:
3333     case LTGT:
3334       return ! equal ? const_true_rtx : const0_rtx;
3335     case LT:
3336     case UNLT:
3337       return op0lt ? const_true_rtx : const0_rtx;
3338     case GT:
3339     case UNGT:
3340       return op1lt ? const_true_rtx : const0_rtx;
3341     case LTU:
3342       return op0ltu ? const_true_rtx : const0_rtx;
3343     case GTU:
3344       return op1ltu ? const_true_rtx : const0_rtx;
3345     case LE:
3346     case UNLE:
3347       return equal || op0lt ? const_true_rtx : const0_rtx;
3348     case GE:
3349     case UNGE:
3350       return equal || op1lt ? const_true_rtx : const0_rtx;
3351     case LEU:
3352       return equal || op0ltu ? const_true_rtx : const0_rtx;
3353     case GEU:
3354       return equal || op1ltu ? const_true_rtx : const0_rtx;
3355     case ORDERED:
3356       return const_true_rtx;
3357     case UNORDERED:
3358       return const0_rtx;
3359     default:
3360       gcc_unreachable ();
3361     }
3362 }
3363 \f
3364 /* Simplify CODE, an operation with result mode MODE and three operands,
3365    OP0, OP1, and OP2.  OP0_MODE was the mode of OP0 before it became
3366    a constant.  Return 0 if no simplifications is possible.  */
3367
3368 rtx
3369 simplify_ternary_operation (enum rtx_code code, enum machine_mode mode,
3370                             enum machine_mode op0_mode, rtx op0, rtx op1,
3371                             rtx op2)
3372 {
3373   unsigned int width = GET_MODE_BITSIZE (mode);
3374
3375   /* VOIDmode means "infinite" precision.  */
3376   if (width == 0)
3377     width = HOST_BITS_PER_WIDE_INT;
3378
3379   switch (code)
3380     {
3381     case SIGN_EXTRACT:
3382     case ZERO_EXTRACT:
3383       if (GET_CODE (op0) == CONST_INT
3384           && GET_CODE (op1) == CONST_INT
3385           && GET_CODE (op2) == CONST_INT
3386           && ((unsigned) INTVAL (op1) + (unsigned) INTVAL (op2) <= width)
3387           && width <= (unsigned) HOST_BITS_PER_WIDE_INT)
3388         {
3389           /* Extracting a bit-field from a constant */
3390           HOST_WIDE_INT val = INTVAL (op0);
3391
3392           if (BITS_BIG_ENDIAN)
3393             val >>= (GET_MODE_BITSIZE (op0_mode)
3394                      - INTVAL (op2) - INTVAL (op1));
3395           else
3396             val >>= INTVAL (op2);
3397
3398           if (HOST_BITS_PER_WIDE_INT != INTVAL (op1))
3399             {
3400               /* First zero-extend.  */
3401               val &= ((HOST_WIDE_INT) 1 << INTVAL (op1)) - 1;
3402               /* If desired, propagate sign bit.  */
3403               if (code == SIGN_EXTRACT
3404                   && (val & ((HOST_WIDE_INT) 1 << (INTVAL (op1) - 1))))
3405                 val |= ~ (((HOST_WIDE_INT) 1 << INTVAL (op1)) - 1);
3406             }
3407
3408           /* Clear the bits that don't belong in our mode,
3409              unless they and our sign bit are all one.
3410              So we get either a reasonable negative value or a reasonable
3411              unsigned value for this mode.  */
3412           if (width < HOST_BITS_PER_WIDE_INT
3413               && ((val & ((HOST_WIDE_INT) (-1) << (width - 1)))
3414                   != ((HOST_WIDE_INT) (-1) << (width - 1))))
3415             val &= ((HOST_WIDE_INT) 1 << width) - 1;
3416
3417           return gen_int_mode (val, mode);
3418         }
3419       break;
3420
3421     case IF_THEN_ELSE:
3422       if (GET_CODE (op0) == CONST_INT)
3423         return op0 != const0_rtx ? op1 : op2;
3424
3425       /* Convert c ? a : a into "a".  */
3426       if (rtx_equal_p (op1, op2) && ! side_effects_p (op0))
3427         return op1;
3428
3429       /* Convert a != b ? a : b into "a".  */
3430       if (GET_CODE (op0) == NE
3431           && ! side_effects_p (op0)
3432           && ! HONOR_NANS (mode)
3433           && ! HONOR_SIGNED_ZEROS (mode)
3434           && ((rtx_equal_p (XEXP (op0, 0), op1)
3435                && rtx_equal_p (XEXP (op0, 1), op2))
3436               || (rtx_equal_p (XEXP (op0, 0), op2)
3437                   && rtx_equal_p (XEXP (op0, 1), op1))))
3438         return op1;
3439
3440       /* Convert a == b ? a : b into "b".  */
3441       if (GET_CODE (op0) == EQ
3442           && ! side_effects_p (op0)
3443           && ! HONOR_NANS (mode)
3444           && ! HONOR_SIGNED_ZEROS (mode)
3445           && ((rtx_equal_p (XEXP (op0, 0), op1)
3446                && rtx_equal_p (XEXP (op0, 1), op2))
3447               || (rtx_equal_p (XEXP (op0, 0), op2)
3448                   && rtx_equal_p (XEXP (op0, 1), op1))))
3449         return op2;
3450
3451       if (COMPARISON_P (op0) && ! side_effects_p (op0))
3452         {
3453           enum machine_mode cmp_mode = (GET_MODE (XEXP (op0, 0)) == VOIDmode
3454                                         ? GET_MODE (XEXP (op0, 1))
3455                                         : GET_MODE (XEXP (op0, 0)));
3456           rtx temp;
3457
3458           /* Look for happy constants in op1 and op2.  */
3459           if (GET_CODE (op1) == CONST_INT && GET_CODE (op2) == CONST_INT)
3460             {
3461               HOST_WIDE_INT t = INTVAL (op1);
3462               HOST_WIDE_INT f = INTVAL (op2);
3463
3464               if (t == STORE_FLAG_VALUE && f == 0)
3465                 code = GET_CODE (op0);
3466               else if (t == 0 && f == STORE_FLAG_VALUE)
3467                 {
3468                   enum rtx_code tmp;
3469                   tmp = reversed_comparison_code (op0, NULL_RTX);
3470                   if (tmp == UNKNOWN)
3471                     break;
3472                   code = tmp;
3473                 }
3474               else
3475                 break;
3476
3477               return simplify_gen_relational (code, mode, cmp_mode,
3478                                               XEXP (op0, 0), XEXP (op0, 1));
3479             }
3480
3481           if (cmp_mode == VOIDmode)
3482             cmp_mode = op0_mode;
3483           temp = simplify_relational_operation (GET_CODE (op0), op0_mode,
3484                                                 cmp_mode, XEXP (op0, 0),
3485                                                 XEXP (op0, 1));
3486
3487           /* See if any simplifications were possible.  */
3488           if (temp)
3489             {
3490               if (GET_CODE (temp) == CONST_INT)
3491                 return temp == const0_rtx ? op2 : op1;
3492               else if (temp)
3493                 return gen_rtx_IF_THEN_ELSE (mode, temp, op1, op2);
3494             }
3495         }
3496       break;
3497
3498     case VEC_MERGE:
3499       gcc_assert (GET_MODE (op0) == mode);
3500       gcc_assert (GET_MODE (op1) == mode);
3501       gcc_assert (VECTOR_MODE_P (mode));
3502       op2 = avoid_constant_pool_reference (op2);
3503       if (GET_CODE (op2) == CONST_INT)
3504         {
3505           int elt_size = GET_MODE_SIZE (GET_MODE_INNER (mode));
3506           unsigned n_elts = (GET_MODE_SIZE (mode) / elt_size);
3507           int mask = (1 << n_elts) - 1;
3508
3509           if (!(INTVAL (op2) & mask))
3510             return op1;
3511           if ((INTVAL (op2) & mask) == mask)
3512             return op0;
3513
3514           op0 = avoid_constant_pool_reference (op0);
3515           op1 = avoid_constant_pool_reference (op1);
3516           if (GET_CODE (op0) == CONST_VECTOR
3517               && GET_CODE (op1) == CONST_VECTOR)
3518             {
3519               rtvec v = rtvec_alloc (n_elts);
3520               unsigned int i;
3521
3522               for (i = 0; i < n_elts; i++)
3523                 RTVEC_ELT (v, i) = (INTVAL (op2) & (1 << i)
3524                                     ? CONST_VECTOR_ELT (op0, i)
3525                                     : CONST_VECTOR_ELT (op1, i));
3526               return gen_rtx_CONST_VECTOR (mode, v);
3527             }
3528         }
3529       break;
3530
3531     default:
3532       gcc_unreachable ();
3533     }
3534
3535   return 0;
3536 }
3537
3538 /* Evaluate a SUBREG of a CONST_INT or CONST_DOUBLE or CONST_VECTOR,
3539    returning another CONST_INT or CONST_DOUBLE or CONST_VECTOR.
3540
3541    Works by unpacking OP into a collection of 8-bit values
3542    represented as a little-endian array of 'unsigned char', selecting by BYTE,
3543    and then repacking them again for OUTERMODE.  */
3544
3545 static rtx
3546 simplify_immed_subreg (enum machine_mode outermode, rtx op,
3547                        enum machine_mode innermode, unsigned int byte)
3548 {
3549   /* We support up to 512-bit values (for V8DFmode).  */
3550   enum {
3551     max_bitsize = 512,
3552     value_bit = 8,
3553     value_mask = (1 << value_bit) - 1
3554   };
3555   unsigned char value[max_bitsize / value_bit];
3556   int value_start;
3557   int i;
3558   int elem;
3559
3560   int num_elem;
3561   rtx * elems;
3562   int elem_bitsize;
3563   rtx result_s;
3564   rtvec result_v = NULL;
3565   enum mode_class outer_class;
3566   enum machine_mode outer_submode;
3567
3568   /* Some ports misuse CCmode.  */
3569   if (GET_MODE_CLASS (outermode) == MODE_CC && GET_CODE (op) == CONST_INT)
3570     return op;
3571
3572   /* We have no way to represent a complex constant at the rtl level.  */
3573   if (COMPLEX_MODE_P (outermode))
3574     return NULL_RTX;
3575
3576   /* Unpack the value.  */
3577
3578   if (GET_CODE (op) == CONST_VECTOR)
3579     {
3580       num_elem = CONST_VECTOR_NUNITS (op);
3581       elems = &CONST_VECTOR_ELT (op, 0);
3582       elem_bitsize = GET_MODE_BITSIZE (GET_MODE_INNER (innermode));
3583     }
3584   else
3585     {
3586       num_elem = 1;
3587       elems = &op;
3588       elem_bitsize = max_bitsize;
3589     }
3590   /* If this asserts, it is too complicated; reducing value_bit may help.  */
3591   gcc_assert (BITS_PER_UNIT % value_bit == 0);
3592   /* I don't know how to handle endianness of sub-units.  */
3593   gcc_assert (elem_bitsize % BITS_PER_UNIT == 0);
3594
3595   for (elem = 0; elem < num_elem; elem++)
3596     {
3597       unsigned char * vp;
3598       rtx el = elems[elem];
3599
3600       /* Vectors are kept in target memory order.  (This is probably
3601          a mistake.)  */
3602       {
3603         unsigned byte = (elem * elem_bitsize) / BITS_PER_UNIT;
3604         unsigned ibyte = (((num_elem - 1 - elem) * elem_bitsize)
3605                           / BITS_PER_UNIT);
3606         unsigned word_byte = WORDS_BIG_ENDIAN ? ibyte : byte;
3607         unsigned subword_byte = BYTES_BIG_ENDIAN ? ibyte : byte;
3608         unsigned bytele = (subword_byte % UNITS_PER_WORD
3609                          + (word_byte / UNITS_PER_WORD) * UNITS_PER_WORD);
3610         vp = value + (bytele * BITS_PER_UNIT) / value_bit;
3611       }
3612
3613       switch (GET_CODE (el))
3614         {
3615         case CONST_INT:
3616           for (i = 0;
3617                i < HOST_BITS_PER_WIDE_INT && i < elem_bitsize;
3618                i += value_bit)
3619             *vp++ = INTVAL (el) >> i;
3620           /* CONST_INTs are always logically sign-extended.  */
3621           for (; i < elem_bitsize; i += value_bit)
3622             *vp++ = INTVAL (el) < 0 ? -1 : 0;
3623           break;
3624
3625         case CONST_DOUBLE:
3626           if (GET_MODE (el) == VOIDmode)
3627             {
3628               /* If this triggers, someone should have generated a
3629                  CONST_INT instead.  */
3630               gcc_assert (elem_bitsize > HOST_BITS_PER_WIDE_INT);
3631
3632               for (i = 0; i < HOST_BITS_PER_WIDE_INT; i += value_bit)
3633                 *vp++ = CONST_DOUBLE_LOW (el) >> i;
3634               while (i < HOST_BITS_PER_WIDE_INT * 2 && i < elem_bitsize)
3635                 {
3636                   *vp++
3637                     = CONST_DOUBLE_HIGH (el) >> (i - HOST_BITS_PER_WIDE_INT);
3638                   i += value_bit;
3639                 }
3640               /* It shouldn't matter what's done here, so fill it with
3641                  zero.  */
3642               for (; i < elem_bitsize; i += value_bit)
3643                 *vp++ = 0;
3644             }
3645           else
3646             {
3647               long tmp[max_bitsize / 32];
3648               int bitsize = GET_MODE_BITSIZE (GET_MODE (el));
3649
3650               gcc_assert (SCALAR_FLOAT_MODE_P (GET_MODE (el)));
3651               gcc_assert (bitsize <= elem_bitsize);
3652               gcc_assert (bitsize % value_bit == 0);
3653
3654               real_to_target (tmp, CONST_DOUBLE_REAL_VALUE (el),
3655                               GET_MODE (el));
3656
3657               /* real_to_target produces its result in words affected by
3658                  FLOAT_WORDS_BIG_ENDIAN.  However, we ignore this,
3659                  and use WORDS_BIG_ENDIAN instead; see the documentation
3660                  of SUBREG in rtl.texi.  */
3661               for (i = 0; i < bitsize; i += value_bit)
3662                 {
3663                   int ibase;
3664                   if (WORDS_BIG_ENDIAN)
3665                     ibase = bitsize - 1 - i;
3666                   else
3667                     ibase = i;
3668                   *vp++ = tmp[ibase / 32] >> i % 32;
3669                 }
3670
3671               /* It shouldn't matter what's done here, so fill it with
3672                  zero.  */
3673               for (; i < elem_bitsize; i += value_bit)
3674                 *vp++ = 0;
3675             }
3676           break;
3677
3678         default:
3679           gcc_unreachable ();
3680         }
3681     }
3682
3683   /* Now, pick the right byte to start with.  */
3684   /* Renumber BYTE so that the least-significant byte is byte 0.  A special
3685      case is paradoxical SUBREGs, which shouldn't be adjusted since they
3686      will already have offset 0.  */
3687   if (GET_MODE_SIZE (innermode) >= GET_MODE_SIZE (outermode))
3688     {
3689       unsigned ibyte = (GET_MODE_SIZE (innermode) - GET_MODE_SIZE (outermode)
3690                         - byte);
3691       unsigned word_byte = WORDS_BIG_ENDIAN ? ibyte : byte;
3692       unsigned subword_byte = BYTES_BIG_ENDIAN ? ibyte : byte;
3693       byte = (subword_byte % UNITS_PER_WORD
3694               + (word_byte / UNITS_PER_WORD) * UNITS_PER_WORD);
3695     }
3696
3697   /* BYTE should still be inside OP.  (Note that BYTE is unsigned,
3698      so if it's become negative it will instead be very large.)  */
3699   gcc_assert (byte < GET_MODE_SIZE (innermode));
3700
3701   /* Convert from bytes to chunks of size value_bit.  */
3702   value_start = byte * (BITS_PER_UNIT / value_bit);
3703
3704   /* Re-pack the value.  */
3705
3706   if (VECTOR_MODE_P (outermode))
3707     {
3708       num_elem = GET_MODE_NUNITS (outermode);
3709       result_v = rtvec_alloc (num_elem);
3710       elems = &RTVEC_ELT (result_v, 0);
3711       outer_submode = GET_MODE_INNER (outermode);
3712     }
3713   else
3714     {
3715       num_elem = 1;
3716       elems = &result_s;
3717       outer_submode = outermode;
3718     }
3719
3720   outer_class = GET_MODE_CLASS (outer_submode);
3721   elem_bitsize = GET_MODE_BITSIZE (outer_submode);
3722
3723   gcc_assert (elem_bitsize % value_bit == 0);
3724   gcc_assert (elem_bitsize + value_start * value_bit <= max_bitsize);
3725
3726   for (elem = 0; elem < num_elem; elem++)
3727     {
3728       unsigned char *vp;
3729
3730       /* Vectors are stored in target memory order.  (This is probably
3731          a mistake.)  */
3732       {
3733         unsigned byte = (elem * elem_bitsize) / BITS_PER_UNIT;
3734         unsigned ibyte = (((num_elem - 1 - elem) * elem_bitsize)
3735                           / BITS_PER_UNIT);
3736         unsigned word_byte = WORDS_BIG_ENDIAN ? ibyte : byte;
3737         unsigned subword_byte = BYTES_BIG_ENDIAN ? ibyte : byte;
3738         unsigned bytele = (subword_byte % UNITS_PER_WORD
3739                          + (word_byte / UNITS_PER_WORD) * UNITS_PER_WORD);
3740         vp = value + value_start + (bytele * BITS_PER_UNIT) / value_bit;
3741       }
3742
3743       switch (outer_class)
3744         {
3745         case MODE_INT:
3746         case MODE_PARTIAL_INT:
3747           {
3748             unsigned HOST_WIDE_INT hi = 0, lo = 0;
3749
3750             for (i = 0;
3751                  i < HOST_BITS_PER_WIDE_INT && i < elem_bitsize;
3752                  i += value_bit)
3753               lo |= (HOST_WIDE_INT)(*vp++ & value_mask) << i;
3754             for (; i < elem_bitsize; i += value_bit)
3755               hi |= ((HOST_WIDE_INT)(*vp++ & value_mask)
3756                      << (i - HOST_BITS_PER_WIDE_INT));
3757
3758             /* immed_double_const doesn't call trunc_int_for_mode.  I don't
3759                know why.  */
3760             if (elem_bitsize <= HOST_BITS_PER_WIDE_INT)
3761               elems[elem] = gen_int_mode (lo, outer_submode);
3762             else if (elem_bitsize <= 2 * HOST_BITS_PER_WIDE_INT)
3763               elems[elem] = immed_double_const (lo, hi, outer_submode);
3764             else
3765               return NULL_RTX;
3766           }
3767           break;
3768
3769         case MODE_FLOAT:
3770           {
3771             REAL_VALUE_TYPE r;
3772             long tmp[max_bitsize / 32];
3773
3774             /* real_from_target wants its input in words affected by
3775                FLOAT_WORDS_BIG_ENDIAN.  However, we ignore this,
3776                and use WORDS_BIG_ENDIAN instead; see the documentation
3777                of SUBREG in rtl.texi.  */
3778             for (i = 0; i < max_bitsize / 32; i++)
3779               tmp[i] = 0;
3780             for (i = 0; i < elem_bitsize; i += value_bit)
3781               {
3782                 int ibase;
3783                 if (WORDS_BIG_ENDIAN)
3784                   ibase = elem_bitsize - 1 - i;
3785                 else
3786                   ibase = i;
3787                 tmp[ibase / 32] |= (*vp++ & value_mask) << i % 32;
3788               }
3789
3790             real_from_target (&r, tmp, outer_submode);
3791             elems[elem] = CONST_DOUBLE_FROM_REAL_VALUE (r, outer_submode);
3792           }
3793           break;
3794
3795         default:
3796           gcc_unreachable ();
3797         }
3798     }
3799   if (VECTOR_MODE_P (outermode))
3800     return gen_rtx_CONST_VECTOR (outermode, result_v);
3801   else
3802     return result_s;
3803 }
3804
3805 /* Simplify SUBREG:OUTERMODE(OP:INNERMODE, BYTE)
3806    Return 0 if no simplifications are possible.  */
3807 rtx
3808 simplify_subreg (enum machine_mode outermode, rtx op,
3809                  enum machine_mode innermode, unsigned int byte)
3810 {
3811   /* Little bit of sanity checking.  */
3812   gcc_assert (innermode != VOIDmode);
3813   gcc_assert (outermode != VOIDmode);
3814   gcc_assert (innermode != BLKmode);
3815   gcc_assert (outermode != BLKmode);
3816
3817   gcc_assert (GET_MODE (op) == innermode
3818               || GET_MODE (op) == VOIDmode);
3819
3820   gcc_assert ((byte % GET_MODE_SIZE (outermode)) == 0);
3821   gcc_assert (byte < GET_MODE_SIZE (innermode));
3822
3823   if (outermode == innermode && !byte)
3824     return op;
3825
3826   if (GET_CODE (op) == CONST_INT
3827       || GET_CODE (op) == CONST_DOUBLE
3828       || GET_CODE (op) == CONST_VECTOR)
3829     return simplify_immed_subreg (outermode, op, innermode, byte);
3830
3831   /* Changing mode twice with SUBREG => just change it once,
3832      or not at all if changing back op starting mode.  */
3833   if (GET_CODE (op) == SUBREG)
3834     {
3835       enum machine_mode innermostmode = GET_MODE (SUBREG_REG (op));
3836       int final_offset = byte + SUBREG_BYTE (op);
3837       rtx newx;
3838
3839       if (outermode == innermostmode
3840           && byte == 0 && SUBREG_BYTE (op) == 0)
3841         return SUBREG_REG (op);
3842
3843       /* The SUBREG_BYTE represents offset, as if the value were stored
3844          in memory.  Irritating exception is paradoxical subreg, where
3845          we define SUBREG_BYTE to be 0.  On big endian machines, this
3846          value should be negative.  For a moment, undo this exception.  */
3847       if (byte == 0 && GET_MODE_SIZE (innermode) < GET_MODE_SIZE (outermode))
3848         {
3849           int difference = (GET_MODE_SIZE (innermode) - GET_MODE_SIZE (outermode));
3850           if (WORDS_BIG_ENDIAN)
3851             final_offset += (difference / UNITS_PER_WORD) * UNITS_PER_WORD;
3852           if (BYTES_BIG_ENDIAN)
3853             final_offset += difference % UNITS_PER_WORD;
3854         }
3855       if (SUBREG_BYTE (op) == 0
3856           && GET_MODE_SIZE (innermostmode) < GET_MODE_SIZE (innermode))
3857         {
3858           int difference = (GET_MODE_SIZE (innermostmode) - GET_MODE_SIZE (innermode));
3859           if (WORDS_BIG_ENDIAN)
3860             final_offset += (difference / UNITS_PER_WORD) * UNITS_PER_WORD;
3861           if (BYTES_BIG_ENDIAN)
3862             final_offset += difference % UNITS_PER_WORD;
3863         }
3864
3865       /* See whether resulting subreg will be paradoxical.  */
3866       if (GET_MODE_SIZE (innermostmode) > GET_MODE_SIZE (outermode))
3867         {
3868           /* In nonparadoxical subregs we can't handle negative offsets.  */
3869           if (final_offset < 0)
3870             return NULL_RTX;
3871           /* Bail out in case resulting subreg would be incorrect.  */
3872           if (final_offset % GET_MODE_SIZE (outermode)
3873               || (unsigned) final_offset >= GET_MODE_SIZE (innermostmode))
3874             return NULL_RTX;
3875         }
3876       else
3877         {
3878           int offset = 0;
3879           int difference = (GET_MODE_SIZE (innermostmode) - GET_MODE_SIZE (outermode));
3880
3881           /* In paradoxical subreg, see if we are still looking on lower part.
3882              If so, our SUBREG_BYTE will be 0.  */
3883           if (WORDS_BIG_ENDIAN)
3884             offset += (difference / UNITS_PER_WORD) * UNITS_PER_WORD;
3885           if (BYTES_BIG_ENDIAN)
3886             offset += difference % UNITS_PER_WORD;
3887           if (offset == final_offset)
3888             final_offset = 0;
3889           else
3890             return NULL_RTX;
3891         }
3892
3893       /* Recurse for further possible simplifications.  */
3894       newx = simplify_subreg (outermode, SUBREG_REG (op), innermostmode,
3895                               final_offset);
3896       if (newx)
3897         return newx;
3898       if (validate_subreg (outermode, innermostmode,
3899                            SUBREG_REG (op), final_offset))
3900         return gen_rtx_SUBREG (outermode, SUBREG_REG (op), final_offset);
3901       return NULL_RTX;
3902     }
3903
3904   /* SUBREG of a hard register => just change the register number
3905      and/or mode.  If the hard register is not valid in that mode,
3906      suppress this simplification.  If the hard register is the stack,
3907      frame, or argument pointer, leave this as a SUBREG.  */
3908
3909   if (REG_P (op)
3910       && REGNO (op) < FIRST_PSEUDO_REGISTER
3911 #ifdef CANNOT_CHANGE_MODE_CLASS
3912       && ! (REG_CANNOT_CHANGE_MODE_P (REGNO (op), innermode, outermode)
3913             && GET_MODE_CLASS (innermode) != MODE_COMPLEX_INT
3914             && GET_MODE_CLASS (innermode) != MODE_COMPLEX_FLOAT)
3915 #endif
3916       && ((reload_completed && !frame_pointer_needed)
3917           || (REGNO (op) != FRAME_POINTER_REGNUM
3918 #if HARD_FRAME_POINTER_REGNUM != FRAME_POINTER_REGNUM
3919               && REGNO (op) != HARD_FRAME_POINTER_REGNUM
3920 #endif
3921              ))
3922 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
3923       && REGNO (op) != ARG_POINTER_REGNUM
3924 #endif
3925       && REGNO (op) != STACK_POINTER_REGNUM
3926       && subreg_offset_representable_p (REGNO (op), innermode,
3927                                         byte, outermode))
3928     {
3929       unsigned int regno = REGNO (op);
3930       unsigned int final_regno
3931         = regno + subreg_regno_offset (regno, innermode, byte, outermode);
3932
3933       /* ??? We do allow it if the current REG is not valid for
3934          its mode.  This is a kludge to work around how float/complex
3935          arguments are passed on 32-bit SPARC and should be fixed.  */
3936       if (HARD_REGNO_MODE_OK (final_regno, outermode)
3937           || ! HARD_REGNO_MODE_OK (regno, innermode))
3938         {
3939           rtx x = gen_rtx_REG_offset (op, outermode, final_regno, byte);
3940
3941           /* Propagate original regno.  We don't have any way to specify
3942              the offset inside original regno, so do so only for lowpart.
3943              The information is used only by alias analysis that can not
3944              grog partial register anyway.  */
3945
3946           if (subreg_lowpart_offset (outermode, innermode) == byte)
3947             ORIGINAL_REGNO (x) = ORIGINAL_REGNO (op);
3948           return x;
3949         }
3950     }
3951
3952   /* If we have a SUBREG of a register that we are replacing and we are
3953      replacing it with a MEM, make a new MEM and try replacing the
3954      SUBREG with it.  Don't do this if the MEM has a mode-dependent address
3955      or if we would be widening it.  */
3956
3957   if (MEM_P (op)
3958       && ! mode_dependent_address_p (XEXP (op, 0))
3959       /* Allow splitting of volatile memory references in case we don't
3960          have instruction to move the whole thing.  */
3961       && (! MEM_VOLATILE_P (op)
3962           || ! have_insn_for (SET, innermode))
3963       && GET_MODE_SIZE (outermode) <= GET_MODE_SIZE (GET_MODE (op)))
3964     return adjust_address_nv (op, outermode, byte);
3965
3966   /* Handle complex values represented as CONCAT
3967      of real and imaginary part.  */
3968   if (GET_CODE (op) == CONCAT)
3969     {
3970       unsigned int inner_size, final_offset;
3971       rtx part, res;
3972
3973       inner_size = GET_MODE_UNIT_SIZE (innermode);
3974       part = byte < inner_size ? XEXP (op, 0) : XEXP (op, 1);
3975       final_offset = byte % inner_size;
3976       if (final_offset + GET_MODE_SIZE (outermode) > inner_size)
3977         return NULL_RTX;
3978
3979       res = simplify_subreg (outermode, part, GET_MODE (part), final_offset);
3980       if (res)
3981         return res;
3982       if (validate_subreg (outermode, GET_MODE (part), part, final_offset))
3983         return gen_rtx_SUBREG (outermode, part, final_offset);
3984       return NULL_RTX;
3985     }
3986
3987   /* Optimize SUBREG truncations of zero and sign extended values.  */
3988   if ((GET_CODE (op) == ZERO_EXTEND
3989        || GET_CODE (op) == SIGN_EXTEND)
3990       && GET_MODE_BITSIZE (outermode) < GET_MODE_BITSIZE (innermode))
3991     {
3992       unsigned int bitpos = subreg_lsb_1 (outermode, innermode, byte);
3993
3994       /* If we're requesting the lowpart of a zero or sign extension,
3995          there are three possibilities.  If the outermode is the same
3996          as the origmode, we can omit both the extension and the subreg.
3997          If the outermode is not larger than the origmode, we can apply
3998          the truncation without the extension.  Finally, if the outermode
3999          is larger than the origmode, but both are integer modes, we
4000          can just extend to the appropriate mode.  */
4001       if (bitpos == 0)
4002         {
4003           enum machine_mode origmode = GET_MODE (XEXP (op, 0));
4004           if (outermode == origmode)
4005             return XEXP (op, 0);
4006           if (GET_MODE_BITSIZE (outermode) <= GET_MODE_BITSIZE (origmode))
4007             return simplify_gen_subreg (outermode, XEXP (op, 0), origmode,
4008                                         subreg_lowpart_offset (outermode,
4009                                                                origmode));
4010           if (SCALAR_INT_MODE_P (outermode))
4011             return simplify_gen_unary (GET_CODE (op), outermode,
4012                                        XEXP (op, 0), origmode);
4013         }
4014
4015       /* A SUBREG resulting from a zero extension may fold to zero if
4016          it extracts higher bits that the ZERO_EXTEND's source bits.  */
4017       if (GET_CODE (op) == ZERO_EXTEND
4018           && bitpos >= GET_MODE_BITSIZE (GET_MODE (XEXP (op, 0))))
4019         return CONST0_RTX (outermode);
4020     }
4021
4022   /* Simplify (subreg:QI (lshiftrt:SI (sign_extend:SI (x:QI)) C), 0) into
4023      to (ashiftrt:QI (x:QI) C), where C is a suitable small constant and
4024      the outer subreg is effectively a truncation to the original mode.  */
4025   if ((GET_CODE (op) == LSHIFTRT
4026        || GET_CODE (op) == ASHIFTRT)
4027       && SCALAR_INT_MODE_P (outermode)
4028       /* Ensure that OUTERMODE is at least twice as wide as the INNERMODE
4029          to avoid the possibility that an outer LSHIFTRT shifts by more
4030          than the sign extension's sign_bit_copies and introduces zeros
4031          into the high bits of the result.  */
4032       && (2 * GET_MODE_BITSIZE (outermode)) <= GET_MODE_BITSIZE (innermode)
4033       && GET_CODE (XEXP (op, 1)) == CONST_INT
4034       && GET_CODE (XEXP (op, 0)) == SIGN_EXTEND
4035       && GET_MODE (XEXP (XEXP (op, 0), 0)) == outermode
4036       && INTVAL (XEXP (op, 1)) < GET_MODE_BITSIZE (outermode)
4037       && subreg_lsb_1 (outermode, innermode, byte) == 0)
4038     return simplify_gen_binary (ASHIFTRT, outermode,
4039                                 XEXP (XEXP (op, 0), 0), XEXP (op, 1));
4040
4041   /* Likewise (subreg:QI (lshiftrt:SI (zero_extend:SI (x:QI)) C), 0) into
4042      to (lshiftrt:QI (x:QI) C), where C is a suitable small constant and
4043      the outer subreg is effectively a truncation to the original mode.  */
4044   if ((GET_CODE (op) == LSHIFTRT
4045        || GET_CODE (op) == ASHIFTRT)
4046       && SCALAR_INT_MODE_P (outermode)
4047       && GET_MODE_BITSIZE (outermode) < GET_MODE_BITSIZE (innermode)
4048       && GET_CODE (XEXP (op, 1)) == CONST_INT
4049       && GET_CODE (XEXP (op, 0)) == ZERO_EXTEND
4050       && GET_MODE (XEXP (XEXP (op, 0), 0)) == outermode
4051       && INTVAL (XEXP (op, 1)) < GET_MODE_BITSIZE (outermode)
4052       && subreg_lsb_1 (outermode, innermode, byte) == 0)
4053     return simplify_gen_binary (LSHIFTRT, outermode,
4054                                 XEXP (XEXP (op, 0), 0), XEXP (op, 1));
4055
4056   /* Likewise (subreg:QI (ashift:SI (zero_extend:SI (x:QI)) C), 0) into
4057      to (ashift:QI (x:QI) C), where C is a suitable small constant and
4058      the outer subreg is effectively a truncation to the original mode.  */
4059   if (GET_CODE (op) == ASHIFT
4060       && SCALAR_INT_MODE_P (outermode)
4061       && GET_MODE_BITSIZE (outermode) < GET_MODE_BITSIZE (innermode)
4062       && GET_CODE (XEXP (op, 1)) == CONST_INT
4063       && (GET_CODE (XEXP (op, 0)) == ZERO_EXTEND
4064           || GET_CODE (XEXP (op, 0)) == SIGN_EXTEND)
4065       && GET_MODE (XEXP (XEXP (op, 0), 0)) == outermode
4066       && INTVAL (XEXP (op, 1)) < GET_MODE_BITSIZE (outermode)
4067       && subreg_lsb_1 (outermode, innermode, byte) == 0)
4068     return simplify_gen_binary (ASHIFT, outermode,
4069                                 XEXP (XEXP (op, 0), 0), XEXP (op, 1));
4070
4071   return NULL_RTX;
4072 }
4073
4074 /* Make a SUBREG operation or equivalent if it folds.  */
4075
4076 rtx
4077 simplify_gen_subreg (enum machine_mode outermode, rtx op,
4078                      enum machine_mode innermode, unsigned int byte)
4079 {
4080   rtx newx;
4081
4082   newx = simplify_subreg (outermode, op, innermode, byte);
4083   if (newx)
4084     return newx;
4085
4086   if (GET_CODE (op) == SUBREG
4087       || GET_CODE (op) == CONCAT
4088       || GET_MODE (op) == VOIDmode)
4089     return NULL_RTX;
4090
4091   if (validate_subreg (outermode, innermode, op, byte))
4092     return gen_rtx_SUBREG (outermode, op, byte);
4093
4094   return NULL_RTX;
4095 }
4096
4097 /* Simplify X, an rtx expression.
4098
4099    Return the simplified expression or NULL if no simplifications
4100    were possible.
4101
4102    This is the preferred entry point into the simplification routines;
4103    however, we still allow passes to call the more specific routines.
4104
4105    Right now GCC has three (yes, three) major bodies of RTL simplification
4106    code that need to be unified.
4107
4108         1. fold_rtx in cse.c.  This code uses various CSE specific
4109            information to aid in RTL simplification.
4110
4111         2. simplify_rtx in combine.c.  Similar to fold_rtx, except that
4112            it uses combine specific information to aid in RTL
4113            simplification.
4114
4115         3. The routines in this file.
4116
4117
4118    Long term we want to only have one body of simplification code; to
4119    get to that state I recommend the following steps:
4120
4121         1. Pour over fold_rtx & simplify_rtx and move any simplifications
4122            which are not pass dependent state into these routines.
4123
4124         2. As code is moved by #1, change fold_rtx & simplify_rtx to
4125            use this routine whenever possible.
4126
4127         3. Allow for pass dependent state to be provided to these
4128            routines and add simplifications based on the pass dependent
4129            state.  Remove code from cse.c & combine.c that becomes
4130            redundant/dead.
4131
4132     It will take time, but ultimately the compiler will be easier to
4133     maintain and improve.  It's totally silly that when we add a
4134     simplification that it needs to be added to 4 places (3 for RTL
4135     simplification and 1 for tree simplification.  */
4136
4137 rtx
4138 simplify_rtx (rtx x)
4139 {
4140   enum rtx_code code = GET_CODE (x);
4141   enum machine_mode mode = GET_MODE (x);
4142
4143   switch (GET_RTX_CLASS (code))
4144     {
4145     case RTX_UNARY:
4146       return simplify_unary_operation (code, mode,
4147                                        XEXP (x, 0), GET_MODE (XEXP (x, 0)));
4148     case RTX_COMM_ARITH:
4149       if (swap_commutative_operands_p (XEXP (x, 0), XEXP (x, 1)))
4150         return simplify_gen_binary (code, mode, XEXP (x, 1), XEXP (x, 0));
4151
4152       /* Fall through....  */
4153
4154     case RTX_BIN_ARITH:
4155       return simplify_binary_operation (code, mode, XEXP (x, 0), XEXP (x, 1));
4156
4157     case RTX_TERNARY:
4158     case RTX_BITFIELD_OPS:
4159       return simplify_ternary_operation (code, mode, GET_MODE (XEXP (x, 0)),
4160                                          XEXP (x, 0), XEXP (x, 1),
4161                                          XEXP (x, 2));
4162
4163     case RTX_COMPARE:
4164     case RTX_COMM_COMPARE:
4165       return simplify_relational_operation (code, mode,
4166                                             ((GET_MODE (XEXP (x, 0))
4167                                              != VOIDmode)
4168                                             ? GET_MODE (XEXP (x, 0))
4169                                             : GET_MODE (XEXP (x, 1))),
4170                                             XEXP (x, 0),
4171                                             XEXP (x, 1));
4172
4173     case RTX_EXTRA:
4174       if (code == SUBREG)
4175         return simplify_gen_subreg (mode, SUBREG_REG (x),
4176                                     GET_MODE (SUBREG_REG (x)),
4177                                     SUBREG_BYTE (x));
4178       break;
4179
4180     case RTX_OBJ:
4181       if (code == LO_SUM)
4182         {
4183           /* Convert (lo_sum (high FOO) FOO) to FOO.  */
4184           if (GET_CODE (XEXP (x, 0)) == HIGH
4185               && rtx_equal_p (XEXP (XEXP (x, 0), 0), XEXP (x, 1)))
4186           return XEXP (x, 1);
4187         }
4188       break;
4189
4190     default:
4191       break;
4192     }
4193   return NULL;
4194 }