contrib/gcc-4.4/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, 2006, 2007, 2008
   4    Free Software Foundation, Inc.
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify it under
   9 the terms of the GNU General Public License as published by the Free
  10 Software Foundation; either version 3, or (at your option) any later
  11 version.
  12
  13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16 for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING3.  If not see
  20 <http://www.gnu.org/licenses/>.  */
  21
  22
  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, const_rtx);
  53 static bool plus_minus_operand_p (const_rtx);
  54 static bool simplify_plus_minus_op_data_cmp (rtx, rtx);
  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, const_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, const_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   /* If this simplifies, do it.  */
 118   tem = simplify_binary_operation (code, mode, op0, op1);
 119   if (tem)
 120     return tem;
 121
 122   /* Put complex operands first and constants second if commutative.  */
 123   if (GET_RTX_CLASS (code) == RTX_COMM_ARITH
 124       && swap_commutative_operands_p (op0, op1))
 125     tem = op0, op0 = op1, op1 = 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   if (GET_MODE (x) == BLKmode)
 162     return x;
 163
 164   addr = XEXP (x, 0);
 165
 166   /* Call target hook to avoid the effects of -fpic etc....  */
 167   addr = targetm.delegitimize_address (addr);
 168
 169   /* Split the address into a base and integer offset.  */
 170   if (GET_CODE (addr) == CONST
 171       && GET_CODE (XEXP (addr, 0)) == PLUS
 172       && GET_CODE (XEXP (XEXP (addr, 0), 1)) == CONST_INT)
 173     {
 174       offset = INTVAL (XEXP (XEXP (addr, 0), 1));
 175       addr = XEXP (XEXP (addr, 0), 0);
 176     }
 177
 178   if (GET_CODE (addr) == LO_SUM)
 179     addr = XEXP (addr, 1);
 180
 181   /* If this is a constant pool reference, we can turn it into its
 182      constant and hope that simplifications happen.  */
 183   if (GET_CODE (addr) == SYMBOL_REF
 184       && CONSTANT_POOL_ADDRESS_P (addr))
 185     {
 186       c = get_pool_constant (addr);
 187       cmode = get_pool_mode (addr);
 188
 189       /* If we're accessing the constant in a different mode than it was
 190          originally stored, attempt to fix that up via subreg simplifications.
 191          If that fails we have no choice but to return the original memory.  */
 192       if (offset != 0 || cmode != GET_MODE (x))
 193         {
 194           rtx tem = simplify_subreg (GET_MODE (x), c, cmode, offset);
 195           if (tem && CONSTANT_P (tem))
 196             return tem;
 197         }
 198       else
 199         return c;
 200     }
 201
 202   return x;
 203 }
 204 \f
 205 /* Make a unary operation by first seeing if it folds and otherwise making
 206    the specified operation.  */
 207
 208 rtx
 209 simplify_gen_unary (enum rtx_code code, enum machine_mode mode, rtx op,
 210                     enum machine_mode op_mode)
 211 {
 212   rtx tem;
 213
 214   /* If this simplifies, use it.  */
 215   if ((tem = simplify_unary_operation (code, mode, op, op_mode)) != 0)
 216     return tem;
 217
 218   return gen_rtx_fmt_e (code, mode, op);
 219 }
 220
 221 /* Likewise for ternary operations.  */
 222
 223 rtx
 224 simplify_gen_ternary (enum rtx_code code, enum machine_mode mode,
 225                       enum machine_mode op0_mode, rtx op0, rtx op1, rtx op2)
 226 {
 227   rtx tem;
 228
 229   /* If this simplifies, use it.  */
 230   if (0 != (tem = simplify_ternary_operation (code, mode, op0_mode,
 231                                               op0, op1, op2)))
 232     return tem;
 233
 234   return gen_rtx_fmt_eee (code, mode, op0, op1, op2);
 235 }
 236
 237 /* Likewise, for relational operations.
 238    CMP_MODE specifies mode comparison is done in.  */
 239
 240 rtx
 241 simplify_gen_relational (enum rtx_code code, enum machine_mode mode,
 242                          enum machine_mode cmp_mode, rtx op0, rtx op1)
 243 {
 244   rtx tem;
 245
 246   if (0 != (tem = simplify_relational_operation (code, mode, cmp_mode,
 247                                                  op0, op1)))
 248     return tem;
 249
 250   return gen_rtx_fmt_ee (code, mode, op0, op1);
 251 }
 252 \f
 253 /* Replace all occurrences of OLD_RTX in X with NEW_RTX and try to simplify the
 254    resulting RTX.  Return a new RTX which is as simplified as possible.  */
 255
 256 rtx
 257 simplify_replace_rtx (rtx x, const_rtx old_rtx, rtx new_rtx)
 258 {
 259   enum rtx_code code = GET_CODE (x);
 260   enum machine_mode mode = GET_MODE (x);
 261   enum machine_mode op_mode;
 262   rtx op0, op1, op2;
 263
 264   /* If X is OLD_RTX, return NEW_RTX.  Otherwise, if this is an expression, try
 265      to build a new expression substituting recursively.  If we can't do
 266      anything, return our input.  */
 267
 268   if (x == old_rtx)
 269     return new_rtx;
 270
 271   switch (GET_RTX_CLASS (code))
 272     {
 273     case RTX_UNARY:
 274       op0 = XEXP (x, 0);
 275       op_mode = GET_MODE (op0);
 276       op0 = simplify_replace_rtx (op0, old_rtx, new_rtx);
 277       if (op0 == XEXP (x, 0))
 278         return x;
 279       return simplify_gen_unary (code, mode, op0, op_mode);
 280
 281     case RTX_BIN_ARITH:
 282     case RTX_COMM_ARITH:
 283       op0 = simplify_replace_rtx (XEXP (x, 0), old_rtx, new_rtx);
 284       op1 = simplify_replace_rtx (XEXP (x, 1), old_rtx, new_rtx);
 285       if (op0 == XEXP (x, 0) && op1 == XEXP (x, 1))
 286         return x;
 287       return simplify_gen_binary (code, mode, op0, op1);
 288
 289     case RTX_COMPARE:
 290     case RTX_COMM_COMPARE:
 291       op0 = XEXP (x, 0);
 292       op1 = XEXP (x, 1);
 293       op_mode = GET_MODE (op0) != VOIDmode ? GET_MODE (op0) : GET_MODE (op1);
 294       op0 = simplify_replace_rtx (op0, old_rtx, new_rtx);
 295       op1 = simplify_replace_rtx (op1, old_rtx, new_rtx);
 296       if (op0 == XEXP (x, 0) && op1 == XEXP (x, 1))
 297         return x;
 298       return simplify_gen_relational (code, mode, op_mode, op0, op1);
 299
 300     case RTX_TERNARY:
 301     case RTX_BITFIELD_OPS:
 302       op0 = XEXP (x, 0);
 303       op_mode = GET_MODE (op0);
 304       op0 = simplify_replace_rtx (op0, old_rtx, new_rtx);
 305       op1 = simplify_replace_rtx (XEXP (x, 1), old_rtx, new_rtx);
 306       op2 = simplify_replace_rtx (XEXP (x, 2), old_rtx, new_rtx);
 307       if (op0 == XEXP (x, 0) && op1 == XEXP (x, 1) && op2 == XEXP (x, 2))
 308         return x;
 309       if (op_mode == VOIDmode)
 310         op_mode = GET_MODE (op0);
 311       return simplify_gen_ternary (code, mode, op_mode, op0, op1, op2);
 312
 313     case RTX_EXTRA:
 314       /* The only case we try to handle is a SUBREG.  */
 315       if (code == SUBREG)
 316         {
 317           op0 = simplify_replace_rtx (SUBREG_REG (x), old_rtx, new_rtx);
 318           if (op0 == SUBREG_REG (x))
 319             return x;
 320           op0 = simplify_gen_subreg (GET_MODE (x), op0,
 321                                      GET_MODE (SUBREG_REG (x)),
 322                                      SUBREG_BYTE (x));
 323           return op0 ? op0 : x;
 324         }
 325       break;
 326
 327     case RTX_OBJ:
 328       if (code == MEM)
 329         {
 330           op0 = simplify_replace_rtx (XEXP (x, 0), old_rtx, new_rtx);
 331           if (op0 == XEXP (x, 0))
 332             return x;
 333           return replace_equiv_address_nv (x, op0);
 334         }
 335       else if (code == LO_SUM)
 336         {
 337           op0 = simplify_replace_rtx (XEXP (x, 0), old_rtx, new_rtx);
 338           op1 = simplify_replace_rtx (XEXP (x, 1), old_rtx, new_rtx);
 339
 340           /* (lo_sum (high x) x) -> x  */
 341           if (GET_CODE (op0) == HIGH && rtx_equal_p (XEXP (op0, 0), op1))
 342             return op1;
 343
 344           if (op0 == XEXP (x, 0) && op1 == XEXP (x, 1))
 345             return x;
 346           return gen_rtx_LO_SUM (mode, op0, op1);
 347         }
 348       else if (code == REG)
 349         {
 350           if (rtx_equal_p (x, old_rtx))
 351             return new_rtx;
 352         }
 353       break;
 354
 355     default:
 356       break;
 357     }
 358   return x;
 359 }
 360 \f
 361 /* Try to simplify a unary operation CODE whose output mode is to be
 362    MODE with input operand OP whose mode was originally OP_MODE.
 363    Return zero if no simplification can be made.  */
 364 rtx
 365 simplify_unary_operation (enum rtx_code code, enum machine_mode mode,
 366                           rtx op, enum machine_mode op_mode)
 367 {
 368   rtx trueop, tem;
 369
 370   if (GET_CODE (op) == CONST)
 371     op = XEXP (op, 0);
 372
 373   trueop = avoid_constant_pool_reference (op);
 374
 375   tem = simplify_const_unary_operation (code, mode, trueop, op_mode);
 376   if (tem)
 377     return tem;
 378
 379   return simplify_unary_operation_1 (code, mode, op);
 380 }
 381
 382 /* Perform some simplifications we can do even if the operands
 383    aren't constant.  */
 384 static rtx
 385 simplify_unary_operation_1 (enum rtx_code code, enum machine_mode mode, rtx op)
 386 {
 387   enum rtx_code reversed;
 388   rtx temp;
 389
 390   switch (code)
 391     {
 392     case NOT:
 393       /* (not (not X)) == X.  */
 394       if (GET_CODE (op) == NOT)
 395         return XEXP (op, 0);
 396
 397       /* (not (eq X Y)) == (ne X Y), etc. if BImode or the result of the
 398          comparison is all ones.   */
 399       if (COMPARISON_P (op)
 400           && (mode == BImode || STORE_FLAG_VALUE == -1)
 401           && ((reversed = reversed_comparison_code (op, NULL_RTX)) != UNKNOWN))
 402         return simplify_gen_relational (reversed, mode, VOIDmode,
 403                                         XEXP (op, 0), XEXP (op, 1));
 404
 405       /* (not (plus X -1)) can become (neg X).  */
 406       if (GET_CODE (op) == PLUS
 407           && XEXP (op, 1) == constm1_rtx)
 408         return simplify_gen_unary (NEG, mode, XEXP (op, 0), mode);
 409
 410       /* Similarly, (not (neg X)) is (plus X -1).  */
 411       if (GET_CODE (op) == NEG)
 412         return plus_constant (XEXP (op, 0), -1);
 413
 414       /* (not (xor X C)) for C constant is (xor X D) with D = ~C.  */
 415       if (GET_CODE (op) == XOR
 416           && GET_CODE (XEXP (op, 1)) == CONST_INT
 417           && (temp = simplify_unary_operation (NOT, mode,
 418                                                XEXP (op, 1), mode)) != 0)
 419         return simplify_gen_binary (XOR, mode, XEXP (op, 0), temp);
 420
 421       /* (not (plus X C)) for signbit C is (xor X D) with D = ~C.  */
 422       if (GET_CODE (op) == PLUS
 423           && GET_CODE (XEXP (op, 1)) == CONST_INT
 424           && mode_signbit_p (mode, XEXP (op, 1))
 425           && (temp = simplify_unary_operation (NOT, mode,
 426                                                XEXP (op, 1), mode)) != 0)
 427         return simplify_gen_binary (XOR, mode, XEXP (op, 0), temp);
 428
 429
 430       /* (not (ashift 1 X)) is (rotate ~1 X).  We used to do this for
 431          operands other than 1, but that is not valid.  We could do a
 432          similar simplification for (not (lshiftrt C X)) where C is
 433          just the sign bit, but this doesn't seem common enough to
 434          bother with.  */
 435       if (GET_CODE (op) == ASHIFT
 436           && XEXP (op, 0) == const1_rtx)
 437         {
 438           temp = simplify_gen_unary (NOT, mode, const1_rtx, mode);
 439           return simplify_gen_binary (ROTATE, mode, temp, XEXP (op, 1));
 440         }
 441
 442       /* (not (ashiftrt foo C)) where C is the number of bits in FOO
 443          minus 1 is (ge foo (const_int 0)) if STORE_FLAG_VALUE is -1,
 444          so we can perform the above simplification.  */
 445
 446       if (STORE_FLAG_VALUE == -1
 447           && GET_CODE (op) == ASHIFTRT
 448           && GET_CODE (XEXP (op, 1)) == CONST_INT
 449           && INTVAL (XEXP (op, 1)) == GET_MODE_BITSIZE (mode) - 1)
 450         return simplify_gen_relational (GE, mode, VOIDmode,
 451                                         XEXP (op, 0), const0_rtx);
 452
 453
 454       if (GET_CODE (op) == SUBREG
 455           && subreg_lowpart_p (op)
 456           && (GET_MODE_SIZE (GET_MODE (op))
 457               < GET_MODE_SIZE (GET_MODE (SUBREG_REG (op))))
 458           && GET_CODE (SUBREG_REG (op)) == ASHIFT
 459           && XEXP (SUBREG_REG (op), 0) == const1_rtx)
 460         {
 461           enum machine_mode inner_mode = GET_MODE (SUBREG_REG (op));
 462           rtx x;
 463
 464           x = gen_rtx_ROTATE (inner_mode,
 465                               simplify_gen_unary (NOT, inner_mode, const1_rtx,
 466                                                   inner_mode),
 467                               XEXP (SUBREG_REG (op), 1));
 468           return rtl_hooks.gen_lowpart_no_emit (mode, x);
 469         }
 470
 471       /* Apply De Morgan's laws to reduce number of patterns for machines
 472          with negating logical insns (and-not, nand, etc.).  If result has
 473          only one NOT, put it first, since that is how the patterns are
 474          coded.  */
 475
 476       if (GET_CODE (op) == IOR || GET_CODE (op) == AND)
 477         {
 478           rtx in1 = XEXP (op, 0), in2 = XEXP (op, 1);
 479           enum machine_mode op_mode;
 480
 481           op_mode = GET_MODE (in1);
 482           in1 = simplify_gen_unary (NOT, op_mode, in1, op_mode);
 483
 484           op_mode = GET_MODE (in2);
 485           if (op_mode == VOIDmode)
 486             op_mode = mode;
 487           in2 = simplify_gen_unary (NOT, op_mode, in2, op_mode);
 488
 489           if (GET_CODE (in2) == NOT && GET_CODE (in1) != NOT)
 490             {
 491               rtx tem = in2;
 492               in2 = in1; in1 = tem;
 493             }
 494
 495           return gen_rtx_fmt_ee (GET_CODE (op) == IOR ? AND : IOR,
 496                                  mode, in1, in2);
 497         }
 498       break;
 499
 500     case NEG:
 501       /* (neg (neg X)) == X.  */
 502       if (GET_CODE (op) == NEG)
 503         return XEXP (op, 0);
 504
 505       /* (neg (plus X 1)) can become (not X).  */
 506       if (GET_CODE (op) == PLUS
 507           && XEXP (op, 1) == const1_rtx)
 508         return simplify_gen_unary (NOT, mode, XEXP (op, 0), mode);
 509
 510       /* Similarly, (neg (not X)) is (plus X 1).  */
 511       if (GET_CODE (op) == NOT)
 512         return plus_constant (XEXP (op, 0), 1);
 513
 514       /* (neg (minus X Y)) can become (minus Y X).  This transformation
 515          isn't safe for modes with signed zeros, since if X and Y are
 516          both +0, (minus Y X) is the same as (minus X Y).  If the
 517          rounding mode is towards +infinity (or -infinity) then the two
 518          expressions will be rounded differently.  */
 519       if (GET_CODE (op) == MINUS
 520           && !HONOR_SIGNED_ZEROS (mode)
 521           && !HONOR_SIGN_DEPENDENT_ROUNDING (mode))
 522         return simplify_gen_binary (MINUS, mode, XEXP (op, 1), XEXP (op, 0));
 523
 524       if (GET_CODE (op) == PLUS
 525           && !HONOR_SIGNED_ZEROS (mode)
 526           && !HONOR_SIGN_DEPENDENT_ROUNDING (mode))
 527         {
 528           /* (neg (plus A C)) is simplified to (minus -C A).  */
 529           if (GET_CODE (XEXP (op, 1)) == CONST_INT
 530               || GET_CODE (XEXP (op, 1)) == CONST_DOUBLE)
 531             {
 532               temp = simplify_unary_operation (NEG, mode, XEXP (op, 1), mode);
 533               if (temp)
 534                 return simplify_gen_binary (MINUS, mode, temp, XEXP (op, 0));
 535             }
 536
 537           /* (neg (plus A B)) is canonicalized to (minus (neg A) B).  */
 538           temp = simplify_gen_unary (NEG, mode, XEXP (op, 0), mode);
 539           return simplify_gen_binary (MINUS, mode, temp, XEXP (op, 1));
 540         }
 541
 542       /* (neg (mult A B)) becomes (mult (neg A) B).
 543          This works even for floating-point values.  */
 544       if (GET_CODE (op) == MULT
 545           && !HONOR_SIGN_DEPENDENT_ROUNDING (mode))
 546         {
 547           temp = simplify_gen_unary (NEG, mode, XEXP (op, 0), mode);
 548           return simplify_gen_binary (MULT, mode, temp, XEXP (op, 1));
 549         }
 550
 551       /* NEG commutes with ASHIFT since it is multiplication.  Only do
 552          this if we can then eliminate the NEG (e.g., if the operand
 553          is a constant).  */
 554       if (GET_CODE (op) == ASHIFT)
 555         {
 556           temp = simplify_unary_operation (NEG, mode, XEXP (op, 0), mode);
 557           if (temp)
 558             return simplify_gen_binary (ASHIFT, mode, temp, XEXP (op, 1));
 559         }
 560
 561       /* (neg (ashiftrt X C)) can be replaced by (lshiftrt X C) when
 562          C is equal to the width of MODE minus 1.  */
 563       if (GET_CODE (op) == ASHIFTRT
 564           && GET_CODE (XEXP (op, 1)) == CONST_INT
 565           && INTVAL (XEXP (op, 1)) == GET_MODE_BITSIZE (mode) - 1)
 566         return simplify_gen_binary (LSHIFTRT, mode,
 567                                     XEXP (op, 0), XEXP (op, 1));
 568
 569       /* (neg (lshiftrt X C)) can be replaced by (ashiftrt X C) when
 570          C is equal to the width of MODE minus 1.  */
 571       if (GET_CODE (op) == LSHIFTRT
 572           && GET_CODE (XEXP (op, 1)) == CONST_INT
 573           && INTVAL (XEXP (op, 1)) == GET_MODE_BITSIZE (mode) - 1)
 574         return simplify_gen_binary (ASHIFTRT, mode,
 575                                     XEXP (op, 0), XEXP (op, 1));
 576
 577       /* (neg (xor A 1)) is (plus A -1) if A is known to be either 0 or 1.  */
 578       if (GET_CODE (op) == XOR
 579           && XEXP (op, 1) == const1_rtx
 580           && nonzero_bits (XEXP (op, 0), mode) == 1)
 581         return plus_constant (XEXP (op, 0), -1);
 582
 583       /* (neg (lt x 0)) is (ashiftrt X C) if STORE_FLAG_VALUE is 1.  */
 584       /* (neg (lt x 0)) is (lshiftrt X C) if STORE_FLAG_VALUE is -1.  */
 585       if (GET_CODE (op) == LT
 586           && XEXP (op, 1) == const0_rtx
 587           && SCALAR_INT_MODE_P (GET_MODE (XEXP (op, 0))))
 588         {
 589           enum machine_mode inner = GET_MODE (XEXP (op, 0));
 590           int isize = GET_MODE_BITSIZE (inner);
 591           if (STORE_FLAG_VALUE == 1)
 592             {
 593               temp = simplify_gen_binary (ASHIFTRT, inner, XEXP (op, 0),
 594                                           GEN_INT (isize - 1));
 595               if (mode == inner)
 596                 return temp;
 597               if (GET_MODE_BITSIZE (mode) > isize)
 598                 return simplify_gen_unary (SIGN_EXTEND, mode, temp, inner);
 599               return simplify_gen_unary (TRUNCATE, mode, temp, inner);
 600             }
 601           else if (STORE_FLAG_VALUE == -1)
 602             {
 603               temp = simplify_gen_binary (LSHIFTRT, inner, XEXP (op, 0),
 604                                           GEN_INT (isize - 1));
 605               if (mode == inner)
 606                 return temp;
 607               if (GET_MODE_BITSIZE (mode) > isize)
 608                 return simplify_gen_unary (ZERO_EXTEND, mode, temp, inner);
 609               return simplify_gen_unary (TRUNCATE, mode, temp, inner);
 610             }
 611         }
 612       break;
 613
 614     case TRUNCATE:
 615       /* We can't handle truncation to a partial integer mode here
 616          because we don't know the real bitsize of the partial
 617          integer mode.  */
 618       if (GET_MODE_CLASS (mode) == MODE_PARTIAL_INT)
 619         break;
 620
 621       /* (truncate:SI ({sign,zero}_extend:DI foo:SI)) == foo:SI.  */
 622       if ((GET_CODE (op) == SIGN_EXTEND
 623            || GET_CODE (op) == ZERO_EXTEND)
 624           && GET_MODE (XEXP (op, 0)) == mode)
 625         return XEXP (op, 0);
 626
 627       /* (truncate:SI (OP:DI ({sign,zero}_extend:DI foo:SI))) is
 628          (OP:SI foo:SI) if OP is NEG or ABS.  */
 629       if ((GET_CODE (op) == ABS
 630            || GET_CODE (op) == NEG)
 631           && (GET_CODE (XEXP (op, 0)) == SIGN_EXTEND
 632               || GET_CODE (XEXP (op, 0)) == ZERO_EXTEND)
 633           && GET_MODE (XEXP (XEXP (op, 0), 0)) == mode)
 634         return simplify_gen_unary (GET_CODE (op), mode,
 635                                    XEXP (XEXP (op, 0), 0), mode);
 636
 637       /* (truncate:A (subreg:B (truncate:C X) 0)) is
 638          (truncate:A X).  */
 639       if (GET_CODE (op) == SUBREG
 640           && GET_CODE (SUBREG_REG (op)) == TRUNCATE
 641           && subreg_lowpart_p (op))
 642         return simplify_gen_unary (TRUNCATE, mode, XEXP (SUBREG_REG (op), 0),
 643                                    GET_MODE (XEXP (SUBREG_REG (op), 0)));
 644
 645       /* If we know that the value is already truncated, we can
 646          replace the TRUNCATE with a SUBREG.  Note that this is also
 647          valid if TRULY_NOOP_TRUNCATION is false for the corresponding
 648          modes we just have to apply a different definition for
 649          truncation.  But don't do this for an (LSHIFTRT (MULT ...))
 650          since this will cause problems with the umulXi3_highpart
 651          patterns.  */
 652       if ((TRULY_NOOP_TRUNCATION (GET_MODE_BITSIZE (mode),
 653                                  GET_MODE_BITSIZE (GET_MODE (op)))
 654            ? (num_sign_bit_copies (op, GET_MODE (op))
 655               > (unsigned int) (GET_MODE_BITSIZE (GET_MODE (op))
 656                                 - GET_MODE_BITSIZE (mode)))
 657            : truncated_to_mode (mode, op))
 658           && ! (GET_CODE (op) == LSHIFTRT
 659                 && GET_CODE (XEXP (op, 0)) == MULT))
 660         return rtl_hooks.gen_lowpart_no_emit (mode, op);
 661
 662       /* A truncate of a comparison can be replaced with a subreg if
 663          STORE_FLAG_VALUE permits.  This is like the previous test,
 664          but it works even if the comparison is done in a mode larger
 665          than HOST_BITS_PER_WIDE_INT.  */
 666       if (GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
 667           && COMPARISON_P (op)
 668           && ((HOST_WIDE_INT) STORE_FLAG_VALUE & ~GET_MODE_MASK (mode)) == 0)
 669         return rtl_hooks.gen_lowpart_no_emit (mode, op);
 670       break;
 671
 672     case FLOAT_TRUNCATE:
 673       if (DECIMAL_FLOAT_MODE_P (mode))
 674         break;
 675
 676       /* (float_truncate:SF (float_extend:DF foo:SF)) = foo:SF.  */
 677       if (GET_CODE (op) == FLOAT_EXTEND
 678           && GET_MODE (XEXP (op, 0)) == mode)
 679         return XEXP (op, 0);
 680
 681       /* (float_truncate:SF (float_truncate:DF foo:XF))
 682          = (float_truncate:SF foo:XF).
 683          This may eliminate double rounding, so it is unsafe.
 684
 685          (float_truncate:SF (float_extend:XF foo:DF))
 686          = (float_truncate:SF foo:DF).
 687
 688          (float_truncate:DF (float_extend:XF foo:SF))
 689          = (float_extend:SF foo:DF).  */
 690       if ((GET_CODE (op) == FLOAT_TRUNCATE
 691            && flag_unsafe_math_optimizations)
 692           || GET_CODE (op) == FLOAT_EXTEND)
 693         return simplify_gen_unary (GET_MODE_SIZE (GET_MODE (XEXP (op,
 694                                                             0)))
 695                                    > GET_MODE_SIZE (mode)
 696                                    ? FLOAT_TRUNCATE : FLOAT_EXTEND,
 697                                    mode,
 698                                    XEXP (op, 0), mode);
 699
 700       /*  (float_truncate (float x)) is (float x)  */
 701       if (GET_CODE (op) == FLOAT
 702           && (flag_unsafe_math_optimizations
 703               || (SCALAR_FLOAT_MODE_P (GET_MODE (op))
 704                   && ((unsigned)significand_size (GET_MODE (op))
 705                       >= (GET_MODE_BITSIZE (GET_MODE (XEXP (op, 0)))
 706                           - num_sign_bit_copies (XEXP (op, 0),
 707                                                  GET_MODE (XEXP (op, 0))))))))
 708         return simplify_gen_unary (FLOAT, mode,
 709                                    XEXP (op, 0),
 710                                    GET_MODE (XEXP (op, 0)));
 711
 712       /* (float_truncate:SF (OP:DF (float_extend:DF foo:sf))) is
 713          (OP:SF foo:SF) if OP is NEG or ABS.  */
 714       if ((GET_CODE (op) == ABS
 715            || GET_CODE (op) == NEG)
 716           && GET_CODE (XEXP (op, 0)) == FLOAT_EXTEND
 717           && GET_MODE (XEXP (XEXP (op, 0), 0)) == mode)
 718         return simplify_gen_unary (GET_CODE (op), mode,
 719                                    XEXP (XEXP (op, 0), 0), mode);
 720
 721       /* (float_truncate:SF (subreg:DF (float_truncate:SF X) 0))
 722          is (float_truncate:SF x).  */
 723       if (GET_CODE (op) == SUBREG
 724           && subreg_lowpart_p (op)
 725           && GET_CODE (SUBREG_REG (op)) == FLOAT_TRUNCATE)
 726         return SUBREG_REG (op);
 727       break;
 728
 729     case FLOAT_EXTEND:
 730       if (DECIMAL_FLOAT_MODE_P (mode))
 731         break;
 732
 733       /*  (float_extend (float_extend x)) is (float_extend x)
 734
 735           (float_extend (float x)) is (float x) assuming that double
 736           rounding can't happen.
 737           */
 738       if (GET_CODE (op) == FLOAT_EXTEND
 739           || (GET_CODE (op) == FLOAT
 740               && SCALAR_FLOAT_MODE_P (GET_MODE (op))
 741               && ((unsigned)significand_size (GET_MODE (op))
 742                   >= (GET_MODE_BITSIZE (GET_MODE (XEXP (op, 0)))
 743                       - num_sign_bit_copies (XEXP (op, 0),
 744                                              GET_MODE (XEXP (op, 0)))))))
 745         return simplify_gen_unary (GET_CODE (op), mode,
 746                                    XEXP (op, 0),
 747                                    GET_MODE (XEXP (op, 0)));
 748
 749       break;
 750
 751     case ABS:
 752       /* (abs (neg <foo>)) -> (abs <foo>) */
 753       if (GET_CODE (op) == NEG)
 754         return simplify_gen_unary (ABS, mode, XEXP (op, 0),
 755                                    GET_MODE (XEXP (op, 0)));
 756
 757       /* If the mode of the operand is VOIDmode (i.e. if it is ASM_OPERANDS),
 758          do nothing.  */
 759       if (GET_MODE (op) == VOIDmode)
 760         break;
 761
 762       /* If operand is something known to be positive, ignore the ABS.  */
 763       if (GET_CODE (op) == FFS || GET_CODE (op) == ABS
 764           || ((GET_MODE_BITSIZE (GET_MODE (op))
 765                <= HOST_BITS_PER_WIDE_INT)
 766               && ((nonzero_bits (op, GET_MODE (op))
 767                    & ((HOST_WIDE_INT) 1
 768                       << (GET_MODE_BITSIZE (GET_MODE (op)) - 1)))
 769                   == 0)))
 770         return op;
 771
 772       /* If operand is known to be only -1 or 0, convert ABS to NEG.  */
 773       if (num_sign_bit_copies (op, mode) == GET_MODE_BITSIZE (mode))
 774         return gen_rtx_NEG (mode, op);
 775
 776       break;
 777
 778     case FFS:
 779       /* (ffs (*_extend <X>)) = (ffs <X>) */
 780       if (GET_CODE (op) == SIGN_EXTEND
 781           || GET_CODE (op) == ZERO_EXTEND)
 782         return simplify_gen_unary (FFS, mode, XEXP (op, 0),
 783                                    GET_MODE (XEXP (op, 0)));
 784       break;
 785
 786     case POPCOUNT:
 787       switch (GET_CODE (op))
 788         {
 789         case BSWAP:
 790         case ZERO_EXTEND:
 791           /* (popcount (zero_extend <X>)) = (popcount <X>) */
 792           return simplify_gen_unary (POPCOUNT, mode, XEXP (op, 0),
 793                                      GET_MODE (XEXP (op, 0)));
 794
 795         case ROTATE:
 796         case ROTATERT:
 797           /* Rotations don't affect popcount.  */
 798           if (!side_effects_p (XEXP (op, 1)))
 799             return simplify_gen_unary (POPCOUNT, mode, XEXP (op, 0),
 800                                        GET_MODE (XEXP (op, 0)));
 801           break;
 802
 803         default:
 804           break;
 805         }
 806       break;
 807
 808     case PARITY:
 809       switch (GET_CODE (op))
 810         {
 811         case NOT:
 812         case BSWAP:
 813         case ZERO_EXTEND:
 814         case SIGN_EXTEND:
 815           return simplify_gen_unary (PARITY, mode, XEXP (op, 0),
 816                                      GET_MODE (XEXP (op, 0)));
 817
 818         case ROTATE:
 819         case ROTATERT:
 820           /* Rotations don't affect parity.  */
 821           if (!side_effects_p (XEXP (op, 1)))
 822             return simplify_gen_unary (PARITY, mode, XEXP (op, 0),
 823                                        GET_MODE (XEXP (op, 0)));
 824           break;
 825
 826         default:
 827           break;
 828         }
 829       break;
 830
 831     case BSWAP:
 832       /* (bswap (bswap x)) -> x.  */
 833       if (GET_CODE (op) == BSWAP)
 834         return XEXP (op, 0);
 835       break;
 836
 837     case FLOAT:
 838       /* (float (sign_extend <X>)) = (float <X>).  */
 839       if (GET_CODE (op) == SIGN_EXTEND)
 840         return simplify_gen_unary (FLOAT, mode, XEXP (op, 0),
 841                                    GET_MODE (XEXP (op, 0)));
 842       break;
 843
 844     case SIGN_EXTEND:
 845       /* (sign_extend (truncate (minus (label_ref L1) (label_ref L2))))
 846          becomes just the MINUS if its mode is MODE.  This allows
 847          folding switch statements on machines using casesi (such as
 848          the VAX).  */
 849       if (GET_CODE (op) == TRUNCATE
 850           && GET_MODE (XEXP (op, 0)) == mode
 851           && GET_CODE (XEXP (op, 0)) == MINUS
 852           && GET_CODE (XEXP (XEXP (op, 0), 0)) == LABEL_REF
 853           && GET_CODE (XEXP (XEXP (op, 0), 1)) == LABEL_REF)
 854         return XEXP (op, 0);
 855
 856       /* Check for a sign extension of a subreg of a promoted
 857          variable, where the promotion is sign-extended, and the
 858          target mode is the same as the variable's promotion.  */
 859       if (GET_CODE (op) == SUBREG
 860           && SUBREG_PROMOTED_VAR_P (op)
 861           && ! SUBREG_PROMOTED_UNSIGNED_P (op)
 862           && GET_MODE_SIZE (mode) <= GET_MODE_SIZE (GET_MODE (XEXP (op, 0))))
 863         return rtl_hooks.gen_lowpart_no_emit (mode, op);
 864
 865 #if defined(POINTERS_EXTEND_UNSIGNED) && !defined(HAVE_ptr_extend)
 866       if (! POINTERS_EXTEND_UNSIGNED
 867           && mode == Pmode && GET_MODE (op) == ptr_mode
 868           && (CONSTANT_P (op)
 869               || (GET_CODE (op) == SUBREG
 870                   && REG_P (SUBREG_REG (op))
 871                   && REG_POINTER (SUBREG_REG (op))
 872                   && GET_MODE (SUBREG_REG (op)) == Pmode)))
 873         return convert_memory_address (Pmode, op);
 874 #endif
 875       break;
 876
 877     case ZERO_EXTEND:
 878       /* Check for a zero extension of a subreg of a promoted
 879          variable, where the promotion is zero-extended, and the
 880          target mode is the same as the variable's promotion.  */
 881       if (GET_CODE (op) == SUBREG
 882           && SUBREG_PROMOTED_VAR_P (op)
 883           && SUBREG_PROMOTED_UNSIGNED_P (op) > 0
 884           && GET_MODE_SIZE (mode) <= GET_MODE_SIZE (GET_MODE (XEXP (op, 0))))
 885         return rtl_hooks.gen_lowpart_no_emit (mode, op);
 886
 887 #if defined(POINTERS_EXTEND_UNSIGNED) && !defined(HAVE_ptr_extend)
 888       if (POINTERS_EXTEND_UNSIGNED > 0
 889           && mode == Pmode && GET_MODE (op) == ptr_mode
 890           && (CONSTANT_P (op)
 891               || (GET_CODE (op) == SUBREG
 892                   && REG_P (SUBREG_REG (op))
 893                   && REG_POINTER (SUBREG_REG (op))
 894                   && GET_MODE (SUBREG_REG (op)) == Pmode)))
 895         return convert_memory_address (Pmode, op);
 896 #endif
 897       break;
 898
 899     default:
 900       break;
 901     }
 902
 903   return 0;
 904 }
 905
 906 /* Try to compute the value of a unary operation CODE whose output mode is to
 907    be MODE with input operand OP whose mode was originally OP_MODE.
 908    Return zero if the value cannot be computed.  */
 909 rtx
 910 simplify_const_unary_operation (enum rtx_code code, enum machine_mode mode,
 911                                 rtx op, enum machine_mode op_mode)
 912 {
 913   unsigned int width = GET_MODE_BITSIZE (mode);
 914
 915   if (code == VEC_DUPLICATE)
 916     {
 917       gcc_assert (VECTOR_MODE_P (mode));
 918       if (GET_MODE (op) != VOIDmode)
 919       {
 920         if (!VECTOR_MODE_P (GET_MODE (op)))
 921           gcc_assert (GET_MODE_INNER (mode) == GET_MODE (op));
 922         else
 923           gcc_assert (GET_MODE_INNER (mode) == GET_MODE_INNER
 924                                                 (GET_MODE (op)));
 925       }
 926       if (GET_CODE (op) == CONST_INT || GET_CODE (op) == CONST_DOUBLE
 927           || GET_CODE (op) == CONST_VECTOR)
 928         {
 929           int elt_size = GET_MODE_SIZE (GET_MODE_INNER (mode));
 930           unsigned n_elts = (GET_MODE_SIZE (mode) / elt_size);
 931           rtvec v = rtvec_alloc (n_elts);
 932           unsigned int i;
 933
 934           if (GET_CODE (op) != CONST_VECTOR)
 935             for (i = 0; i < n_elts; i++)
 936               RTVEC_ELT (v, i) = op;
 937           else
 938             {
 939               enum machine_mode inmode = GET_MODE (op);
 940               int in_elt_size = GET_MODE_SIZE (GET_MODE_INNER (inmode));
 941               unsigned in_n_elts = (GET_MODE_SIZE (inmode) / in_elt_size);
 942
 943               gcc_assert (in_n_elts < n_elts);
 944               gcc_assert ((n_elts % in_n_elts) == 0);
 945               for (i = 0; i < n_elts; i++)
 946                 RTVEC_ELT (v, i) = CONST_VECTOR_ELT (op, i % in_n_elts);
 947             }
 948           return gen_rtx_CONST_VECTOR (mode, v);
 949         }
 950     }
 951
 952   if (VECTOR_MODE_P (mode) && GET_CODE (op) == CONST_VECTOR)
 953     {
 954       int elt_size = GET_MODE_SIZE (GET_MODE_INNER (mode));
 955       unsigned n_elts = (GET_MODE_SIZE (mode) / elt_size);
 956       enum machine_mode opmode = GET_MODE (op);
 957       int op_elt_size = GET_MODE_SIZE (GET_MODE_INNER (opmode));
 958       unsigned op_n_elts = (GET_MODE_SIZE (opmode) / op_elt_size);
 959       rtvec v = rtvec_alloc (n_elts);
 960       unsigned int i;
 961
 962       gcc_assert (op_n_elts == n_elts);
 963       for (i = 0; i < n_elts; i++)
 964         {
 965           rtx x = simplify_unary_operation (code, GET_MODE_INNER (mode),
 966                                             CONST_VECTOR_ELT (op, i),
 967                                             GET_MODE_INNER (opmode));
 968           if (!x)
 969             return 0;
 970           RTVEC_ELT (v, i) = x;
 971         }
 972       return gen_rtx_CONST_VECTOR (mode, v);
 973     }
 974
 975   /* The order of these tests is critical so that, for example, we don't
 976      check the wrong mode (input vs. output) for a conversion operation,
 977      such as FIX.  At some point, this should be simplified.  */
 978
 979   if (code == FLOAT && GET_MODE (op) == VOIDmode
 980       && (GET_CODE (op) == CONST_DOUBLE || GET_CODE (op) == CONST_INT))
 981     {
 982       HOST_WIDE_INT hv, lv;
 983       REAL_VALUE_TYPE d;
 984
 985       if (GET_CODE (op) == CONST_INT)
 986         lv = INTVAL (op), hv = HWI_SIGN_EXTEND (lv);
 987       else
 988         lv = CONST_DOUBLE_LOW (op),  hv = CONST_DOUBLE_HIGH (op);
 989
 990       REAL_VALUE_FROM_INT (d, lv, hv, mode);
 991       d = real_value_truncate (mode, d);
 992       return CONST_DOUBLE_FROM_REAL_VALUE (d, mode);
 993     }
 994   else if (code == UNSIGNED_FLOAT && GET_MODE (op) == VOIDmode
 995            && (GET_CODE (op) == CONST_DOUBLE
 996                || GET_CODE (op) == CONST_INT))
 997     {
 998       HOST_WIDE_INT hv, lv;
 999       REAL_VALUE_TYPE d;
1000
1001       if (GET_CODE (op) == CONST_INT)
1002         lv = INTVAL (op), hv = HWI_SIGN_EXTEND (lv);
1003       else
1004         lv = CONST_DOUBLE_LOW (op),  hv = CONST_DOUBLE_HIGH (op);
1005
1006       if (op_mode == VOIDmode)
1007         {
1008           /* We don't know how to interpret negative-looking numbers in
1009              this case, so don't try to fold those.  */
1010           if (hv < 0)
1011             return 0;
1012         }
1013       else if (GET_MODE_BITSIZE (op_mode) >= HOST_BITS_PER_WIDE_INT * 2)
1014         ;
1015       else
1016         hv = 0, lv &= GET_MODE_MASK (op_mode);
1017
1018       REAL_VALUE_FROM_UNSIGNED_INT (d, lv, hv, mode);
1019       d = real_value_truncate (mode, d);
1020       return CONST_DOUBLE_FROM_REAL_VALUE (d, mode);
1021     }
1022
1023   if (GET_CODE (op) == CONST_INT
1024       && width <= HOST_BITS_PER_WIDE_INT && width > 0)
1025     {
1026       HOST_WIDE_INT arg0 = INTVAL (op);
1027       HOST_WIDE_INT val;
1028
1029       switch (code)
1030         {
1031         case NOT:
1032           val = ~ arg0;
1033           break;
1034
1035         case NEG:
1036           val = - arg0;
1037           break;
1038
1039         case ABS:
1040           val = (arg0 >= 0 ? arg0 : - arg0);
1041           break;
1042
1043         case FFS:
1044           /* Don't use ffs here.  Instead, get low order bit and then its
1045              number.  If arg0 is zero, this will return 0, as desired.  */
1046           arg0 &= GET_MODE_MASK (mode);
1047           val = exact_log2 (arg0 & (- arg0)) + 1;
1048           break;
1049
1050         case CLZ:
1051           arg0 &= GET_MODE_MASK (mode);
1052           if (arg0 == 0 && CLZ_DEFINED_VALUE_AT_ZERO (mode, val))
1053             ;
1054           else
1055             val = GET_MODE_BITSIZE (mode) - floor_log2 (arg0) - 1;
1056           break;
1057
1058         case CTZ:
1059           arg0 &= GET_MODE_MASK (mode);
1060           if (arg0 == 0)
1061             {
1062               /* Even if the value at zero is undefined, we have to come
1063                  up with some replacement.  Seems good enough.  */
1064               if (! CTZ_DEFINED_VALUE_AT_ZERO (mode, val))
1065                 val = GET_MODE_BITSIZE (mode);
1066             }
1067           else
1068             val = exact_log2 (arg0 & -arg0);
1069           break;
1070
1071         case POPCOUNT:
1072           arg0 &= GET_MODE_MASK (mode);
1073           val = 0;
1074           while (arg0)
1075             val++, arg0 &= arg0 - 1;
1076           break;
1077
1078         case PARITY:
1079           arg0 &= GET_MODE_MASK (mode);
1080           val = 0;
1081           while (arg0)
1082             val++, arg0 &= arg0 - 1;
1083           val &= 1;
1084           break;
1085
1086         case BSWAP:
1087           {
1088             unsigned int s;
1089
1090             val = 0;
1091             for (s = 0; s < width; s += 8)
1092               {
1093                 unsigned int d = width - s - 8;
1094                 unsigned HOST_WIDE_INT byte;
1095                 byte = (arg0 >> s) & 0xff;
1096                 val |= byte << d;
1097               }
1098           }
1099           break;
1100
1101         case TRUNCATE:
1102           val = arg0;
1103           break;
1104
1105         case ZERO_EXTEND:
1106           /* When zero-extending a CONST_INT, we need to know its
1107              original mode.  */
1108           gcc_assert (op_mode != VOIDmode);
1109           if (GET_MODE_BITSIZE (op_mode) == HOST_BITS_PER_WIDE_INT)
1110             {
1111               /* If we were really extending the mode,
1112                  we would have to distinguish between zero-extension
1113                  and sign-extension.  */
1114               gcc_assert (width == GET_MODE_BITSIZE (op_mode));
1115               val = arg0;
1116             }
1117           else if (GET_MODE_BITSIZE (op_mode) < HOST_BITS_PER_WIDE_INT)
1118             val = arg0 & ~((HOST_WIDE_INT) (-1) << GET_MODE_BITSIZE (op_mode));
1119           else
1120             return 0;
1121           break;
1122
1123         case SIGN_EXTEND:
1124           if (op_mode == VOIDmode)
1125             op_mode = mode;
1126           if (GET_MODE_BITSIZE (op_mode) == HOST_BITS_PER_WIDE_INT)
1127             {
1128               /* If we were really extending the mode,
1129                  we would have to distinguish between zero-extension
1130                  and sign-extension.  */
1131               gcc_assert (width == GET_MODE_BITSIZE (op_mode));
1132               val = arg0;
1133             }
1134           else if (GET_MODE_BITSIZE (op_mode) < HOST_BITS_PER_WIDE_INT)
1135             {
1136               val
1137                 = arg0 & ~((HOST_WIDE_INT) (-1) << GET_MODE_BITSIZE (op_mode));
1138               if (val
1139                   & ((HOST_WIDE_INT) 1 << (GET_MODE_BITSIZE (op_mode) - 1)))
1140                 val -= (HOST_WIDE_INT) 1 << GET_MODE_BITSIZE (op_mode);
1141             }
1142           else
1143             return 0;
1144           break;
1145
1146         case SQRT:
1147         case FLOAT_EXTEND:
1148         case FLOAT_TRUNCATE:
1149         case SS_TRUNCATE:
1150         case US_TRUNCATE:
1151         case SS_NEG:
1152         case US_NEG:
1153           return 0;
1154
1155         default:
1156           gcc_unreachable ();
1157         }
1158
1159       return gen_int_mode (val, mode);
1160     }
1161
1162   /* We can do some operations on integer CONST_DOUBLEs.  Also allow
1163      for a DImode operation on a CONST_INT.  */
1164   else if (GET_MODE (op) == VOIDmode
1165            && width <= HOST_BITS_PER_WIDE_INT * 2
1166            && (GET_CODE (op) == CONST_DOUBLE
1167                || GET_CODE (op) == CONST_INT))
1168     {
1169       unsigned HOST_WIDE_INT l1, lv;
1170       HOST_WIDE_INT h1, hv;
1171
1172       if (GET_CODE (op) == CONST_DOUBLE)
1173         l1 = CONST_DOUBLE_LOW (op), h1 = CONST_DOUBLE_HIGH (op);
1174       else
1175         l1 = INTVAL (op), h1 = HWI_SIGN_EXTEND (l1);
1176
1177       switch (code)
1178         {
1179         case NOT:
1180           lv = ~ l1;
1181           hv = ~ h1;
1182           break;
1183
1184         case NEG:
1185           neg_double (l1, h1, &lv, &hv);
1186           break;
1187
1188         case ABS:
1189           if (h1 < 0)
1190             neg_double (l1, h1, &lv, &hv);
1191           else
1192             lv = l1, hv = h1;
1193           break;
1194
1195         case FFS:
1196           hv = 0;
1197           if (l1 == 0)
1198             {
1199               if (h1 == 0)
1200                 lv = 0;
1201               else
1202                 lv = HOST_BITS_PER_WIDE_INT + exact_log2 (h1 & -h1) + 1;
1203             }
1204           else
1205             lv = exact_log2 (l1 & -l1) + 1;
1206           break;
1207
1208         case CLZ:
1209           hv = 0;
1210           if (h1 != 0)
1211             lv = GET_MODE_BITSIZE (mode) - floor_log2 (h1) - 1
1212               - HOST_BITS_PER_WIDE_INT;
1213           else if (l1 != 0)
1214             lv = GET_MODE_BITSIZE (mode) - floor_log2 (l1) - 1;
1215           else if (! CLZ_DEFINED_VALUE_AT_ZERO (mode, lv))
1216             lv = GET_MODE_BITSIZE (mode);
1217           break;
1218
1219         case CTZ:
1220           hv = 0;
1221           if (l1 != 0)
1222             lv = exact_log2 (l1 & -l1);
1223           else if (h1 != 0)
1224             lv = HOST_BITS_PER_WIDE_INT + exact_log2 (h1 & -h1);
1225           else if (! CTZ_DEFINED_VALUE_AT_ZERO (mode, lv))
1226             lv = GET_MODE_BITSIZE (mode);
1227           break;
1228
1229         case POPCOUNT:
1230           hv = 0;
1231           lv = 0;
1232           while (l1)
1233             lv++, l1 &= l1 - 1;
1234           while (h1)
1235             lv++, h1 &= h1 - 1;
1236           break;
1237
1238         case PARITY:
1239           hv = 0;
1240           lv = 0;
1241           while (l1)
1242             lv++, l1 &= l1 - 1;
1243           while (h1)
1244             lv++, h1 &= h1 - 1;
1245           lv &= 1;
1246           break;
1247
1248         case BSWAP:
1249           {
1250             unsigned int s;
1251
1252             hv = 0;
1253             lv = 0;
1254             for (s = 0; s < width; s += 8)
1255               {
1256                 unsigned int d = width - s - 8;
1257                 unsigned HOST_WIDE_INT byte;
1258
1259                 if (s < HOST_BITS_PER_WIDE_INT)
1260                   byte = (l1 >> s) & 0xff;
1261                 else
1262                   byte = (h1 >> (s - HOST_BITS_PER_WIDE_INT)) & 0xff;
1263
1264                 if (d < HOST_BITS_PER_WIDE_INT)
1265                   lv |= byte << d;
1266                 else
1267                   hv |= byte << (d - HOST_BITS_PER_WIDE_INT);
1268               }
1269           }
1270           break;
1271
1272         case TRUNCATE:
1273           /* This is just a change-of-mode, so do nothing.  */
1274           lv = l1, hv = h1;
1275           break;
1276
1277         case ZERO_EXTEND:
1278           gcc_assert (op_mode != VOIDmode);
1279
1280           if (GET_MODE_BITSIZE (op_mode) > HOST_BITS_PER_WIDE_INT)
1281             return 0;
1282
1283           hv = 0;
1284           lv = l1 & GET_MODE_MASK (op_mode);
1285           break;
1286
1287         case SIGN_EXTEND:
1288           if (op_mode == VOIDmode
1289               || GET_MODE_BITSIZE (op_mode) > HOST_BITS_PER_WIDE_INT)
1290             return 0;
1291           else
1292             {
1293               lv = l1 & GET_MODE_MASK (op_mode);
1294               if (GET_MODE_BITSIZE (op_mode) < HOST_BITS_PER_WIDE_INT
1295                   && (lv & ((HOST_WIDE_INT) 1
1296                             << (GET_MODE_BITSIZE (op_mode) - 1))) != 0)
1297                 lv -= (HOST_WIDE_INT) 1 << GET_MODE_BITSIZE (op_mode);
1298
1299               hv = HWI_SIGN_EXTEND (lv);
1300             }
1301           break;
1302
1303         case SQRT:
1304           return 0;
1305
1306         default:
1307           return 0;
1308         }
1309
1310       return immed_double_const (lv, hv, mode);
1311     }
1312
1313   else if (GET_CODE (op) == CONST_DOUBLE
1314            && SCALAR_FLOAT_MODE_P (mode))
1315     {
1316       REAL_VALUE_TYPE d, t;
1317       REAL_VALUE_FROM_CONST_DOUBLE (d, op);
1318
1319       switch (code)
1320         {
1321         case SQRT:
1322           if (HONOR_SNANS (mode) && real_isnan (&d))
1323             return 0;
1324           real_sqrt (&t, mode, &d);
1325           d = t;
1326           break;
1327         case ABS:
1328           d = REAL_VALUE_ABS (d);
1329           break;
1330         case NEG:
1331           d = REAL_VALUE_NEGATE (d);
1332           break;
1333         case FLOAT_TRUNCATE:
1334           d = real_value_truncate (mode, d);
1335           break;
1336         case FLOAT_EXTEND:
1337           /* All this does is change the mode.  */
1338           break;
1339         case FIX:
1340           real_arithmetic (&d, FIX_TRUNC_EXPR, &d, NULL);
1341           break;
1342         case NOT:
1343           {
1344             long tmp[4];
1345             int i;
1346
1347             real_to_target (tmp, &d, GET_MODE (op));
1348             for (i = 0; i < 4; i++)
1349               tmp[i] = ~tmp[i];
1350             real_from_target (&d, tmp, mode);
1351             break;
1352           }
1353         default:
1354           gcc_unreachable ();
1355         }
1356       return CONST_DOUBLE_FROM_REAL_VALUE (d, mode);
1357     }
1358
1359   else if (GET_CODE (op) == CONST_DOUBLE
1360            && SCALAR_FLOAT_MODE_P (GET_MODE (op))
1361            && GET_MODE_CLASS (mode) == MODE_INT
1362            && width <= 2*HOST_BITS_PER_WIDE_INT && width > 0)
1363     {
1364       /* Although the overflow semantics of RTL's FIX and UNSIGNED_FIX
1365          operators are intentionally left unspecified (to ease implementation
1366          by target backends), for consistency, this routine implements the
1367          same semantics for constant folding as used by the middle-end.  */
1368
1369       /* This was formerly used only for non-IEEE float.
1370          eggert@twinsun.com says it is safe for IEEE also.  */
1371       HOST_WIDE_INT xh, xl, th, tl;
1372       REAL_VALUE_TYPE x, t;
1373       REAL_VALUE_FROM_CONST_DOUBLE (x, op);
1374       switch (code)
1375         {
1376         case FIX:
1377           if (REAL_VALUE_ISNAN (x))
1378             return const0_rtx;
1379
1380           /* Test against the signed upper bound.  */
1381           if (width > HOST_BITS_PER_WIDE_INT)
1382             {
1383               th = ((unsigned HOST_WIDE_INT) 1
1384                     << (width - HOST_BITS_PER_WIDE_INT - 1)) - 1;
1385               tl = -1;
1386             }
1387           else
1388             {
1389               th = 0;
1390               tl = ((unsigned HOST_WIDE_INT) 1 << (width - 1)) - 1;
1391             }
1392           real_from_integer (&t, VOIDmode, tl, th, 0);
1393           if (REAL_VALUES_LESS (t, x))
1394             {
1395               xh = th;
1396               xl = tl;
1397               break;
1398             }
1399
1400           /* Test against the signed lower bound.  */
1401           if (width > HOST_BITS_PER_WIDE_INT)
1402             {
1403               th = (HOST_WIDE_INT) -1 << (width - HOST_BITS_PER_WIDE_INT - 1);
1404               tl = 0;
1405             }
1406           else
1407             {
1408               th = -1;
1409               tl = (HOST_WIDE_INT) -1 << (width - 1);
1410             }
1411           real_from_integer (&t, VOIDmode, tl, th, 0);
1412           if (REAL_VALUES_LESS (x, t))
1413             {
1414               xh = th;
1415               xl = tl;
1416               break;
1417             }
1418           REAL_VALUE_TO_INT (&xl, &xh, x);
1419           break;
1420
1421         case UNSIGNED_FIX:
1422           if (REAL_VALUE_ISNAN (x) || REAL_VALUE_NEGATIVE (x))
1423             return const0_rtx;
1424
1425           /* Test against the unsigned upper bound.  */
1426           if (width == 2*HOST_BITS_PER_WIDE_INT)
1427             {
1428               th = -1;
1429               tl = -1;
1430             }
1431           else if (width >= HOST_BITS_PER_WIDE_INT)
1432             {
1433               th = ((unsigned HOST_WIDE_INT) 1
1434                     << (width - HOST_BITS_PER_WIDE_INT)) - 1;
1435               tl = -1;
1436             }
1437           else
1438             {
1439               th = 0;
1440               tl = ((unsigned HOST_WIDE_INT) 1 << width) - 1;
1441             }
1442           real_from_integer (&t, VOIDmode, tl, th, 1);
1443           if (REAL_VALUES_LESS (t, x))
1444             {
1445               xh = th;
1446               xl = tl;
1447               break;
1448             }
1449
1450           REAL_VALUE_TO_INT (&xl, &xh, x);
1451           break;
1452
1453         default:
1454           gcc_unreachable ();
1455         }
1456       return immed_double_const (xl, xh, mode);
1457     }
1458
1459   return NULL_RTX;
1460 }
1461 \f
1462 /* Subroutine of simplify_binary_operation to simplify a commutative,
1463    associative binary operation CODE with result mode MODE, operating
1464    on OP0 and OP1.  CODE is currently one of PLUS, MULT, AND, IOR, XOR,
1465    SMIN, SMAX, UMIN or UMAX.  Return zero if no simplification or
1466    canonicalization is possible.  */
1467
1468 static rtx
1469 simplify_associative_operation (enum rtx_code code, enum machine_mode mode,
1470                                 rtx op0, rtx op1)
1471 {
1472   rtx tem;
1473
1474   /* Linearize the operator to the left.  */
1475   if (GET_CODE (op1) == code)
1476     {
1477       /* "(a op b) op (c op d)" becomes "((a op b) op c) op d)".  */
1478       if (GET_CODE (op0) == code)
1479         {
1480           tem = simplify_gen_binary (code, mode, op0, XEXP (op1, 0));
1481           return simplify_gen_binary (code, mode, tem, XEXP (op1, 1));
1482         }
1483
1484       /* "a op (b op c)" becomes "(b op c) op a".  */
1485       if (! swap_commutative_operands_p (op1, op0))
1486         return simplify_gen_binary (code, mode, op1, op0);
1487
1488       tem = op0;
1489       op0 = op1;
1490       op1 = tem;
1491     }
1492
1493   if (GET_CODE (op0) == code)
1494     {
1495       /* Canonicalize "(x op c) op y" as "(x op y) op c".  */
1496       if (swap_commutative_operands_p (XEXP (op0, 1), op1))
1497         {
1498           tem = simplify_gen_binary (code, mode, XEXP (op0, 0), op1);
1499           return simplify_gen_binary (code, mode, tem, XEXP (op0, 1));
1500         }
1501
1502       /* Attempt to simplify "(a op b) op c" as "a op (b op c)".  */
1503       tem = simplify_binary_operation (code, mode, XEXP (op0, 1), op1);
1504       if (tem != 0)
1505         return simplify_gen_binary (code, mode, XEXP (op0, 0), tem);
1506
1507       /* Attempt to simplify "(a op b) op c" as "(a op c) op b".  */
1508       tem = simplify_binary_operation (code, mode, XEXP (op0, 0), op1);
1509       if (tem != 0)
1510         return simplify_gen_binary (code, mode, tem, XEXP (op0, 1));
1511     }
1512
1513   return 0;
1514 }
1515
1516
1517 /* Simplify a binary operation CODE with result mode MODE, operating on OP0
1518    and OP1.  Return 0 if no simplification is possible.
1519
1520    Don't use this for relational operations such as EQ or LT.
1521    Use simplify_relational_operation instead.  */
1522 rtx
1523 simplify_binary_operation (enum rtx_code code, enum machine_mode mode,
1524                            rtx op0, rtx op1)
1525 {
1526   rtx trueop0, trueop1;
1527   rtx tem;
1528
1529   /* Relational operations don't work here.  We must know the mode
1530      of the operands in order to do the comparison correctly.
1531      Assuming a full word can give incorrect results.
1532      Consider comparing 128 with -128 in QImode.  */
1533   gcc_assert (GET_RTX_CLASS (code) != RTX_COMPARE);
1534   gcc_assert (GET_RTX_CLASS (code) != RTX_COMM_COMPARE);
1535
1536   /* Make sure the constant is second.  */
1537   if (GET_RTX_CLASS (code) == RTX_COMM_ARITH
1538       && swap_commutative_operands_p (op0, op1))
1539     {
1540       tem = op0, op0 = op1, op1 = tem;
1541     }
1542
1543   trueop0 = avoid_constant_pool_reference (op0);
1544   trueop1 = avoid_constant_pool_reference (op1);
1545
1546   tem = simplify_const_binary_operation (code, mode, trueop0, trueop1);
1547   if (tem)
1548     return tem;
1549   return simplify_binary_operation_1 (code, mode, op0, op1, trueop0, trueop1);
1550 }
1551
1552 /* Subroutine of simplify_binary_operation.  Simplify a binary operation
1553    CODE with result mode MODE, operating on OP0 and OP1.  If OP0 and/or
1554    OP1 are constant pool references, TRUEOP0 and TRUEOP1 represent the
1555    actual constants.  */
1556
1557 static rtx
1558 simplify_binary_operation_1 (enum rtx_code code, enum machine_mode mode,
1559                              rtx op0, rtx op1, rtx trueop0, rtx trueop1)
1560 {
1561   rtx tem, reversed, opleft, opright;
1562   HOST_WIDE_INT val;
1563   unsigned int width = GET_MODE_BITSIZE (mode);
1564
1565   /* Even if we can't compute a constant result,
1566      there are some cases worth simplifying.  */
1567
1568   switch (code)
1569     {
1570     case PLUS:
1571       /* Maybe simplify x + 0 to x.  The two expressions are equivalent
1572          when x is NaN, infinite, or finite and nonzero.  They aren't
1573          when x is -0 and the rounding mode is not towards -infinity,
1574          since (-0) + 0 is then 0.  */
1575       if (!HONOR_SIGNED_ZEROS (mode) && trueop1 == CONST0_RTX (mode))
1576         return op0;
1577
1578       /* ((-a) + b) -> (b - a) and similarly for (a + (-b)).  These
1579          transformations are safe even for IEEE.  */
1580       if (GET_CODE (op0) == NEG)
1581         return simplify_gen_binary (MINUS, mode, op1, XEXP (op0, 0));
1582       else if (GET_CODE (op1) == NEG)
1583         return simplify_gen_binary (MINUS, mode, op0, XEXP (op1, 0));
1584
1585       /* (~a) + 1 -> -a */
1586       if (INTEGRAL_MODE_P (mode)
1587           && GET_CODE (op0) == NOT
1588           && trueop1 == const1_rtx)
1589         return simplify_gen_unary (NEG, mode, XEXP (op0, 0), mode);
1590
1591       /* Handle both-operands-constant cases.  We can only add
1592          CONST_INTs to constants since the sum of relocatable symbols
1593          can't be handled by most assemblers.  Don't add CONST_INT
1594          to CONST_INT since overflow won't be computed properly if wider
1595          than HOST_BITS_PER_WIDE_INT.  */
1596
1597       if ((GET_CODE (op0) == CONST
1598            || GET_CODE (op0) == SYMBOL_REF
1599            || GET_CODE (op0) == LABEL_REF)
1600           && GET_CODE (op1) == CONST_INT)
1601         return plus_constant (op0, INTVAL (op1));
1602       else if ((GET_CODE (op1) == CONST
1603                 || GET_CODE (op1) == SYMBOL_REF
1604                 || GET_CODE (op1) == LABEL_REF)
1605                && GET_CODE (op0) == CONST_INT)
1606         return plus_constant (op1, INTVAL (op0));
1607
1608       /* See if this is something like X * C - X or vice versa or
1609          if the multiplication is written as a shift.  If so, we can
1610          distribute and make a new multiply, shift, or maybe just
1611          have X (if C is 2 in the example above).  But don't make
1612          something more expensive than we had before.  */
1613
1614       if (SCALAR_INT_MODE_P (mode))
1615         {
1616           HOST_WIDE_INT coeff0h = 0, coeff1h = 0;
1617           unsigned HOST_WIDE_INT coeff0l = 1, coeff1l = 1;
1618           rtx lhs = op0, rhs = op1;
1619
1620           if (GET_CODE (lhs) == NEG)
1621             {
1622               coeff0l = -1;
1623               coeff0h = -1;
1624               lhs = XEXP (lhs, 0);
1625             }
1626           else if (GET_CODE (lhs) == MULT
1627                    && GET_CODE (XEXP (lhs, 1)) == CONST_INT)
1628             {
1629               coeff0l = INTVAL (XEXP (lhs, 1));
1630               coeff0h = INTVAL (XEXP (lhs, 1)) < 0 ? -1 : 0;
1631               lhs = XEXP (lhs, 0);
1632             }
1633           else if (GET_CODE (lhs) == ASHIFT
1634                    && GET_CODE (XEXP (lhs, 1)) == CONST_INT
1635                    && INTVAL (XEXP (lhs, 1)) >= 0
1636                    && INTVAL (XEXP (lhs, 1)) < HOST_BITS_PER_WIDE_INT)
1637             {
1638               coeff0l = ((HOST_WIDE_INT) 1) << INTVAL (XEXP (lhs, 1));
1639               coeff0h = 0;
1640               lhs = XEXP (lhs, 0);
1641             }
1642
1643           if (GET_CODE (rhs) == NEG)
1644             {
1645               coeff1l = -1;
1646               coeff1h = -1;
1647               rhs = XEXP (rhs, 0);
1648             }
1649           else if (GET_CODE (rhs) == MULT
1650                    && GET_CODE (XEXP (rhs, 1)) == CONST_INT)
1651             {
1652               coeff1l = INTVAL (XEXP (rhs, 1));
1653               coeff1h = INTVAL (XEXP (rhs, 1)) < 0 ? -1 : 0;
1654               rhs = XEXP (rhs, 0);
1655             }
1656           else if (GET_CODE (rhs) == ASHIFT
1657                    && GET_CODE (XEXP (rhs, 1)) == CONST_INT
1658                    && INTVAL (XEXP (rhs, 1)) >= 0
1659                    && INTVAL (XEXP (rhs, 1)) < HOST_BITS_PER_WIDE_INT)
1660             {
1661               coeff1l = ((HOST_WIDE_INT) 1) << INTVAL (XEXP (rhs, 1));
1662               coeff1h = 0;
1663               rhs = XEXP (rhs, 0);
1664             }
1665
1666           if (rtx_equal_p (lhs, rhs))
1667             {
1668               rtx orig = gen_rtx_PLUS (mode, op0, op1);
1669               rtx coeff;
1670               unsigned HOST_WIDE_INT l;
1671               HOST_WIDE_INT h;
1672               bool speed = optimize_function_for_speed_p (cfun);
1673
1674               add_double (coeff0l, coeff0h, coeff1l, coeff1h, &l, &h);
1675               coeff = immed_double_const (l, h, mode);
1676
1677               tem = simplify_gen_binary (MULT, mode, lhs, coeff);
1678               return rtx_cost (tem, SET, speed) <= rtx_cost (orig, SET, speed)
1679                 ? tem : 0;
1680             }
1681         }
1682
1683       /* (plus (xor X C1) C2) is (xor X (C1^C2)) if C2 is signbit.  */
1684       if ((GET_CODE (op1) == CONST_INT
1685            || GET_CODE (op1) == CONST_DOUBLE)
1686           && GET_CODE (op0) == XOR
1687           && (GET_CODE (XEXP (op0, 1)) == CONST_INT
1688               || GET_CODE (XEXP (op0, 1)) == CONST_DOUBLE)
1689           && mode_signbit_p (mode, op1))
1690         return simplify_gen_binary (XOR, mode, XEXP (op0, 0),
1691                                     simplify_gen_binary (XOR, mode, op1,
1692                                                          XEXP (op0, 1)));
1693
1694       /* Canonicalize (plus (mult (neg B) C) A) to (minus A (mult B C)).  */
1695       if (!HONOR_SIGN_DEPENDENT_ROUNDING (mode)
1696           && GET_CODE (op0) == MULT
1697           && GET_CODE (XEXP (op0, 0)) == NEG)
1698         {
1699           rtx in1, in2;
1700
1701           in1 = XEXP (XEXP (op0, 0), 0);
1702           in2 = XEXP (op0, 1);
1703           return simplify_gen_binary (MINUS, mode, op1,
1704                                       simplify_gen_binary (MULT, mode,
1705                                                            in1, in2));
1706         }
1707
1708       /* (plus (comparison A B) C) can become (neg (rev-comp A B)) if
1709          C is 1 and STORE_FLAG_VALUE is -1 or if C is -1 and STORE_FLAG_VALUE
1710          is 1.  */
1711       if (COMPARISON_P (op0)
1712           && ((STORE_FLAG_VALUE == -1 && trueop1 == const1_rtx)
1713               || (STORE_FLAG_VALUE == 1 && trueop1 == constm1_rtx))
1714           && (reversed = reversed_comparison (op0, mode)))
1715         return
1716           simplify_gen_unary (NEG, mode, reversed, mode);
1717
1718       /* If one of the operands is a PLUS or a MINUS, see if we can
1719          simplify this by the associative law.
1720          Don't use the associative law for floating point.
1721          The inaccuracy makes it nonassociative,
1722          and subtle programs can break if operations are associated.  */
1723
1724       if (INTEGRAL_MODE_P (mode)
1725           && (plus_minus_operand_p (op0)
1726               || plus_minus_operand_p (op1))
1727           && (tem = simplify_plus_minus (code, mode, op0, op1)) != 0)
1728         return tem;
1729
1730       /* Reassociate floating point addition only when the user
1731          specifies associative math operations.  */
1732       if (FLOAT_MODE_P (mode)
1733           && flag_associative_math)
1734         {
1735           tem = simplify_associative_operation (code, mode, op0, op1);
1736           if (tem)
1737             return tem;
1738         }
1739       break;
1740
1741     case COMPARE:
1742 #ifdef HAVE_cc0
1743       /* Convert (compare FOO (const_int 0)) to FOO unless we aren't
1744          using cc0, in which case we want to leave it as a COMPARE
1745          so we can distinguish it from a register-register-copy.
1746
1747          In IEEE floating point, x-0 is not the same as x.  */
1748       if (!(HONOR_SIGNED_ZEROS (mode)
1749             && HONOR_SIGN_DEPENDENT_ROUNDING (mode))
1750           && trueop1 == CONST0_RTX (mode))
1751         return op0;
1752 #endif
1753
1754       /* Convert (compare (gt (flags) 0) (lt (flags) 0)) to (flags).  */
1755       if (((GET_CODE (op0) == GT && GET_CODE (op1) == LT)
1756            || (GET_CODE (op0) == GTU && GET_CODE (op1) == LTU))
1757           && XEXP (op0, 1) == const0_rtx && XEXP (op1, 1) == const0_rtx)
1758         {
1759           rtx xop00 = XEXP (op0, 0);
1760           rtx xop10 = XEXP (op1, 0);
1761
1762 #ifdef HAVE_cc0
1763           if (GET_CODE (xop00) == CC0 && GET_CODE (xop10) == CC0)
1764 #else
1765             if (REG_P (xop00) && REG_P (xop10)
1766                 && GET_MODE (xop00) == GET_MODE (xop10)
1767                 && REGNO (xop00) == REGNO (xop10)
1768                 && GET_MODE_CLASS (GET_MODE (xop00)) == MODE_CC
1769                 && GET_MODE_CLASS (GET_MODE (xop10)) == MODE_CC)
1770 #endif
1771               return xop00;
1772         }
1773       break;
1774
1775     case MINUS:
1776       /* We can't assume x-x is 0 even with non-IEEE floating point,
1777          but since it is zero except in very strange circumstances, we
1778          will treat it as zero with -ffinite-math-only.  */
1779       if (rtx_equal_p (trueop0, trueop1)
1780           && ! side_effects_p (op0)
1781           && (!FLOAT_MODE_P (mode) || !HONOR_NANS (mode)))
1782         return CONST0_RTX (mode);
1783
1784       /* Change subtraction from zero into negation.  (0 - x) is the
1785          same as -x when x is NaN, infinite, or finite and nonzero.
1786          But if the mode has signed zeros, and does not round towards
1787          -infinity, then 0 - 0 is 0, not -0.  */
1788       if (!HONOR_SIGNED_ZEROS (mode) && trueop0 == CONST0_RTX (mode))
1789         return simplify_gen_unary (NEG, mode, op1, mode);
1790
1791       /* (-1 - a) is ~a.  */
1792       if (trueop0 == constm1_rtx)
1793         return simplify_gen_unary (NOT, mode, op1, mode);
1794
1795       /* Subtracting 0 has no effect unless the mode has signed zeros
1796          and supports rounding towards -infinity.  In such a case,
1797          0 - 0 is -0.  */
1798       if (!(HONOR_SIGNED_ZEROS (mode)
1799             && HONOR_SIGN_DEPENDENT_ROUNDING (mode))
1800           && trueop1 == CONST0_RTX (mode))
1801         return op0;
1802
1803       /* See if this is something like X * C - X or vice versa or
1804          if the multiplication is written as a shift.  If so, we can
1805          distribute and make a new multiply, shift, or maybe just
1806          have X (if C is 2 in the example above).  But don't make
1807          something more expensive than we had before.  */
1808
1809       if (SCALAR_INT_MODE_P (mode))
1810         {
1811           HOST_WIDE_INT coeff0h = 0, negcoeff1h = -1;
1812           unsigned HOST_WIDE_INT coeff0l = 1, negcoeff1l = -1;
1813           rtx lhs = op0, rhs = op1;
1814
1815           if (GET_CODE (lhs) == NEG)
1816             {
1817               coeff0l = -1;
1818               coeff0h = -1;
1819               lhs = XEXP (lhs, 0);
1820             }
1821           else if (GET_CODE (lhs) == MULT
1822                    && GET_CODE (XEXP (lhs, 1)) == CONST_INT)
1823             {
1824               coeff0l = INTVAL (XEXP (lhs, 1));
1825               coeff0h = INTVAL (XEXP (lhs, 1)) < 0 ? -1 : 0;
1826               lhs = XEXP (lhs, 0);
1827             }
1828           else if (GET_CODE (lhs) == ASHIFT
1829                    && GET_CODE (XEXP (lhs, 1)) == CONST_INT
1830                    && INTVAL (XEXP (lhs, 1)) >= 0
1831                    && INTVAL (XEXP (lhs, 1)) < HOST_BITS_PER_WIDE_INT)
1832             {
1833               coeff0l = ((HOST_WIDE_INT) 1) << INTVAL (XEXP (lhs, 1));
1834               coeff0h = 0;
1835               lhs = XEXP (lhs, 0);
1836             }
1837
1838           if (GET_CODE (rhs) == NEG)
1839             {
1840               negcoeff1l = 1;
1841               negcoeff1h = 0;
1842               rhs = XEXP (rhs, 0);
1843             }
1844           else if (GET_CODE (rhs) == MULT
1845                    && GET_CODE (XEXP (rhs, 1)) == CONST_INT)
1846             {
1847               negcoeff1l = -INTVAL (XEXP (rhs, 1));
1848               negcoeff1h = INTVAL (XEXP (rhs, 1)) <= 0 ? 0 : -1;
1849               rhs = XEXP (rhs, 0);
1850             }
1851           else if (GET_CODE (rhs) == ASHIFT
1852                    && GET_CODE (XEXP (rhs, 1)) == CONST_INT
1853                    && INTVAL (XEXP (rhs, 1)) >= 0
1854                    && INTVAL (XEXP (rhs, 1)) < HOST_BITS_PER_WIDE_INT)
1855             {
1856               negcoeff1l = -(((HOST_WIDE_INT) 1) << INTVAL (XEXP (rhs, 1)));
1857               negcoeff1h = -1;
1858               rhs = XEXP (rhs, 0);
1859             }
1860
1861           if (rtx_equal_p (lhs, rhs))
1862             {
1863               rtx orig = gen_rtx_MINUS (mode, op0, op1);
1864               rtx coeff;
1865               unsigned HOST_WIDE_INT l;
1866               HOST_WIDE_INT h;
1867               bool speed = optimize_function_for_speed_p (cfun);
1868
1869               add_double (coeff0l, coeff0h, negcoeff1l, negcoeff1h, &l, &h);
1870               coeff = immed_double_const (l, h, mode);
1871
1872               tem = simplify_gen_binary (MULT, mode, lhs, coeff);
1873               return rtx_cost (tem, SET, speed) <= rtx_cost (orig, SET, speed)
1874                 ? tem : 0;
1875             }
1876         }
1877
1878       /* (a - (-b)) -> (a + b).  True even for IEEE.  */
1879       if (GET_CODE (op1) == NEG)
1880         return simplify_gen_binary (PLUS, mode, op0, XEXP (op1, 0));
1881
1882       /* (-x - c) may be simplified as (-c - x).  */
1883       if (GET_CODE (op0) == NEG
1884           && (GET_CODE (op1) == CONST_INT
1885               || GET_CODE (op1) == CONST_DOUBLE))
1886         {
1887           tem = simplify_unary_operation (NEG, mode, op1, mode);
1888           if (tem)
1889             return simplify_gen_binary (MINUS, mode, tem, XEXP (op0, 0));
1890         }
1891
1892       /* Don't let a relocatable value get a negative coeff.  */
1893       if (GET_CODE (op1) == CONST_INT && GET_MODE (op0) != VOIDmode)
1894         return simplify_gen_binary (PLUS, mode,
1895                                     op0,
1896                                     neg_const_int (mode, op1));
1897
1898       /* (x - (x & y)) -> (x & ~y) */
1899       if (GET_CODE (op1) == AND)
1900         {
1901           if (rtx_equal_p (op0, XEXP (op1, 0)))
1902             {
1903               tem = simplify_gen_unary (NOT, mode, XEXP (op1, 1),
1904                                         GET_MODE (XEXP (op1, 1)));
1905               return simplify_gen_binary (AND, mode, op0, tem);
1906             }
1907           if (rtx_equal_p (op0, XEXP (op1, 1)))
1908             {
1909               tem = simplify_gen_unary (NOT, mode, XEXP (op1, 0),
1910                                         GET_MODE (XEXP (op1, 0)));
1911               return simplify_gen_binary (AND, mode, op0, tem);
1912             }
1913         }
1914
1915       /* If STORE_FLAG_VALUE is 1, (minus 1 (comparison foo bar)) can be done
1916          by reversing the comparison code if valid.  */
1917       if (STORE_FLAG_VALUE == 1
1918           && trueop0 == const1_rtx
1919           && COMPARISON_P (op1)
1920           && (reversed = reversed_comparison (op1, mode)))
1921         return reversed;
1922
1923       /* Canonicalize (minus A (mult (neg B) C)) to (plus (mult B C) A).  */
1924       if (!HONOR_SIGN_DEPENDENT_ROUNDING (mode)
1925           && GET_CODE (op1) == MULT
1926           && GET_CODE (XEXP (op1, 0)) == NEG)
1927         {
1928           rtx in1, in2;
1929
1930           in1 = XEXP (XEXP (op1, 0), 0);
1931           in2 = XEXP (op1, 1);
1932           return simplify_gen_binary (PLUS, mode,
1933                                       simplify_gen_binary (MULT, mode,
1934                                                            in1, in2),
1935                                       op0);
1936         }
1937
1938       /* Canonicalize (minus (neg A) (mult B C)) to
1939          (minus (mult (neg B) C) A).  */
1940       if (!HONOR_SIGN_DEPENDENT_ROUNDING (mode)
1941           && GET_CODE (op1) == MULT
1942           && GET_CODE (op0) == NEG)
1943         {
1944           rtx in1, in2;
1945
1946           in1 = simplify_gen_unary (NEG, mode, XEXP (op1, 0), mode);
1947           in2 = XEXP (op1, 1);
1948           return simplify_gen_binary (MINUS, mode,
1949                                       simplify_gen_binary (MULT, mode,
1950                                                            in1, in2),
1951                                       XEXP (op0, 0));
1952         }
1953
1954       /* If one of the operands is a PLUS or a MINUS, see if we can
1955          simplify this by the associative law.  This will, for example,
1956          canonicalize (minus A (plus B C)) to (minus (minus A B) C).
1957          Don't use the associative law for floating point.
1958          The inaccuracy makes it nonassociative,
1959          and subtle programs can break if operations are associated.  */
1960
1961       if (INTEGRAL_MODE_P (mode)
1962           && (plus_minus_operand_p (op0)
1963               || plus_minus_operand_p (op1))
1964           && (tem = simplify_plus_minus (code, mode, op0, op1)) != 0)
1965         return tem;
1966       break;
1967
1968     case MULT:
1969       if (trueop1 == constm1_rtx)
1970         return simplify_gen_unary (NEG, mode, op0, mode);
1971
1972       /* Maybe simplify x * 0 to 0.  The reduction is not valid if
1973          x is NaN, since x * 0 is then also NaN.  Nor is it valid
1974          when the mode has signed zeros, since multiplying a negative
1975          number by 0 will give -0, not 0.  */
1976       if (!HONOR_NANS (mode)
1977           && !HONOR_SIGNED_ZEROS (mode)
1978           && trueop1 == CONST0_RTX (mode)
1979           && ! side_effects_p (op0))
1980         return op1;
1981
1982       /* In IEEE floating point, x*1 is not equivalent to x for
1983          signalling NaNs.  */
1984       if (!HONOR_SNANS (mode)
1985           && trueop1 == CONST1_RTX (mode))
1986         return op0;
1987
1988       /* Convert multiply by constant power of two into shift unless
1989          we are still generating RTL.  This test is a kludge.  */
1990       if (GET_CODE (trueop1) == CONST_INT
1991           && (val = exact_log2 (INTVAL (trueop1))) >= 0
1992           /* If the mode is larger than the host word size, and the
1993              uppermost bit is set, then this isn't a power of two due
1994              to implicit sign extension.  */
1995           && (width <= HOST_BITS_PER_WIDE_INT
1996               || val != HOST_BITS_PER_WIDE_INT - 1))
1997         return simplify_gen_binary (ASHIFT, mode, op0, GEN_INT (val));
1998
1999       /* Likewise for multipliers wider than a word.  */
2000       if (GET_CODE (trueop1) == CONST_DOUBLE
2001           && (GET_MODE (trueop1) == VOIDmode
2002               || GET_MODE_CLASS (GET_MODE (trueop1)) == MODE_INT)
2003           && GET_MODE (op0) == mode
2004           && CONST_DOUBLE_LOW (trueop1) == 0
2005           && (val = exact_log2 (CONST_DOUBLE_HIGH (trueop1))) >= 0)
2006         return simplify_gen_binary (ASHIFT, mode, op0,
2007                                     GEN_INT (val + HOST_BITS_PER_WIDE_INT));
2008
2009       /* x*2 is x+x and x*(-1) is -x */
2010       if (GET_CODE (trueop1) == CONST_DOUBLE
2011           && SCALAR_FLOAT_MODE_P (GET_MODE (trueop1))
2012           && !DECIMAL_FLOAT_MODE_P (GET_MODE (trueop1))
2013           && GET_MODE (op0) == mode)
2014         {
2015           REAL_VALUE_TYPE d;
2016           REAL_VALUE_FROM_CONST_DOUBLE (d, trueop1);
2017
2018           if (REAL_VALUES_EQUAL (d, dconst2))
2019             return simplify_gen_binary (PLUS, mode, op0, copy_rtx (op0));
2020
2021           if (!HONOR_SNANS (mode)
2022               && REAL_VALUES_EQUAL (d, dconstm1))
2023             return simplify_gen_unary (NEG, mode, op0, mode);
2024         }
2025
2026       /* Optimize -x * -x as x * x.  */
2027       if (FLOAT_MODE_P (mode)
2028           && GET_CODE (op0) == NEG
2029           && GET_CODE (op1) == NEG
2030           && rtx_equal_p (XEXP (op0, 0), XEXP (op1, 0))
2031           && !side_effects_p (XEXP (op0, 0)))
2032         return simplify_gen_binary (MULT, mode, XEXP (op0, 0), XEXP (op1, 0));
2033
2034       /* Likewise, optimize abs(x) * abs(x) as x * x.  */
2035       if (SCALAR_FLOAT_MODE_P (mode)
2036           && GET_CODE (op0) == ABS
2037           && GET_CODE (op1) == ABS
2038           && rtx_equal_p (XEXP (op0, 0), XEXP (op1, 0))
2039           && !side_effects_p (XEXP (op0, 0)))
2040         return simplify_gen_binary (MULT, mode, XEXP (op0, 0), XEXP (op1, 0));
2041
2042       /* Reassociate multiplication, but for floating point MULTs
2043          only when the user specifies unsafe math optimizations.  */
2044       if (! FLOAT_MODE_P (mode)
2045           || flag_unsafe_math_optimizations)
2046         {
2047           tem = simplify_associative_operation (code, mode, op0, op1);
2048           if (tem)
2049             return tem;
2050         }
2051       break;
2052
2053     case IOR:
2054       if (trueop1 == const0_rtx)
2055         return op0;
2056       if (GET_CODE (trueop1) == CONST_INT
2057           && ((INTVAL (trueop1) & GET_MODE_MASK (mode))
2058               == GET_MODE_MASK (mode)))
2059         return op1;
2060       if (rtx_equal_p (trueop0, trueop1) && ! side_effects_p (op0))
2061         return op0;
2062       /* A | (~A) -> -1 */
2063       if (((GET_CODE (op0) == NOT && rtx_equal_p (XEXP (op0, 0), op1))
2064            || (GET_CODE (op1) == NOT && rtx_equal_p (XEXP (op1, 0), op0)))
2065           && ! side_effects_p (op0)
2066           && SCALAR_INT_MODE_P (mode))
2067         return constm1_rtx;
2068
2069       /* (ior A C) is C if all bits of A that might be nonzero are on in C.  */
2070       if (GET_CODE (op1) == CONST_INT
2071           && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
2072           && (nonzero_bits (op0, mode) & ~INTVAL (op1)) == 0)
2073         return op1;
2074
2075       /* Canonicalize (X & C1) | C2.  */
2076       if (GET_CODE (op0) == AND
2077           && GET_CODE (trueop1) == CONST_INT
2078           && GET_CODE (XEXP (op0, 1)) == CONST_INT)
2079         {
2080           HOST_WIDE_INT mask = GET_MODE_MASK (mode);
2081           HOST_WIDE_INT c1 = INTVAL (XEXP (op0, 1));
2082           HOST_WIDE_INT c2 = INTVAL (trueop1);
2083
2084           /* If (C1&C2) == C1, then (X&C1)|C2 becomes X.  */
2085           if ((c1 & c2) == c1
2086               && !side_effects_p (XEXP (op0, 0)))
2087             return trueop1;
2088
2089           /* If (C1|C2) == ~0 then (X&C1)|C2 becomes X|C2.  */
2090           if (((c1|c2) & mask) == mask)
2091             return simplify_gen_binary (IOR, mode, XEXP (op0, 0), op1);
2092
2093           /* Minimize the number of bits set in C1, i.e. C1 := C1 & ~C2.  */
2094           if (((c1 & ~c2) & mask) != (c1 & mask))
2095             {
2096               tem = simplify_gen_binary (AND, mode, XEXP (op0, 0),
2097                                          gen_int_mode (c1 & ~c2, mode));
2098               return simplify_gen_binary (IOR, mode, tem, op1);
2099             }
2100         }
2101
2102       /* Convert (A & B) | A to A.  */
2103       if (GET_CODE (op0) == AND
2104           && (rtx_equal_p (XEXP (op0, 0), op1)
2105               || rtx_equal_p (XEXP (op0, 1), op1))
2106           && ! side_effects_p (XEXP (op0, 0))
2107           && ! side_effects_p (XEXP (op0, 1)))
2108         return op1;
2109
2110       /* Convert (ior (ashift A CX) (lshiftrt A CY)) where CX+CY equals the
2111          mode size to (rotate A CX).  */
2112
2113       if (GET_CODE (op1) == ASHIFT
2114           || GET_CODE (op1) == SUBREG)
2115         {
2116           opleft = op1;
2117           opright = op0;
2118         }
2119       else
2120         {
2121           opright = op1;
2122           opleft = op0;
2123         }
2124
2125       if (GET_CODE (opleft) == ASHIFT && GET_CODE (opright) == LSHIFTRT
2126           && rtx_equal_p (XEXP (opleft, 0), XEXP (opright, 0))
2127           && GET_CODE (XEXP (opleft, 1)) == CONST_INT
2128           && GET_CODE (XEXP (opright, 1)) == CONST_INT
2129           && (INTVAL (XEXP (opleft, 1)) + INTVAL (XEXP (opright, 1))
2130               == GET_MODE_BITSIZE (mode)))
2131         return gen_rtx_ROTATE (mode, XEXP (opright, 0), XEXP (opleft, 1));
2132
2133       /* Same, but for ashift that has been "simplified" to a wider mode
2134         by simplify_shift_const.  */
2135
2136       if (GET_CODE (opleft) == SUBREG
2137           && GET_CODE (SUBREG_REG (opleft)) == ASHIFT
2138           && GET_CODE (opright) == LSHIFTRT
2139           && GET_CODE (XEXP (opright, 0)) == SUBREG
2140           && GET_MODE (opleft) == GET_MODE (XEXP (opright, 0))
2141           && SUBREG_BYTE (opleft) == SUBREG_BYTE (XEXP (opright, 0))
2142           && (GET_MODE_SIZE (GET_MODE (opleft))
2143               < GET_MODE_SIZE (GET_MODE (SUBREG_REG (opleft))))
2144           && rtx_equal_p (XEXP (SUBREG_REG (opleft), 0),
2145                           SUBREG_REG (XEXP (opright, 0)))
2146           && GET_CODE (XEXP (SUBREG_REG (opleft), 1)) == CONST_INT
2147           && GET_CODE (XEXP (opright, 1)) == CONST_INT
2148           && (INTVAL (XEXP (SUBREG_REG (opleft), 1)) + INTVAL (XEXP (opright, 1))
2149               == GET_MODE_BITSIZE (mode)))
2150         return gen_rtx_ROTATE (mode, XEXP (opright, 0),
2151                                XEXP (SUBREG_REG (opleft), 1));
2152
2153       /* If we have (ior (and (X C1) C2)), simplify this by making
2154          C1 as small as possible if C1 actually changes.  */
2155       if (GET_CODE (op1) == CONST_INT
2156           && (GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
2157               || INTVAL (op1) > 0)
2158           && GET_CODE (op0) == AND
2159           && GET_CODE (XEXP (op0, 1)) == CONST_INT
2160           && GET_CODE (op1) == CONST_INT
2161           && (INTVAL (XEXP (op0, 1)) & INTVAL (op1)) != 0)
2162         return simplify_gen_binary (IOR, mode,
2163                                     simplify_gen_binary
2164                                           (AND, mode, XEXP (op0, 0),
2165                                            GEN_INT (INTVAL (XEXP (op0, 1))
2166                                                     & ~INTVAL (op1))),
2167                                     op1);
2168
2169       /* If OP0 is (ashiftrt (plus ...) C), it might actually be
2170          a (sign_extend (plus ...)).  Then check if OP1 is a CONST_INT and
2171          the PLUS does not affect any of the bits in OP1: then we can do
2172          the IOR as a PLUS and we can associate.  This is valid if OP1
2173          can be safely shifted left C bits.  */
2174       if (GET_CODE (trueop1) == CONST_INT && GET_CODE (op0) == ASHIFTRT
2175           && GET_CODE (XEXP (op0, 0)) == PLUS
2176           && GET_CODE (XEXP (XEXP (op0, 0), 1)) == CONST_INT
2177           && GET_CODE (XEXP (op0, 1)) == CONST_INT
2178           && INTVAL (XEXP (op0, 1)) < HOST_BITS_PER_WIDE_INT)
2179         {
2180           int count = INTVAL (XEXP (op0, 1));
2181           HOST_WIDE_INT mask = INTVAL (trueop1) << count;
2182
2183           if (mask >> count == INTVAL (trueop1)
2184               && (mask & nonzero_bits (XEXP (op0, 0), mode)) == 0)
2185             return simplify_gen_binary (ASHIFTRT, mode,
2186                                         plus_constant (XEXP (op0, 0), mask),
2187                                         XEXP (op0, 1));
2188         }
2189
2190       tem = simplify_associative_operation (code, mode, op0, op1);
2191       if (tem)
2192         return tem;
2193       break;
2194
2195     case XOR:
2196       if (trueop1 == const0_rtx)
2197         return op0;
2198       if (GET_CODE (trueop1) == CONST_INT
2199           && ((INTVAL (trueop1) & GET_MODE_MASK (mode))
2200               == GET_MODE_MASK (mode)))
2201         return simplify_gen_unary (NOT, mode, op0, mode);
2202       if (rtx_equal_p (trueop0, trueop1)
2203           && ! side_effects_p (op0)
2204           && GET_MODE_CLASS (mode) != MODE_CC)
2205          return CONST0_RTX (mode);
2206
2207       /* Canonicalize XOR of the most significant bit to PLUS.  */
2208       if ((GET_CODE (op1) == CONST_INT
2209            || GET_CODE (op1) == CONST_DOUBLE)
2210           && mode_signbit_p (mode, op1))
2211         return simplify_gen_binary (PLUS, mode, op0, op1);
2212       /* (xor (plus X C1) C2) is (xor X (C1^C2)) if C1 is signbit.  */
2213       if ((GET_CODE (op1) == CONST_INT
2214            || GET_CODE (op1) == CONST_DOUBLE)
2215           && GET_CODE (op0) == PLUS
2216           && (GET_CODE (XEXP (op0, 1)) == CONST_INT
2217               || GET_CODE (XEXP (op0, 1)) == CONST_DOUBLE)
2218           && mode_signbit_p (mode, XEXP (op0, 1)))
2219         return simplify_gen_binary (XOR, mode, XEXP (op0, 0),
2220                                     simplify_gen_binary (XOR, mode, op1,
2221                                                          XEXP (op0, 1)));
2222
2223       /* If we are XORing two things that have no bits in common,
2224          convert them into an IOR.  This helps to detect rotation encoded
2225          using those methods and possibly other simplifications.  */
2226
2227       if (GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
2228           && (nonzero_bits (op0, mode)
2229               & nonzero_bits (op1, mode)) == 0)
2230         return (simplify_gen_binary (IOR, mode, op0, op1));
2231
2232       /* Convert (XOR (NOT x) (NOT y)) to (XOR x y).
2233          Also convert (XOR (NOT x) y) to (NOT (XOR x y)), similarly for
2234          (NOT y).  */
2235       {
2236         int num_negated = 0;
2237
2238         if (GET_CODE (op0) == NOT)
2239           num_negated++, op0 = XEXP (op0, 0);
2240         if (GET_CODE (op1) == NOT)
2241           num_negated++, op1 = XEXP (op1, 0);
2242
2243         if (num_negated == 2)
2244           return simplify_gen_binary (XOR, mode, op0, op1);
2245         else if (num_negated == 1)
2246           return simplify_gen_unary (NOT, mode,
2247                                      simplify_gen_binary (XOR, mode, op0, op1),
2248                                      mode);
2249       }
2250
2251       /* Convert (xor (and A B) B) to (and (not A) B).  The latter may
2252          correspond to a machine insn or result in further simplifications
2253          if B is a constant.  */
2254
2255       if (GET_CODE (op0) == AND
2256           && rtx_equal_p (XEXP (op0, 1), op1)
2257           && ! side_effects_p (op1))
2258         return simplify_gen_binary (AND, mode,
2259                                     simplify_gen_unary (NOT, mode,
2260                                                         XEXP (op0, 0), mode),
2261                                     op1);
2262
2263       else if (GET_CODE (op0) == AND
2264                && rtx_equal_p (XEXP (op0, 0), op1)
2265                && ! side_effects_p (op1))
2266         return simplify_gen_binary (AND, mode,
2267                                     simplify_gen_unary (NOT, mode,
2268                                                         XEXP (op0, 1), mode),
2269                                     op1);
2270
2271       /* (xor (comparison foo bar) (const_int 1)) can become the reversed
2272          comparison if STORE_FLAG_VALUE is 1.  */
2273       if (STORE_FLAG_VALUE == 1
2274           && trueop1 == const1_rtx
2275           && COMPARISON_P (op0)
2276           && (reversed = reversed_comparison (op0, mode)))
2277         return reversed;
2278
2279       /* (lshiftrt foo C) where C is the number of bits in FOO minus 1
2280          is (lt foo (const_int 0)), so we can perform the above
2281          simplification if STORE_FLAG_VALUE is 1.  */
2282
2283       if (STORE_FLAG_VALUE == 1
2284           && trueop1 == const1_rtx
2285           && GET_CODE (op0) == LSHIFTRT
2286           && GET_CODE (XEXP (op0, 1)) == CONST_INT
2287           && INTVAL (XEXP (op0, 1)) == GET_MODE_BITSIZE (mode) - 1)
2288         return gen_rtx_GE (mode, XEXP (op0, 0), const0_rtx);
2289
2290       /* (xor (comparison foo bar) (const_int sign-bit))
2291          when STORE_FLAG_VALUE is the sign bit.  */
2292       if (GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
2293           && ((STORE_FLAG_VALUE & GET_MODE_MASK (mode))
2294               == (unsigned HOST_WIDE_INT) 1 << (GET_MODE_BITSIZE (mode) - 1))
2295           && trueop1 == const_true_rtx
2296           && COMPARISON_P (op0)
2297           && (reversed = reversed_comparison (op0, mode)))
2298         return reversed;
2299
2300       tem = simplify_associative_operation (code, mode, op0, op1);
2301       if (tem)
2302         return tem;
2303       break;
2304
2305     case AND:
2306       if (trueop1 == CONST0_RTX (mode) && ! side_effects_p (op0))
2307         return trueop1;
2308       if (GET_CODE (trueop1) == CONST_INT
2309           && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
2310         {
2311           HOST_WIDE_INT nzop0 = nonzero_bits (trueop0, mode);
2312           HOST_WIDE_INT val1 = INTVAL (trueop1);
2313           /* If we are turning off bits already known off in OP0, we need
2314              not do an AND.  */
2315           if ((nzop0 & ~val1) == 0)
2316             return op0;
2317           /* If we are clearing all the nonzero bits, the result is zero.  */
2318           if ((val1 & nzop0) == 0 && !side_effects_p (op0))
2319             return CONST0_RTX (mode);
2320         }
2321       if (rtx_equal_p (trueop0, trueop1) && ! side_effects_p (op0)
2322           && GET_MODE_CLASS (mode) != MODE_CC)
2323         return op0;
2324       /* A & (~A) -> 0 */
2325       if (((GET_CODE (op0) == NOT && rtx_equal_p (XEXP (op0, 0), op1))
2326            || (GET_CODE (op1) == NOT && rtx_equal_p (XEXP (op1, 0), op0)))
2327           && ! side_effects_p (op0)
2328           && GET_MODE_CLASS (mode) != MODE_CC)
2329         return CONST0_RTX (mode);
2330
2331       /* Transform (and (extend X) C) into (zero_extend (and X C)) if
2332          there are no nonzero bits of C outside of X's mode.  */
2333       if ((GET_CODE (op0) == SIGN_EXTEND
2334            || GET_CODE (op0) == ZERO_EXTEND)
2335           && GET_CODE (trueop1) == CONST_INT
2336           && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
2337           && (~GET_MODE_MASK (GET_MODE (XEXP (op0, 0)))
2338               & INTVAL (trueop1)) == 0)
2339         {
2340           enum machine_mode imode = GET_MODE (XEXP (op0, 0));
2341           tem = simplify_gen_binary (AND, imode, XEXP (op0, 0),
2342                                      gen_int_mode (INTVAL (trueop1),
2343                                                    imode));
2344           return simplify_gen_unary (ZERO_EXTEND, mode, tem, imode);
2345         }
2346
2347       /* Canonicalize (A | C1) & C2 as (A & C2) | (C1 & C2).  */
2348       if (GET_CODE (op0) == IOR
2349           && GET_CODE (trueop1) == CONST_INT
2350           && GET_CODE (XEXP (op0, 1)) == CONST_INT)
2351         {
2352           HOST_WIDE_INT tmp = INTVAL (trueop1) & INTVAL (XEXP (op0, 1));
2353           return simplify_gen_binary (IOR, mode,
2354                                       simplify_gen_binary (AND, mode,
2355                                                            XEXP (op0, 0), op1),
2356                                       gen_int_mode (tmp, mode));
2357         }
2358
2359       /* Convert (A ^ B) & A to A & (~B) since the latter is often a single
2360          insn (and may simplify more).  */
2361       if (GET_CODE (op0) == XOR
2362           && rtx_equal_p (XEXP (op0, 0), op1)
2363           && ! side_effects_p (op1))
2364         return simplify_gen_binary (AND, mode,
2365                                     simplify_gen_unary (NOT, mode,
2366                                                         XEXP (op0, 1), mode),
2367                                     op1);
2368
2369       if (GET_CODE (op0) == XOR
2370           && rtx_equal_p (XEXP (op0, 1), op1)
2371           && ! side_effects_p (op1))
2372         return simplify_gen_binary (AND, mode,
2373                                     simplify_gen_unary (NOT, mode,
2374                                                         XEXP (op0, 0), mode),
2375                                     op1);
2376
2377       /* Similarly for (~(A ^ B)) & A.  */
2378       if (GET_CODE (op0) == NOT
2379           && GET_CODE (XEXP (op0, 0)) == XOR
2380           && rtx_equal_p (XEXP (XEXP (op0, 0), 0), op1)
2381           && ! side_effects_p (op1))
2382         return simplify_gen_binary (AND, mode, XEXP (XEXP (op0, 0), 1), op1);
2383
2384       if (GET_CODE (op0) == NOT
2385           && GET_CODE (XEXP (op0, 0)) == XOR
2386           && rtx_equal_p (XEXP (XEXP (op0, 0), 1), op1)
2387           && ! side_effects_p (op1))
2388         return simplify_gen_binary (AND, mode, XEXP (XEXP (op0, 0), 0), op1);
2389
2390       /* Convert (A | B) & A to A.  */
2391       if (GET_CODE (op0) == IOR
2392           && (rtx_equal_p (XEXP (op0, 0), op1)
2393               || rtx_equal_p (XEXP (op0, 1), op1))
2394           && ! side_effects_p (XEXP (op0, 0))
2395           && ! side_effects_p (XEXP (op0, 1)))
2396         return op1;
2397
2398       /* For constants M and N, if M == (1LL << cst) - 1 && (N & M) == M,
2399          ((A & N) + B) & M -> (A + B) & M
2400          Similarly if (N & M) == 0,
2401          ((A | N) + B) & M -> (A + B) & M
2402          and for - instead of + and/or ^ instead of |.
2403          Also, if (N & M) == 0, then
2404          (A +- N) & M -> A & M.  */
2405       if (GET_CODE (trueop1) == CONST_INT
2406           && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
2407           && ~INTVAL (trueop1)
2408           && (INTVAL (trueop1) & (INTVAL (trueop1) + 1)) == 0
2409           && (GET_CODE (op0) == PLUS || GET_CODE (op0) == MINUS))
2410         {
2411           rtx pmop[2];
2412           int which;
2413
2414           pmop[0] = XEXP (op0, 0);
2415           pmop[1] = XEXP (op0, 1);
2416
2417           if (GET_CODE (pmop[1]) == CONST_INT
2418               && (INTVAL (pmop[1]) & INTVAL (trueop1)) == 0)
2419             return simplify_gen_binary (AND, mode, pmop[0], op1);
2420
2421           for (which = 0; which < 2; which++)
2422             {
2423               tem = pmop[which];
2424               switch (GET_CODE (tem))
2425                 {
2426                 case AND:
2427                   if (GET_CODE (XEXP (tem, 1)) == CONST_INT
2428                       && (INTVAL (XEXP (tem, 1)) & INTVAL (trueop1))
2429                       == INTVAL (trueop1))
2430                     pmop[which] = XEXP (tem, 0);
2431                   break;
2432                 case IOR:
2433                 case XOR:
2434                   if (GET_CODE (XEXP (tem, 1)) == CONST_INT
2435                       && (INTVAL (XEXP (tem, 1)) & INTVAL (trueop1)) == 0)
2436                     pmop[which] = XEXP (tem, 0);
2437                   break;
2438                 default:
2439                   break;
2440                 }
2441             }
2442
2443           if (pmop[0] != XEXP (op0, 0) || pmop[1] != XEXP (op0, 1))
2444             {
2445               tem = simplify_gen_binary (GET_CODE (op0), mode,
2446                                          pmop[0], pmop[1]);
2447               return simplify_gen_binary (code, mode, tem, op1);
2448             }
2449         }
2450
2451       /* (and X (ior (not X) Y) -> (and X Y) */
2452       if (GET_CODE (op1) == IOR
2453           && GET_CODE (XEXP (op1, 0)) == NOT
2454           && op0 == XEXP (XEXP (op1, 0), 0))
2455        return simplify_gen_binary (AND, mode, op0, XEXP (op1, 1));
2456
2457       /* (and (ior (not X) Y) X) -> (and X Y) */
2458       if (GET_CODE (op0) == IOR
2459           && GET_CODE (XEXP (op0, 0)) == NOT
2460           && op1 == XEXP (XEXP (op0, 0), 0))
2461         return simplify_gen_binary (AND, mode, op1, XEXP (op0, 1));
2462
2463       tem = simplify_associative_operation (code, mode, op0, op1);
2464       if (tem)
2465         return tem;
2466       break;
2467
2468     case UDIV:
2469       /* 0/x is 0 (or x&0 if x has side-effects).  */
2470       if (trueop0 == CONST0_RTX (mode))
2471         {
2472           if (side_effects_p (op1))
2473             return simplify_gen_binary (AND, mode, op1, trueop0);
2474           return trueop0;
2475         }
2476       /* x/1 is x.  */
2477       if (trueop1 == CONST1_RTX (mode))
2478         return rtl_hooks.gen_lowpart_no_emit (mode, op0);
2479       /* Convert divide by power of two into shift.  */
2480       if (GET_CODE (trueop1) == CONST_INT
2481           && (val = exact_log2 (INTVAL (trueop1))) > 0)
2482         return simplify_gen_binary (LSHIFTRT, mode, op0, GEN_INT (val));
2483       break;
2484
2485     case DIV:
2486       /* Handle floating point and integers separately.  */
2487       if (SCALAR_FLOAT_MODE_P (mode))
2488         {
2489           /* Maybe change 0.0 / x to 0.0.  This transformation isn't
2490              safe for modes with NaNs, since 0.0 / 0.0 will then be
2491              NaN rather than 0.0.  Nor is it safe for modes with signed
2492              zeros, since dividing 0 by a negative number gives -0.0  */
2493           if (trueop0 == CONST0_RTX (mode)
2494               && !HONOR_NANS (mode)
2495               && !HONOR_SIGNED_ZEROS (mode)
2496               && ! side_effects_p (op1))
2497             return op0;
2498           /* x/1.0 is x.  */
2499           if (trueop1 == CONST1_RTX (mode)
2500               && !HONOR_SNANS (mode))
2501             return op0;
2502
2503           if (GET_CODE (trueop1) == CONST_DOUBLE
2504               && trueop1 != CONST0_RTX (mode))
2505             {
2506               REAL_VALUE_TYPE d;
2507               REAL_VALUE_FROM_CONST_DOUBLE (d, trueop1);
2508
2509               /* x/-1.0 is -x.  */
2510               if (REAL_VALUES_EQUAL (d, dconstm1)
2511                   && !HONOR_SNANS (mode))
2512                 return simplify_gen_unary (NEG, mode, op0, mode);
2513
2514               /* Change FP division by a constant into multiplication.
2515                  Only do this with -freciprocal-math.  */
2516               if (flag_reciprocal_math
2517                   && !REAL_VALUES_EQUAL (d, dconst0))
2518                 {
2519                   REAL_ARITHMETIC (d, RDIV_EXPR, dconst1, d);
2520                   tem = CONST_DOUBLE_FROM_REAL_VALUE (d, mode);
2521                   return simplify_gen_binary (MULT, mode, op0, tem);
2522                 }
2523             }
2524         }
2525       else
2526         {
2527           /* 0/x is 0 (or x&0 if x has side-effects).  */
2528           if (trueop0 == CONST0_RTX (mode))
2529             {
2530               if (side_effects_p (op1))
2531                 return simplify_gen_binary (AND, mode, op1, trueop0);
2532               return trueop0;
2533             }
2534           /* x/1 is x.  */
2535           if (trueop1 == CONST1_RTX (mode))
2536             return rtl_hooks.gen_lowpart_no_emit (mode, op0);
2537           /* x/-1 is -x.  */
2538           if (trueop1 == constm1_rtx)
2539             {
2540               rtx x = rtl_hooks.gen_lowpart_no_emit (mode, op0);
2541               return simplify_gen_unary (NEG, mode, x, mode);
2542             }
2543         }
2544       break;
2545
2546     case UMOD:
2547       /* 0%x is 0 (or x&0 if x has side-effects).  */
2548       if (trueop0 == CONST0_RTX (mode))
2549         {
2550           if (side_effects_p (op1))
2551             return simplify_gen_binary (AND, mode, op1, trueop0);
2552           return trueop0;
2553         }
2554       /* x%1 is 0 (of x&0 if x has side-effects).  */
2555       if (trueop1 == CONST1_RTX (mode))
2556         {
2557           if (side_effects_p (op0))
2558             return simplify_gen_binary (AND, mode, op0, CONST0_RTX (mode));
2559           return CONST0_RTX (mode);
2560         }
2561       /* Implement modulus by power of two as AND.  */
2562       if (GET_CODE (trueop1) == CONST_INT
2563           && exact_log2 (INTVAL (trueop1)) > 0)
2564         return simplify_gen_binary (AND, mode, op0,
2565                                     GEN_INT (INTVAL (op1) - 1));
2566       break;
2567
2568     case MOD:
2569       /* 0%x is 0 (or x&0 if x has side-effects).  */
2570       if (trueop0 == CONST0_RTX (mode))
2571         {
2572           if (side_effects_p (op1))
2573             return simplify_gen_binary (AND, mode, op1, trueop0);
2574           return trueop0;
2575         }
2576       /* x%1 and x%-1 is 0 (or x&0 if x has side-effects).  */
2577       if (trueop1 == CONST1_RTX (mode) || trueop1 == constm1_rtx)
2578         {
2579           if (side_effects_p (op0))
2580             return simplify_gen_binary (AND, mode, op0, CONST0_RTX (mode));
2581           return CONST0_RTX (mode);
2582         }
2583       break;
2584
2585     case ROTATERT:
2586     case ROTATE:
2587     case ASHIFTRT:
2588       if (trueop1 == CONST0_RTX (mode))
2589         return op0;
2590       if (trueop0 == CONST0_RTX (mode) && ! side_effects_p (op1))
2591         return op0;
2592       /* Rotating ~0 always results in ~0.  */
2593       if (GET_CODE (trueop0) == CONST_INT && width <= HOST_BITS_PER_WIDE_INT
2594           && (unsigned HOST_WIDE_INT) INTVAL (trueop0) == GET_MODE_MASK (mode)
2595           && ! side_effects_p (op1))
2596         return op0;
2597     canonicalize_shift:
2598       if (SHIFT_COUNT_TRUNCATED && GET_CODE (op1) == CONST_INT)
2599         {
2600           val = INTVAL (op1) & (GET_MODE_BITSIZE (mode) - 1);
2601           if (val != INTVAL (op1))
2602             return simplify_gen_binary (code, mode, op0, GEN_INT (val));
2603         }
2604       break;
2605
2606     case ASHIFT:
2607     case SS_ASHIFT:
2608     case US_ASHIFT:
2609       if (trueop1 == CONST0_RTX (mode))
2610         return op0;
2611       if (trueop0 == CONST0_RTX (mode) && ! side_effects_p (op1))
2612         return op0;
2613       goto canonicalize_shift;
2614
2615     case LSHIFTRT:
2616       if (trueop1 == CONST0_RTX (mode))
2617         return op0;
2618       if (trueop0 == CONST0_RTX (mode) && ! side_effects_p (op1))
2619         return op0;
2620       /* Optimize (lshiftrt (clz X) C) as (eq X 0).  */
2621       if (GET_CODE (op0) == CLZ
2622           && GET_CODE (trueop1) == CONST_INT
2623           && STORE_FLAG_VALUE == 1
2624           && INTVAL (trueop1) < (HOST_WIDE_INT)width)
2625         {
2626           enum machine_mode imode = GET_MODE (XEXP (op0, 0));
2627           unsigned HOST_WIDE_INT zero_val = 0;
2628
2629           if (CLZ_DEFINED_VALUE_AT_ZERO (imode, zero_val)
2630               && zero_val == GET_MODE_BITSIZE (imode)
2631               && INTVAL (trueop1) == exact_log2 (zero_val))
2632             return simplify_gen_relational (EQ, mode, imode,
2633                                             XEXP (op0, 0), const0_rtx);
2634         }
2635       goto canonicalize_shift;
2636
2637     case SMIN:
2638       if (width <= HOST_BITS_PER_WIDE_INT
2639           && GET_CODE (trueop1) == CONST_INT
2640           && INTVAL (trueop1) == (HOST_WIDE_INT) 1 << (width -1)
2641           && ! side_effects_p (op0))
2642         return op1;
2643       if (rtx_equal_p (trueop0, trueop1) && ! side_effects_p (op0))
2644         return op0;
2645       tem = simplify_associative_operation (code, mode, op0, op1);
2646       if (tem)
2647         return tem;
2648       break;
2649
2650     case SMAX:
2651       if (width <= HOST_BITS_PER_WIDE_INT
2652           && GET_CODE (trueop1) == CONST_INT
2653           && ((unsigned HOST_WIDE_INT) INTVAL (trueop1)
2654               == (unsigned HOST_WIDE_INT) GET_MODE_MASK (mode) >> 1)
2655           && ! side_effects_p (op0))
2656         return op1;
2657       if (rtx_equal_p (trueop0, trueop1) && ! side_effects_p (op0))
2658         return op0;
2659       tem = simplify_associative_operation (code, mode, op0, op1);
2660       if (tem)
2661         return tem;
2662       break;
2663
2664     case UMIN:
2665       if (trueop1 == CONST0_RTX (mode) && ! side_effects_p (op0))
2666         return op1;
2667       if (rtx_equal_p (trueop0, trueop1) && ! side_effects_p (op0))
2668         return op0;
2669       tem = simplify_associative_operation (code, mode, op0, op1);
2670       if (tem)
2671         return tem;
2672       break;
2673
2674     case UMAX:
2675       if (trueop1 == constm1_rtx && ! side_effects_p (op0))
2676         return op1;
2677       if (rtx_equal_p (trueop0, trueop1) && ! side_effects_p (op0))
2678         return op0;
2679       tem = simplify_associative_operation (code, mode, op0, op1);
2680       if (tem)
2681         return tem;
2682       break;
2683
2684     case SS_PLUS:
2685     case US_PLUS:
2686     case SS_MINUS:
2687     case US_MINUS:
2688     case SS_MULT:
2689     case US_MULT:
2690     case SS_DIV:
2691     case US_DIV:
2692       /* ??? There are simplifications that can be done.  */
2693       return 0;
2694
2695     case VEC_SELECT:
2696       if (!VECTOR_MODE_P (mode))
2697         {
2698           gcc_assert (VECTOR_MODE_P (GET_MODE (trueop0)));
2699           gcc_assert (mode == GET_MODE_INNER (GET_MODE (trueop0)));
2700           gcc_assert (GET_CODE (trueop1) == PARALLEL);
2701           gcc_assert (XVECLEN (trueop1, 0) == 1);
2702           gcc_assert (GET_CODE (XVECEXP (trueop1, 0, 0)) == CONST_INT);
2703
2704           if (GET_CODE (trueop0) == CONST_VECTOR)
2705             return CONST_VECTOR_ELT (trueop0, INTVAL (XVECEXP
2706                                                       (trueop1, 0, 0)));
2707
2708           /* Extract a scalar element from a nested VEC_SELECT expression
2709              (with optional nested VEC_CONCAT expression).  Some targets
2710              (i386) extract scalar element from a vector using chain of
2711              nested VEC_SELECT expressions.  When input operand is a memory
2712              operand, this operation can be simplified to a simple scalar
2713              load from an offseted memory address.  */
2714           if (GET_CODE (trueop0) == VEC_SELECT)
2715             {
2716               rtx op0 = XEXP (trueop0, 0);
2717               rtx op1 = XEXP (trueop0, 1);
2718
2719               enum machine_mode opmode = GET_MODE (op0);
2720               int elt_size = GET_MODE_SIZE (GET_MODE_INNER (opmode));
2721               int n_elts = GET_MODE_SIZE (opmode) / elt_size;
2722
2723               int i = INTVAL (XVECEXP (trueop1, 0, 0));
2724               int elem;
2725
2726               rtvec vec;
2727               rtx tmp_op, tmp;
2728
2729               gcc_assert (GET_CODE (op1) == PARALLEL);
2730               gcc_assert (i < n_elts);
2731
2732               /* Select element, pointed by nested selector.  */
2733               elem = INTVAL (XVECEXP (op1, 0, i));
2734
2735               /* Handle the case when nested VEC_SELECT wraps VEC_CONCAT.  */
2736               if (GET_CODE (op0) == VEC_CONCAT)
2737                 {
2738                   rtx op00 = XEXP (op0, 0);
2739                   rtx op01 = XEXP (op0, 1);
2740
2741                   enum machine_mode mode00, mode01;
2742                   int n_elts00, n_elts01;
2743
2744                   mode00 = GET_MODE (op00);
2745                   mode01 = GET_MODE (op01);
2746
2747                   /* Find out number of elements of each operand.  */
2748                   if (VECTOR_MODE_P (mode00))
2749                     {
2750                       elt_size = GET_MODE_SIZE (GET_MODE_INNER (mode00));
2751                       n_elts00 = GET_MODE_SIZE (mode00) / elt_size;
2752                     }
2753                   else
2754                     n_elts00 = 1;
2755
2756                   if (VECTOR_MODE_P (mode01))
2757                     {
2758                       elt_size = GET_MODE_SIZE (GET_MODE_INNER (mode01));
2759                       n_elts01 = GET_MODE_SIZE (mode01) / elt_size;
2760                     }
2761                   else
2762                     n_elts01 = 1;
2763
2764                   gcc_assert (n_elts == n_elts00 + n_elts01);
2765
2766                   /* Select correct operand of VEC_CONCAT
2767                      and adjust selector. */
2768                   if (elem < n_elts01)
2769                     tmp_op = op00;
2770                   else
2771                     {
2772                       tmp_op = op01;
2773                       elem -= n_elts00;
2774                     }
2775                 }
2776               else
2777                 tmp_op = op0;
2778
2779               vec = rtvec_alloc (1);
2780               RTVEC_ELT (vec, 0) = GEN_INT (elem);
2781
2782               tmp = gen_rtx_fmt_ee (code, mode,
2783                                     tmp_op, gen_rtx_PARALLEL (VOIDmode, vec));
2784               return tmp;
2785             }
2786         }
2787       else
2788         {
2789           gcc_assert (VECTOR_MODE_P (GET_MODE (trueop0)));
2790           gcc_assert (GET_MODE_INNER (mode)
2791                       == GET_MODE_INNER (GET_MODE (trueop0)));
2792           gcc_assert (GET_CODE (trueop1) == PARALLEL);
2793
2794           if (GET_CODE (trueop0) == CONST_VECTOR)
2795             {
2796               int elt_size = GET_MODE_SIZE (GET_MODE_INNER (mode));
2797               unsigned n_elts = (GET_MODE_SIZE (mode) / elt_size);
2798               rtvec v = rtvec_alloc (n_elts);
2799               unsigned int i;
2800
2801               gcc_assert (XVECLEN (trueop1, 0) == (int) n_elts);
2802               for (i = 0; i < n_elts; i++)
2803                 {
2804                   rtx x = XVECEXP (trueop1, 0, i);
2805
2806                   gcc_assert (GET_CODE (x) == CONST_INT);
2807                   RTVEC_ELT (v, i) = CONST_VECTOR_ELT (trueop0,
2808                                                        INTVAL (x));
2809                 }
2810
2811               return gen_rtx_CONST_VECTOR (mode, v);
2812             }
2813         }
2814
2815       if (XVECLEN (trueop1, 0) == 1
2816           && GET_CODE (XVECEXP (trueop1, 0, 0)) == CONST_INT
2817           && GET_CODE (trueop0) == VEC_CONCAT)
2818         {
2819           rtx vec = trueop0;
2820           int offset = INTVAL (XVECEXP (trueop1, 0, 0)) * GET_MODE_SIZE (mode);
2821
2822           /* Try to find the element in the VEC_CONCAT.  */
2823           while (GET_MODE (vec) != mode
2824                  && GET_CODE (vec) == VEC_CONCAT)
2825             {
2826               HOST_WIDE_INT vec_size = GET_MODE_SIZE (GET_MODE (XEXP (vec, 0)));
2827               if (offset < vec_size)
2828                 vec = XEXP (vec, 0);
2829               else
2830                 {
2831                   offset -= vec_size;
2832                   vec = XEXP (vec, 1);
2833                 }
2834               vec = avoid_constant_pool_reference (vec);
2835             }
2836
2837           if (GET_MODE (vec) == mode)
2838             return vec;
2839         }
2840
2841       return 0;
2842     case VEC_CONCAT:
2843       {
2844         enum machine_mode op0_mode = (GET_MODE (trueop0) != VOIDmode
2845                                       ? GET_MODE (trueop0)
2846                                       : GET_MODE_INNER (mode));
2847         enum machine_mode op1_mode = (GET_MODE (trueop1) != VOIDmode
2848                                       ? GET_MODE (trueop1)
2849                                       : GET_MODE_INNER (mode));
2850
2851         gcc_assert (VECTOR_MODE_P (mode));
2852         gcc_assert (GET_MODE_SIZE (op0_mode) + GET_MODE_SIZE (op1_mode)
2853                     == GET_MODE_SIZE (mode));
2854
2855         if (VECTOR_MODE_P (op0_mode))
2856           gcc_assert (GET_MODE_INNER (mode)
2857                       == GET_MODE_INNER (op0_mode));
2858         else
2859           gcc_assert (GET_MODE_INNER (mode) == op0_mode);
2860
2861         if (VECTOR_MODE_P (op1_mode))
2862           gcc_assert (GET_MODE_INNER (mode)
2863                       == GET_MODE_INNER (op1_mode));
2864         else
2865           gcc_assert (GET_MODE_INNER (mode) == op1_mode);
2866
2867         if ((GET_CODE (trueop0) == CONST_VECTOR
2868              || GET_CODE (trueop0) == CONST_INT
2869              || GET_CODE (trueop0) == CONST_DOUBLE)
2870             && (GET_CODE (trueop1) == CONST_VECTOR
2871                 || GET_CODE (trueop1) == CONST_INT
2872                 || GET_CODE (trueop1) == CONST_DOUBLE))
2873           {
2874             int elt_size = GET_MODE_SIZE (GET_MODE_INNER (mode));
2875             unsigned n_elts = (GET_MODE_SIZE (mode) / elt_size);
2876             rtvec v = rtvec_alloc (n_elts);
2877             unsigned int i;
2878             unsigned in_n_elts = 1;
2879
2880             if (VECTOR_MODE_P (op0_mode))
2881               in_n_elts = (GET_MODE_SIZE (op0_mode) / elt_size);
2882             for (i = 0; i < n_elts; i++)
2883               {
2884                 if (i < in_n_elts)
2885                   {
2886                     if (!VECTOR_MODE_P (op0_mode))
2887                       RTVEC_ELT (v, i) = trueop0;
2888                     else
2889                       RTVEC_ELT (v, i) = CONST_VECTOR_ELT (trueop0, i);
2890                   }
2891                 else
2892                   {
2893                     if (!VECTOR_MODE_P (op1_mode))
2894                       RTVEC_ELT (v, i) = trueop1;
2895                     else
2896                       RTVEC_ELT (v, i) = CONST_VECTOR_ELT (trueop1,
2897                                                            i - in_n_elts);
2898                   }
2899               }
2900
2901             return gen_rtx_CONST_VECTOR (mode, v);
2902           }
2903       }
2904       return 0;
2905
2906     default:
2907       gcc_unreachable ();
2908     }
2909
2910   return 0;
2911 }
2912
2913 rtx
2914 simplify_const_binary_operation (enum rtx_code code, enum machine_mode mode,
2915                                  rtx op0, rtx op1)
2916 {
2917   HOST_WIDE_INT arg0, arg1, arg0s, arg1s;
2918   HOST_WIDE_INT val;
2919   unsigned int width = GET_MODE_BITSIZE (mode);
2920
2921   if (VECTOR_MODE_P (mode)
2922       && code != VEC_CONCAT
2923       && GET_CODE (op0) == CONST_VECTOR
2924       && GET_CODE (op1) == CONST_VECTOR)
2925     {
2926       unsigned n_elts = GET_MODE_NUNITS (mode);
2927       enum machine_mode op0mode = GET_MODE (op0);
2928       unsigned op0_n_elts = GET_MODE_NUNITS (op0mode);
2929       enum machine_mode op1mode = GET_MODE (op1);
2930       unsigned op1_n_elts = GET_MODE_NUNITS (op1mode);
2931       rtvec v = rtvec_alloc (n_elts);
2932       unsigned int i;
2933
2934       gcc_assert (op0_n_elts == n_elts);
2935       gcc_assert (op1_n_elts == n_elts);
2936       for (i = 0; i < n_elts; i++)
2937         {
2938           rtx x = simplify_binary_operation (code, GET_MODE_INNER (mode),
2939                                              CONST_VECTOR_ELT (op0, i),
2940                                              CONST_VECTOR_ELT (op1, i));
2941           if (!x)
2942             return 0;
2943           RTVEC_ELT (v, i) = x;
2944         }
2945
2946       return gen_rtx_CONST_VECTOR (mode, v);
2947     }
2948
2949   if (VECTOR_MODE_P (mode)
2950       && code == VEC_CONCAT
2951       && (CONST_INT_P (op0)
2952           || GET_CODE (op0) == CONST_DOUBLE
2953           || GET_CODE (op0) == CONST_FIXED)
2954       && (CONST_INT_P (op1)
2955           || GET_CODE (op1) == CONST_DOUBLE
2956           || GET_CODE (op1) == CONST_FIXED))
2957     {
2958       unsigned n_elts = GET_MODE_NUNITS (mode);
2959       rtvec v = rtvec_alloc (n_elts);
2960
2961       gcc_assert (n_elts >= 2);
2962       if (n_elts == 2)
2963         {
2964           gcc_assert (GET_CODE (op0) != CONST_VECTOR);
2965           gcc_assert (GET_CODE (op1) != CONST_VECTOR);
2966
2967           RTVEC_ELT (v, 0) = op0;
2968           RTVEC_ELT (v, 1) = op1;
2969         }
2970       else
2971         {
2972           unsigned op0_n_elts = GET_MODE_NUNITS (GET_MODE (op0));
2973           unsigned op1_n_elts = GET_MODE_NUNITS (GET_MODE (op1));
2974           unsigned i;
2975
2976           gcc_assert (GET_CODE (op0) == CONST_VECTOR);
2977           gcc_assert (GET_CODE (op1) == CONST_VECTOR);
2978           gcc_assert (op0_n_elts + op1_n_elts == n_elts);
2979
2980           for (i = 0; i < op0_n_elts; ++i)
2981             RTVEC_ELT (v, i) = XVECEXP (op0, 0, i);
2982           for (i = 0; i < op1_n_elts; ++i)
2983             RTVEC_ELT (v, op0_n_elts+i) = XVECEXP (op1, 0, i);
2984         }
2985
2986       return gen_rtx_CONST_VECTOR (mode, v);
2987     }
2988
2989   if (SCALAR_FLOAT_MODE_P (mode)
2990       && GET_CODE (op0) == CONST_DOUBLE
2991       && GET_CODE (op1) == CONST_DOUBLE
2992       && mode == GET_MODE (op0) && mode == GET_MODE (op1))
2993     {
2994       if (code == AND
2995           || code == IOR
2996           || code == XOR)
2997         {
2998           long tmp0[4];
2999           long tmp1[4];
3000           REAL_VALUE_TYPE r;
3001           int i;
3002
3003           real_to_target (tmp0, CONST_DOUBLE_REAL_VALUE (op0),
3004                           GET_MODE (op0));
3005           real_to_target (tmp1, CONST_DOUBLE_REAL_VALUE (op1),
3006                           GET_MODE (op1));
3007           for (i = 0; i < 4; i++)
3008             {
3009               switch (code)
3010               {
3011               case AND:
3012                 tmp0[i] &= tmp1[i];
3013                 break;
3014               case IOR:
3015                 tmp0[i] |= tmp1[i];
3016                 break;
3017               case XOR:
3018                 tmp0[i] ^= tmp1[i];
3019                 break;
3020               default:
3021                 gcc_unreachable ();
3022               }
3023             }
3024            real_from_target (&r, tmp0, mode);
3025            return CONST_DOUBLE_FROM_REAL_VALUE (r, mode);
3026         }
3027       else
3028         {
3029           REAL_VALUE_TYPE f0, f1, value, result;
3030           bool inexact;
3031
3032           REAL_VALUE_FROM_CONST_DOUBLE (f0, op0);
3033           REAL_VALUE_FROM_CONST_DOUBLE (f1, op1);
3034           real_convert (&f0, mode, &f0);
3035           real_convert (&f1, mode, &f1);
3036
3037           if (HONOR_SNANS (mode)
3038               && (REAL_VALUE_ISNAN (f0) || REAL_VALUE_ISNAN (f1)))
3039             return 0;
3040
3041           if (code == DIV
3042               && REAL_VALUES_EQUAL (f1, dconst0)
3043               && (flag_trapping_math || ! MODE_HAS_INFINITIES (mode)))
3044             return 0;
3045
3046           if (MODE_HAS_INFINITIES (mode) && HONOR_NANS (mode)
3047               && flag_trapping_math
3048               && REAL_VALUE_ISINF (f0) && REAL_VALUE_ISINF (f1))
3049             {
3050               int s0 = REAL_VALUE_NEGATIVE (f0);
3051               int s1 = REAL_VALUE_NEGATIVE (f1);
3052
3053               switch (code)
3054                 {
3055                 case PLUS:
3056                   /* Inf + -Inf = NaN plus exception.  */
3057                   if (s0 != s1)
3058                     return 0;
3059                   break;
3060                 case MINUS:
3061                   /* Inf - Inf = NaN plus exception.  */
3062                   if (s0 == s1)
3063                     return 0;
3064                   break;
3065                 case DIV:
3066                   /* Inf / Inf = NaN plus exception.  */
3067                   return 0;
3068                 default:
3069                   break;
3070                 }
3071             }
3072
3073           if (code == MULT && MODE_HAS_INFINITIES (mode) && HONOR_NANS (mode)
3074               && flag_trapping_math
3075               && ((REAL_VALUE_ISINF (f0) && REAL_VALUES_EQUAL (f1, dconst0))
3076                   || (REAL_VALUE_ISINF (f1)
3077                       && REAL_VALUES_EQUAL (f0, dconst0))))
3078             /* Inf * 0 = NaN plus exception.  */
3079             return 0;
3080
3081           inexact = real_arithmetic (&value, rtx_to_tree_code (code),
3082                                      &f0, &f1);
3083           real_convert (&result, mode, &value);
3084
3085           /* Don't constant fold this floating point operation if
3086              the result has overflowed and flag_trapping_math.  */
3087
3088           if (flag_trapping_math
3089               && MODE_HAS_INFINITIES (mode)
3090               && REAL_VALUE_ISINF (result)
3091               && !REAL_VALUE_ISINF (f0)
3092               && !REAL_VALUE_ISINF (f1))
3093             /* Overflow plus exception.  */
3094             return 0;
3095
3096           /* Don't constant fold this floating point operation if the
3097              result may dependent upon the run-time rounding mode and
3098              flag_rounding_math is set, or if GCC's software emulation
3099              is unable to accurately represent the result.  */
3100
3101           if ((flag_rounding_math
3102                || (MODE_COMPOSITE_P (mode) && !flag_unsafe_math_optimizations))
3103               && (inexact || !real_identical (&result, &value)))
3104             return NULL_RTX;
3105
3106           return CONST_DOUBLE_FROM_REAL_VALUE (result, mode);
3107         }
3108     }
3109
3110   /* We can fold some multi-word operations.  */
3111   if (GET_MODE_CLASS (mode) == MODE_INT
3112       && width == HOST_BITS_PER_WIDE_INT * 2
3113       && (GET_CODE (op0) == CONST_DOUBLE || GET_CODE (op0) == CONST_INT)
3114       && (GET_CODE (op1) == CONST_DOUBLE || GET_CODE (op1) == CONST_INT))
3115     {
3116       unsigned HOST_WIDE_INT l1, l2, lv, lt;
3117       HOST_WIDE_INT h1, h2, hv, ht;
3118
3119       if (GET_CODE (op0) == CONST_DOUBLE)
3120         l1 = CONST_DOUBLE_LOW (op0), h1 = CONST_DOUBLE_HIGH (op0);
3121       else
3122         l1 = INTVAL (op0), h1 = HWI_SIGN_EXTEND (l1);
3123
3124       if (GET_CODE (op1) == CONST_DOUBLE)
3125         l2 = CONST_DOUBLE_LOW (op1), h2 = CONST_DOUBLE_HIGH (op1);
3126       else
3127         l2 = INTVAL (op1), h2 = HWI_SIGN_EXTEND (l2);
3128
3129       switch (code)
3130         {
3131         case MINUS:
3132           /* A - B == A + (-B).  */
3133           neg_double (l2, h2, &lv, &hv);
3134           l2 = lv, h2 = hv;
3135
3136           /* Fall through....  */
3137
3138         case PLUS:
3139           add_double (l1, h1, l2, h2, &lv, &hv);
3140           break;
3141
3142         case MULT:
3143           mul_double (l1, h1, l2, h2, &lv, &hv);
3144           break;
3145
3146         case DIV:
3147           if (div_and_round_double (TRUNC_DIV_EXPR, 0, l1, h1, l2, h2,
3148                                     &lv, &hv, &lt, &ht))
3149             return 0;
3150           break;
3151
3152         case MOD:
3153           if (div_and_round_double (TRUNC_DIV_EXPR, 0, l1, h1, l2, h2,
3154                                     &lt, &ht, &lv, &hv))
3155             return 0;
3156           break;
3157
3158         case UDIV:
3159           if (div_and_round_double (TRUNC_DIV_EXPR, 1, l1, h1, l2, h2,
3160                                     &lv, &hv, &lt, &ht))
3161             return 0;
3162           break;
3163
3164         case UMOD:
3165           if (div_and_round_double (TRUNC_DIV_EXPR, 1, l1, h1, l2, h2,
3166                                     &lt, &ht, &lv, &hv))
3167             return 0;
3168           break;
3169
3170         case AND:
3171           lv = l1 & l2, hv = h1 & h2;
3172           break;
3173
3174         case IOR:
3175           lv = l1 | l2, hv = h1 | h2;
3176           break;
3177
3178         case XOR:
3179           lv = l1 ^ l2, hv = h1 ^ h2;
3180           break;
3181
3182         case SMIN:
3183           if (h1 < h2
3184               || (h1 == h2
3185                   && ((unsigned HOST_WIDE_INT) l1
3186                       < (unsigned HOST_WIDE_INT) l2)))
3187             lv = l1, hv = h1;
3188           else
3189             lv = l2, hv = h2;
3190           break;
3191
3192         case SMAX:
3193           if (h1 > h2
3194               || (h1 == h2
3195                   && ((unsigned HOST_WIDE_INT) l1
3196                       > (unsigned HOST_WIDE_INT) l2)))
3197             lv = l1, hv = h1;
3198           else
3199             lv = l2, hv = h2;
3200           break;
3201
3202         case UMIN:
3203           if ((unsigned HOST_WIDE_INT) h1 < (unsigned HOST_WIDE_INT) h2
3204               || (h1 == h2
3205                   && ((unsigned HOST_WIDE_INT) l1
3206                       < (unsigned HOST_WIDE_INT) l2)))
3207             lv = l1, hv = h1;
3208           else
3209             lv = l2, hv = h2;
3210           break;
3211
3212         case UMAX:
3213           if ((unsigned HOST_WIDE_INT) h1 > (unsigned HOST_WIDE_INT) h2
3214               || (h1 == h2
3215                   && ((unsigned HOST_WIDE_INT) l1
3216                       > (unsigned HOST_WIDE_INT) l2)))
3217             lv = l1, hv = h1;
3218           else
3219             lv = l2, hv = h2;
3220           break;
3221
3222         case LSHIFTRT:   case ASHIFTRT:
3223         case ASHIFT:
3224         case ROTATE:     case ROTATERT:
3225           if (SHIFT_COUNT_TRUNCATED)
3226             l2 &= (GET_MODE_BITSIZE (mode) - 1), h2 = 0;
3227
3228           if (h2 != 0 || l2 >= GET_MODE_BITSIZE (mode))
3229             return 0;
3230
3231           if (code == LSHIFTRT || code == ASHIFTRT)
3232             rshift_double (l1, h1, l2, GET_MODE_BITSIZE (mode), &lv, &hv,
3233                            code == ASHIFTRT);
3234           else if (code == ASHIFT)
3235             lshift_double (l1, h1, l2, GET_MODE_BITSIZE (mode), &lv, &hv, 1);
3236           else if (code == ROTATE)
3237             lrotate_double (l1, h1, l2, GET_MODE_BITSIZE (mode), &lv, &hv);
3238           else /* code == ROTATERT */
3239             rrotate_double (l1, h1, l2, GET_MODE_BITSIZE (mode), &lv, &hv);
3240           break;
3241
3242         default:
3243           return 0;
3244         }
3245
3246       return immed_double_const (lv, hv, mode);
3247     }
3248
3249   if (GET_CODE (op0) == CONST_INT && GET_CODE (op1) == CONST_INT
3250       && width <= HOST_BITS_PER_WIDE_INT && width != 0)
3251     {
3252       /* Get the integer argument values in two forms:
3253          zero-extended in ARG0, ARG1 and sign-extended in ARG0S, ARG1S.  */
3254
3255       arg0 = INTVAL (op0);
3256       arg1 = INTVAL (op1);
3257
3258       if (width < HOST_BITS_PER_WIDE_INT)
3259         {
3260           arg0 &= ((HOST_WIDE_INT) 1 << width) - 1;
3261           arg1 &= ((HOST_WIDE_INT) 1 << width) - 1;
3262
3263           arg0s = arg0;
3264           if (arg0s & ((HOST_WIDE_INT) 1 << (width - 1)))
3265             arg0s |= ((HOST_WIDE_INT) (-1) << width);
3266
3267           arg1s = arg1;
3268           if (arg1s & ((HOST_WIDE_INT) 1 << (width - 1)))
3269             arg1s |= ((HOST_WIDE_INT) (-1) << width);
3270         }
3271       else
3272         {
3273           arg0s = arg0;
3274           arg1s = arg1;
3275         }
3276
3277       /* Compute the value of the arithmetic.  */
3278
3279       switch (code)
3280         {
3281         case PLUS:
3282           val = arg0s + arg1s;
3283           break;
3284
3285         case MINUS:
3286           val = arg0s - arg1s;
3287           break;
3288
3289         case MULT:
3290           val = arg0s * arg1s;
3291           break;
3292
3293         case DIV:
3294           if (arg1s == 0
3295               || (arg0s == (HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT - 1)
3296                   && arg1s == -1))
3297             return 0;
3298           val = arg0s / arg1s;
3299           break;
3300
3301         case MOD:
3302           if (arg1s == 0
3303               || (arg0s == (HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT - 1)
3304                   && arg1s == -1))
3305             return 0;
3306           val = arg0s % arg1s;
3307           break;
3308
3309         case UDIV:
3310           if (arg1 == 0
3311               || (arg0s == (HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT - 1)
3312                   && arg1s == -1))
3313             return 0;
3314           val = (unsigned HOST_WIDE_INT) arg0 / arg1;
3315           break;
3316
3317         case UMOD:
3318           if (arg1 == 0
3319               || (arg0s == (HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT - 1)
3320                   && arg1s == -1))
3321             return 0;
3322           val = (unsigned HOST_WIDE_INT) arg0 % arg1;
3323           break;
3324
3325         case AND:
3326           val = arg0 & arg1;
3327           break;
3328
3329         case IOR:
3330           val = arg0 | arg1;
3331           break;
3332
3333         case XOR:
3334           val = arg0 ^ arg1;
3335           break;
3336
3337         case LSHIFTRT:
3338         case ASHIFT:
3339         case ASHIFTRT:
3340           /* Truncate the shift if SHIFT_COUNT_TRUNCATED, otherwise make sure
3341              the value is in range.  We can't return any old value for
3342              out-of-range arguments because either the middle-end (via
3343              shift_truncation_mask) or the back-end might be relying on
3344              target-specific knowledge.  Nor can we rely on
3345              shift_truncation_mask, since the shift might not be part of an
3346              ashlM3, lshrM3 or ashrM3 instruction.  */
3347           if (SHIFT_COUNT_TRUNCATED)
3348             arg1 = (unsigned HOST_WIDE_INT) arg1 % width;
3349           else if (arg1 < 0 || arg1 >= GET_MODE_BITSIZE (mode))
3350             return 0;
3351
3352           val = (code == ASHIFT
3353                  ? ((unsigned HOST_WIDE_INT) arg0) << arg1
3354                  : ((unsigned HOST_WIDE_INT) arg0) >> arg1);
3355
3356           /* Sign-extend the result for arithmetic right shifts.  */
3357           if (code == ASHIFTRT && arg0s < 0 && arg1 > 0)
3358             val |= ((HOST_WIDE_INT) -1) << (width - arg1);
3359           break;
3360
3361         case ROTATERT:
3362           if (arg1 < 0)
3363             return 0;
3364
3365           arg1 %= width;
3366           val = ((((unsigned HOST_WIDE_INT) arg0) << (width - arg1))
3367                  | (((unsigned HOST_WIDE_INT) arg0) >> arg1));
3368           break;
3369
3370         case ROTATE:
3371           if (arg1 < 0)
3372             return 0;
3373
3374           arg1 %= width;
3375           val = ((((unsigned HOST_WIDE_INT) arg0) << arg1)
3376                  | (((unsigned HOST_WIDE_INT) arg0) >> (width - arg1)));
3377           break;
3378
3379         case COMPARE:
3380           /* Do nothing here.  */
3381           return 0;
3382
3383         case SMIN:
3384           val = arg0s <= arg1s ? arg0s : arg1s;
3385           break;
3386
3387         case UMIN:
3388           val = ((unsigned HOST_WIDE_INT) arg0
3389                  <= (unsigned HOST_WIDE_INT) arg1 ? arg0 : arg1);
3390           break;
3391
3392         case SMAX:
3393           val = arg0s > arg1s ? arg0s : arg1s;
3394           break;
3395
3396         case UMAX:
3397           val = ((unsigned HOST_WIDE_INT) arg0
3398                  > (unsigned HOST_WIDE_INT) arg1 ? arg0 : arg1);
3399           break;
3400
3401         case SS_PLUS:
3402         case US_PLUS:
3403         case SS_MINUS:
3404         case US_MINUS:
3405         case SS_MULT:
3406         case US_MULT:
3407         case SS_DIV:
3408         case US_DIV:
3409         case SS_ASHIFT:
3410         case US_ASHIFT:
3411           /* ??? There are simplifications that can be done.  */
3412           return 0;
3413
3414         default:
3415           gcc_unreachable ();
3416         }
3417
3418       return gen_int_mode (val, mode);
3419     }
3420
3421   return NULL_RTX;
3422 }
3423
3424
3425 \f
3426 /* Simplify a PLUS or MINUS, at least one of whose operands may be another
3427    PLUS or MINUS.
3428
3429    Rather than test for specific case, we do this by a brute-force method
3430    and do all possible simplifications until no more changes occur.  Then
3431    we rebuild the operation.  */
3432
3433 struct simplify_plus_minus_op_data
3434 {
3435   rtx op;
3436   short neg;
3437 };
3438
3439 static bool
3440 simplify_plus_minus_op_data_cmp (rtx x, rtx y)
3441 {
3442   int result;
3443
3444   result = (commutative_operand_precedence (y)
3445             - commutative_operand_precedence (x));
3446   if (result)
3447     return result > 0;
3448
3449   /* Group together equal REGs to do more simplification.  */
3450   if (REG_P (x) && REG_P (y))
3451     return REGNO (x) > REGNO (y);
3452   else
3453     return false;
3454 }
3455
3456 static rtx
3457 simplify_plus_minus (enum rtx_code code, enum machine_mode mode, rtx op0,
3458                      rtx op1)
3459 {
3460   struct simplify_plus_minus_op_data ops[8];
3461   rtx result, tem;
3462   int n_ops = 2, input_ops = 2;
3463   int changed, n_constants = 0, canonicalized = 0;
3464   int i, j;
3465
3466   memset (ops, 0, sizeof ops);
3467
3468   /* Set up the two operands and then expand them until nothing has been
3469      changed.  If we run out of room in our array, give up; this should
3470      almost never happen.  */
3471
3472   ops[0].op = op0;
3473   ops[0].neg = 0;
3474   ops[1].op = op1;
3475   ops[1].neg = (code == MINUS);
3476
3477   do
3478     {
3479       changed = 0;
3480
3481       for (i = 0; i < n_ops; i++)
3482         {
3483           rtx this_op = ops[i].op;
3484           int this_neg = ops[i].neg;
3485           enum rtx_code this_code = GET_CODE (this_op);
3486
3487           switch (this_code)
3488             {
3489             case PLUS:
3490             case MINUS:
3491               if (n_ops == 7)
3492                 return NULL_RTX;
3493
3494               ops[n_ops].op = XEXP (this_op, 1);
3495               ops[n_ops].neg = (this_code == MINUS) ^ this_neg;
3496               n_ops++;
3497
3498               ops[i].op = XEXP (this_op, 0);
3499               input_ops++;
3500               changed = 1;
3501               canonicalized |= this_neg;
3502               break;
3503
3504             case NEG:
3505               ops[i].op = XEXP (this_op, 0);
3506               ops[i].neg = ! this_neg;
3507               changed = 1;
3508               canonicalized = 1;
3509               break;
3510
3511             case CONST:
3512               if (n_ops < 7
3513                   && GET_CODE (XEXP (this_op, 0)) == PLUS
3514                   && CONSTANT_P (XEXP (XEXP (this_op, 0), 0))
3515                   && CONSTANT_P (XEXP (XEXP (this_op, 0), 1)))
3516                 {
3517                   ops[i].op = XEXP (XEXP (this_op, 0), 0);
3518                   ops[n_ops].op = XEXP (XEXP (this_op, 0), 1);
3519                   ops[n_ops].neg = this_neg;
3520                   n_ops++;
3521                   changed = 1;
3522                   canonicalized = 1;
3523                 }
3524               break;
3525
3526             case NOT:
3527               /* ~a -> (-a - 1) */
3528               if (n_ops != 7)
3529                 {
3530                   ops[n_ops].op = constm1_rtx;
3531                   ops[n_ops++].neg = this_neg;
3532                   ops[i].op = XEXP (this_op, 0);
3533                   ops[i].neg = !this_neg;
3534                   changed = 1;
3535                   canonicalized = 1;
3536                 }
3537               break;
3538
3539             case CONST_INT:
3540               n_constants++;
3541               if (this_neg)
3542                 {
3543                   ops[i].op = neg_const_int (mode, this_op);
3544                   ops[i].neg = 0;
3545                   changed = 1;
3546                   canonicalized = 1;
3547                 }
3548               break;
3549
3550             default:
3551               break;
3552             }
3553         }
3554     }
3555   while (changed);
3556
3557   if (n_constants > 1)
3558     canonicalized = 1;
3559
3560   gcc_assert (n_ops >= 2);
3561
3562   /* If we only have two operands, we can avoid the loops.  */
3563   if (n_ops == 2)
3564     {
3565       enum rtx_code code = ops[0].neg || ops[1].neg ? MINUS : PLUS;
3566       rtx lhs, rhs;
3567
3568       /* Get the two operands.  Be careful with the order, especially for
3569          the cases where code == MINUS.  */
3570       if (ops[0].neg && ops[1].neg)
3571         {
3572           lhs = gen_rtx_NEG (mode, ops[0].op);
3573           rhs = ops[1].op;
3574         }
3575       else if (ops[0].neg)
3576         {
3577           lhs = ops[1].op;
3578           rhs = ops[0].op;
3579         }
3580       else
3581         {
3582           lhs = ops[0].op;
3583           rhs = ops[1].op;
3584         }
3585
3586       return simplify_const_binary_operation (code, mode, lhs, rhs);
3587     }
3588
3589   /* Now simplify each pair of operands until nothing changes.  */
3590   do
3591     {
3592       /* Insertion sort is good enough for an eight-element array.  */
3593       for (i = 1; i < n_ops; i++)
3594         {
3595           struct simplify_plus_minus_op_data save;
3596           j = i - 1;
3597           if (!simplify_plus_minus_op_data_cmp (ops[j].op, ops[i].op))
3598             continue;
3599
3600           canonicalized = 1;
3601           save = ops[i];
3602           do
3603             ops[j + 1] = ops[j];
3604           while (j-- && simplify_plus_minus_op_data_cmp (ops[j].op, save.op));
3605           ops[j + 1] = save;
3606         }
3607
3608       changed = 0;
3609       for (i = n_ops - 1; i > 0; i--)
3610         for (j = i - 1; j >= 0; j--)
3611           {
3612             rtx lhs = ops[j].op, rhs = ops[i].op;
3613             int lneg = ops[j].neg, rneg = ops[i].neg;
3614
3615             if (lhs != 0 && rhs != 0)
3616               {
3617                 enum rtx_code ncode = PLUS;
3618
3619                 if (lneg != rneg)
3620                   {
3621                     ncode = MINUS;
3622                     if (lneg)
3623                       tem = lhs, lhs = rhs, rhs = tem;
3624                   }
3625                 else if (swap_commutative_operands_p (lhs, rhs))
3626                   tem = lhs, lhs = rhs, rhs = tem;
3627
3628                 if ((GET_CODE (lhs) == CONST || GET_CODE (lhs) == CONST_INT)
3629                     && (GET_CODE (rhs) == CONST || GET_CODE (rhs) == CONST_INT))
3630                   {
3631                     rtx tem_lhs, tem_rhs;
3632
3633                     tem_lhs = GET_CODE (lhs) == CONST ? XEXP (lhs, 0) : lhs;
3634                     tem_rhs = GET_CODE (rhs) == CONST ? XEXP (rhs, 0) : rhs;
3635                     tem = simplify_binary_operation (ncode, mode, tem_lhs, tem_rhs);
3636
3637                     if (tem && !CONSTANT_P (tem))
3638                       tem = gen_rtx_CONST (GET_MODE (tem), tem);
3639                   }
3640                 else
3641                   tem = simplify_binary_operation (ncode, mode, lhs, rhs);
3642
3643                 /* Reject "simplifications" that just wrap the two
3644                    arguments in a CONST.  Failure to do so can result
3645                    in infinite recursion with simplify_binary_operation
3646                    when it calls us to simplify CONST operations.  */
3647                 if (tem
3648                     && ! (GET_CODE (tem) == CONST
3649                           && GET_CODE (XEXP (tem, 0)) == ncode
3650                           && XEXP (XEXP (tem, 0), 0) == lhs
3651                           && XEXP (XEXP (tem, 0), 1) == rhs))
3652                   {
3653                     lneg &= rneg;
3654                     if (GET_CODE (tem) == NEG)
3655                       tem = XEXP (tem, 0), lneg = !lneg;
3656                     if (GET_CODE (tem) == CONST_INT && lneg)
3657                       tem = neg_const_int (mode, tem), lneg = 0;
3658
3659                     ops[i].op = tem;
3660                     ops[i].neg = lneg;
3661                     ops[j].op = NULL_RTX;
3662                     changed = 1;
3663                     canonicalized = 1;
3664                   }
3665               }
3666           }
3667
3668       /* If nothing changed, fail.  */
3669       if (!canonicalized)
3670         return NULL_RTX;
3671
3672       /* Pack all the operands to the lower-numbered entries.  */
3673       for (i = 0, j = 0; j < n_ops; j++)
3674         if (ops[j].op)
3675           {
3676             ops[i] = ops[j];
3677             i++;
3678           }
3679       n_ops = i;
3680     }
3681   while (changed);
3682
3683   /* Create (minus -C X) instead of (neg (const (plus X C))).  */
3684   if (n_ops == 2
3685       && GET_CODE (ops[1].op) == CONST_INT
3686       && CONSTANT_P (ops[0].op)
3687       && ops[0].neg)
3688     return gen_rtx_fmt_ee (MINUS, mode, ops[1].op, ops[0].op);
3689
3690   /* We suppressed creation of trivial CONST expressions in the
3691      combination loop to avoid recursion.  Create one manually now.
3692      The combination loop should have ensured that there is exactly
3693      one CONST_INT, and the sort will have ensured that it is last
3694      in the array and that any other constant will be next-to-last.  */
3695
3696   if (n_ops > 1
3697       && GET_CODE (ops[n_ops - 1].op) == CONST_INT
3698       && CONSTANT_P (ops[n_ops - 2].op))
3699     {
3700       rtx value = ops[n_ops - 1].op;
3701       if (ops[n_ops - 1].neg ^ ops[n_ops - 2].neg)
3702         value = neg_const_int (mode, value);
3703       ops[n_ops - 2].op = plus_constant (ops[n_ops - 2].op, INTVAL (value));
3704       n_ops--;
3705     }
3706
3707   /* Put a non-negated operand first, if possible.  */
3708
3709   for (i = 0; i < n_ops && ops[i].neg; i++)
3710     continue;
3711   if (i == n_ops)
3712     ops[0].op = gen_rtx_NEG (mode, ops[0].op);
3713   else if (i != 0)
3714     {
3715       tem = ops[0].op;
3716       ops[0] = ops[i];
3717       ops[i].op = tem;
3718       ops[i].neg = 1;
3719     }
3720
3721   /* Now make the result by performing the requested operations.  */
3722   result = ops[0].op;
3723   for (i = 1; i < n_ops; i++)
3724     result = gen_rtx_fmt_ee (ops[i].neg ? MINUS : PLUS,
3725                              mode, result, ops[i].op);
3726
3727   return result;
3728 }
3729
3730 /* Check whether an operand is suitable for calling simplify_plus_minus.  */
3731 static bool
3732 plus_minus_operand_p (const_rtx x)
3733 {
3734   return GET_CODE (x) == PLUS
3735          || GET_CODE (x) == MINUS
3736          || (GET_CODE (x) == CONST
3737              && GET_CODE (XEXP (x, 0)) == PLUS
3738              && CONSTANT_P (XEXP (XEXP (x, 0), 0))
3739              && CONSTANT_P (XEXP (XEXP (x, 0), 1)));
3740 }
3741
3742 /* Like simplify_binary_operation except used for relational operators.
3743    MODE is the mode of the result. If MODE is VOIDmode, both operands must
3744    not also be VOIDmode.
3745
3746    CMP_MODE specifies in which mode the comparison is done in, so it is
3747    the mode of the operands.  If CMP_MODE is VOIDmode, it is taken from
3748    the operands or, if both are VOIDmode, the operands are compared in
3749    "infinite precision".  */
3750 rtx
3751 simplify_relational_operation (enum rtx_code code, enum machine_mode mode,
3752                                enum machine_mode cmp_mode, rtx op0, rtx op1)
3753 {
3754   rtx tem, trueop0, trueop1;
3755
3756   if (cmp_mode == VOIDmode)
3757     cmp_mode = GET_MODE (op0);
3758   if (cmp_mode == VOIDmode)
3759     cmp_mode = GET_MODE (op1);
3760
3761   tem = simplify_const_relational_operation (code, cmp_mode, op0, op1);
3762   if (tem)
3763     {
3764       if (SCALAR_FLOAT_MODE_P (mode))
3765         {
3766           if (tem == const0_rtx)
3767             return CONST0_RTX (mode);
3768 #ifdef FLOAT_STORE_FLAG_VALUE
3769           {
3770             REAL_VALUE_TYPE val;
3771             val = FLOAT_STORE_FLAG_VALUE (mode);
3772             return CONST_DOUBLE_FROM_REAL_VALUE (val, mode);
3773           }
3774 #else
3775           return NULL_RTX;
3776 #endif
3777         }
3778       if (VECTOR_MODE_P (mode))
3779         {
3780           if (tem == const0_rtx)
3781             return CONST0_RTX (mode);
3782 #ifdef VECTOR_STORE_FLAG_VALUE
3783           {
3784             int i, units;
3785             rtvec v;
3786
3787             rtx val = VECTOR_STORE_FLAG_VALUE (mode);
3788             if (val == NULL_RTX)
3789               return NULL_RTX;
3790             if (val == const1_rtx)
3791               return CONST1_RTX (mode);
3792
3793             units = GET_MODE_NUNITS (mode);
3794             v = rtvec_alloc (units);
3795             for (i = 0; i < units; i++)
3796               RTVEC_ELT (v, i) = val;
3797             return gen_rtx_raw_CONST_VECTOR (mode, v);
3798           }
3799 #else
3800           return NULL_RTX;
3801 #endif
3802         }
3803
3804       return tem;
3805     }
3806
3807   /* For the following tests, ensure const0_rtx is op1.  */
3808   if (swap_commutative_operands_p (op0, op1)
3809       || (op0 == const0_rtx && op1 != const0_rtx))
3810     tem = op0, op0 = op1, op1 = tem, code = swap_condition (code);
3811
3812   /* If op0 is a compare, extract the comparison arguments from it.  */
3813   if (GET_CODE (op0) == COMPARE && op1 == const0_rtx)
3814     return simplify_relational_operation (code, mode, VOIDmode,
3815                                           XEXP (op0, 0), XEXP (op0, 1));
3816
3817   if (GET_MODE_CLASS (cmp_mode) == MODE_CC
3818       || CC0_P (op0))
3819     return NULL_RTX;
3820
3821   trueop0 = avoid_constant_pool_reference (op0);
3822   trueop1 = avoid_constant_pool_reference (op1);
3823   return simplify_relational_operation_1 (code, mode, cmp_mode,
3824                                           trueop0, trueop1);
3825 }
3826
3827 /* This part of simplify_relational_operation is only used when CMP_MODE
3828    is not in class MODE_CC (i.e. it is a real comparison).
3829
3830    MODE is the mode of the result, while CMP_MODE specifies in which
3831    mode the comparison is done in, so it is the mode of the operands.  */
3832
3833 static rtx
3834 simplify_relational_operation_1 (enum rtx_code code, enum machine_mode mode,
3835                                  enum machine_mode cmp_mode, rtx op0, rtx op1)
3836 {
3837   enum rtx_code op0code = GET_CODE (op0);
3838
3839   if (op1 == const0_rtx && COMPARISON_P (op0))
3840     {
3841       /* If op0 is a comparison, extract the comparison arguments
3842          from it.  */
3843       if (code == NE)
3844         {
3845           if (GET_MODE (op0) == mode)
3846             return simplify_rtx (op0);
3847           else
3848             return simplify_gen_relational (GET_CODE (op0), mode, VOIDmode,
3849                                             XEXP (op0, 0), XEXP (op0, 1));
3850         }
3851       else if (code == EQ)
3852         {
3853           enum rtx_code new_code = reversed_comparison_code (op0, NULL_RTX);
3854           if (new_code != UNKNOWN)
3855             return simplify_gen_relational (new_code, mode, VOIDmode,
3856                                             XEXP (op0, 0), XEXP (op0, 1));
3857         }
3858     }
3859
3860   /* Canonicalize (LTU/GEU (PLUS a b) b) as (LTU/GEU (PLUS a b) a).  */
3861   if ((code == LTU || code == GEU)
3862       && GET_CODE (op0) == PLUS
3863       && rtx_equal_p (op1, XEXP (op0, 1))
3864       /* Don't recurse "infinitely" for (LTU/GEU (PLUS b b) b).  */
3865       && !rtx_equal_p (op1, XEXP (op0, 0)))
3866     return simplify_gen_relational (code, mode, cmp_mode, op0, XEXP (op0, 0));
3867
3868   if (op1 == const0_rtx)
3869     {
3870       /* Canonicalize (GTU x 0) as (NE x 0).  */
3871       if (code == GTU)
3872         return simplify_gen_relational (NE, mode, cmp_mode, op0, op1);
3873       /* Canonicalize (LEU x 0) as (EQ x 0).  */
3874       if (code == LEU)
3875         return simplify_gen_relational (EQ, mode, cmp_mode, op0, op1);
3876     }
3877   else if (op1 == const1_rtx)
3878     {
3879       switch (code)
3880         {
3881         case GE:
3882           /* Canonicalize (GE x 1) as (GT x 0).  */
3883           return simplify_gen_relational (GT, mode, cmp_mode,
3884                                           op0, const0_rtx);
3885         case GEU:
3886           /* Canonicalize (GEU x 1) as (NE x 0).  */
3887           return simplify_gen_relational (NE, mode, cmp_mode,
3888                                           op0, const0_rtx);
3889         case LT:
3890           /* Canonicalize (LT x 1) as (LE x 0).  */
3891           return simplify_gen_relational (LE, mode, cmp_mode,
3892                                           op0, const0_rtx);
3893         case LTU:
3894           /* Canonicalize (LTU x 1) as (EQ x 0).  */
3895           return simplify_gen_relational (EQ, mode, cmp_mode,
3896                                           op0, const0_rtx);
3897         default:
3898           break;
3899         }
3900     }
3901   else if (op1 == constm1_rtx)
3902     {
3903       /* Canonicalize (LE x -1) as (LT x 0).  */
3904       if (code == LE)
3905         return simplify_gen_relational (LT, mode, cmp_mode, op0, const0_rtx);
3906       /* Canonicalize (GT x -1) as (GE x 0).  */
3907       if (code == GT)
3908         return simplify_gen_relational (GE, mode, cmp_mode, op0, const0_rtx);
3909     }
3910
3911   /* (eq/ne (plus x cst1) cst2) simplifies to (eq/ne x (cst2 - cst1))  */
3912   if ((code == EQ || code == NE)
3913       && (op0code == PLUS || op0code == MINUS)
3914       && CONSTANT_P (op1)
3915       && CONSTANT_P (XEXP (op0, 1))
3916       && (INTEGRAL_MODE_P (cmp_mode) || flag_unsafe_math_optimizations))
3917     {
3918       rtx x = XEXP (op0, 0);
3919       rtx c = XEXP (op0, 1);
3920
3921       c = simplify_gen_binary (op0code == PLUS ? MINUS : PLUS,
3922                                cmp_mode, op1, c);
3923       return simplify_gen_relational (code, mode, cmp_mode, x, c);
3924     }
3925
3926   /* (ne:SI (zero_extract:SI FOO (const_int 1) BAR) (const_int 0))) is
3927      the same as (zero_extract:SI FOO (const_int 1) BAR).  */
3928   if (code == NE
3929       && op1 == const0_rtx
3930       && GET_MODE_CLASS (mode) == MODE_INT
3931       && cmp_mode != VOIDmode
3932       /* ??? Work-around BImode bugs in the ia64 backend.  */
3933       && mode != BImode
3934       && cmp_mode != BImode
3935       && nonzero_bits (op0, cmp_mode) == 1
3936       && STORE_FLAG_VALUE == 1)
3937     return GET_MODE_SIZE (mode) > GET_MODE_SIZE (cmp_mode)
3938            ? simplify_gen_unary (ZERO_EXTEND, mode, op0, cmp_mode)
3939            : lowpart_subreg (mode, op0, cmp_mode);
3940
3941   /* (eq/ne (xor x y) 0) simplifies to (eq/ne x y).  */
3942   if ((code == EQ || code == NE)
3943       && op1 == const0_rtx
3944       && op0code == XOR)
3945     return simplify_gen_relational (code, mode, cmp_mode,
3946                                     XEXP (op0, 0), XEXP (op0, 1));
3947
3948   /* (eq/ne (xor x y) x) simplifies to (eq/ne y 0).  */
3949   if ((code == EQ || code == NE)
3950       && op0code == XOR
3951       && rtx_equal_p (XEXP (op0, 0), op1)
3952       && !side_effects_p (XEXP (op0, 0)))
3953     return simplify_gen_relational (code, mode, cmp_mode,
3954                                     XEXP (op0, 1), const0_rtx);
3955
3956   /* Likewise (eq/ne (xor x y) y) simplifies to (eq/ne x 0).  */
3957   if ((code == EQ || code == NE)
3958       && op0code == XOR
3959       && rtx_equal_p (XEXP (op0, 1), op1)
3960       && !side_effects_p (XEXP (op0, 1)))
3961     return simplify_gen_relational (code, mode, cmp_mode,
3962                                     XEXP (op0, 0), const0_rtx);
3963
3964   /* (eq/ne (xor x C1) C2) simplifies to (eq/ne x (C1^C2)).  */
3965   if ((code == EQ || code == NE)
3966       && op0code == XOR
3967       && (GET_CODE (op1) == CONST_INT
3968           || GET_CODE (op1) == CONST_DOUBLE)
3969       && (GET_CODE (XEXP (op0, 1)) == CONST_INT
3970           || GET_CODE (XEXP (op0, 1)) == CONST_DOUBLE))
3971     return simplify_gen_relational (code, mode, cmp_mode, XEXP (op0, 0),
3972                                     simplify_gen_binary (XOR, cmp_mode,
3973                                                          XEXP (op0, 1), op1));
3974
3975   if (op0code == POPCOUNT && op1 == const0_rtx)
3976     switch (code)
3977       {
3978       case EQ:
3979       case LE:
3980       case LEU:
3981         /* (eq (popcount x) (const_int 0)) -> (eq x (const_int 0)).  */
3982         return simplify_gen_relational (EQ, mode, GET_MODE (XEXP (op0, 0)),
3983                                         XEXP (op0, 0), const0_rtx);
3984
3985       case NE:
3986       case GT:
3987       case GTU:
3988         /* (ne (popcount x) (const_int 0)) -> (ne x (const_int 0)).  */
3989         return simplify_gen_relational (NE, mode, GET_MODE (XEXP (op0, 0)),
3990                                         XEXP (op0, 0), const0_rtx);
3991
3992       default:
3993         break;
3994       }
3995
3996   return NULL_RTX;
3997 }
3998
3999 enum
4000 {
4001   CMP_EQ = 1,
4002   CMP_LT = 2,
4003   CMP_GT = 4,
4004   CMP_LTU = 8,
4005   CMP_GTU = 16
4006 };
4007
4008
4009 /* Convert the known results for EQ, LT, GT, LTU, GTU contained in
4010    KNOWN_RESULT to a CONST_INT, based on the requested comparison CODE
4011    For KNOWN_RESULT to make sense it should be either CMP_EQ, or the
4012    logical OR of one of (CMP_LT, CMP_GT) and one of (CMP_LTU, CMP_GTU).
4013    For floating-point comparisons, assume that the operands were ordered.  */
4014
4015 static rtx
4016 comparison_result (enum rtx_code code, int known_results)
4017 {
4018   switch (code)
4019     {
4020     case EQ:
4021     case UNEQ:
4022       return (known_results & CMP_EQ) ? const_true_rtx : const0_rtx;
4023     case NE:
4024     case LTGT:
4025       return (known_results & CMP_EQ) ? const0_rtx : const_true_rtx;
4026
4027     case LT:
4028     case UNLT:
4029       return (known_results & CMP_LT) ? const_true_rtx : const0_rtx;
4030     case GE:
4031     case UNGE:
4032       return (known_results & CMP_LT) ? const0_rtx : const_true_rtx;
4033
4034     case GT:
4035     case UNGT:
4036       return (known_results & CMP_GT) ? const_true_rtx : const0_rtx;
4037     case LE:
4038     case UNLE:
4039       return (known_results & CMP_GT) ? const0_rtx : const_true_rtx;
4040
4041     case LTU:
4042       return (known_results & CMP_LTU) ? const_true_rtx : const0_rtx;
4043     case GEU:
4044       return (known_results & CMP_LTU) ? const0_rtx : const_true_rtx;
4045
4046     case GTU:
4047       return (known_results & CMP_GTU) ? const_true_rtx : const0_rtx;
4048     case LEU:
4049       return (known_results & CMP_GTU) ? const0_rtx : const_true_rtx;
4050
4051     case ORDERED:
4052       return const_true_rtx;
4053     case UNORDERED:
4054       return const0_rtx;
4055     default:
4056       gcc_unreachable ();
4057     }
4058 }
4059
4060 /* Check if the given comparison (done in the given MODE) is actually a
4061    tautology or a contradiction.
4062    If no simplification is possible, this function returns zero.
4063    Otherwise, it returns either const_true_rtx or const0_rtx.  */
4064
4065 rtx
4066 simplify_const_relational_operation (enum rtx_code code,
4067                                      enum machine_mode mode,
4068                                      rtx op0, rtx op1)
4069 {
4070   rtx tem;
4071   rtx trueop0;
4072   rtx trueop1;
4073
4074   gcc_assert (mode != VOIDmode
4075               || (GET_MODE (op0) == VOIDmode
4076                   && GET_MODE (op1) == VOIDmode));
4077
4078   /* If op0 is a compare, extract the comparison arguments from it.  */
4079   if (GET_CODE (op0) == COMPARE && op1 == const0_rtx)
4080     {
4081       op1 = XEXP (op0, 1);
4082       op0 = XEXP (op0, 0);
4083
4084       if (GET_MODE (op0) != VOIDmode)
4085         mode = GET_MODE (op0);
4086       else if (GET_MODE (op1) != VOIDmode)
4087         mode = GET_MODE (op1);
4088       else
4089         return 0;
4090     }
4091
4092   /* We can't simplify MODE_CC values since we don't know what the
4093      actual comparison is.  */
4094   if (GET_MODE_CLASS (GET_MODE (op0)) == MODE_CC || CC0_P (op0))
4095     return 0;
4096
4097   /* Make sure the constant is second.  */
4098   if (swap_commutative_operands_p (op0, op1))
4099     {
4100       tem = op0, op0 = op1, op1 = tem;
4101       code = swap_condition (code);
4102     }
4103
4104   trueop0 = avoid_constant_pool_reference (op0);
4105   trueop1 = avoid_constant_pool_reference (op1);
4106
4107   /* For integer comparisons of A and B maybe we can simplify A - B and can
4108      then simplify a comparison of that with zero.  If A and B are both either
4109      a register or a CONST_INT, this can't help; testing for these cases will
4110      prevent infinite recursion here and speed things up.
4111
4112      We can only do this for EQ and NE comparisons as otherwise we may
4113      lose or introduce overflow which we cannot disregard as undefined as
4114      we do not know the signedness of the operation on either the left or
4115      the right hand side of the comparison.  */
4116
4117   if (INTEGRAL_MODE_P (mode) && trueop1 != const0_rtx
4118       && (code == EQ || code == NE)
4119       && ! ((REG_P (op0) || GET_CODE (trueop0) == CONST_INT)
4120             && (REG_P (op1) || GET_CODE (trueop1) == CONST_INT))
4121       && 0 != (tem = simplify_binary_operation (MINUS, mode, op0, op1))
4122       /* We cannot do this if tem is a nonzero address.  */
4123       && ! nonzero_address_p (tem))
4124     return simplify_const_relational_operation (signed_condition (code),
4125                                                 mode, tem, const0_rtx);
4126
4127   if (! HONOR_NANS (mode) && code == ORDERED)
4128     return const_true_rtx;
4129
4130   if (! HONOR_NANS (mode) && code == UNORDERED)
4131     return const0_rtx;
4132
4133   /* For modes without NaNs, if the two operands are equal, we know the
4134      result except if they have side-effects.  Even with NaNs we know
4135      the result of unordered comparisons and, if signaling NaNs are
4136      irrelevant, also the result of LT/GT/LTGT.  */
4137   if ((! HONOR_NANS (GET_MODE (trueop0))
4138        || code == UNEQ || code == UNLE || code == UNGE
4139        || ((code == LT || code == GT || code == LTGT)
4140            && ! HONOR_SNANS (GET_MODE (trueop0))))
4141       && rtx_equal_p (trueop0, trueop1)
4142       && ! side_effects_p (trueop0))
4143     return comparison_result (code, CMP_EQ);
4144
4145   /* If the operands are floating-point constants, see if we can fold
4146      the result.  */
4147   if (GET_CODE (trueop0) == CONST_DOUBLE
4148       && GET_CODE (trueop1) == CONST_DOUBLE
4149       && SCALAR_FLOAT_MODE_P (GET_MODE (trueop0)))
4150     {
4151       REAL_VALUE_TYPE d0, d1;
4152
4153       REAL_VALUE_FROM_CONST_DOUBLE (d0, trueop0);
4154       REAL_VALUE_FROM_CONST_DOUBLE (d1, trueop1);
4155
4156       /* Comparisons are unordered iff at least one of the values is NaN.  */
4157       if (REAL_VALUE_ISNAN (d0) || REAL_VALUE_ISNAN (d1))
4158         switch (code)
4159           {
4160           case UNEQ:
4161           case UNLT:
4162           case UNGT:
4163           case UNLE:
4164           case UNGE:
4165           case NE:
4166           case UNORDERED:
4167             return const_true_rtx;
4168           case EQ:
4169           case LT:
4170           case GT:
4171           case LE:
4172           case GE:
4173           case LTGT:
4174           case ORDERED:
4175             return const0_rtx;
4176           default:
4177             return 0;
4178           }
4179
4180       return comparison_result (code,
4181                                 (REAL_VALUES_EQUAL (d0, d1) ? CMP_EQ :
4182                                  REAL_VALUES_LESS (d0, d1) ? CMP_LT : CMP_GT));
4183     }
4184
4185   /* Otherwise, see if the operands are both integers.  */
4186   if ((GET_MODE_CLASS (mode) == MODE_INT || mode == VOIDmode)
4187        && (GET_CODE (trueop0) == CONST_DOUBLE
4188            || GET_CODE (trueop0) == CONST_INT)
4189        && (GET_CODE (trueop1) == CONST_DOUBLE
4190            || GET_CODE (trueop1) == CONST_INT))
4191     {
4192       int width = GET_MODE_BITSIZE (mode);
4193       HOST_WIDE_INT l0s, h0s, l1s, h1s;
4194       unsigned HOST_WIDE_INT l0u, h0u, l1u, h1u;
4195
4196       /* Get the two words comprising each integer constant.  */
4197       if (GET_CODE (trueop0) == CONST_DOUBLE)
4198         {
4199           l0u = l0s = CONST_DOUBLE_LOW (trueop0);
4200           h0u = h0s = CONST_DOUBLE_HIGH (trueop0);
4201         }
4202       else
4203         {
4204           l0u = l0s = INTVAL (trueop0);
4205           h0u = h0s = HWI_SIGN_EXTEND (l0s);
4206         }
4207
4208       if (GET_CODE (trueop1) == CONST_DOUBLE)
4209         {
4210           l1u = l1s = CONST_DOUBLE_LOW (trueop1);
4211           h1u = h1s = CONST_DOUBLE_HIGH (trueop1);
4212         }
4213       else
4214         {
4215           l1u = l1s = INTVAL (trueop1);
4216           h1u = h1s = HWI_SIGN_EXTEND (l1s);
4217         }
4218
4219       /* If WIDTH is nonzero and smaller than HOST_BITS_PER_WIDE_INT,
4220          we have to sign or zero-extend the values.  */
4221       if (width != 0 && width < HOST_BITS_PER_WIDE_INT)
4222         {
4223           l0u &= ((HOST_WIDE_INT) 1 << width) - 1;
4224           l1u &= ((HOST_WIDE_INT) 1 << width) - 1;
4225
4226           if (l0s & ((HOST_WIDE_INT) 1 << (width - 1)))
4227             l0s |= ((HOST_WIDE_INT) (-1) << width);
4228
4229           if (l1s & ((HOST_WIDE_INT) 1 << (width - 1)))
4230             l1s |= ((HOST_WIDE_INT) (-1) << width);
4231         }
4232       if (width != 0 && width <= HOST_BITS_PER_WIDE_INT)
4233         h0u = h1u = 0, h0s = HWI_SIGN_EXTEND (l0s), h1s = HWI_SIGN_EXTEND (l1s);
4234
4235       if (h0u == h1u && l0u == l1u)
4236         return comparison_result (code, CMP_EQ);
4237       else
4238         {
4239           int cr;
4240           cr = (h0s < h1s || (h0s == h1s && l0u < l1u)) ? CMP_LT : CMP_GT;
4241           cr |= (h0u < h1u || (h0u == h1u && l0u < l1u)) ? CMP_LTU : CMP_GTU;
4242           return comparison_result (code, cr);
4243         }
4244     }
4245
4246   /* Optimize comparisons with upper and lower bounds.  */
4247   if (SCALAR_INT_MODE_P (mode)
4248       && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
4249       && GET_CODE (trueop1) == CONST_INT)
4250     {
4251       int sign;
4252       unsigned HOST_WIDE_INT nonzero = nonzero_bits (trueop0, mode);
4253       HOST_WIDE_INT val = INTVAL (trueop1);
4254       HOST_WIDE_INT mmin, mmax;
4255
4256       if (code == GEU
4257           || code == LEU
4258           || code == GTU
4259           || code == LTU)
4260         sign = 0;
4261       else
4262         sign = 1;
4263
4264       /* Get a reduced range if the sign bit is zero.  */
4265       if (nonzero <= (GET_MODE_MASK (mode) >> 1))
4266         {
4267           mmin = 0;
4268           mmax = nonzero;
4269         }
4270       else
4271         {
4272           rtx mmin_rtx, mmax_rtx;
4273           get_mode_bounds (mode, sign, mode, &mmin_rtx, &mmax_rtx);
4274
4275           mmin = INTVAL (mmin_rtx);
4276           mmax = INTVAL (mmax_rtx);
4277           if (sign)
4278             {
4279               unsigned int sign_copies = num_sign_bit_copies (trueop0, mode);
4280
4281               mmin >>= (sign_copies - 1);
4282               mmax >>= (sign_copies - 1);
4283             }
4284         }
4285
4286       switch (code)
4287         {
4288         /* x >= y is always true for y <= mmin, always false for y > mmax.  */
4289         case GEU:
4290           if ((unsigned HOST_WIDE_INT) val <= (unsigned HOST_WIDE_INT) mmin)
4291             return const_true_rtx;
4292           if ((unsigned HOST_WIDE_INT) val > (unsigned HOST_WIDE_INT) mmax)
4293             return const0_rtx;
4294           break;
4295         case GE:
4296           if (val <= mmin)
4297             return const_true_rtx;
4298           if (val > mmax)
4299             return const0_rtx;
4300           break;
4301
4302         /* x <= y is always true for y >= mmax, always false for y < mmin.  */
4303         case LEU:
4304           if ((unsigned HOST_WIDE_INT) val >= (unsigned HOST_WIDE_INT) mmax)
4305             return const_true_rtx;
4306           if ((unsigned HOST_WIDE_INT) val < (unsigned HOST_WIDE_INT) mmin)
4307             return const0_rtx;
4308           break;
4309         case LE:
4310           if (val >= mmax)
4311             return const_true_rtx;
4312           if (val < mmin)
4313             return const0_rtx;
4314           break;
4315
4316         case EQ:
4317           /* x == y is always false for y out of range.  */
4318           if (val < mmin || val > mmax)
4319             return const0_rtx;
4320           break;
4321
4322         /* x > y is always false for y >= mmax, always true for y < mmin.  */
4323         case GTU:
4324           if ((unsigned HOST_WIDE_INT) val >= (unsigned HOST_WIDE_INT) mmax)
4325             return const0_rtx;
4326           if ((unsigned HOST_WIDE_INT) val < (unsigned HOST_WIDE_INT) mmin)
4327             return const_true_rtx;
4328           break;
4329         case GT:
4330           if (val >= mmax)
4331             return const0_rtx;
4332           if (val < mmin)
4333             return const_true_rtx;
4334           break;
4335
4336         /* x < y is always false for y <= mmin, always true for y > mmax.  */
4337         case LTU:
4338           if ((unsigned HOST_WIDE_INT) val <= (unsigned HOST_WIDE_INT) mmin)
4339             return const0_rtx;
4340           if ((unsigned HOST_WIDE_INT) val > (unsigned HOST_WIDE_INT) mmax)
4341             return const_true_rtx;
4342           break;
4343         case LT:
4344           if (val <= mmin)
4345             return const0_rtx;
4346           if (val > mmax)
4347             return const_true_rtx;
4348           break;
4349
4350         case NE:
4351           /* x != y is always true for y out of range.  */
4352           if (val < mmin || val > mmax)
4353             return const_true_rtx;
4354           break;
4355
4356         default:
4357           break;
4358         }
4359     }
4360
4361   /* Optimize integer comparisons with zero.  */
4362   if (trueop1 == const0_rtx)
4363     {
4364       /* Some addresses are known to be nonzero.  We don't know
4365          their sign, but equality comparisons are known.  */
4366       if (nonzero_address_p (trueop0))
4367         {
4368           if (code == EQ || code == LEU)
4369             return const0_rtx;
4370           if (code == NE || code == GTU)
4371             return const_true_rtx;
4372         }
4373
4374       /* See if the first operand is an IOR with a constant.  If so, we
4375          may be able to determine the result of this comparison.  */
4376       if (GET_CODE (op0) == IOR)
4377         {
4378           rtx inner_const = avoid_constant_pool_reference (XEXP (op0, 1));
4379           if (GET_CODE (inner_const) == CONST_INT && inner_const != const0_rtx)
4380             {
4381               int sign_bitnum = GET_MODE_BITSIZE (mode) - 1;
4382               int has_sign = (HOST_BITS_PER_WIDE_INT >= sign_bitnum
4383                               && (INTVAL (inner_const)
4384                                   & ((HOST_WIDE_INT) 1 << sign_bitnum)));
4385
4386               switch (code)
4387                 {
4388                 case EQ:
4389                 case LEU:
4390                   return const0_rtx;
4391                 case NE:
4392                 case GTU:
4393                   return const_true_rtx;
4394                 case LT:
4395                 case LE:
4396                   if (has_sign)
4397                     return const_true_rtx;
4398                   break;
4399                 case GT:
4400                 case GE:
4401                   if (has_sign)
4402                     return const0_rtx;
4403                   break;
4404                 default:
4405                   break;
4406                 }
4407             }
4408         }
4409     }
4410
4411   /* Optimize comparison of ABS with zero.  */
4412   if (trueop1 == CONST0_RTX (mode)
4413       && (GET_CODE (trueop0) == ABS
4414           || (GET_CODE (trueop0) == FLOAT_EXTEND
4415               && GET_CODE (XEXP (trueop0, 0)) == ABS)))
4416     {
4417       switch (code)
4418         {
4419         case LT:
4420           /* Optimize abs(x) < 0.0.  */
4421           if (!HONOR_SNANS (mode)
4422               && (!INTEGRAL_MODE_P (mode)
4423                   || (!flag_wrapv && !flag_trapv && flag_strict_overflow)))
4424             {
4425               if (INTEGRAL_MODE_P (mode)
4426                   && (issue_strict_overflow_warning
4427                       (WARN_STRICT_OVERFLOW_CONDITIONAL)))
4428                 warning (OPT_Wstrict_overflow,
4429                          ("assuming signed overflow does not occur when "
4430                           "assuming abs (x) < 0 is false"));
4431                return const0_rtx;
4432             }
4433           break;
4434
4435         case GE:
4436           /* Optimize abs(x) >= 0.0.  */
4437           if (!HONOR_NANS (mode)
4438               && (!INTEGRAL_MODE_P (mode)
4439                   || (!flag_wrapv && !flag_trapv && flag_strict_overflow)))
4440             {
4441               if (INTEGRAL_MODE_P (mode)
4442                   && (issue_strict_overflow_warning
4443                   (WARN_STRICT_OVERFLOW_CONDITIONAL)))
4444                 warning (OPT_Wstrict_overflow,
4445                          ("assuming signed overflow does not occur when "
4446                           "assuming abs (x) >= 0 is true"));
4447               return const_true_rtx;
4448             }
4449           break;
4450
4451         case UNGE:
4452           /* Optimize ! (abs(x) < 0.0).  */
4453           return const_true_rtx;
4454
4455         default:
4456           break;
4457         }
4458     }
4459
4460   return 0;
4461 }
4462 \f
4463 /* Simplify CODE, an operation with result mode MODE and three operands,
4464    OP0, OP1, and OP2.  OP0_MODE was the mode of OP0 before it became
4465    a constant.  Return 0 if no simplifications is possible.  */
4466
4467 rtx
4468 simplify_ternary_operation (enum rtx_code code, enum machine_mode mode,
4469                             enum machine_mode op0_mode, rtx op0, rtx op1,
4470                             rtx op2)
4471 {
4472   unsigned int width = GET_MODE_BITSIZE (mode);
4473
4474   /* VOIDmode means "infinite" precision.  */
4475   if (width == 0)
4476     width = HOST_BITS_PER_WIDE_INT;
4477
4478   switch (code)
4479     {
4480     case SIGN_EXTRACT:
4481     case ZERO_EXTRACT:
4482       if (GET_CODE (op0) == CONST_INT
4483           && GET_CODE (op1) == CONST_INT
4484           && GET_CODE (op2) == CONST_INT
4485           && ((unsigned) INTVAL (op1) + (unsigned) INTVAL (op2) <= width)
4486           && width <= (unsigned) HOST_BITS_PER_WIDE_INT)
4487         {
4488           /* Extracting a bit-field from a constant */
4489           HOST_WIDE_INT val = INTVAL (op0);
4490
4491           if (BITS_BIG_ENDIAN)
4492             val >>= (GET_MODE_BITSIZE (op0_mode)
4493                      - INTVAL (op2) - INTVAL (op1));
4494           else
4495             val >>= INTVAL (op2);
4496
4497           if (HOST_BITS_PER_WIDE_INT != INTVAL (op1))
4498             {
4499               /* First zero-extend.  */
4500               val &= ((HOST_WIDE_INT) 1 << INTVAL (op1)) - 1;
4501               /* If desired, propagate sign bit.  */
4502               if (code == SIGN_EXTRACT
4503                   && (val & ((HOST_WIDE_INT) 1 << (INTVAL (op1) - 1))))
4504                 val |= ~ (((HOST_WIDE_INT) 1 << INTVAL (op1)) - 1);
4505             }
4506
4507           /* Clear the bits that don't belong in our mode,
4508              unless they and our sign bit are all one.
4509              So we get either a reasonable negative value or a reasonable
4510              unsigned value for this mode.  */
4511           if (width < HOST_BITS_PER_WIDE_INT
4512               && ((val & ((HOST_WIDE_INT) (-1) << (width - 1)))
4513                   != ((HOST_WIDE_INT) (-1) << (width - 1))))
4514             val &= ((HOST_WIDE_INT) 1 << width) - 1;
4515
4516           return gen_int_mode (val, mode);
4517         }
4518       break;
4519
4520     case IF_THEN_ELSE:
4521       if (GET_CODE (op0) == CONST_INT)
4522         return op0 != const0_rtx ? op1 : op2;
4523
4524       /* Convert c ? a : a into "a".  */
4525       if (rtx_equal_p (op1, op2) && ! side_effects_p (op0))
4526         return op1;
4527
4528       /* Convert a != b ? a : b into "a".  */
4529       if (GET_CODE (op0) == NE
4530           && ! side_effects_p (op0)
4531           && ! HONOR_NANS (mode)
4532           && ! HONOR_SIGNED_ZEROS (mode)
4533           && ((rtx_equal_p (XEXP (op0, 0), op1)
4534                && rtx_equal_p (XEXP (op0, 1), op2))
4535               || (rtx_equal_p (XEXP (op0, 0), op2)
4536                   && rtx_equal_p (XEXP (op0, 1), op1))))
4537         return op1;
4538
4539       /* Convert a == b ? a : b into "b".  */
4540       if (GET_CODE (op0) == EQ
4541           && ! side_effects_p (op0)
4542           && ! HONOR_NANS (mode)
4543           && ! HONOR_SIGNED_ZEROS (mode)
4544           && ((rtx_equal_p (XEXP (op0, 0), op1)
4545                && rtx_equal_p (XEXP (op0, 1), op2))
4546               || (rtx_equal_p (XEXP (op0, 0), op2)
4547                   && rtx_equal_p (XEXP (op0, 1), op1))))
4548         return op2;
4549
4550       if (COMPARISON_P (op0) && ! side_effects_p (op0))
4551         {
4552           enum machine_mode cmp_mode = (GET_MODE (XEXP (op0, 0)) == VOIDmode
4553                                         ? GET_MODE (XEXP (op0, 1))
4554                                         : GET_MODE (XEXP (op0, 0)));
4555           rtx temp;
4556
4557           /* Look for happy constants in op1 and op2.  */
4558           if (GET_CODE (op1) == CONST_INT && GET_CODE (op2) == CONST_INT)
4559             {
4560               HOST_WIDE_INT t = INTVAL (op1);
4561               HOST_WIDE_INT f = INTVAL (op2);
4562
4563               if (t == STORE_FLAG_VALUE && f == 0)
4564                 code = GET_CODE (op0);
4565               else if (t == 0 && f == STORE_FLAG_VALUE)
4566                 {
4567                   enum rtx_code tmp;
4568                   tmp = reversed_comparison_code (op0, NULL_RTX);
4569                   if (tmp == UNKNOWN)
4570                     break;
4571                   code = tmp;
4572                 }
4573               else
4574                 break;
4575
4576               return simplify_gen_relational (code, mode, cmp_mode,
4577                                               XEXP (op0, 0), XEXP (op0, 1));
4578             }
4579
4580           if (cmp_mode == VOIDmode)
4581             cmp_mode = op0_mode;
4582           temp = simplify_relational_operation (GET_CODE (op0), op0_mode,
4583                                                 cmp_mode, XEXP (op0, 0),
4584                                                 XEXP (op0, 1));
4585
4586           /* See if any simplifications were possible.  */
4587           if (temp)
4588             {
4589               if (GET_CODE (temp) == CONST_INT)
4590                 return temp == const0_rtx ? op2 : op1;
4591               else if (temp)
4592                 return gen_rtx_IF_THEN_ELSE (mode, temp, op1, op2);
4593             }
4594         }
4595       break;
4596
4597     case VEC_MERGE:
4598       gcc_assert (GET_MODE (op0) == mode);
4599       gcc_assert (GET_MODE (op1) == mode);
4600       gcc_assert (VECTOR_MODE_P (mode));
4601       op2 = avoid_constant_pool_reference (op2);
4602       if (GET_CODE (op2) == CONST_INT)
4603         {
4604           int elt_size = GET_MODE_SIZE (GET_MODE_INNER (mode));
4605           unsigned n_elts = (GET_MODE_SIZE (mode) / elt_size);
4606           int mask = (1 << n_elts) - 1;
4607
4608           if (!(INTVAL (op2) & mask))
4609             return op1;
4610           if ((INTVAL (op2) & mask) == mask)
4611             return op0;
4612
4613           op0 = avoid_constant_pool_reference (op0);
4614           op1 = avoid_constant_pool_reference (op1);
4615           if (GET_CODE (op0) == CONST_VECTOR
4616               && GET_CODE (op1) == CONST_VECTOR)
4617             {
4618               rtvec v = rtvec_alloc (n_elts);
4619               unsigned int i;
4620
4621               for (i = 0; i < n_elts; i++)
4622                 RTVEC_ELT (v, i) = (INTVAL (op2) & (1 << i)
4623                                     ? CONST_VECTOR_ELT (op0, i)
4624                                     : CONST_VECTOR_ELT (op1, i));
4625               return gen_rtx_CONST_VECTOR (mode, v);
4626             }
4627         }
4628       break;
4629
4630     default:
4631       gcc_unreachable ();
4632     }
4633
4634   return 0;
4635 }
4636
4637 /* Evaluate a SUBREG of a CONST_INT or CONST_DOUBLE or CONST_FIXED
4638    or CONST_VECTOR,
4639    returning another CONST_INT or CONST_DOUBLE or CONST_FIXED or CONST_VECTOR.
4640
4641    Works by unpacking OP into a collection of 8-bit values
4642    represented as a little-endian array of 'unsigned char', selecting by BYTE,
4643    and then repacking them again for OUTERMODE.  */
4644
4645 static rtx
4646 simplify_immed_subreg (enum machine_mode outermode, rtx op,
4647                        enum machine_mode innermode, unsigned int byte)
4648 {
4649   /* We support up to 512-bit values (for V8DFmode).  */
4650   enum {
4651     max_bitsize = 512,
4652     value_bit = 8,
4653     value_mask = (1 << value_bit) - 1
4654   };
4655   unsigned char value[max_bitsize / value_bit];
4656   int value_start;
4657   int i;
4658   int elem;
4659
4660   int num_elem;
4661   rtx * elems;
4662   int elem_bitsize;
4663   rtx result_s;
4664   rtvec result_v = NULL;
4665   enum mode_class outer_class;
4666   enum machine_mode outer_submode;
4667
4668   /* Some ports misuse CCmode.  */
4669   if (GET_MODE_CLASS (outermode) == MODE_CC && GET_CODE (op) == CONST_INT)
4670     return op;
4671
4672   /* We have no way to represent a complex constant at the rtl level.  */
4673   if (COMPLEX_MODE_P (outermode))
4674     return NULL_RTX;
4675
4676   /* Unpack the value.  */
4677
4678   if (GET_CODE (op) == CONST_VECTOR)
4679     {
4680       num_elem = CONST_VECTOR_NUNITS (op);
4681       elems = &CONST_VECTOR_ELT (op, 0);
4682       elem_bitsize = GET_MODE_BITSIZE (GET_MODE_INNER (innermode));
4683     }
4684   else
4685     {
4686       num_elem = 1;
4687       elems = &op;
4688       elem_bitsize = max_bitsize;
4689     }
4690   /* If this asserts, it is too complicated; reducing value_bit may help.  */
4691   gcc_assert (BITS_PER_UNIT % value_bit == 0);
4692   /* I don't know how to handle endianness of sub-units.  */
4693   gcc_assert (elem_bitsize % BITS_PER_UNIT == 0);
4694
4695   for (elem = 0; elem < num_elem; elem++)
4696     {
4697       unsigned char * vp;
4698       rtx el = elems[elem];
4699
4700       /* Vectors are kept in target memory order.  (This is probably
4701          a mistake.)  */
4702       {
4703         unsigned byte = (elem * elem_bitsize) / BITS_PER_UNIT;
4704         unsigned ibyte = (((num_elem - 1 - elem) * elem_bitsize)
4705                           / BITS_PER_UNIT);
4706         unsigned word_byte = WORDS_BIG_ENDIAN ? ibyte : byte;
4707         unsigned subword_byte = BYTES_BIG_ENDIAN ? ibyte : byte;
4708         unsigned bytele = (subword_byte % UNITS_PER_WORD
4709                          + (word_byte / UNITS_PER_WORD) * UNITS_PER_WORD);
4710         vp = value + (bytele * BITS_PER_UNIT) / value_bit;
4711       }
4712
4713       switch (GET_CODE (el))
4714         {
4715         case CONST_INT:
4716           for (i = 0;
4717                i < HOST_BITS_PER_WIDE_INT && i < elem_bitsize;
4718                i += value_bit)
4719             *vp++ = INTVAL (el) >> i;
4720           /* CONST_INTs are always logically sign-extended.  */
4721           for (; i < elem_bitsize; i += value_bit)
4722             *vp++ = INTVAL (el) < 0 ? -1 : 0;
4723           break;
4724
4725         case CONST_DOUBLE:
4726           if (GET_MODE (el) == VOIDmode)
4727             {
4728               /* If this triggers, someone should have generated a
4729                  CONST_INT instead.  */
4730               gcc_assert (elem_bitsize > HOST_BITS_PER_WIDE_INT);
4731
4732               for (i = 0; i < HOST_BITS_PER_WIDE_INT; i += value_bit)
4733                 *vp++ = CONST_DOUBLE_LOW (el) >> i;
4734               while (i < HOST_BITS_PER_WIDE_INT * 2 && i < elem_bitsize)
4735                 {
4736                   *vp++
4737                     = CONST_DOUBLE_HIGH (el) >> (i - HOST_BITS_PER_WIDE_INT);
4738                   i += value_bit;
4739                 }
4740               /* It shouldn't matter what's done here, so fill it with
4741                  zero.  */
4742               for (; i < elem_bitsize; i += value_bit)
4743                 *vp++ = 0;
4744             }
4745           else
4746             {
4747               long tmp[max_bitsize / 32];
4748               int bitsize = GET_MODE_BITSIZE (GET_MODE (el));
4749
4750               gcc_assert (SCALAR_FLOAT_MODE_P (GET_MODE (el)));
4751               gcc_assert (bitsize <= elem_bitsize);
4752               gcc_assert (bitsize % value_bit == 0);
4753
4754               real_to_target (tmp, CONST_DOUBLE_REAL_VALUE (el),
4755                               GET_MODE (el));
4756
4757               /* real_to_target produces its result in words affected by
4758                  FLOAT_WORDS_BIG_ENDIAN.  However, we ignore this,
4759                  and use WORDS_BIG_ENDIAN instead; see the documentation
4760                  of SUBREG in rtl.texi.  */
4761               for (i = 0; i < bitsize; i += value_bit)
4762                 {
4763                   int ibase;
4764                   if (WORDS_BIG_ENDIAN)
4765                     ibase = bitsize - 1 - i;
4766                   else
4767                     ibase = i;
4768                   *vp++ = tmp[ibase / 32] >> i % 32;
4769                 }
4770
4771               /* It shouldn't matter what's done here, so fill it with
4772                  zero.  */
4773               for (; i < elem_bitsize; i += value_bit)
4774                 *vp++ = 0;
4775             }
4776           break;
4777
4778         case CONST_FIXED:
4779           if (elem_bitsize <= HOST_BITS_PER_WIDE_INT)
4780             {
4781               for (i = 0; i < elem_bitsize; i += value_bit)
4782                 *vp++ = CONST_FIXED_VALUE_LOW (el) >> i;
4783             }
4784           else
4785             {
4786               for (i = 0; i < HOST_BITS_PER_WIDE_INT; i += value_bit)
4787                 *vp++ = CONST_FIXED_VALUE_LOW (el) >> i;
4788               for (; i < 2 * HOST_BITS_PER_WIDE_INT && i < elem_bitsize;
4789                    i += value_bit)
4790                 *vp++ = CONST_FIXED_VALUE_HIGH (el)
4791                         >> (i - HOST_BITS_PER_WIDE_INT);
4792               for (; i < elem_bitsize; i += value_bit)
4793                 *vp++ = 0;
4794             }
4795           break;
4796
4797         default:
4798           gcc_unreachable ();
4799         }
4800     }
4801
4802   /* Now, pick the right byte to start with.  */
4803   /* Renumber BYTE so that the least-significant byte is byte 0.  A special
4804      case is paradoxical SUBREGs, which shouldn't be adjusted since they
4805      will already have offset 0.  */
4806   if (GET_MODE_SIZE (innermode) >= GET_MODE_SIZE (outermode))
4807     {
4808       unsigned ibyte = (GET_MODE_SIZE (innermode) - GET_MODE_SIZE (outermode)
4809                         - byte);
4810       unsigned word_byte = WORDS_BIG_ENDIAN ? ibyte : byte;
4811       unsigned subword_byte = BYTES_BIG_ENDIAN ? ibyte : byte;
4812       byte = (subword_byte % UNITS_PER_WORD
4813               + (word_byte / UNITS_PER_WORD) * UNITS_PER_WORD);
4814     }
4815
4816   /* BYTE should still be inside OP.  (Note that BYTE is unsigned,
4817      so if it's become negative it will instead be very large.)  */
4818   gcc_assert (byte < GET_MODE_SIZE (innermode));
4819
4820   /* Convert from bytes to chunks of size value_bit.  */
4821   value_start = byte * (BITS_PER_UNIT / value_bit);
4822
4823   /* Re-pack the value.  */
4824
4825   if (VECTOR_MODE_P (outermode))
4826     {
4827       num_elem = GET_MODE_NUNITS (outermode);
4828       result_v = rtvec_alloc (num_elem);
4829       elems = &RTVEC_ELT (result_v, 0);
4830       outer_submode = GET_MODE_INNER (outermode);
4831     }
4832   else
4833     {
4834       num_elem = 1;
4835       elems = &result_s;
4836       outer_submode = outermode;
4837     }
4838
4839   outer_class = GET_MODE_CLASS (outer_submode);
4840   elem_bitsize = GET_MODE_BITSIZE (outer_submode);
4841
4842   gcc_assert (elem_bitsize % value_bit == 0);
4843   gcc_assert (elem_bitsize + value_start * value_bit <= max_bitsize);
4844
4845   for (elem = 0; elem < num_elem; elem++)
4846     {
4847       unsigned char *vp;
4848
4849       /* Vectors are stored in target memory order.  (This is probably
4850          a mistake.)  */
4851       {
4852         unsigned byte = (elem * elem_bitsize) / BITS_PER_UNIT;
4853         unsigned ibyte = (((num_elem - 1 - elem) * elem_bitsize)
4854                           / BITS_PER_UNIT);
4855         unsigned word_byte = WORDS_BIG_ENDIAN ? ibyte : byte;
4856         unsigned subword_byte = BYTES_BIG_ENDIAN ? ibyte : byte;
4857         unsigned bytele = (subword_byte % UNITS_PER_WORD
4858                          + (word_byte / UNITS_PER_WORD) * UNITS_PER_WORD);
4859         vp = value + value_start + (bytele * BITS_PER_UNIT) / value_bit;
4860       }
4861
4862       switch (outer_class)
4863         {
4864         case MODE_INT:
4865         case MODE_PARTIAL_INT:
4866           {
4867             unsigned HOST_WIDE_INT hi = 0, lo = 0;
4868
4869             for (i = 0;
4870                  i < HOST_BITS_PER_WIDE_INT && i < elem_bitsize;
4871                  i += value_bit)
4872               lo |= (HOST_WIDE_INT)(*vp++ & value_mask) << i;
4873             for (; i < elem_bitsize; i += value_bit)
4874               hi |= ((HOST_WIDE_INT)(*vp++ & value_mask)
4875                      << (i - HOST_BITS_PER_WIDE_INT));
4876
4877             /* immed_double_const doesn't call trunc_int_for_mode.  I don't
4878                know why.  */
4879             if (elem_bitsize <= HOST_BITS_PER_WIDE_INT)
4880               elems[elem] = gen_int_mode (lo, outer_submode);
4881             else if (elem_bitsize <= 2 * HOST_BITS_PER_WIDE_INT)
4882               elems[elem] = immed_double_const (lo, hi, outer_submode);
4883             else
4884               return NULL_RTX;
4885           }
4886           break;
4887
4888         case MODE_FLOAT:
4889         case MODE_DECIMAL_FLOAT:
4890           {
4891             REAL_VALUE_TYPE r;
4892             long tmp[max_bitsize / 32];
4893
4894             /* real_from_target wants its input in words affected by
4895                FLOAT_WORDS_BIG_ENDIAN.  However, we ignore this,
4896                and use WORDS_BIG_ENDIAN instead; see the documentation
4897                of SUBREG in rtl.texi.  */
4898             for (i = 0; i < max_bitsize / 32; i++)
4899               tmp[i] = 0;
4900             for (i = 0; i < elem_bitsize; i += value_bit)
4901               {
4902                 int ibase;
4903                 if (WORDS_BIG_ENDIAN)
4904                   ibase = elem_bitsize - 1 - i;
4905                 else
4906                   ibase = i;
4907                 tmp[ibase / 32] |= (*vp++ & value_mask) << i % 32;
4908               }
4909
4910             real_from_target (&r, tmp, outer_submode);
4911             elems[elem] = CONST_DOUBLE_FROM_REAL_VALUE (r, outer_submode);
4912           }
4913           break;
4914
4915         case MODE_FRACT:
4916         case MODE_UFRACT:
4917         case MODE_ACCUM:
4918         case MODE_UACCUM:
4919           {
4920             FIXED_VALUE_TYPE f;
4921             f.data.low = 0;
4922             f.data.high = 0;
4923             f.mode = outer_submode;
4924
4925             for (i = 0;
4926                  i < HOST_BITS_PER_WIDE_INT && i < elem_bitsize;
4927                  i += value_bit)
4928               f.data.low |= (HOST_WIDE_INT)(*vp++ & value_mask) << i;
4929             for (; i < elem_bitsize; i += value_bit)
4930               f.data.high |= ((HOST_WIDE_INT)(*vp++ & value_mask)
4931                              << (i - HOST_BITS_PER_WIDE_INT));
4932
4933             elems[elem] = CONST_FIXED_FROM_FIXED_VALUE (f, outer_submode);
4934           }
4935           break;
4936
4937         default:
4938           gcc_unreachable ();
4939         }
4940     }
4941   if (VECTOR_MODE_P (outermode))
4942     return gen_rtx_CONST_VECTOR (outermode, result_v);
4943   else
4944     return result_s;
4945 }
4946
4947 /* Simplify SUBREG:OUTERMODE(OP:INNERMODE, BYTE)
4948    Return 0 if no simplifications are possible.  */
4949 rtx
4950 simplify_subreg (enum machine_mode outermode, rtx op,
4951                  enum machine_mode innermode, unsigned int byte)
4952 {
4953   /* Little bit of sanity checking.  */
4954   gcc_assert (innermode != VOIDmode);
4955   gcc_assert (outermode != VOIDmode);
4956   gcc_assert (innermode != BLKmode);
4957   gcc_assert (outermode != BLKmode);
4958
4959   gcc_assert (GET_MODE (op) == innermode
4960               || GET_MODE (op) == VOIDmode);
4961
4962   gcc_assert ((byte % GET_MODE_SIZE (outermode)) == 0);
4963   gcc_assert (byte < GET_MODE_SIZE (innermode));
4964
4965   if (outermode == innermode && !byte)
4966     return op;
4967
4968   if (GET_CODE (op) == CONST_INT
4969       || GET_CODE (op) == CONST_DOUBLE
4970       || GET_CODE (op) == CONST_FIXED
4971       || GET_CODE (op) == CONST_VECTOR)
4972     return simplify_immed_subreg (outermode, op, innermode, byte);
4973
4974   /* Changing mode twice with SUBREG => just change it once,
4975      or not at all if changing back op starting mode.  */
4976   if (GET_CODE (op) == SUBREG)
4977     {
4978       enum machine_mode innermostmode = GET_MODE (SUBREG_REG (op));
4979       int final_offset = byte + SUBREG_BYTE (op);
4980       rtx newx;
4981
4982       if (outermode == innermostmode
4983           && byte == 0 && SUBREG_BYTE (op) == 0)
4984         return SUBREG_REG (op);
4985
4986       /* The SUBREG_BYTE represents offset, as if the value were stored
4987          in memory.  Irritating exception is paradoxical subreg, where
4988          we define SUBREG_BYTE to be 0.  On big endian machines, this
4989          value should be negative.  For a moment, undo this exception.  */
4990       if (byte == 0 && GET_MODE_SIZE (innermode) < GET_MODE_SIZE (outermode))
4991         {
4992           int difference = (GET_MODE_SIZE (innermode) - GET_MODE_SIZE (outermode));
4993           if (WORDS_BIG_ENDIAN)
4994             final_offset += (difference / UNITS_PER_WORD) * UNITS_PER_WORD;
4995           if (BYTES_BIG_ENDIAN)
4996             final_offset += difference % UNITS_PER_WORD;
4997         }
4998       if (SUBREG_BYTE (op) == 0
4999           && GET_MODE_SIZE (innermostmode) < GET_MODE_SIZE (innermode))
5000         {
5001           int difference = (GET_MODE_SIZE (innermostmode) - GET_MODE_SIZE (innermode));
5002           if (WORDS_BIG_ENDIAN)
5003             final_offset += (difference / UNITS_PER_WORD) * UNITS_PER_WORD;
5004           if (BYTES_BIG_ENDIAN)
5005             final_offset += difference % UNITS_PER_WORD;
5006         }
5007
5008       /* See whether resulting subreg will be paradoxical.  */
5009       if (GET_MODE_SIZE (innermostmode) > GET_MODE_SIZE (outermode))
5010         {
5011           /* In nonparadoxical subregs we can't handle negative offsets.  */
5012           if (final_offset < 0)
5013             return NULL_RTX;
5014           /* Bail out in case resulting subreg would be incorrect.  */
5015           if (final_offset % GET_MODE_SIZE (outermode)
5016               || (unsigned) final_offset >= GET_MODE_SIZE (innermostmode))
5017             return NULL_RTX;
5018         }
5019       else
5020         {
5021           int offset = 0;
5022           int difference = (GET_MODE_SIZE (innermostmode) - GET_MODE_SIZE (outermode));
5023
5024           /* In paradoxical subreg, see if we are still looking on lower part.
5025              If so, our SUBREG_BYTE will be 0.  */
5026           if (WORDS_BIG_ENDIAN)
5027             offset += (difference / UNITS_PER_WORD) * UNITS_PER_WORD;
5028           if (BYTES_BIG_ENDIAN)
5029             offset += difference % UNITS_PER_WORD;
5030           if (offset == final_offset)
5031             final_offset = 0;
5032           else
5033             return NULL_RTX;
5034         }
5035
5036       /* Recurse for further possible simplifications.  */
5037       newx = simplify_subreg (outermode, SUBREG_REG (op), innermostmode,
5038                               final_offset);
5039       if (newx)
5040         return newx;
5041       if (validate_subreg (outermode, innermostmode,
5042                            SUBREG_REG (op), final_offset))
5043         {
5044           newx = gen_rtx_SUBREG (outermode, SUBREG_REG (op), final_offset);
5045           if (SUBREG_PROMOTED_VAR_P (op)
5046               && SUBREG_PROMOTED_UNSIGNED_P (op) >= 0
5047               && GET_MODE_CLASS (outermode) == MODE_INT
5048               && IN_RANGE (GET_MODE_SIZE (outermode),
5049                            GET_MODE_SIZE (innermode),
5050                            GET_MODE_SIZE (innermostmode))
5051               && subreg_lowpart_p (newx))
5052             {
5053               SUBREG_PROMOTED_VAR_P (newx) = 1;
5054               SUBREG_PROMOTED_UNSIGNED_SET
5055                 (newx, SUBREG_PROMOTED_UNSIGNED_P (op));
5056             }
5057           return newx;
5058         }
5059       return NULL_RTX;
5060     }
5061
5062   /* Merge implicit and explicit truncations.  */
5063
5064   if (GET_CODE (op) == TRUNCATE
5065       && GET_MODE_SIZE (outermode) < GET_MODE_SIZE (innermode)
5066       && subreg_lowpart_offset (outermode, innermode) == byte)
5067     return simplify_gen_unary (TRUNCATE, outermode, XEXP (op, 0),
5068                                GET_MODE (XEXP (op, 0)));
5069
5070   /* SUBREG of a hard register => just change the register number
5071      and/or mode.  If the hard register is not valid in that mode,
5072      suppress this simplification.  If the hard register is the stack,
5073      frame, or argument pointer, leave this as a SUBREG.  */
5074
5075   if (REG_P (op) && HARD_REGISTER_P (op))
5076     {
5077       unsigned int regno, final_regno;
5078
5079       regno = REGNO (op);
5080       final_regno = simplify_subreg_regno (regno, innermode, byte, outermode);
5081       if (HARD_REGISTER_NUM_P (final_regno))
5082         {
5083           rtx x;
5084           int final_offset = byte;
5085
5086           /* Adjust offset for paradoxical subregs.  */
5087           if (byte == 0
5088               && GET_MODE_SIZE (innermode) < GET_MODE_SIZE (outermode))
5089             {
5090               int difference = (GET_MODE_SIZE (innermode)
5091                                 - GET_MODE_SIZE (outermode));
5092               if (WORDS_BIG_ENDIAN)
5093                 final_offset += (difference / UNITS_PER_WORD) * UNITS_PER_WORD;
5094               if (BYTES_BIG_ENDIAN)
5095                 final_offset += difference % UNITS_PER_WORD;
5096             }
5097
5098           x = gen_rtx_REG_offset (op, outermode, final_regno, final_offset);
5099
5100           /* Propagate original regno.  We don't have any way to specify
5101              the offset inside original regno, so do so only for lowpart.
5102              The information is used only by alias analysis that can not
5103              grog partial register anyway.  */
5104
5105           if (subreg_lowpart_offset (outermode, innermode) == byte)
5106             ORIGINAL_REGNO (x) = ORIGINAL_REGNO (op);
5107           return x;
5108         }
5109     }
5110
5111   /* If we have a SUBREG of a register that we are replacing and we are
5112      replacing it with a MEM, make a new MEM and try replacing the
5113      SUBREG with it.  Don't do this if the MEM has a mode-dependent address
5114      or if we would be widening it.  */
5115
5116   if (MEM_P (op)
5117       && ! mode_dependent_address_p (XEXP (op, 0))
5118       /* Allow splitting of volatile memory references in case we don't
5119          have instruction to move the whole thing.  */
5120       && (! MEM_VOLATILE_P (op)
5121           || ! have_insn_for (SET, innermode))
5122       && GET_MODE_SIZE (outermode) <= GET_MODE_SIZE (GET_MODE (op)))
5123     return adjust_address_nv (op, outermode, byte);
5124
5125   /* Handle complex values represented as CONCAT
5126      of real and imaginary part.  */
5127   if (GET_CODE (op) == CONCAT)
5128     {
5129       unsigned int part_size, final_offset;
5130       rtx part, res;
5131
5132       part_size = GET_MODE_UNIT_SIZE (GET_MODE (XEXP (op, 0)));
5133       if (byte < part_size)
5134         {
5135           part = XEXP (op, 0);
5136           final_offset = byte;
5137         }
5138       else
5139         {
5140           part = XEXP (op, 1);
5141           final_offset = byte - part_size;
5142         }
5143
5144       if (final_offset + GET_MODE_SIZE (outermode) > part_size)
5145         return NULL_RTX;
5146
5147       res = simplify_subreg (outermode, part, GET_MODE (part), final_offset);
5148       if (res)
5149         return res;
5150       if (validate_subreg (outermode, GET_MODE (part), part, final_offset))
5151         return gen_rtx_SUBREG (outermode, part, final_offset);
5152       return NULL_RTX;
5153     }
5154
5155   /* Optimize SUBREG truncations of zero and sign extended values.  */
5156   if ((GET_CODE (op) == ZERO_EXTEND
5157        || GET_CODE (op) == SIGN_EXTEND)
5158       && GET_MODE_BITSIZE (outermode) < GET_MODE_BITSIZE (innermode))
5159     {
5160       unsigned int bitpos = subreg_lsb_1 (outermode, innermode, byte);
5161
5162       /* If we're requesting the lowpart of a zero or sign extension,
5163          there are three possibilities.  If the outermode is the same
5164          as the origmode, we can omit both the extension and the subreg.
5165          If the outermode is not larger than the origmode, we can apply
5166          the truncation without the extension.  Finally, if the outermode
5167          is larger than the origmode, but both are integer modes, we
5168          can just extend to the appropriate mode.  */
5169       if (bitpos == 0)
5170         {
5171           enum machine_mode origmode = GET_MODE (XEXP (op, 0));
5172           if (outermode == origmode)
5173             return XEXP (op, 0);
5174           if (GET_MODE_BITSIZE (outermode) <= GET_MODE_BITSIZE (origmode))
5175             return simplify_gen_subreg (outermode, XEXP (op, 0), origmode,
5176                                         subreg_lowpart_offset (outermode,
5177                                                                origmode));
5178           if (SCALAR_INT_MODE_P (outermode))
5179             return simplify_gen_unary (GET_CODE (op), outermode,
5180                                        XEXP (op, 0), origmode);
5181         }
5182
5183       /* A SUBREG resulting from a zero extension may fold to zero if
5184          it extracts higher bits that the ZERO_EXTEND's source bits.  */
5185       if (GET_CODE (op) == ZERO_EXTEND
5186           && bitpos >= GET_MODE_BITSIZE (GET_MODE (XEXP (op, 0))))
5187         return CONST0_RTX (outermode);
5188     }
5189
5190   /* Simplify (subreg:QI (lshiftrt:SI (sign_extend:SI (x:QI)) C), 0) into
5191      to (ashiftrt:QI (x:QI) C), where C is a suitable small constant and
5192      the outer subreg is effectively a truncation to the original mode.  */
5193   if ((GET_CODE (op) == LSHIFTRT
5194        || GET_CODE (op) == ASHIFTRT)
5195       && SCALAR_INT_MODE_P (outermode)
5196       /* Ensure that OUTERMODE is at least twice as wide as the INNERMODE
5197          to avoid the possibility that an outer LSHIFTRT shifts by more
5198          than the sign extension's sign_bit_copies and introduces zeros
5199          into the high bits of the result.  */
5200       && (2 * GET_MODE_BITSIZE (outermode)) <= GET_MODE_BITSIZE (innermode)
5201       && GET_CODE (XEXP (op, 1)) == CONST_INT
5202       && GET_CODE (XEXP (op, 0)) == SIGN_EXTEND
5203       && GET_MODE (XEXP (XEXP (op, 0), 0)) == outermode
5204       && INTVAL (XEXP (op, 1)) < GET_MODE_BITSIZE (outermode)
5205       && subreg_lsb_1 (outermode, innermode, byte) == 0)
5206     return simplify_gen_binary (ASHIFTRT, outermode,
5207                                 XEXP (XEXP (op, 0), 0), XEXP (op, 1));
5208
5209   /* Likewise (subreg:QI (lshiftrt:SI (zero_extend:SI (x:QI)) C), 0) into
5210      to (lshiftrt:QI (x:QI) C), where C is a suitable small constant and
5211      the outer subreg is effectively a truncation to the original mode.  */
5212   if ((GET_CODE (op) == LSHIFTRT
5213        || GET_CODE (op) == ASHIFTRT)
5214       && SCALAR_INT_MODE_P (outermode)
5215       && GET_MODE_BITSIZE (outermode) < GET_MODE_BITSIZE (innermode)
5216       && GET_CODE (XEXP (op, 1)) == CONST_INT
5217       && GET_CODE (XEXP (op, 0)) == ZERO_EXTEND
5218       && GET_MODE (XEXP (XEXP (op, 0), 0)) == outermode
5219       && INTVAL (XEXP (op, 1)) < GET_MODE_BITSIZE (outermode)
5220       && subreg_lsb_1 (outermode, innermode, byte) == 0)
5221     return simplify_gen_binary (LSHIFTRT, outermode,
5222                                 XEXP (XEXP (op, 0), 0), XEXP (op, 1));
5223
5224   /* Likewise (subreg:QI (ashift:SI (zero_extend:SI (x:QI)) C), 0) into
5225      to (ashift:QI (x:QI) C), where C is a suitable small constant and
5226      the outer subreg is effectively a truncation to the original mode.  */
5227   if (GET_CODE (op) == ASHIFT
5228       && SCALAR_INT_MODE_P (outermode)
5229       && GET_MODE_BITSIZE (outermode) < GET_MODE_BITSIZE (innermode)
5230       && GET_CODE (XEXP (op, 1)) == CONST_INT
5231       && (GET_CODE (XEXP (op, 0)) == ZERO_EXTEND
5232           || GET_CODE (XEXP (op, 0)) == SIGN_EXTEND)
5233       && GET_MODE (XEXP (XEXP (op, 0), 0)) == outermode
5234       && INTVAL (XEXP (op, 1)) < GET_MODE_BITSIZE (outermode)
5235       && subreg_lsb_1 (outermode, innermode, byte) == 0)
5236     return simplify_gen_binary (ASHIFT, outermode,
5237                                 XEXP (XEXP (op, 0), 0), XEXP (op, 1));
5238
5239   /* Recognize a word extraction from a multi-word subreg.  */
5240   if ((GET_CODE (op) == LSHIFTRT
5241        || GET_CODE (op) == ASHIFTRT)
5242       && SCALAR_INT_MODE_P (outermode)
5243       && GET_MODE_BITSIZE (outermode) >= BITS_PER_WORD
5244       && GET_MODE_BITSIZE (innermode) >= (2 * GET_MODE_BITSIZE (outermode))
5245       && GET_CODE (XEXP (op, 1)) == CONST_INT
5246       && (INTVAL (XEXP (op, 1)) & (GET_MODE_BITSIZE (outermode) - 1)) == 0
5247       && INTVAL (XEXP (op, 1)) >= 0
5248       && INTVAL (XEXP (op, 1)) < GET_MODE_BITSIZE (innermode)
5249       && byte == subreg_lowpart_offset (outermode, innermode))
5250     {
5251       int shifted_bytes = INTVAL (XEXP (op, 1)) / BITS_PER_UNIT;
5252       return simplify_gen_subreg (outermode, XEXP (op, 0), innermode,
5253                                   (WORDS_BIG_ENDIAN
5254                                    ? byte - shifted_bytes : byte + shifted_bytes));
5255     }
5256
5257   return NULL_RTX;
5258 }
5259
5260 /* Make a SUBREG operation or equivalent if it folds.  */
5261
5262 rtx
5263 simplify_gen_subreg (enum machine_mode outermode, rtx op,
5264                      enum machine_mode innermode, unsigned int byte)
5265 {
5266   rtx newx;
5267
5268   newx = simplify_subreg (outermode, op, innermode, byte);
5269   if (newx)
5270     return newx;
5271
5272   if (GET_CODE (op) == SUBREG
5273       || GET_CODE (op) == CONCAT
5274       || GET_MODE (op) == VOIDmode)
5275     return NULL_RTX;
5276
5277   if (validate_subreg (outermode, innermode, op, byte))
5278     return gen_rtx_SUBREG (outermode, op, byte);
5279
5280   return NULL_RTX;
5281 }
5282
5283 /* Simplify X, an rtx expression.
5284
5285    Return the simplified expression or NULL if no simplifications
5286    were possible.
5287
5288    This is the preferred entry point into the simplification routines;
5289    however, we still allow passes to call the more specific routines.
5290
5291    Right now GCC has three (yes, three) major bodies of RTL simplification
5292    code that need to be unified.
5293
5294         1. fold_rtx in cse.c.  This code uses various CSE specific
5295            information to aid in RTL simplification.
5296
5297         2. simplify_rtx in combine.c.  Similar to fold_rtx, except that
5298            it uses combine specific information to aid in RTL
5299            simplification.
5300
5301         3. The routines in this file.
5302
5303
5304    Long term we want to only have one body of simplification code; to
5305    get to that state I recommend the following steps:
5306
5307         1. Pour over fold_rtx & simplify_rtx and move any simplifications
5308            which are not pass dependent state into these routines.
5309
5310         2. As code is moved by #1, change fold_rtx & simplify_rtx to
5311            use this routine whenever possible.
5312
5313         3. Allow for pass dependent state to be provided to these
5314            routines and add simplifications based on the pass dependent
5315            state.  Remove code from cse.c & combine.c that becomes
5316            redundant/dead.
5317
5318     It will take time, but ultimately the compiler will be easier to
5319     maintain and improve.  It's totally silly that when we add a
5320     simplification that it needs to be added to 4 places (3 for RTL
5321     simplification and 1 for tree simplification.  */
5322
5323 rtx
5324 simplify_rtx (const_rtx x)
5325 {
5326   const enum rtx_code code = GET_CODE (x);
5327   const enum machine_mode mode = GET_MODE (x);
5328
5329   switch (GET_RTX_CLASS (code))
5330     {
5331     case RTX_UNARY:
5332       return simplify_unary_operation (code, mode,
5333                                        XEXP (x, 0), GET_MODE (XEXP (x, 0)));
5334     case RTX_COMM_ARITH:
5335       if (swap_commutative_operands_p (XEXP (x, 0), XEXP (x, 1)))
5336         return simplify_gen_binary (code, mode, XEXP (x, 1), XEXP (x, 0));
5337
5338       /* Fall through....  */
5339
5340     case RTX_BIN_ARITH:
5341       return simplify_binary_operation (code, mode, XEXP (x, 0), XEXP (x, 1));
5342
5343     case RTX_TERNARY:
5344     case RTX_BITFIELD_OPS:
5345       return simplify_ternary_operation (code, mode, GET_MODE (XEXP (x, 0)),
5346                                          XEXP (x, 0), XEXP (x, 1),
5347                                          XEXP (x, 2));
5348
5349     case RTX_COMPARE:
5350     case RTX_COMM_COMPARE:
5351       return simplify_relational_operation (code, mode,
5352                                             ((GET_MODE (XEXP (x, 0))
5353                                              != VOIDmode)
5354                                             ? GET_MODE (XEXP (x, 0))
5355                                             : GET_MODE (XEXP (x, 1))),
5356                                             XEXP (x, 0),
5357                                             XEXP (x, 1));
5358
5359     case RTX_EXTRA:
5360       if (code == SUBREG)
5361         return simplify_subreg (mode, SUBREG_REG (x),
5362                                 GET_MODE (SUBREG_REG (x)),
5363                                 SUBREG_BYTE (x));
5364       break;
5365
5366     case RTX_OBJ:
5367       if (code == LO_SUM)
5368         {
5369           /* Convert (lo_sum (high FOO) FOO) to FOO.  */
5370           if (GET_CODE (XEXP (x, 0)) == HIGH
5371               && rtx_equal_p (XEXP (XEXP (x, 0), 0), XEXP (x, 1)))
5372           return XEXP (x, 1);
5373         }
5374       break;
5375
5376     default:
5377       break;
5378     }
5379   return NULL;
5380 }