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