gcc/simplify-rtx.c

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