gcc/combine.c

   1 /* Optimize by combining instructions for GNU compiler.
   2    Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
   3    1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
   4    Free Software Foundation, Inc.
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify it under
   9 the terms of the GNU General Public License as published by the Free
  10 Software Foundation; either version 3, or (at your option) any later
  11 version.
  12
  13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16 for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING3.  If not see
  20 <http://www.gnu.org/licenses/>.  */
  21
  22 /* This module is essentially the "combiner" phase of the U. of Arizona
  23    Portable Optimizer, but redone to work on our list-structured
  24    representation for RTL instead of their string representation.
  25
  26    The LOG_LINKS of each insn identify the most recent assignment
  27    to each REG used in the insn.  It is a list of previous insns,
  28    each of which contains a SET for a REG that is used in this insn
  29    and not used or set in between.  LOG_LINKs never cross basic blocks.
  30    They were set up by the preceding pass (lifetime analysis).
  31
  32    We try to combine each pair of insns joined by a logical link.
  33    We also try to combine triples of insns A, B and C when
  34    C has a link back to B and B has a link back to A.
  35
  36    LOG_LINKS does not have links for use of the CC0.  They don't
  37    need to, because the insn that sets the CC0 is always immediately
  38    before the insn that tests it.  So we always regard a branch
  39    insn as having a logical link to the preceding insn.  The same is true
  40    for an insn explicitly using CC0.
  41
  42    We check (with use_crosses_set_p) to avoid combining in such a way
  43    as to move a computation to a place where its value would be different.
  44
  45    Combination is done by mathematically substituting the previous
  46    insn(s) values for the regs they set into the expressions in
  47    the later insns that refer to these regs.  If the result is a valid insn
  48    for our target machine, according to the machine description,
  49    we install it, delete the earlier insns, and update the data flow
  50    information (LOG_LINKS and REG_NOTES) for what we did.
  51
  52    There are a few exceptions where the dataflow information isn't
  53    completely updated (however this is only a local issue since it is
  54    regenerated before the next pass that uses it):
  55
  56    - reg_live_length is not updated
  57    - reg_n_refs is not adjusted in the rare case when a register is
  58      no longer required in a computation
  59    - there are extremely rare cases (see distribute_notes) when a
  60      REG_DEAD note is lost
  61    - a LOG_LINKS entry that refers to an insn with multiple SETs may be
  62      removed because there is no way to know which register it was
  63      linking
  64
  65    To simplify substitution, we combine only when the earlier insn(s)
  66    consist of only a single assignment.  To simplify updating afterward,
  67    we never combine when a subroutine call appears in the middle.
  68
  69    Since we do not represent assignments to CC0 explicitly except when that
  70    is all an insn does, there is no LOG_LINKS entry in an insn that uses
  71    the condition code for the insn that set the condition code.
  72    Fortunately, these two insns must be consecutive.
  73    Therefore, every JUMP_INSN is taken to have an implicit logical link
  74    to the preceding insn.  This is not quite right, since non-jumps can
  75    also use the condition code; but in practice such insns would not
  76    combine anyway.  */
  77
  78 #include "config.h"
  79 #include "system.h"
  80 #include "coretypes.h"
  81 #include "tm.h"
  82 #include "rtl.h"
  83 #include "tree.h"
  84 #include "tm_p.h"
  85 #include "flags.h"
  86 #include "regs.h"
  87 #include "hard-reg-set.h"
  88 #include "basic-block.h"
  89 #include "insn-config.h"
  90 #include "function.h"
  91 /* Include expr.h after insn-config.h so we get HAVE_conditional_move.  */
  92 #include "expr.h"
  93 #include "insn-attr.h"
  94 #include "recog.h"
  95 #include "diagnostic-core.h"
  96 #include "toplev.h"
  97 #include "target.h"
  98 #include "optabs.h"
  99 #include "insn-codes.h"
 100 #include "rtlhooks-def.h"
 101 /* Include output.h for dump_file.  */
 102 #include "output.h"
 103 #include "params.h"
 104 #include "timevar.h"
 105 #include "tree-pass.h"
 106 #include "df.h"
 107 #include "cgraph.h"
 108
 109 /* Number of attempts to combine instructions in this function.  */
 110
 111 static int combine_attempts;
 112
 113 /* Number of attempts that got as far as substitution in this function.  */
 114
 115 static int combine_merges;
 116
 117 /* Number of instructions combined with added SETs in this function.  */
 118
 119 static int combine_extras;
 120
 121 /* Number of instructions combined in this function.  */
 122
 123 static int combine_successes;
 124
 125 /* Totals over entire compilation.  */
 126
 127 static int total_attempts, total_merges, total_extras, total_successes;
 128
 129 /* combine_instructions may try to replace the right hand side of the
 130    second instruction with the value of an associated REG_EQUAL note
 131    before throwing it at try_combine.  That is problematic when there
 132    is a REG_DEAD note for a register used in the old right hand side
 133    and can cause distribute_notes to do wrong things.  This is the
 134    second instruction if it has been so modified, null otherwise.  */
 135
 136 static rtx i2mod;
 137
 138 /* When I2MOD is nonnull, this is a copy of the old right hand side.  */
 139
 140 static rtx i2mod_old_rhs;
 141
 142 /* When I2MOD is nonnull, this is a copy of the new right hand side.  */
 143
 144 static rtx i2mod_new_rhs;
 145 \f
 146 typedef struct reg_stat_struct {
 147   /* Record last point of death of (hard or pseudo) register n.  */
 148   rtx                           last_death;
 149
 150   /* Record last point of modification of (hard or pseudo) register n.  */
 151   rtx                           last_set;
 152
 153   /* The next group of fields allows the recording of the last value assigned
 154      to (hard or pseudo) register n.  We use this information to see if an
 155      operation being processed is redundant given a prior operation performed
 156      on the register.  For example, an `and' with a constant is redundant if
 157      all the zero bits are already known to be turned off.
 158
 159      We use an approach similar to that used by cse, but change it in the
 160      following ways:
 161
 162      (1) We do not want to reinitialize at each label.
 163      (2) It is useful, but not critical, to know the actual value assigned
 164          to a register.  Often just its form is helpful.
 165
 166      Therefore, we maintain the following fields:
 167
 168      last_set_value             the last value assigned
 169      last_set_label             records the value of label_tick when the
 170                                 register was assigned
 171      last_set_table_tick        records the value of label_tick when a
 172                                 value using the register is assigned
 173      last_set_invalid           set to nonzero when it is not valid
 174                                 to use the value of this register in some
 175                                 register's value
 176
 177      To understand the usage of these tables, it is important to understand
 178      the distinction between the value in last_set_value being valid and
 179      the register being validly contained in some other expression in the
 180      table.
 181
 182      (The next two parameters are out of date).
 183
 184      reg_stat[i].last_set_value is valid if it is nonzero, and either
 185      reg_n_sets[i] is 1 or reg_stat[i].last_set_label == label_tick.
 186
 187      Register I may validly appear in any expression returned for the value
 188      of another register if reg_n_sets[i] is 1.  It may also appear in the
 189      value for register J if reg_stat[j].last_set_invalid is zero, or
 190      reg_stat[i].last_set_label < reg_stat[j].last_set_label.
 191
 192      If an expression is found in the table containing a register which may
 193      not validly appear in an expression, the register is replaced by
 194      something that won't match, (clobber (const_int 0)).  */
 195
 196   /* Record last value assigned to (hard or pseudo) register n.  */
 197
 198   rtx                           last_set_value;
 199
 200   /* Record the value of label_tick when an expression involving register n
 201      is placed in last_set_value.  */
 202
 203   int                           last_set_table_tick;
 204
 205   /* Record the value of label_tick when the value for register n is placed in
 206      last_set_value.  */
 207
 208   int                           last_set_label;
 209
 210   /* These fields are maintained in parallel with last_set_value and are
 211      used to store the mode in which the register was last set, the bits
 212      that were known to be zero when it was last set, and the number of
 213      sign bits copies it was known to have when it was last set.  */
 214
 215   unsigned HOST_WIDE_INT        last_set_nonzero_bits;
 216   char                          last_set_sign_bit_copies;
 217   ENUM_BITFIELD(machine_mode)   last_set_mode : 8;
 218
 219   /* Set nonzero if references to register n in expressions should not be
 220      used.  last_set_invalid is set nonzero when this register is being
 221      assigned to and last_set_table_tick == label_tick.  */
 222
 223   char                          last_set_invalid;
 224
 225   /* Some registers that are set more than once and used in more than one
 226      basic block are nevertheless always set in similar ways.  For example,
 227      a QImode register may be loaded from memory in two places on a machine
 228      where byte loads zero extend.
 229
 230      We record in the following fields if a register has some leading bits
 231      that are always equal to the sign bit, and what we know about the
 232      nonzero bits of a register, specifically which bits are known to be
 233      zero.
 234
 235      If an entry is zero, it means that we don't know anything special.  */
 236
 237   unsigned char                 sign_bit_copies;
 238
 239   unsigned HOST_WIDE_INT        nonzero_bits;
 240
 241   /* Record the value of the label_tick when the last truncation
 242      happened.  The field truncated_to_mode is only valid if
 243      truncation_label == label_tick.  */
 244
 245   int                           truncation_label;
 246
 247   /* Record the last truncation seen for this register.  If truncation
 248      is not a nop to this mode we might be able to save an explicit
 249      truncation if we know that value already contains a truncated
 250      value.  */
 251
 252   ENUM_BITFIELD(machine_mode)   truncated_to_mode : 8;
 253 } reg_stat_type;
 254
 255 DEF_VEC_O(reg_stat_type);
 256 DEF_VEC_ALLOC_O(reg_stat_type,heap);
 257
 258 static VEC(reg_stat_type,heap) *reg_stat;
 259
 260 /* Record the luid of the last insn that invalidated memory
 261    (anything that writes memory, and subroutine calls, but not pushes).  */
 262
 263 static int mem_last_set;
 264
 265 /* Record the luid of the last CALL_INSN
 266    so we can tell whether a potential combination crosses any calls.  */
 267
 268 static int last_call_luid;
 269
 270 /* When `subst' is called, this is the insn that is being modified
 271    (by combining in a previous insn).  The PATTERN of this insn
 272    is still the old pattern partially modified and it should not be
 273    looked at, but this may be used to examine the successors of the insn
 274    to judge whether a simplification is valid.  */
 275
 276 static rtx subst_insn;
 277
 278 /* This is the lowest LUID that `subst' is currently dealing with.
 279    get_last_value will not return a value if the register was set at or
 280    after this LUID.  If not for this mechanism, we could get confused if
 281    I2 or I1 in try_combine were an insn that used the old value of a register
 282    to obtain a new value.  In that case, we might erroneously get the
 283    new value of the register when we wanted the old one.  */
 284
 285 static int subst_low_luid;
 286
 287 /* This contains any hard registers that are used in newpat; reg_dead_at_p
 288    must consider all these registers to be always live.  */
 289
 290 static HARD_REG_SET newpat_used_regs;
 291
 292 /* This is an insn to which a LOG_LINKS entry has been added.  If this
 293    insn is the earlier than I2 or I3, combine should rescan starting at
 294    that location.  */
 295
 296 static rtx added_links_insn;
 297
 298 /* Basic block in which we are performing combines.  */
 299 static basic_block this_basic_block;
 300 static bool optimize_this_for_speed_p;
 301
 302 \f
 303 /* Length of the currently allocated uid_insn_cost array.  */
 304
 305 static int max_uid_known;
 306
 307 /* The following array records the insn_rtx_cost for every insn
 308    in the instruction stream.  */
 309
 310 static int *uid_insn_cost;
 311
 312 /* The following array records the LOG_LINKS for every insn in the
 313    instruction stream as an INSN_LIST rtx.  */
 314
 315 static rtx *uid_log_links;
 316
 317 #define INSN_COST(INSN)         (uid_insn_cost[INSN_UID (INSN)])
 318 #define LOG_LINKS(INSN)         (uid_log_links[INSN_UID (INSN)])
 319
 320 /* Incremented for each basic block.  */
 321
 322 static int label_tick;
 323
 324 /* Reset to label_tick for each extended basic block in scanning order.  */
 325
 326 static int label_tick_ebb_start;
 327
 328 /* Mode used to compute significance in reg_stat[].nonzero_bits.  It is the
 329    largest integer mode that can fit in HOST_BITS_PER_WIDE_INT.  */
 330
 331 static enum machine_mode nonzero_bits_mode;
 332
 333 /* Nonzero when reg_stat[].nonzero_bits and reg_stat[].sign_bit_copies can
 334    be safely used.  It is zero while computing them and after combine has
 335    completed.  This former test prevents propagating values based on
 336    previously set values, which can be incorrect if a variable is modified
 337    in a loop.  */
 338
 339 static int nonzero_sign_valid;
 340
 341 \f
 342 /* Record one modification to rtl structure
 343    to be undone by storing old_contents into *where.  */
 344
 345 enum undo_kind { UNDO_RTX, UNDO_INT, UNDO_MODE };
 346
 347 struct undo
 348 {
 349   struct undo *next;
 350   enum undo_kind kind;
 351   union { rtx r; int i; enum machine_mode m; } old_contents;
 352   union { rtx *r; int *i; } where;
 353 };
 354
 355 /* Record a bunch of changes to be undone, up to MAX_UNDO of them.
 356    num_undo says how many are currently recorded.
 357
 358    other_insn is nonzero if we have modified some other insn in the process
 359    of working on subst_insn.  It must be verified too.  */
 360
 361 struct undobuf
 362 {
 363   struct undo *undos;
 364   struct undo *frees;
 365   rtx other_insn;
 366 };
 367
 368 static struct undobuf undobuf;
 369
 370 /* Number of times the pseudo being substituted for
 371    was found and replaced.  */
 372
 373 static int n_occurrences;
 374
 375 static rtx reg_nonzero_bits_for_combine (const_rtx, enum machine_mode, const_rtx,
 376                                          enum machine_mode,
 377                                          unsigned HOST_WIDE_INT,
 378                                          unsigned HOST_WIDE_INT *);
 379 static rtx reg_num_sign_bit_copies_for_combine (const_rtx, enum machine_mode, const_rtx,
 380                                                 enum machine_mode,
 381                                                 unsigned int, unsigned int *);
 382 static void do_SUBST (rtx *, rtx);
 383 static void do_SUBST_INT (int *, int);
 384 static void init_reg_last (void);
 385 static void setup_incoming_promotions (rtx);
 386 static void set_nonzero_bits_and_sign_copies (rtx, const_rtx, void *);
 387 static int cant_combine_insn_p (rtx);
 388 static int can_combine_p (rtx, rtx, rtx, rtx, rtx, rtx, rtx *, rtx *);
 389 static int combinable_i3pat (rtx, rtx *, rtx, rtx, rtx, int, int, rtx *);
 390 static int contains_muldiv (rtx);
 391 static rtx try_combine (rtx, rtx, rtx, rtx, int *);
 392 static void undo_all (void);
 393 static void undo_commit (void);
 394 static rtx *find_split_point (rtx *, rtx, bool);
 395 static rtx subst (rtx, rtx, rtx, int, int);
 396 static rtx combine_simplify_rtx (rtx, enum machine_mode, int);
 397 static rtx simplify_if_then_else (rtx);
 398 static rtx simplify_set (rtx);
 399 static rtx simplify_logical (rtx);
 400 static rtx expand_compound_operation (rtx);
 401 static const_rtx expand_field_assignment (const_rtx);
 402 static rtx make_extraction (enum machine_mode, rtx, HOST_WIDE_INT,
 403                             rtx, unsigned HOST_WIDE_INT, int, int, int);
 404 static rtx extract_left_shift (rtx, int);
 405 static rtx make_compound_operation (rtx, enum rtx_code);
 406 static int get_pos_from_mask (unsigned HOST_WIDE_INT,
 407                               unsigned HOST_WIDE_INT *);
 408 static rtx canon_reg_for_combine (rtx, rtx);
 409 static rtx force_to_mode (rtx, enum machine_mode,
 410                           unsigned HOST_WIDE_INT, int);
 411 static rtx if_then_else_cond (rtx, rtx *, rtx *);
 412 static rtx known_cond (rtx, enum rtx_code, rtx, rtx);
 413 static int rtx_equal_for_field_assignment_p (rtx, rtx);
 414 static rtx make_field_assignment (rtx);
 415 static rtx apply_distributive_law (rtx);
 416 static rtx distribute_and_simplify_rtx (rtx, int);
 417 static rtx simplify_and_const_int_1 (enum machine_mode, rtx,
 418                                      unsigned HOST_WIDE_INT);
 419 static rtx simplify_and_const_int (rtx, enum machine_mode, rtx,
 420                                    unsigned HOST_WIDE_INT);
 421 static int merge_outer_ops (enum rtx_code *, HOST_WIDE_INT *, enum rtx_code,
 422                             HOST_WIDE_INT, enum machine_mode, int *);
 423 static rtx simplify_shift_const_1 (enum rtx_code, enum machine_mode, rtx, int);
 424 static rtx simplify_shift_const (rtx, enum rtx_code, enum machine_mode, rtx,
 425                                  int);
 426 static int recog_for_combine (rtx *, rtx, rtx *);
 427 static rtx gen_lowpart_for_combine (enum machine_mode, rtx);
 428 static enum rtx_code simplify_comparison (enum rtx_code, rtx *, rtx *);
 429 static void update_table_tick (rtx);
 430 static void record_value_for_reg (rtx, rtx, rtx);
 431 static void check_promoted_subreg (rtx, rtx);
 432 static void record_dead_and_set_regs_1 (rtx, const_rtx, void *);
 433 static void record_dead_and_set_regs (rtx);
 434 static int get_last_value_validate (rtx *, rtx, int, int);
 435 static rtx get_last_value (const_rtx);
 436 static int use_crosses_set_p (const_rtx, int);
 437 static void reg_dead_at_p_1 (rtx, const_rtx, void *);
 438 static int reg_dead_at_p (rtx, rtx);
 439 static void move_deaths (rtx, rtx, int, rtx, rtx *);
 440 static int reg_bitfield_target_p (rtx, rtx);
 441 static void distribute_notes (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
 442 static void distribute_links (rtx);
 443 static void mark_used_regs_combine (rtx);
 444 static void record_promoted_value (rtx, rtx);
 445 static int unmentioned_reg_p_1 (rtx *, void *);
 446 static bool unmentioned_reg_p (rtx, rtx);
 447 static int record_truncated_value (rtx *, void *);
 448 static void record_truncated_values (rtx *, void *);
 449 static bool reg_truncated_to_mode (enum machine_mode, const_rtx);
 450 static rtx gen_lowpart_or_truncate (enum machine_mode, rtx);
 451 \f
 452
 453 /* It is not safe to use ordinary gen_lowpart in combine.
 454    See comments in gen_lowpart_for_combine.  */
 455 #undef RTL_HOOKS_GEN_LOWPART
 456 #define RTL_HOOKS_GEN_LOWPART              gen_lowpart_for_combine
 457
 458 /* Our implementation of gen_lowpart never emits a new pseudo.  */
 459 #undef RTL_HOOKS_GEN_LOWPART_NO_EMIT
 460 #define RTL_HOOKS_GEN_LOWPART_NO_EMIT      gen_lowpart_for_combine
 461
 462 #undef RTL_HOOKS_REG_NONZERO_REG_BITS
 463 #define RTL_HOOKS_REG_NONZERO_REG_BITS     reg_nonzero_bits_for_combine
 464
 465 #undef RTL_HOOKS_REG_NUM_SIGN_BIT_COPIES
 466 #define RTL_HOOKS_REG_NUM_SIGN_BIT_COPIES  reg_num_sign_bit_copies_for_combine
 467
 468 #undef RTL_HOOKS_REG_TRUNCATED_TO_MODE
 469 #define RTL_HOOKS_REG_TRUNCATED_TO_MODE    reg_truncated_to_mode
 470
 471 static const struct rtl_hooks combine_rtl_hooks = RTL_HOOKS_INITIALIZER;
 472
 473 \f
 474 /* Try to split PATTERN found in INSN.  This returns NULL_RTX if
 475    PATTERN can not be split.  Otherwise, it returns an insn sequence.
 476    This is a wrapper around split_insns which ensures that the
 477    reg_stat vector is made larger if the splitter creates a new
 478    register.  */
 479
 480 static rtx
 481 combine_split_insns (rtx pattern, rtx insn)
 482 {
 483   rtx ret;
 484   unsigned int nregs;
 485
 486   ret = split_insns (pattern, insn);
 487   nregs = max_reg_num ();
 488   if (nregs > VEC_length (reg_stat_type, reg_stat))
 489     VEC_safe_grow_cleared (reg_stat_type, heap, reg_stat, nregs);
 490   return ret;
 491 }
 492
 493 /* This is used by find_single_use to locate an rtx in LOC that
 494    contains exactly one use of DEST, which is typically either a REG
 495    or CC0.  It returns a pointer to the innermost rtx expression
 496    containing DEST.  Appearances of DEST that are being used to
 497    totally replace it are not counted.  */
 498
 499 static rtx *
 500 find_single_use_1 (rtx dest, rtx *loc)
 501 {
 502   rtx x = *loc;
 503   enum rtx_code code = GET_CODE (x);
 504   rtx *result = NULL;
 505   rtx *this_result;
 506   int i;
 507   const char *fmt;
 508
 509   switch (code)
 510     {
 511     case CONST_INT:
 512     case CONST:
 513     case LABEL_REF:
 514     case SYMBOL_REF:
 515     case CONST_DOUBLE:
 516     case CONST_VECTOR:
 517     case CLOBBER:
 518       return 0;
 519
 520     case SET:
 521       /* If the destination is anything other than CC0, PC, a REG or a SUBREG
 522          of a REG that occupies all of the REG, the insn uses DEST if
 523          it is mentioned in the destination or the source.  Otherwise, we
 524          need just check the source.  */
 525       if (GET_CODE (SET_DEST (x)) != CC0
 526           && GET_CODE (SET_DEST (x)) != PC
 527           && !REG_P (SET_DEST (x))
 528           && ! (GET_CODE (SET_DEST (x)) == SUBREG
 529                 && REG_P (SUBREG_REG (SET_DEST (x)))
 530                 && (((GET_MODE_SIZE (GET_MODE (SUBREG_REG (SET_DEST (x))))
 531                       + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD)
 532                     == ((GET_MODE_SIZE (GET_MODE (SET_DEST (x)))
 533                          + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD))))
 534         break;
 535
 536       return find_single_use_1 (dest, &SET_SRC (x));
 537
 538     case MEM:
 539     case SUBREG:
 540       return find_single_use_1 (dest, &XEXP (x, 0));
 541
 542     default:
 543       break;
 544     }
 545
 546   /* If it wasn't one of the common cases above, check each expression and
 547      vector of this code.  Look for a unique usage of DEST.  */
 548
 549   fmt = GET_RTX_FORMAT (code);
 550   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
 551     {
 552       if (fmt[i] == 'e')
 553         {
 554           if (dest == XEXP (x, i)
 555               || (REG_P (dest) && REG_P (XEXP (x, i))
 556                   && REGNO (dest) == REGNO (XEXP (x, i))))
 557             this_result = loc;
 558           else
 559             this_result = find_single_use_1 (dest, &XEXP (x, i));
 560
 561           if (result == NULL)
 562             result = this_result;
 563           else if (this_result)
 564             /* Duplicate usage.  */
 565             return NULL;
 566         }
 567       else if (fmt[i] == 'E')
 568         {
 569           int j;
 570
 571           for (j = XVECLEN (x, i) - 1; j >= 0; j--)
 572             {
 573               if (XVECEXP (x, i, j) == dest
 574                   || (REG_P (dest)
 575                       && REG_P (XVECEXP (x, i, j))
 576                       && REGNO (XVECEXP (x, i, j)) == REGNO (dest)))
 577                 this_result = loc;
 578               else
 579                 this_result = find_single_use_1 (dest, &XVECEXP (x, i, j));
 580
 581               if (result == NULL)
 582                 result = this_result;
 583               else if (this_result)
 584                 return NULL;
 585             }
 586         }
 587     }
 588
 589   return result;
 590 }
 591
 592
 593 /* See if DEST, produced in INSN, is used only a single time in the
 594    sequel.  If so, return a pointer to the innermost rtx expression in which
 595    it is used.
 596
 597    If PLOC is nonzero, *PLOC is set to the insn containing the single use.
 598
 599    If DEST is cc0_rtx, we look only at the next insn.  In that case, we don't
 600    care about REG_DEAD notes or LOG_LINKS.
 601
 602    Otherwise, we find the single use by finding an insn that has a
 603    LOG_LINKS pointing at INSN and has a REG_DEAD note for DEST.  If DEST is
 604    only referenced once in that insn, we know that it must be the first
 605    and last insn referencing DEST.  */
 606
 607 static rtx *
 608 find_single_use (rtx dest, rtx insn, rtx *ploc)
 609 {
 610   basic_block bb;
 611   rtx next;
 612   rtx *result;
 613   rtx link;
 614
 615 #ifdef HAVE_cc0
 616   if (dest == cc0_rtx)
 617     {
 618       next = NEXT_INSN (insn);
 619       if (next == 0
 620           || (!NONJUMP_INSN_P (next) && !JUMP_P (next)))
 621         return 0;
 622
 623       result = find_single_use_1 (dest, &PATTERN (next));
 624       if (result && ploc)
 625         *ploc = next;
 626       return result;
 627     }
 628 #endif
 629
 630   if (!REG_P (dest))
 631     return 0;
 632
 633   bb = BLOCK_FOR_INSN (insn);
 634   for (next = NEXT_INSN (insn);
 635        next && BLOCK_FOR_INSN (next) == bb;
 636        next = NEXT_INSN (next))
 637     if (INSN_P (next) && dead_or_set_p (next, dest))
 638       {
 639         for (link = LOG_LINKS (next); link; link = XEXP (link, 1))
 640           if (XEXP (link, 0) == insn)
 641             break;
 642
 643         if (link)
 644           {
 645             result = find_single_use_1 (dest, &PATTERN (next));
 646             if (ploc)
 647               *ploc = next;
 648             return result;
 649           }
 650       }
 651
 652   return 0;
 653 }
 654 \f
 655 /* Substitute NEWVAL, an rtx expression, into INTO, a place in some
 656    insn.  The substitution can be undone by undo_all.  If INTO is already
 657    set to NEWVAL, do not record this change.  Because computing NEWVAL might
 658    also call SUBST, we have to compute it before we put anything into
 659    the undo table.  */
 660
 661 static void
 662 do_SUBST (rtx *into, rtx newval)
 663 {
 664   struct undo *buf;
 665   rtx oldval = *into;
 666
 667   if (oldval == newval)
 668     return;
 669
 670   /* We'd like to catch as many invalid transformations here as
 671      possible.  Unfortunately, there are way too many mode changes
 672      that are perfectly valid, so we'd waste too much effort for
 673      little gain doing the checks here.  Focus on catching invalid
 674      transformations involving integer constants.  */
 675   if (GET_MODE_CLASS (GET_MODE (oldval)) == MODE_INT
 676       && CONST_INT_P (newval))
 677     {
 678       /* Sanity check that we're replacing oldval with a CONST_INT
 679          that is a valid sign-extension for the original mode.  */
 680       gcc_assert (INTVAL (newval)
 681                   == trunc_int_for_mode (INTVAL (newval), GET_MODE (oldval)));
 682
 683       /* Replacing the operand of a SUBREG or a ZERO_EXTEND with a
 684          CONST_INT is not valid, because after the replacement, the
 685          original mode would be gone.  Unfortunately, we can't tell
 686          when do_SUBST is called to replace the operand thereof, so we
 687          perform this test on oldval instead, checking whether an
 688          invalid replacement took place before we got here.  */
 689       gcc_assert (!(GET_CODE (oldval) == SUBREG
 690                     && CONST_INT_P (SUBREG_REG (oldval))));
 691       gcc_assert (!(GET_CODE (oldval) == ZERO_EXTEND
 692                     && CONST_INT_P (XEXP (oldval, 0))));
 693     }
 694
 695   if (undobuf.frees)
 696     buf = undobuf.frees, undobuf.frees = buf->next;
 697   else
 698     buf = XNEW (struct undo);
 699
 700   buf->kind = UNDO_RTX;
 701   buf->where.r = into;
 702   buf->old_contents.r = oldval;
 703   *into = newval;
 704
 705   buf->next = undobuf.undos, undobuf.undos = buf;
 706 }
 707
 708 #define SUBST(INTO, NEWVAL)     do_SUBST(&(INTO), (NEWVAL))
 709
 710 /* Similar to SUBST, but NEWVAL is an int expression.  Note that substitution
 711    for the value of a HOST_WIDE_INT value (including CONST_INT) is
 712    not safe.  */
 713
 714 static void
 715 do_SUBST_INT (int *into, int newval)
 716 {
 717   struct undo *buf;
 718   int oldval = *into;
 719
 720   if (oldval == newval)
 721     return;
 722
 723   if (undobuf.frees)
 724     buf = undobuf.frees, undobuf.frees = buf->next;
 725   else
 726     buf = XNEW (struct undo);
 727
 728   buf->kind = UNDO_INT;
 729   buf->where.i = into;
 730   buf->old_contents.i = oldval;
 731   *into = newval;
 732
 733   buf->next = undobuf.undos, undobuf.undos = buf;
 734 }
 735
 736 #define SUBST_INT(INTO, NEWVAL)  do_SUBST_INT(&(INTO), (NEWVAL))
 737
 738 /* Similar to SUBST, but just substitute the mode.  This is used when
 739    changing the mode of a pseudo-register, so that any other
 740    references to the entry in the regno_reg_rtx array will change as
 741    well.  */
 742
 743 static void
 744 do_SUBST_MODE (rtx *into, enum machine_mode newval)
 745 {
 746   struct undo *buf;
 747   enum machine_mode oldval = GET_MODE (*into);
 748
 749   if (oldval == newval)
 750     return;
 751
 752   if (undobuf.frees)
 753     buf = undobuf.frees, undobuf.frees = buf->next;
 754   else
 755     buf = XNEW (struct undo);
 756
 757   buf->kind = UNDO_MODE;
 758   buf->where.r = into;
 759   buf->old_contents.m = oldval;
 760   adjust_reg_mode (*into, newval);
 761
 762   buf->next = undobuf.undos, undobuf.undos = buf;
 763 }
 764
 765 #define SUBST_MODE(INTO, NEWVAL)  do_SUBST_MODE(&(INTO), (NEWVAL))
 766 \f
 767 /* Subroutine of try_combine.  Determine whether the combine replacement
 768    patterns NEWPAT, NEWI2PAT and NEWOTHERPAT are cheaper according to
 769    insn_rtx_cost that the original instruction sequence I0, I1, I2, I3 and
 770    undobuf.other_insn.  Note that I1 and/or NEWI2PAT may be NULL_RTX.
 771    NEWOTHERPAT and undobuf.other_insn may also both be NULL_RTX.  This
 772    function returns false, if the costs of all instructions can be
 773    estimated, and the replacements are more expensive than the original
 774    sequence.  */
 775
 776 static bool
 777 combine_validate_cost (rtx i0, rtx i1, rtx i2, rtx i3, rtx newpat,
 778                        rtx newi2pat, rtx newotherpat)
 779 {
 780   int i0_cost, i1_cost, i2_cost, i3_cost;
 781   int new_i2_cost, new_i3_cost;
 782   int old_cost, new_cost;
 783
 784   /* Lookup the original insn_rtx_costs.  */
 785   i2_cost = INSN_COST (i2);
 786   i3_cost = INSN_COST (i3);
 787
 788   if (i1)
 789     {
 790       i1_cost = INSN_COST (i1);
 791       if (i0)
 792         {
 793           i0_cost = INSN_COST (i0);
 794           old_cost = (i0_cost > 0 && i1_cost > 0 && i2_cost > 0 && i3_cost > 0
 795                       ? i0_cost + i1_cost + i2_cost + i3_cost : 0);
 796         }
 797       else
 798         {
 799           old_cost = (i1_cost > 0 && i2_cost > 0 && i3_cost > 0
 800                       ? i1_cost + i2_cost + i3_cost : 0);
 801           i0_cost = 0;
 802         }
 803     }
 804   else
 805     {
 806       old_cost = (i2_cost > 0 && i3_cost > 0) ? i2_cost + i3_cost : 0;
 807       i1_cost = i0_cost = 0;
 808     }
 809
 810   /* Calculate the replacement insn_rtx_costs.  */
 811   new_i3_cost = insn_rtx_cost (newpat, optimize_this_for_speed_p);
 812   if (newi2pat)
 813     {
 814       new_i2_cost = insn_rtx_cost (newi2pat, optimize_this_for_speed_p);
 815       new_cost = (new_i2_cost > 0 && new_i3_cost > 0)
 816                  ? new_i2_cost + new_i3_cost : 0;
 817     }
 818   else
 819     {
 820       new_cost = new_i3_cost;
 821       new_i2_cost = 0;
 822     }
 823
 824   if (undobuf.other_insn)
 825     {
 826       int old_other_cost, new_other_cost;
 827
 828       old_other_cost = INSN_COST (undobuf.other_insn);
 829       new_other_cost = insn_rtx_cost (newotherpat, optimize_this_for_speed_p);
 830       if (old_other_cost > 0 && new_other_cost > 0)
 831         {
 832           old_cost += old_other_cost;
 833           new_cost += new_other_cost;
 834         }
 835       else
 836         old_cost = 0;
 837     }
 838
 839   /* Disallow this recombination if both new_cost and old_cost are
 840      greater than zero, and new_cost is greater than old cost.  */
 841   if (old_cost > 0
 842       && new_cost > old_cost)
 843     {
 844       if (dump_file)
 845         {
 846           if (i0)
 847             {
 848               fprintf (dump_file,
 849                        "rejecting combination of insns %d, %d, %d and %d\n",
 850                        INSN_UID (i0), INSN_UID (i1), INSN_UID (i2),
 851                        INSN_UID (i3));
 852               fprintf (dump_file, "original costs %d + %d + %d + %d = %d\n",
 853                        i0_cost, i1_cost, i2_cost, i3_cost, old_cost);
 854             }
 855           else if (i1)
 856             {
 857               fprintf (dump_file,
 858                        "rejecting combination of insns %d, %d and %d\n",
 859                        INSN_UID (i1), INSN_UID (i2), INSN_UID (i3));
 860               fprintf (dump_file, "original costs %d + %d + %d = %d\n",
 861                        i1_cost, i2_cost, i3_cost, old_cost);
 862             }
 863           else
 864             {
 865               fprintf (dump_file,
 866                        "rejecting combination of insns %d and %d\n",
 867                        INSN_UID (i2), INSN_UID (i3));
 868               fprintf (dump_file, "original costs %d + %d = %d\n",
 869                        i2_cost, i3_cost, old_cost);
 870             }
 871
 872           if (newi2pat)
 873             {
 874               fprintf (dump_file, "replacement costs %d + %d = %d\n",
 875                        new_i2_cost, new_i3_cost, new_cost);
 876             }
 877           else
 878             fprintf (dump_file, "replacement cost %d\n", new_cost);
 879         }
 880
 881       return false;
 882     }
 883
 884   /* Update the uid_insn_cost array with the replacement costs.  */
 885   INSN_COST (i2) = new_i2_cost;
 886   INSN_COST (i3) = new_i3_cost;
 887   if (i1)
 888     INSN_COST (i1) = 0;
 889
 890   return true;
 891 }
 892
 893
 894 /* Delete any insns that copy a register to itself.  */
 895
 896 static void
 897 delete_noop_moves (void)
 898 {
 899   rtx insn, next;
 900   basic_block bb;
 901
 902   FOR_EACH_BB (bb)
 903     {
 904       for (insn = BB_HEAD (bb); insn != NEXT_INSN (BB_END (bb)); insn = next)
 905         {
 906           next = NEXT_INSN (insn);
 907           if (INSN_P (insn) && noop_move_p (insn))
 908             {
 909               if (dump_file)
 910                 fprintf (dump_file, "deleting noop move %d\n", INSN_UID (insn));
 911
 912               delete_insn_and_edges (insn);
 913             }
 914         }
 915     }
 916 }
 917
 918 \f
 919 /* Fill in log links field for all insns.  */
 920
 921 static void
 922 create_log_links (void)
 923 {
 924   basic_block bb;
 925   rtx *next_use, insn;
 926   df_ref *def_vec, *use_vec;
 927
 928   next_use = XCNEWVEC (rtx, max_reg_num ());
 929
 930   /* Pass through each block from the end, recording the uses of each
 931      register and establishing log links when def is encountered.
 932      Note that we do not clear next_use array in order to save time,
 933      so we have to test whether the use is in the same basic block as def.
 934
 935      There are a few cases below when we do not consider the definition or
 936      usage -- these are taken from original flow.c did. Don't ask me why it is
 937      done this way; I don't know and if it works, I don't want to know.  */
 938
 939   FOR_EACH_BB (bb)
 940     {
 941       FOR_BB_INSNS_REVERSE (bb, insn)
 942         {
 943           if (!NONDEBUG_INSN_P (insn))
 944             continue;
 945
 946           /* Log links are created only once.  */
 947           gcc_assert (!LOG_LINKS (insn));
 948
 949           for (def_vec = DF_INSN_DEFS (insn); *def_vec; def_vec++)
 950             {
 951               df_ref def = *def_vec;
 952               int regno = DF_REF_REGNO (def);
 953               rtx use_insn;
 954
 955               if (!next_use[regno])
 956                 continue;
 957
 958               /* Do not consider if it is pre/post modification in MEM.  */
 959               if (DF_REF_FLAGS (def) & DF_REF_PRE_POST_MODIFY)
 960                 continue;
 961
 962               /* Do not make the log link for frame pointer.  */
 963               if ((regno == FRAME_POINTER_REGNUM
 964                    && (! reload_completed || frame_pointer_needed))
 965 #if !HARD_FRAME_POINTER_IS_FRAME_POINTER
 966                   || (regno == HARD_FRAME_POINTER_REGNUM
 967                       && (! reload_completed || frame_pointer_needed))
 968 #endif
 969 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
 970                   || (regno == ARG_POINTER_REGNUM && fixed_regs[regno])
 971 #endif
 972                   )
 973                 continue;
 974
 975               use_insn = next_use[regno];
 976               if (BLOCK_FOR_INSN (use_insn) == bb)
 977                 {
 978                   /* flow.c claimed:
 979
 980                      We don't build a LOG_LINK for hard registers contained
 981                      in ASM_OPERANDs.  If these registers get replaced,
 982                      we might wind up changing the semantics of the insn,
 983                      even if reload can make what appear to be valid
 984                      assignments later.  */
 985                   if (regno >= FIRST_PSEUDO_REGISTER
 986                       || asm_noperands (PATTERN (use_insn)) < 0)
 987                     {
 988                       /* Don't add duplicate links between instructions.  */
 989                       rtx links;
 990                       for (links = LOG_LINKS (use_insn); links;
 991                            links = XEXP (links, 1))
 992                         if (insn == XEXP (links, 0))
 993                           break;
 994
 995                       if (!links)
 996                         LOG_LINKS (use_insn) =
 997                           alloc_INSN_LIST (insn, LOG_LINKS (use_insn));
 998                     }
 999                 }
1000               next_use[regno] = NULL_RTX;
1001             }
1002
1003           for (use_vec = DF_INSN_USES (insn); *use_vec; use_vec++)
1004             {
1005               df_ref use = *use_vec;
1006               int regno = DF_REF_REGNO (use);
1007
1008               /* Do not consider the usage of the stack pointer
1009                  by function call.  */
1010               if (DF_REF_FLAGS (use) & DF_REF_CALL_STACK_USAGE)
1011                 continue;
1012
1013               next_use[regno] = insn;
1014             }
1015         }
1016     }
1017
1018   free (next_use);
1019 }
1020
1021 /* Clear LOG_LINKS fields of insns.  */
1022
1023 static void
1024 clear_log_links (void)
1025 {
1026   rtx insn;
1027
1028   for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
1029     if (INSN_P (insn))
1030       free_INSN_LIST_list (&LOG_LINKS (insn));
1031 }
1032
1033 /* Walk the LOG_LINKS of insn B to see if we find a reference to A.  Return
1034    true if we found a LOG_LINK that proves that A feeds B.  This only works
1035    if there are no instructions between A and B which could have a link
1036    depending on A, since in that case we would not record a link for B.  */
1037
1038 static bool
1039 insn_a_feeds_b (rtx a, rtx b)
1040 {
1041   rtx links;
1042   for (links = LOG_LINKS (b); links; links = XEXP (links, 1))
1043     if (XEXP (links, 0) == a)
1044       return true;
1045   return false;
1046 }
1047 \f
1048 /* Main entry point for combiner.  F is the first insn of the function.
1049    NREGS is the first unused pseudo-reg number.
1050
1051    Return nonzero if the combiner has turned an indirect jump
1052    instruction into a direct jump.  */
1053 static int
1054 combine_instructions (rtx f, unsigned int nregs)
1055 {
1056   rtx insn, next;
1057 #ifdef HAVE_cc0
1058   rtx prev;
1059 #endif
1060   rtx links, nextlinks;
1061   rtx first;
1062   basic_block last_bb;
1063
1064   int new_direct_jump_p = 0;
1065
1066   for (first = f; first && !INSN_P (first); )
1067     first = NEXT_INSN (first);
1068   if (!first)
1069     return 0;
1070
1071   combine_attempts = 0;
1072   combine_merges = 0;
1073   combine_extras = 0;
1074   combine_successes = 0;
1075
1076   rtl_hooks = combine_rtl_hooks;
1077
1078   VEC_safe_grow_cleared (reg_stat_type, heap, reg_stat, nregs);
1079
1080   init_recog_no_volatile ();
1081
1082   /* Allocate array for insn info.  */
1083   max_uid_known = get_max_uid ();
1084   uid_log_links = XCNEWVEC (rtx, max_uid_known + 1);
1085   uid_insn_cost = XCNEWVEC (int, max_uid_known + 1);
1086
1087   nonzero_bits_mode = mode_for_size (HOST_BITS_PER_WIDE_INT, MODE_INT, 0);
1088
1089   /* Don't use reg_stat[].nonzero_bits when computing it.  This can cause
1090      problems when, for example, we have j <<= 1 in a loop.  */
1091
1092   nonzero_sign_valid = 0;
1093   label_tick = label_tick_ebb_start = 1;
1094
1095   /* Scan all SETs and see if we can deduce anything about what
1096      bits are known to be zero for some registers and how many copies
1097      of the sign bit are known to exist for those registers.
1098
1099      Also set any known values so that we can use it while searching
1100      for what bits are known to be set.  */
1101
1102   setup_incoming_promotions (first);
1103   /* Allow the entry block and the first block to fall into the same EBB.
1104      Conceptually the incoming promotions are assigned to the entry block.  */
1105   last_bb = ENTRY_BLOCK_PTR;
1106
1107   create_log_links ();
1108   FOR_EACH_BB (this_basic_block)
1109     {
1110       optimize_this_for_speed_p = optimize_bb_for_speed_p (this_basic_block);
1111       last_call_luid = 0;
1112       mem_last_set = -1;
1113
1114       label_tick++;
1115       if (!single_pred_p (this_basic_block)
1116           || single_pred (this_basic_block) != last_bb)
1117         label_tick_ebb_start = label_tick;
1118       last_bb = this_basic_block;
1119
1120       FOR_BB_INSNS (this_basic_block, insn)
1121         if (INSN_P (insn) && BLOCK_FOR_INSN (insn))
1122           {
1123             subst_low_luid = DF_INSN_LUID (insn);
1124             subst_insn = insn;
1125
1126             note_stores (PATTERN (insn), set_nonzero_bits_and_sign_copies,
1127                          insn);
1128             record_dead_and_set_regs (insn);
1129
1130 #ifdef AUTO_INC_DEC
1131             for (links = REG_NOTES (insn); links; links = XEXP (links, 1))
1132               if (REG_NOTE_KIND (links) == REG_INC)
1133                 set_nonzero_bits_and_sign_copies (XEXP (links, 0), NULL_RTX,
1134                                                   insn);
1135 #endif
1136
1137             /* Record the current insn_rtx_cost of this instruction.  */
1138             if (NONJUMP_INSN_P (insn))
1139               INSN_COST (insn) = insn_rtx_cost (PATTERN (insn),
1140                                                 optimize_this_for_speed_p);
1141             if (dump_file)
1142               fprintf(dump_file, "insn_cost %d: %d\n",
1143                     INSN_UID (insn), INSN_COST (insn));
1144           }
1145     }
1146
1147   nonzero_sign_valid = 1;
1148
1149   /* Now scan all the insns in forward order.  */
1150   label_tick = label_tick_ebb_start = 1;
1151   init_reg_last ();
1152   setup_incoming_promotions (first);
1153   last_bb = ENTRY_BLOCK_PTR;
1154
1155   FOR_EACH_BB (this_basic_block)
1156     {
1157       optimize_this_for_speed_p = optimize_bb_for_speed_p (this_basic_block);
1158       last_call_luid = 0;
1159       mem_last_set = -1;
1160
1161       label_tick++;
1162       if (!single_pred_p (this_basic_block)
1163           || single_pred (this_basic_block) != last_bb)
1164         label_tick_ebb_start = label_tick;
1165       last_bb = this_basic_block;
1166
1167       rtl_profile_for_bb (this_basic_block);
1168       for (insn = BB_HEAD (this_basic_block);
1169            insn != NEXT_INSN (BB_END (this_basic_block));
1170            insn = next ? next : NEXT_INSN (insn))
1171         {
1172           next = 0;
1173           if (NONDEBUG_INSN_P (insn))
1174             {
1175               /* See if we know about function return values before this
1176                  insn based upon SUBREG flags.  */
1177               check_promoted_subreg (insn, PATTERN (insn));
1178
1179               /* See if we can find hardregs and subreg of pseudos in
1180                  narrower modes.  This could help turning TRUNCATEs
1181                  into SUBREGs.  */
1182               note_uses (&PATTERN (insn), record_truncated_values, NULL);
1183
1184               /* Try this insn with each insn it links back to.  */
1185
1186               for (links = LOG_LINKS (insn); links; links = XEXP (links, 1))
1187                 if ((next = try_combine (insn, XEXP (links, 0), NULL_RTX,
1188                                          NULL_RTX, &new_direct_jump_p)) != 0)
1189                   goto retry;
1190
1191               /* Try each sequence of three linked insns ending with this one.  */
1192
1193               for (links = LOG_LINKS (insn); links; links = XEXP (links, 1))
1194                 {
1195                   rtx link = XEXP (links, 0);
1196
1197                   /* If the linked insn has been replaced by a note, then there
1198                      is no point in pursuing this chain any further.  */
1199                   if (NOTE_P (link))
1200                     continue;
1201
1202                   for (nextlinks = LOG_LINKS (link);
1203                        nextlinks;
1204                        nextlinks = XEXP (nextlinks, 1))
1205                     if ((next = try_combine (insn, link, XEXP (nextlinks, 0),
1206                                              NULL_RTX,
1207                                              &new_direct_jump_p)) != 0)
1208                       goto retry;
1209                 }
1210
1211 #ifdef HAVE_cc0
1212               /* Try to combine a jump insn that uses CC0
1213                  with a preceding insn that sets CC0, and maybe with its
1214                  logical predecessor as well.
1215                  This is how we make decrement-and-branch insns.
1216                  We need this special code because data flow connections
1217                  via CC0 do not get entered in LOG_LINKS.  */
1218
1219               if (JUMP_P (insn)
1220                   && (prev = prev_nonnote_insn (insn)) != 0
1221                   && NONJUMP_INSN_P (prev)
1222                   && sets_cc0_p (PATTERN (prev)))
1223                 {
1224                   if ((next = try_combine (insn, prev, NULL_RTX, NULL_RTX,
1225                                            &new_direct_jump_p)) != 0)
1226                     goto retry;
1227
1228                   for (nextlinks = LOG_LINKS (prev); nextlinks;
1229                        nextlinks = XEXP (nextlinks, 1))
1230                     if ((next = try_combine (insn, prev, XEXP (nextlinks, 0),
1231                                              NULL_RTX,
1232                                              &new_direct_jump_p)) != 0)
1233                       goto retry;
1234                 }
1235
1236               /* Do the same for an insn that explicitly references CC0.  */
1237               if (NONJUMP_INSN_P (insn)
1238                   && (prev = prev_nonnote_insn (insn)) != 0
1239                   && NONJUMP_INSN_P (prev)
1240                   && sets_cc0_p (PATTERN (prev))
1241                   && GET_CODE (PATTERN (insn)) == SET
1242                   && reg_mentioned_p (cc0_rtx, SET_SRC (PATTERN (insn))))
1243                 {
1244                   if ((next = try_combine (insn, prev, NULL_RTX, NULL_RTX,
1245                                            &new_direct_jump_p)) != 0)
1246                     goto retry;
1247
1248                   for (nextlinks = LOG_LINKS (prev); nextlinks;
1249                        nextlinks = XEXP (nextlinks, 1))
1250                     if ((next = try_combine (insn, prev, XEXP (nextlinks, 0),
1251                                              NULL_RTX,
1252                                              &new_direct_jump_p)) != 0)
1253                       goto retry;
1254                 }
1255
1256               /* Finally, see if any of the insns that this insn links to
1257                  explicitly references CC0.  If so, try this insn, that insn,
1258                  and its predecessor if it sets CC0.  */
1259               for (links = LOG_LINKS (insn); links; links = XEXP (links, 1))
1260                 if (NONJUMP_INSN_P (XEXP (links, 0))
1261                     && GET_CODE (PATTERN (XEXP (links, 0))) == SET
1262                     && reg_mentioned_p (cc0_rtx, SET_SRC (PATTERN (XEXP (links, 0))))
1263                     && (prev = prev_nonnote_insn (XEXP (links, 0))) != 0
1264                     && NONJUMP_INSN_P (prev)
1265                     && sets_cc0_p (PATTERN (prev))
1266                     && (next = try_combine (insn, XEXP (links, 0),
1267                                             prev, NULL_RTX,
1268                                             &new_direct_jump_p)) != 0)
1269                   goto retry;
1270 #endif
1271
1272               /* Try combining an insn with two different insns whose results it
1273                  uses.  */
1274               for (links = LOG_LINKS (insn); links; links = XEXP (links, 1))
1275                 for (nextlinks = XEXP (links, 1); nextlinks;
1276                      nextlinks = XEXP (nextlinks, 1))
1277                   if ((next = try_combine (insn, XEXP (links, 0),
1278                                            XEXP (nextlinks, 0), NULL_RTX,
1279                                            &new_direct_jump_p)) != 0)
1280                     goto retry;
1281
1282               /* Try four-instruction combinations.  */
1283               for (links = LOG_LINKS (insn); links; links = XEXP (links, 1))
1284                 {
1285                   rtx next1;
1286                   rtx link = XEXP (links, 0);
1287
1288                   /* If the linked insn has been replaced by a note, then there
1289                      is no point in pursuing this chain any further.  */
1290                   if (NOTE_P (link))
1291                     continue;
1292
1293                   for (next1 = LOG_LINKS (link); next1; next1 = XEXP (next1, 1))
1294                     {
1295                       rtx link1 = XEXP (next1, 0);
1296                       if (NOTE_P (link1))
1297                         continue;
1298                       /* I0 -> I1 -> I2 -> I3.  */
1299                       for (nextlinks = LOG_LINKS (link1); nextlinks;
1300                            nextlinks = XEXP (nextlinks, 1))
1301                         if ((next = try_combine (insn, link, link1,
1302                                                  XEXP (nextlinks, 0),
1303                                                  &new_direct_jump_p)) != 0)
1304                           goto retry;
1305                       /* I0, I1 -> I2, I2 -> I3.  */
1306                       for (nextlinks = XEXP (next1, 1); nextlinks;
1307                            nextlinks = XEXP (nextlinks, 1))
1308                         if ((next = try_combine (insn, link, link1,
1309                                                  XEXP (nextlinks, 0),
1310                                                  &new_direct_jump_p)) != 0)
1311                           goto retry;
1312                     }
1313
1314                   for (next1 = XEXP (links, 1); next1; next1 = XEXP (next1, 1))
1315                     {
1316                       rtx link1 = XEXP (next1, 0);
1317                       if (NOTE_P (link1))
1318                         continue;
1319                       /* I0 -> I2; I1, I2 -> I3.  */
1320                       for (nextlinks = LOG_LINKS (link); nextlinks;
1321                            nextlinks = XEXP (nextlinks, 1))
1322                         if ((next = try_combine (insn, link, link1,
1323                                                  XEXP (nextlinks, 0),
1324                                                  &new_direct_jump_p)) != 0)
1325                           goto retry;
1326                       /* I0 -> I1; I1, I2 -> I3.  */
1327                       for (nextlinks = LOG_LINKS (link1); nextlinks;
1328                            nextlinks = XEXP (nextlinks, 1))
1329                         if ((next = try_combine (insn, link, link1,
1330                                                  XEXP (nextlinks, 0),
1331                                                  &new_direct_jump_p)) != 0)
1332                           goto retry;
1333                     }
1334                 }
1335
1336               /* Try this insn with each REG_EQUAL note it links back to.  */
1337               for (links = LOG_LINKS (insn); links; links = XEXP (links, 1))
1338                 {
1339                   rtx set, note;
1340                   rtx temp = XEXP (links, 0);
1341                   if ((set = single_set (temp)) != 0
1342                       && (note = find_reg_equal_equiv_note (temp)) != 0
1343                       && (note = XEXP (note, 0), GET_CODE (note)) != EXPR_LIST
1344                       /* Avoid using a register that may already been marked
1345                          dead by an earlier instruction.  */
1346                       && ! unmentioned_reg_p (note, SET_SRC (set))
1347                       && (GET_MODE (note) == VOIDmode
1348                           ? SCALAR_INT_MODE_P (GET_MODE (SET_DEST (set)))
1349                           : GET_MODE (SET_DEST (set)) == GET_MODE (note)))
1350                     {
1351                       /* Temporarily replace the set's source with the
1352                          contents of the REG_EQUAL note.  The insn will
1353                          be deleted or recognized by try_combine.  */
1354                       rtx orig = SET_SRC (set);
1355                       SET_SRC (set) = note;
1356                       i2mod = temp;
1357                       i2mod_old_rhs = copy_rtx (orig);
1358                       i2mod_new_rhs = copy_rtx (note);
1359                       next = try_combine (insn, i2mod, NULL_RTX, NULL_RTX,
1360                                           &new_direct_jump_p);
1361                       i2mod = NULL_RTX;
1362                       if (next)
1363                         goto retry;
1364                       SET_SRC (set) = orig;
1365                     }
1366                 }
1367
1368               if (!NOTE_P (insn))
1369                 record_dead_and_set_regs (insn);
1370
1371             retry:
1372               ;
1373             }
1374         }
1375     }
1376
1377   default_rtl_profile ();
1378   clear_log_links ();
1379   clear_bb_flags ();
1380   new_direct_jump_p |= purge_all_dead_edges ();
1381   delete_noop_moves ();
1382
1383   /* Clean up.  */
1384   free (uid_log_links);
1385   free (uid_insn_cost);
1386   VEC_free (reg_stat_type, heap, reg_stat);
1387
1388   {
1389     struct undo *undo, *next;
1390     for (undo = undobuf.frees; undo; undo = next)
1391       {
1392         next = undo->next;
1393         free (undo);
1394       }
1395     undobuf.frees = 0;
1396   }
1397
1398   total_attempts += combine_attempts;
1399   total_merges += combine_merges;
1400   total_extras += combine_extras;
1401   total_successes += combine_successes;
1402
1403   nonzero_sign_valid = 0;
1404   rtl_hooks = general_rtl_hooks;
1405
1406   /* Make recognizer allow volatile MEMs again.  */
1407   init_recog ();
1408
1409   return new_direct_jump_p;
1410 }
1411
1412 /* Wipe the last_xxx fields of reg_stat in preparation for another pass.  */
1413
1414 static void
1415 init_reg_last (void)
1416 {
1417   unsigned int i;
1418   reg_stat_type *p;
1419
1420   FOR_EACH_VEC_ELT (reg_stat_type, reg_stat, i, p)
1421     memset (p, 0, offsetof (reg_stat_type, sign_bit_copies));
1422 }
1423 \f
1424 /* Set up any promoted values for incoming argument registers.  */
1425
1426 static void
1427 setup_incoming_promotions (rtx first)
1428 {
1429   tree arg;
1430   bool strictly_local = false;
1431
1432   for (arg = DECL_ARGUMENTS (current_function_decl); arg;
1433        arg = DECL_CHAIN (arg))
1434     {
1435       rtx x, reg = DECL_INCOMING_RTL (arg);
1436       int uns1, uns3;
1437       enum machine_mode mode1, mode2, mode3, mode4;
1438
1439       /* Only continue if the incoming argument is in a register.  */
1440       if (!REG_P (reg))
1441         continue;
1442
1443       /* Determine, if possible, whether all call sites of the current
1444          function lie within the current compilation unit.  (This does
1445          take into account the exporting of a function via taking its
1446          address, and so forth.)  */
1447       strictly_local = cgraph_local_info (current_function_decl)->local;
1448
1449       /* The mode and signedness of the argument before any promotions happen
1450          (equal to the mode of the pseudo holding it at that stage).  */
1451       mode1 = TYPE_MODE (TREE_TYPE (arg));
1452       uns1 = TYPE_UNSIGNED (TREE_TYPE (arg));
1453
1454       /* The mode and signedness of the argument after any source language and
1455          TARGET_PROMOTE_PROTOTYPES-driven promotions.  */
1456       mode2 = TYPE_MODE (DECL_ARG_TYPE (arg));
1457       uns3 = TYPE_UNSIGNED (DECL_ARG_TYPE (arg));
1458
1459       /* The mode and signedness of the argument as it is actually passed,
1460          after any TARGET_PROMOTE_FUNCTION_ARGS-driven ABI promotions.  */
1461       mode3 = promote_function_mode (DECL_ARG_TYPE (arg), mode2, &uns3,
1462                                      TREE_TYPE (cfun->decl), 0);
1463
1464       /* The mode of the register in which the argument is being passed.  */
1465       mode4 = GET_MODE (reg);
1466
1467       /* Eliminate sign extensions in the callee when:
1468          (a) A mode promotion has occurred;  */
1469       if (mode1 == mode3)
1470         continue;
1471       /* (b) The mode of the register is the same as the mode of
1472              the argument as it is passed; */
1473       if (mode3 != mode4)
1474         continue;
1475       /* (c) There's no language level extension;  */
1476       if (mode1 == mode2)
1477         ;
1478       /* (c.1) All callers are from the current compilation unit.  If that's
1479          the case we don't have to rely on an ABI, we only have to know
1480          what we're generating right now, and we know that we will do the
1481          mode1 to mode2 promotion with the given sign.  */
1482       else if (!strictly_local)
1483         continue;
1484       /* (c.2) The combination of the two promotions is useful.  This is
1485          true when the signs match, or if the first promotion is unsigned.
1486          In the later case, (sign_extend (zero_extend x)) is the same as
1487          (zero_extend (zero_extend x)), so make sure to force UNS3 true.  */
1488       else if (uns1)
1489         uns3 = true;
1490       else if (uns3)
1491         continue;
1492
1493       /* Record that the value was promoted from mode1 to mode3,
1494          so that any sign extension at the head of the current
1495          function may be eliminated.  */
1496       x = gen_rtx_CLOBBER (mode1, const0_rtx);
1497       x = gen_rtx_fmt_e ((uns3 ? ZERO_EXTEND : SIGN_EXTEND), mode3, x);
1498       record_value_for_reg (reg, first, x);
1499     }
1500 }
1501
1502 /* Called via note_stores.  If X is a pseudo that is narrower than
1503    HOST_BITS_PER_WIDE_INT and is being set, record what bits are known zero.
1504
1505    If we are setting only a portion of X and we can't figure out what
1506    portion, assume all bits will be used since we don't know what will
1507    be happening.
1508
1509    Similarly, set how many bits of X are known to be copies of the sign bit
1510    at all locations in the function.  This is the smallest number implied
1511    by any set of X.  */
1512
1513 static void
1514 set_nonzero_bits_and_sign_copies (rtx x, const_rtx set, void *data)
1515 {
1516   rtx insn = (rtx) data;
1517   unsigned int num;
1518
1519   if (REG_P (x)
1520       && REGNO (x) >= FIRST_PSEUDO_REGISTER
1521       /* If this register is undefined at the start of the file, we can't
1522          say what its contents were.  */
1523       && ! REGNO_REG_SET_P
1524            (DF_LR_IN (ENTRY_BLOCK_PTR->next_bb), REGNO (x))
1525       && GET_MODE_BITSIZE (GET_MODE (x)) <= HOST_BITS_PER_WIDE_INT)
1526     {
1527       reg_stat_type *rsp = VEC_index (reg_stat_type, reg_stat, REGNO (x));
1528
1529       if (set == 0 || GET_CODE (set) == CLOBBER)
1530         {
1531           rsp->nonzero_bits = GET_MODE_MASK (GET_MODE (x));
1532           rsp->sign_bit_copies = 1;
1533           return;
1534         }
1535
1536       /* If this register is being initialized using itself, and the
1537          register is uninitialized in this basic block, and there are
1538          no LOG_LINKS which set the register, then part of the
1539          register is uninitialized.  In that case we can't assume
1540          anything about the number of nonzero bits.
1541
1542          ??? We could do better if we checked this in
1543          reg_{nonzero_bits,num_sign_bit_copies}_for_combine.  Then we
1544          could avoid making assumptions about the insn which initially
1545          sets the register, while still using the information in other
1546          insns.  We would have to be careful to check every insn
1547          involved in the combination.  */
1548
1549       if (insn
1550           && reg_referenced_p (x, PATTERN (insn))
1551           && !REGNO_REG_SET_P (DF_LR_IN (BLOCK_FOR_INSN (insn)),
1552                                REGNO (x)))
1553         {
1554           rtx link;
1555
1556           for (link = LOG_LINKS (insn); link; link = XEXP (link, 1))
1557             {
1558               if (dead_or_set_p (XEXP (link, 0), x))
1559                 break;
1560             }
1561           if (!link)
1562             {
1563               rsp->nonzero_bits = GET_MODE_MASK (GET_MODE (x));
1564               rsp->sign_bit_copies = 1;
1565               return;
1566             }
1567         }
1568
1569       /* If this is a complex assignment, see if we can convert it into a
1570          simple assignment.  */
1571       set = expand_field_assignment (set);
1572
1573       /* If this is a simple assignment, or we have a paradoxical SUBREG,
1574          set what we know about X.  */
1575
1576       if (SET_DEST (set) == x
1577           || (GET_CODE (SET_DEST (set)) == SUBREG
1578               && (GET_MODE_SIZE (GET_MODE (SET_DEST (set)))
1579                   > GET_MODE_SIZE (GET_MODE (SUBREG_REG (SET_DEST (set)))))
1580               && SUBREG_REG (SET_DEST (set)) == x))
1581         {
1582           rtx src = SET_SRC (set);
1583
1584 #ifdef SHORT_IMMEDIATES_SIGN_EXTEND
1585           /* If X is narrower than a word and SRC is a non-negative
1586              constant that would appear negative in the mode of X,
1587              sign-extend it for use in reg_stat[].nonzero_bits because some
1588              machines (maybe most) will actually do the sign-extension
1589              and this is the conservative approach.
1590
1591              ??? For 2.5, try to tighten up the MD files in this regard
1592              instead of this kludge.  */
1593
1594           if (GET_MODE_BITSIZE (GET_MODE (x)) < BITS_PER_WORD
1595               && CONST_INT_P (src)
1596               && INTVAL (src) > 0
1597               && 0 != (INTVAL (src)
1598                        & ((HOST_WIDE_INT) 1
1599                           << (GET_MODE_BITSIZE (GET_MODE (x)) - 1))))
1600             src = GEN_INT (INTVAL (src)
1601                            | ((HOST_WIDE_INT) (-1)
1602                               << GET_MODE_BITSIZE (GET_MODE (x))));
1603 #endif
1604
1605           /* Don't call nonzero_bits if it cannot change anything.  */
1606           if (rsp->nonzero_bits != ~(unsigned HOST_WIDE_INT) 0)
1607             rsp->nonzero_bits |= nonzero_bits (src, nonzero_bits_mode);
1608           num = num_sign_bit_copies (SET_SRC (set), GET_MODE (x));
1609           if (rsp->sign_bit_copies == 0
1610               || rsp->sign_bit_copies > num)
1611             rsp->sign_bit_copies = num;
1612         }
1613       else
1614         {
1615           rsp->nonzero_bits = GET_MODE_MASK (GET_MODE (x));
1616           rsp->sign_bit_copies = 1;
1617         }
1618     }
1619 }
1620 \f
1621 /* See if INSN can be combined into I3.  PRED, PRED2, SUCC and SUCC2 are
1622    optionally insns that were previously combined into I3 or that will be
1623    combined into the merger of INSN and I3.  The order is PRED, PRED2,
1624    INSN, SUCC, SUCC2, I3.
1625
1626    Return 0 if the combination is not allowed for any reason.
1627
1628    If the combination is allowed, *PDEST will be set to the single
1629    destination of INSN and *PSRC to the single source, and this function
1630    will return 1.  */
1631
1632 static int
1633 can_combine_p (rtx insn, rtx i3, rtx pred ATTRIBUTE_UNUSED,
1634                rtx pred2 ATTRIBUTE_UNUSED, rtx succ, rtx succ2,
1635                rtx *pdest, rtx *psrc)
1636 {
1637   int i;
1638   const_rtx set = 0;
1639   rtx src, dest;
1640   rtx p;
1641 #ifdef AUTO_INC_DEC
1642   rtx link;
1643 #endif
1644   bool all_adjacent = true;
1645
1646   if (succ)
1647     {
1648       if (succ2)
1649         {
1650           if (next_active_insn (succ2) != i3)
1651             all_adjacent = false;
1652           if (next_active_insn (succ) != succ2)
1653             all_adjacent = false;
1654         }
1655       else if (next_active_insn (succ) != i3)
1656         all_adjacent = false;
1657       if (next_active_insn (insn) != succ)
1658         all_adjacent = false;
1659     }
1660   else if (next_active_insn (insn) != i3)
1661     all_adjacent = false;
1662
1663   /* Can combine only if previous insn is a SET of a REG, a SUBREG or CC0.
1664      or a PARALLEL consisting of such a SET and CLOBBERs.
1665
1666      If INSN has CLOBBER parallel parts, ignore them for our processing.
1667      By definition, these happen during the execution of the insn.  When it
1668      is merged with another insn, all bets are off.  If they are, in fact,
1669      needed and aren't also supplied in I3, they may be added by
1670      recog_for_combine.  Otherwise, it won't match.
1671
1672      We can also ignore a SET whose SET_DEST is mentioned in a REG_UNUSED
1673      note.
1674
1675      Get the source and destination of INSN.  If more than one, can't
1676      combine.  */
1677
1678   if (GET_CODE (PATTERN (insn)) == SET)
1679     set = PATTERN (insn);
1680   else if (GET_CODE (PATTERN (insn)) == PARALLEL
1681            && GET_CODE (XVECEXP (PATTERN (insn), 0, 0)) == SET)
1682     {
1683       for (i = 0; i < XVECLEN (PATTERN (insn), 0); i++)
1684         {
1685           rtx elt = XVECEXP (PATTERN (insn), 0, i);
1686
1687           switch (GET_CODE (elt))
1688             {
1689             /* This is important to combine floating point insns
1690                for the SH4 port.  */
1691             case USE:
1692               /* Combining an isolated USE doesn't make sense.
1693                  We depend here on combinable_i3pat to reject them.  */
1694               /* The code below this loop only verifies that the inputs of
1695                  the SET in INSN do not change.  We call reg_set_between_p
1696                  to verify that the REG in the USE does not change between
1697                  I3 and INSN.
1698                  If the USE in INSN was for a pseudo register, the matching
1699                  insn pattern will likely match any register; combining this
1700                  with any other USE would only be safe if we knew that the
1701                  used registers have identical values, or if there was
1702                  something to tell them apart, e.g. different modes.  For
1703                  now, we forgo such complicated tests and simply disallow
1704                  combining of USES of pseudo registers with any other USE.  */
1705               if (REG_P (XEXP (elt, 0))
1706                   && GET_CODE (PATTERN (i3)) == PARALLEL)
1707                 {
1708                   rtx i3pat = PATTERN (i3);
1709                   int i = XVECLEN (i3pat, 0) - 1;
1710                   unsigned int regno = REGNO (XEXP (elt, 0));
1711
1712                   do
1713                     {
1714                       rtx i3elt = XVECEXP (i3pat, 0, i);
1715
1716                       if (GET_CODE (i3elt) == USE
1717                           && REG_P (XEXP (i3elt, 0))
1718                           && (REGNO (XEXP (i3elt, 0)) == regno
1719                               ? reg_set_between_p (XEXP (elt, 0),
1720                                                    PREV_INSN (insn), i3)
1721                               : regno >= FIRST_PSEUDO_REGISTER))
1722                         return 0;
1723                     }
1724                   while (--i >= 0);
1725                 }
1726               break;
1727
1728               /* We can ignore CLOBBERs.  */
1729             case CLOBBER:
1730               break;
1731
1732             case SET:
1733               /* Ignore SETs whose result isn't used but not those that
1734                  have side-effects.  */
1735               if (find_reg_note (insn, REG_UNUSED, SET_DEST (elt))
1736                   && insn_nothrow_p (insn)
1737                   && !side_effects_p (elt))
1738                 break;
1739
1740               /* If we have already found a SET, this is a second one and
1741                  so we cannot combine with this insn.  */
1742               if (set)
1743                 return 0;
1744
1745               set = elt;
1746               break;
1747
1748             default:
1749               /* Anything else means we can't combine.  */
1750               return 0;
1751             }
1752         }
1753
1754       if (set == 0
1755           /* If SET_SRC is an ASM_OPERANDS we can't throw away these CLOBBERs,
1756              so don't do anything with it.  */
1757           || GET_CODE (SET_SRC (set)) == ASM_OPERANDS)
1758         return 0;
1759     }
1760   else
1761     return 0;
1762
1763   if (set == 0)
1764     return 0;
1765
1766   set = expand_field_assignment (set);
1767   src = SET_SRC (set), dest = SET_DEST (set);
1768
1769   /* Don't eliminate a store in the stack pointer.  */
1770   if (dest == stack_pointer_rtx
1771       /* Don't combine with an insn that sets a register to itself if it has
1772          a REG_EQUAL note.  This may be part of a LIBCALL sequence.  */
1773       || (rtx_equal_p (src, dest) && find_reg_note (insn, REG_EQUAL, NULL_RTX))
1774       /* Can't merge an ASM_OPERANDS.  */
1775       || GET_CODE (src) == ASM_OPERANDS
1776       /* Can't merge a function call.  */
1777       || GET_CODE (src) == CALL
1778       /* Don't eliminate a function call argument.  */
1779       || (CALL_P (i3)
1780           && (find_reg_fusage (i3, USE, dest)
1781               || (REG_P (dest)
1782                   && REGNO (dest) < FIRST_PSEUDO_REGISTER
1783                   && global_regs[REGNO (dest)])))
1784       /* Don't substitute into an incremented register.  */
1785       || FIND_REG_INC_NOTE (i3, dest)
1786       || (succ && FIND_REG_INC_NOTE (succ, dest))
1787       || (succ2 && FIND_REG_INC_NOTE (succ2, dest))
1788       /* Don't substitute into a non-local goto, this confuses CFG.  */
1789       || (JUMP_P (i3) && find_reg_note (i3, REG_NON_LOCAL_GOTO, NULL_RTX))
1790       /* Make sure that DEST is not used after SUCC but before I3.  */
1791       || (!all_adjacent
1792           && ((succ2
1793                && (reg_used_between_p (dest, succ2, i3)
1794                    || reg_used_between_p (dest, succ, succ2)))
1795               || (!succ2 && succ && reg_used_between_p (dest, succ, i3))))
1796       /* Make sure that the value that is to be substituted for the register
1797          does not use any registers whose values alter in between.  However,
1798          If the insns are adjacent, a use can't cross a set even though we
1799          think it might (this can happen for a sequence of insns each setting
1800          the same destination; last_set of that register might point to
1801          a NOTE).  If INSN has a REG_EQUIV note, the register is always
1802          equivalent to the memory so the substitution is valid even if there
1803          are intervening stores.  Also, don't move a volatile asm or
1804          UNSPEC_VOLATILE across any other insns.  */
1805       || (! all_adjacent
1806           && (((!MEM_P (src)
1807                 || ! find_reg_note (insn, REG_EQUIV, src))
1808                && use_crosses_set_p (src, DF_INSN_LUID (insn)))
1809               || (GET_CODE (src) == ASM_OPERANDS && MEM_VOLATILE_P (src))
1810               || GET_CODE (src) == UNSPEC_VOLATILE))
1811       /* Don't combine across a CALL_INSN, because that would possibly
1812          change whether the life span of some REGs crosses calls or not,
1813          and it is a pain to update that information.
1814          Exception: if source is a constant, moving it later can't hurt.
1815          Accept that as a special case.  */
1816       || (DF_INSN_LUID (insn) < last_call_luid && ! CONSTANT_P (src)))
1817     return 0;
1818
1819   /* DEST must either be a REG or CC0.  */
1820   if (REG_P (dest))
1821     {
1822       /* If register alignment is being enforced for multi-word items in all
1823          cases except for parameters, it is possible to have a register copy
1824          insn referencing a hard register that is not allowed to contain the
1825          mode being copied and which would not be valid as an operand of most
1826          insns.  Eliminate this problem by not combining with such an insn.
1827
1828          Also, on some machines we don't want to extend the life of a hard
1829          register.  */
1830
1831       if (REG_P (src)
1832           && ((REGNO (dest) < FIRST_PSEUDO_REGISTER
1833                && ! HARD_REGNO_MODE_OK (REGNO (dest), GET_MODE (dest)))
1834               /* Don't extend the life of a hard register unless it is
1835                  user variable (if we have few registers) or it can't
1836                  fit into the desired register (meaning something special
1837                  is going on).
1838                  Also avoid substituting a return register into I3, because
1839                  reload can't handle a conflict with constraints of other
1840                  inputs.  */
1841               || (REGNO (src) < FIRST_PSEUDO_REGISTER
1842                   && ! HARD_REGNO_MODE_OK (REGNO (src), GET_MODE (src)))))
1843         return 0;
1844     }
1845   else if (GET_CODE (dest) != CC0)
1846     return 0;
1847
1848
1849   if (GET_CODE (PATTERN (i3)) == PARALLEL)
1850     for (i = XVECLEN (PATTERN (i3), 0) - 1; i >= 0; i--)
1851       if (GET_CODE (XVECEXP (PATTERN (i3), 0, i)) == CLOBBER)
1852         {
1853           /* Don't substitute for a register intended as a clobberable
1854              operand.  */
1855           rtx reg = XEXP (XVECEXP (PATTERN (i3), 0, i), 0);
1856           if (rtx_equal_p (reg, dest))
1857             return 0;
1858
1859           /* If the clobber represents an earlyclobber operand, we must not
1860              substitute an expression containing the clobbered register.
1861              As we do not analyze the constraint strings here, we have to
1862              make the conservative assumption.  However, if the register is
1863              a fixed hard reg, the clobber cannot represent any operand;
1864              we leave it up to the machine description to either accept or
1865              reject use-and-clobber patterns.  */
1866           if (!REG_P (reg)
1867               || REGNO (reg) >= FIRST_PSEUDO_REGISTER
1868               || !fixed_regs[REGNO (reg)])
1869             if (reg_overlap_mentioned_p (reg, src))
1870               return 0;
1871         }
1872
1873   /* If INSN contains anything volatile, or is an `asm' (whether volatile
1874      or not), reject, unless nothing volatile comes between it and I3 */
1875
1876   if (GET_CODE (src) == ASM_OPERANDS || volatile_refs_p (src))
1877     {
1878       /* Make sure neither succ nor succ2 contains a volatile reference.  */
1879       if (succ2 != 0 && volatile_refs_p (PATTERN (succ2)))
1880         return 0;
1881       if (succ != 0 && volatile_refs_p (PATTERN (succ)))
1882         return 0;
1883       /* We'll check insns between INSN and I3 below.  */
1884     }
1885
1886   /* If INSN is an asm, and DEST is a hard register, reject, since it has
1887      to be an explicit register variable, and was chosen for a reason.  */
1888
1889   if (GET_CODE (src) == ASM_OPERANDS
1890       && REG_P (dest) && REGNO (dest) < FIRST_PSEUDO_REGISTER)
1891     return 0;
1892
1893   /* If there are any volatile insns between INSN and I3, reject, because
1894      they might affect machine state.  */
1895
1896   for (p = NEXT_INSN (insn); p != i3; p = NEXT_INSN (p))
1897     if (INSN_P (p) && p != succ && p != succ2 && volatile_insn_p (PATTERN (p)))
1898       return 0;
1899
1900   /* If INSN contains an autoincrement or autodecrement, make sure that
1901      register is not used between there and I3, and not already used in
1902      I3 either.  Neither must it be used in PRED or SUCC, if they exist.
1903      Also insist that I3 not be a jump; if it were one
1904      and the incremented register were spilled, we would lose.  */
1905
1906 #ifdef AUTO_INC_DEC
1907   for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
1908     if (REG_NOTE_KIND (link) == REG_INC
1909         && (JUMP_P (i3)
1910             || reg_used_between_p (XEXP (link, 0), insn, i3)
1911             || (pred != NULL_RTX
1912                 && reg_overlap_mentioned_p (XEXP (link, 0), PATTERN (pred)))
1913             || (pred2 != NULL_RTX
1914                 && reg_overlap_mentioned_p (XEXP (link, 0), PATTERN (pred2)))
1915             || (succ != NULL_RTX
1916                 && reg_overlap_mentioned_p (XEXP (link, 0), PATTERN (succ)))
1917             || (succ2 != NULL_RTX
1918                 && reg_overlap_mentioned_p (XEXP (link, 0), PATTERN (succ2)))
1919             || reg_overlap_mentioned_p (XEXP (link, 0), PATTERN (i3))))
1920       return 0;
1921 #endif
1922
1923 #ifdef HAVE_cc0
1924   /* Don't combine an insn that follows a CC0-setting insn.
1925      An insn that uses CC0 must not be separated from the one that sets it.
1926      We do, however, allow I2 to follow a CC0-setting insn if that insn
1927      is passed as I1; in that case it will be deleted also.
1928      We also allow combining in this case if all the insns are adjacent
1929      because that would leave the two CC0 insns adjacent as well.
1930      It would be more logical to test whether CC0 occurs inside I1 or I2,
1931      but that would be much slower, and this ought to be equivalent.  */
1932
1933   p = prev_nonnote_insn (insn);
1934   if (p && p != pred && NONJUMP_INSN_P (p) && sets_cc0_p (PATTERN (p))
1935       && ! all_adjacent)
1936     return 0;
1937 #endif
1938
1939   /* If we get here, we have passed all the tests and the combination is
1940      to be allowed.  */
1941
1942   *pdest = dest;
1943   *psrc = src;
1944
1945   return 1;
1946 }
1947 \f
1948 /* LOC is the location within I3 that contains its pattern or the component
1949    of a PARALLEL of the pattern.  We validate that it is valid for combining.
1950
1951    One problem is if I3 modifies its output, as opposed to replacing it
1952    entirely, we can't allow the output to contain I2DEST, I1DEST or I0DEST as
1953    doing so would produce an insn that is not equivalent to the original insns.
1954
1955    Consider:
1956
1957          (set (reg:DI 101) (reg:DI 100))
1958          (set (subreg:SI (reg:DI 101) 0) <foo>)
1959
1960    This is NOT equivalent to:
1961
1962          (parallel [(set (subreg:SI (reg:DI 100) 0) <foo>)
1963                     (set (reg:DI 101) (reg:DI 100))])
1964
1965    Not only does this modify 100 (in which case it might still be valid
1966    if 100 were dead in I2), it sets 101 to the ORIGINAL value of 100.
1967
1968    We can also run into a problem if I2 sets a register that I1
1969    uses and I1 gets directly substituted into I3 (not via I2).  In that
1970    case, we would be getting the wrong value of I2DEST into I3, so we
1971    must reject the combination.  This case occurs when I2 and I1 both
1972    feed into I3, rather than when I1 feeds into I2, which feeds into I3.
1973    If I1_NOT_IN_SRC is nonzero, it means that finding I1 in the source
1974    of a SET must prevent combination from occurring.  The same situation
1975    can occur for I0, in which case I0_NOT_IN_SRC is set.
1976
1977    Before doing the above check, we first try to expand a field assignment
1978    into a set of logical operations.
1979
1980    If PI3_DEST_KILLED is nonzero, it is a pointer to a location in which
1981    we place a register that is both set and used within I3.  If more than one
1982    such register is detected, we fail.
1983
1984    Return 1 if the combination is valid, zero otherwise.  */
1985
1986 static int
1987 combinable_i3pat (rtx i3, rtx *loc, rtx i2dest, rtx i1dest, rtx i0dest,
1988                   int i1_not_in_src, int i0_not_in_src, rtx *pi3dest_killed)
1989 {
1990   rtx x = *loc;
1991
1992   if (GET_CODE (x) == SET)
1993     {
1994       rtx set = x ;
1995       rtx dest = SET_DEST (set);
1996       rtx src = SET_SRC (set);
1997       rtx inner_dest = dest;
1998       rtx subdest;
1999
2000       while (GET_CODE (inner_dest) == STRICT_LOW_PART
2001              || GET_CODE (inner_dest) == SUBREG
2002              || GET_CODE (inner_dest) == ZERO_EXTRACT)
2003         inner_dest = XEXP (inner_dest, 0);
2004
2005       /* Check for the case where I3 modifies its output, as discussed
2006          above.  We don't want to prevent pseudos from being combined
2007          into the address of a MEM, so only prevent the combination if
2008          i1 or i2 set the same MEM.  */
2009       if ((inner_dest != dest &&
2010            (!MEM_P (inner_dest)
2011             || rtx_equal_p (i2dest, inner_dest)
2012             || (i1dest && rtx_equal_p (i1dest, inner_dest))
2013             || (i0dest && rtx_equal_p (i0dest, inner_dest)))
2014            && (reg_overlap_mentioned_p (i2dest, inner_dest)
2015                || (i1dest && reg_overlap_mentioned_p (i1dest, inner_dest))
2016                || (i0dest && reg_overlap_mentioned_p (i0dest, inner_dest))))
2017
2018           /* This is the same test done in can_combine_p except we can't test
2019              all_adjacent; we don't have to, since this instruction will stay
2020              in place, thus we are not considering increasing the lifetime of
2021              INNER_DEST.
2022
2023              Also, if this insn sets a function argument, combining it with
2024              something that might need a spill could clobber a previous
2025              function argument; the all_adjacent test in can_combine_p also
2026              checks this; here, we do a more specific test for this case.  */
2027
2028           || (REG_P (inner_dest)
2029               && REGNO (inner_dest) < FIRST_PSEUDO_REGISTER
2030               && (! HARD_REGNO_MODE_OK (REGNO (inner_dest),
2031                                         GET_MODE (inner_dest))))
2032           || (i1_not_in_src && reg_overlap_mentioned_p (i1dest, src))
2033           || (i0_not_in_src && reg_overlap_mentioned_p (i0dest, src)))
2034         return 0;
2035
2036       /* If DEST is used in I3, it is being killed in this insn, so
2037          record that for later.  We have to consider paradoxical
2038          subregs here, since they kill the whole register, but we
2039          ignore partial subregs, STRICT_LOW_PART, etc.
2040          Never add REG_DEAD notes for the FRAME_POINTER_REGNUM or the
2041          STACK_POINTER_REGNUM, since these are always considered to be
2042          live.  Similarly for ARG_POINTER_REGNUM if it is fixed.  */
2043       subdest = dest;
2044       if (GET_CODE (subdest) == SUBREG
2045           && (GET_MODE_SIZE (GET_MODE (subdest))
2046               >= GET_MODE_SIZE (GET_MODE (SUBREG_REG (subdest)))))
2047         subdest = SUBREG_REG (subdest);
2048       if (pi3dest_killed
2049           && REG_P (subdest)
2050           && reg_referenced_p (subdest, PATTERN (i3))
2051           && REGNO (subdest) != FRAME_POINTER_REGNUM
2052 #if !HARD_FRAME_POINTER_IS_FRAME_POINTER
2053           && REGNO (subdest) != HARD_FRAME_POINTER_REGNUM
2054 #endif
2055 #if ARG_POINTER_REGNUM != FRAME_POINTER_REGNUM
2056           && (REGNO (subdest) != ARG_POINTER_REGNUM
2057               || ! fixed_regs [REGNO (subdest)])
2058 #endif
2059           && REGNO (subdest) != STACK_POINTER_REGNUM)
2060         {
2061           if (*pi3dest_killed)
2062             return 0;
2063
2064           *pi3dest_killed = subdest;
2065         }
2066     }
2067
2068   else if (GET_CODE (x) == PARALLEL)
2069     {
2070       int i;
2071
2072       for (i = 0; i < XVECLEN (x, 0); i++)
2073         if (! combinable_i3pat (i3, &XVECEXP (x, 0, i), i2dest, i1dest, i0dest,
2074                                 i1_not_in_src, i0_not_in_src, pi3dest_killed))
2075           return 0;
2076     }
2077
2078   return 1;
2079 }
2080 \f
2081 /* Return 1 if X is an arithmetic expression that contains a multiplication
2082    and division.  We don't count multiplications by powers of two here.  */
2083
2084 static int
2085 contains_muldiv (rtx x)
2086 {
2087   switch (GET_CODE (x))
2088     {
2089     case MOD:  case DIV:  case UMOD:  case UDIV:
2090       return 1;
2091
2092     case MULT:
2093       return ! (CONST_INT_P (XEXP (x, 1))
2094                 && exact_log2 (INTVAL (XEXP (x, 1))) >= 0);
2095     default:
2096       if (BINARY_P (x))
2097         return contains_muldiv (XEXP (x, 0))
2098             || contains_muldiv (XEXP (x, 1));
2099
2100       if (UNARY_P (x))
2101         return contains_muldiv (XEXP (x, 0));
2102
2103       return 0;
2104     }
2105 }
2106 \f
2107 /* Determine whether INSN can be used in a combination.  Return nonzero if
2108    not.  This is used in try_combine to detect early some cases where we
2109    can't perform combinations.  */
2110
2111 static int
2112 cant_combine_insn_p (rtx insn)
2113 {
2114   rtx set;
2115   rtx src, dest;
2116
2117   /* If this isn't really an insn, we can't do anything.
2118      This can occur when flow deletes an insn that it has merged into an
2119      auto-increment address.  */
2120   if (! INSN_P (insn))
2121     return 1;
2122
2123   /* Never combine loads and stores involving hard regs that are likely
2124      to be spilled.  The register allocator can usually handle such
2125      reg-reg moves by tying.  If we allow the combiner to make
2126      substitutions of likely-spilled regs, reload might die.
2127      As an exception, we allow combinations involving fixed regs; these are
2128      not available to the register allocator so there's no risk involved.  */
2129
2130   set = single_set (insn);
2131   if (! set)
2132     return 0;
2133   src = SET_SRC (set);
2134   dest = SET_DEST (set);
2135   if (GET_CODE (src) == SUBREG)
2136     src = SUBREG_REG (src);
2137   if (GET_CODE (dest) == SUBREG)
2138     dest = SUBREG_REG (dest);
2139   if (REG_P (src) && REG_P (dest)
2140       && ((HARD_REGISTER_P (src)
2141            && ! TEST_HARD_REG_BIT (fixed_reg_set, REGNO (src))
2142            && targetm.class_likely_spilled_p (REGNO_REG_CLASS (REGNO (src))))
2143           || (HARD_REGISTER_P (dest)
2144               && ! TEST_HARD_REG_BIT (fixed_reg_set, REGNO (dest))
2145               && targetm.class_likely_spilled_p (REGNO_REG_CLASS (REGNO (dest))))))
2146     return 1;
2147
2148   return 0;
2149 }
2150
2151 struct likely_spilled_retval_info
2152 {
2153   unsigned regno, nregs;
2154   unsigned mask;
2155 };
2156
2157 /* Called via note_stores by likely_spilled_retval_p.  Remove from info->mask
2158    hard registers that are known to be written to / clobbered in full.  */
2159 static void
2160 likely_spilled_retval_1 (rtx x, const_rtx set, void *data)
2161 {
2162   struct likely_spilled_retval_info *const info =
2163     (struct likely_spilled_retval_info *) data;
2164   unsigned regno, nregs;
2165   unsigned new_mask;
2166
2167   if (!REG_P (XEXP (set, 0)))
2168     return;
2169   regno = REGNO (x);
2170   if (regno >= info->regno + info->nregs)
2171     return;
2172   nregs = hard_regno_nregs[regno][GET_MODE (x)];
2173   if (regno + nregs <= info->regno)
2174     return;
2175   new_mask = (2U << (nregs - 1)) - 1;
2176   if (regno < info->regno)
2177     new_mask >>= info->regno - regno;
2178   else
2179     new_mask <<= regno - info->regno;
2180   info->mask &= ~new_mask;
2181 }
2182
2183 /* Return nonzero iff part of the return value is live during INSN, and
2184    it is likely spilled.  This can happen when more than one insn is needed
2185    to copy the return value, e.g. when we consider to combine into the
2186    second copy insn for a complex value.  */
2187
2188 static int
2189 likely_spilled_retval_p (rtx insn)
2190 {
2191   rtx use = BB_END (this_basic_block);
2192   rtx reg, p;
2193   unsigned regno, nregs;
2194   /* We assume here that no machine mode needs more than
2195      32 hard registers when the value overlaps with a register
2196      for which TARGET_FUNCTION_VALUE_REGNO_P is true.  */
2197   unsigned mask;
2198   struct likely_spilled_retval_info info;
2199
2200   if (!NONJUMP_INSN_P (use) || GET_CODE (PATTERN (use)) != USE || insn == use)
2201     return 0;
2202   reg = XEXP (PATTERN (use), 0);
2203   if (!REG_P (reg) || !targetm.calls.function_value_regno_p (REGNO (reg)))
2204     return 0;
2205   regno = REGNO (reg);
2206   nregs = hard_regno_nregs[regno][GET_MODE (reg)];
2207   if (nregs == 1)
2208     return 0;
2209   mask = (2U << (nregs - 1)) - 1;
2210
2211   /* Disregard parts of the return value that are set later.  */
2212   info.regno = regno;
2213   info.nregs = nregs;
2214   info.mask = mask;
2215   for (p = PREV_INSN (use); info.mask && p != insn; p = PREV_INSN (p))
2216     if (INSN_P (p))
2217       note_stores (PATTERN (p), likely_spilled_retval_1, &info);
2218   mask = info.mask;
2219
2220   /* Check if any of the (probably) live return value registers is
2221      likely spilled.  */
2222   nregs --;
2223   do
2224     {
2225       if ((mask & 1 << nregs)
2226           && targetm.class_likely_spilled_p (REGNO_REG_CLASS (regno + nregs)))
2227         return 1;
2228     } while (nregs--);
2229   return 0;
2230 }
2231
2232 /* Adjust INSN after we made a change to its destination.
2233
2234    Changing the destination can invalidate notes that say something about
2235    the results of the insn and a LOG_LINK pointing to the insn.  */
2236
2237 static void
2238 adjust_for_new_dest (rtx insn)
2239 {
2240   /* For notes, be conservative and simply remove them.  */
2241   remove_reg_equal_equiv_notes (insn);
2242
2243   /* The new insn will have a destination that was previously the destination
2244      of an insn just above it.  Call distribute_links to make a LOG_LINK from
2245      the next use of that destination.  */
2246   distribute_links (gen_rtx_INSN_LIST (VOIDmode, insn, NULL_RTX));
2247
2248   df_insn_rescan (insn);
2249 }
2250
2251 /* Return TRUE if combine can reuse reg X in mode MODE.
2252    ADDED_SETS is nonzero if the original set is still required.  */
2253 static bool
2254 can_change_dest_mode (rtx x, int added_sets, enum machine_mode mode)
2255 {
2256   unsigned int regno;
2257
2258   if (!REG_P(x))
2259     return false;
2260
2261   regno = REGNO (x);
2262   /* Allow hard registers if the new mode is legal, and occupies no more
2263      registers than the old mode.  */
2264   if (regno < FIRST_PSEUDO_REGISTER)
2265     return (HARD_REGNO_MODE_OK (regno, mode)
2266             && (hard_regno_nregs[regno][GET_MODE (x)]
2267                 >= hard_regno_nregs[regno][mode]));
2268
2269   /* Or a pseudo that is only used once.  */
2270   return (REG_N_SETS (regno) == 1 && !added_sets
2271           && !REG_USERVAR_P (x));
2272 }
2273
2274
2275 /* Check whether X, the destination of a set, refers to part of
2276    the register specified by REG.  */
2277
2278 static bool
2279 reg_subword_p (rtx x, rtx reg)
2280 {
2281   /* Check that reg is an integer mode register.  */
2282   if (!REG_P (reg) || GET_MODE_CLASS (GET_MODE (reg)) != MODE_INT)
2283     return false;
2284
2285   if (GET_CODE (x) == STRICT_LOW_PART
2286       || GET_CODE (x) == ZERO_EXTRACT)
2287     x = XEXP (x, 0);
2288
2289   return GET_CODE (x) == SUBREG
2290          && SUBREG_REG (x) == reg
2291          && GET_MODE_CLASS (GET_MODE (x)) == MODE_INT;
2292 }
2293
2294 #ifdef AUTO_INC_DEC
2295 /* Replace auto-increment addressing modes with explicit operations to access
2296    the same addresses without modifying the corresponding registers.  */
2297
2298 static rtx
2299 cleanup_auto_inc_dec (rtx src, enum machine_mode mem_mode)
2300 {
2301   rtx x = src;
2302   const RTX_CODE code = GET_CODE (x);
2303   int i;
2304   const char *fmt;
2305
2306   switch (code)
2307     {
2308     case REG:
2309     case CONST_INT:
2310     case CONST_DOUBLE:
2311     case CONST_FIXED:
2312     case CONST_VECTOR:
2313     case SYMBOL_REF:
2314     case CODE_LABEL:
2315     case PC:
2316     case CC0:
2317     case SCRATCH:
2318       /* SCRATCH must be shared because they represent distinct values.  */
2319       return x;
2320     case CLOBBER:
2321       if (REG_P (XEXP (x, 0)) && REGNO (XEXP (x, 0)) < FIRST_PSEUDO_REGISTER)
2322         return x;
2323       break;
2324
2325     case CONST:
2326       if (shared_const_p (x))
2327         return x;
2328       break;
2329
2330     case MEM:
2331       mem_mode = GET_MODE (x);
2332       break;
2333
2334     case PRE_INC:
2335     case PRE_DEC:
2336       gcc_assert (mem_mode != VOIDmode && mem_mode != BLKmode);
2337       return gen_rtx_PLUS (GET_MODE (x),
2338                            cleanup_auto_inc_dec (XEXP (x, 0), mem_mode),
2339                            GEN_INT (code == PRE_INC
2340                                     ? GET_MODE_SIZE (mem_mode)
2341                                     : -GET_MODE_SIZE (mem_mode)));
2342
2343     case POST_INC:
2344     case POST_DEC:
2345     case PRE_MODIFY:
2346     case POST_MODIFY:
2347       return cleanup_auto_inc_dec (code == PRE_MODIFY
2348                                    ? XEXP (x, 1) : XEXP (x, 0),
2349                                    mem_mode);
2350
2351     default:
2352       break;
2353     }
2354
2355   /* Copy the various flags, fields, and other information.  We assume
2356      that all fields need copying, and then clear the fields that should
2357      not be copied.  That is the sensible default behavior, and forces
2358      us to explicitly document why we are *not* copying a flag.  */
2359   x = shallow_copy_rtx (x);
2360
2361   /* We do not copy the USED flag, which is used as a mark bit during
2362      walks over the RTL.  */
2363   RTX_FLAG (x, used) = 0;
2364
2365   /* We do not copy FRAME_RELATED for INSNs.  */
2366   if (INSN_P (x))
2367     RTX_FLAG (x, frame_related) = 0;
2368
2369   fmt = GET_RTX_FORMAT (code);
2370   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2371     if (fmt[i] == 'e')
2372       XEXP (x, i) = cleanup_auto_inc_dec (XEXP (x, i), mem_mode);
2373     else if (fmt[i] == 'E' || fmt[i] == 'V')
2374       {
2375         int j;
2376         XVEC (x, i) = rtvec_alloc (XVECLEN (x, i));
2377         for (j = 0; j < XVECLEN (x, i); j++)
2378           XVECEXP (x, i, j)
2379             = cleanup_auto_inc_dec (XVECEXP (src, i, j), mem_mode);
2380       }
2381
2382   return x;
2383 }
2384 #endif
2385
2386 /* Auxiliary data structure for propagate_for_debug_stmt.  */
2387
2388 struct rtx_subst_pair
2389 {
2390   rtx to;
2391   bool adjusted;
2392 };
2393
2394 /* DATA points to an rtx_subst_pair.  Return the value that should be
2395    substituted.  */
2396
2397 static rtx
2398 propagate_for_debug_subst (rtx from, const_rtx old_rtx, void *data)
2399 {
2400   struct rtx_subst_pair *pair = (struct rtx_subst_pair *)data;
2401
2402   if (!rtx_equal_p (from, old_rtx))
2403     return NULL_RTX;
2404   if (!pair->adjusted)
2405     {
2406       pair->adjusted = true;
2407 #ifdef AUTO_INC_DEC
2408       pair->to = cleanup_auto_inc_dec (pair->to, VOIDmode);
2409 #else
2410       pair->to = copy_rtx (pair->to);
2411 #endif
2412       pair->to = make_compound_operation (pair->to, SET);
2413       return pair->to;
2414     }
2415   return copy_rtx (pair->to);
2416 }
2417
2418 /* Replace all the occurrences of DEST with SRC in DEBUG_INSNs between INSN
2419    and LAST.  */
2420
2421 static void
2422 propagate_for_debug (rtx insn, rtx last, rtx dest, rtx src)
2423 {
2424   rtx next, loc;
2425
2426   struct rtx_subst_pair p;
2427   p.to = src;
2428   p.adjusted = false;
2429
2430   next = NEXT_INSN (insn);
2431   while (next != last)
2432     {
2433       insn = next;
2434       next = NEXT_INSN (insn);
2435       if (DEBUG_INSN_P (insn))
2436         {
2437           loc = simplify_replace_fn_rtx (INSN_VAR_LOCATION_LOC (insn),
2438                                          dest, propagate_for_debug_subst, &p);
2439           if (loc == INSN_VAR_LOCATION_LOC (insn))
2440             continue;
2441           INSN_VAR_LOCATION_LOC (insn) = loc;
2442           df_insn_rescan (insn);
2443         }
2444     }
2445 }
2446
2447 /* Delete the unconditional jump INSN and adjust the CFG correspondingly.
2448    Note that the INSN should be deleted *after* removing dead edges, so
2449    that the kept edge is the fallthrough edge for a (set (pc) (pc))
2450    but not for a (set (pc) (label_ref FOO)).  */
2451
2452 static void
2453 update_cfg_for_uncondjump (rtx insn)
2454 {
2455   basic_block bb = BLOCK_FOR_INSN (insn);
2456   bool at_end = (BB_END (bb) == insn);
2457
2458   if (at_end)
2459     purge_dead_edges (bb);
2460
2461   delete_insn (insn);
2462   if (at_end && EDGE_COUNT (bb->succs) == 1)
2463     single_succ_edge (bb)->flags |= EDGE_FALLTHRU;
2464 }
2465
2466 /* Try to combine the insns I0, I1 and I2 into I3.
2467    Here I0, I1 and I2 appear earlier than I3.
2468    I0 and I1 can be zero; then we combine just I2 into I3, or I1 and I2 into
2469    I3.
2470
2471    If we are combining more than two insns and the resulting insn is not
2472    recognized, try splitting it into two insns.  If that happens, I2 and I3
2473    are retained and I1/I0 are pseudo-deleted by turning them into a NOTE.
2474    Otherwise, I0, I1 and I2 are pseudo-deleted.
2475
2476    Return 0 if the combination does not work.  Then nothing is changed.
2477    If we did the combination, return the insn at which combine should
2478    resume scanning.
2479
2480    Set NEW_DIRECT_JUMP_P to a nonzero value if try_combine creates a
2481    new direct jump instruction.  */
2482
2483 static rtx
2484 try_combine (rtx i3, rtx i2, rtx i1, rtx i0, int *new_direct_jump_p)
2485 {
2486   /* New patterns for I3 and I2, respectively.  */
2487   rtx newpat, newi2pat = 0;
2488   rtvec newpat_vec_with_clobbers = 0;
2489   int substed_i2 = 0, substed_i1 = 0, substed_i0 = 0;
2490   /* Indicates need to preserve SET in I0, I1 or I2 in I3 if it is not
2491      dead.  */
2492   int added_sets_0, added_sets_1, added_sets_2;
2493   /* Total number of SETs to put into I3.  */
2494   int total_sets;
2495   /* Nonzero if I2's or I1's body now appears in I3.  */
2496   int i2_is_used = 0, i1_is_used = 0;
2497   /* INSN_CODEs for new I3, new I2, and user of condition code.  */
2498   int insn_code_number, i2_code_number = 0, other_code_number = 0;
2499   /* Contains I3 if the destination of I3 is used in its source, which means
2500      that the old life of I3 is being killed.  If that usage is placed into
2501      I2 and not in I3, a REG_DEAD note must be made.  */
2502   rtx i3dest_killed = 0;
2503   /* SET_DEST and SET_SRC of I2, I1 and I0.  */
2504   rtx i2dest = 0, i2src = 0, i1dest = 0, i1src = 0, i0dest = 0, i0src = 0;
2505   /* Set if I2DEST was reused as a scratch register.  */
2506   bool i2scratch = false;
2507   /* The PATTERNs of I0, I1, and I2, or a copy of them in certain cases.  */
2508   rtx i0pat = 0, i1pat = 0, i2pat = 0;
2509   /* Indicates if I2DEST or I1DEST is in I2SRC or I1_SRC.  */
2510   int i2dest_in_i2src = 0, i1dest_in_i1src = 0, i2dest_in_i1src = 0;
2511   int i0dest_in_i0src = 0, i1dest_in_i0src = 0, i2dest_in_i0src = 0;
2512   int i2dest_killed = 0, i1dest_killed = 0, i0dest_killed = 0;
2513   int i1_feeds_i2_n = 0, i0_feeds_i2_n = 0, i0_feeds_i1_n = 0;
2514   /* Notes that must be added to REG_NOTES in I3 and I2.  */
2515   rtx new_i3_notes, new_i2_notes;
2516   /* Notes that we substituted I3 into I2 instead of the normal case.  */
2517   int i3_subst_into_i2 = 0;
2518   /* Notes that I1, I2 or I3 is a MULT operation.  */
2519   int have_mult = 0;
2520   int swap_i2i3 = 0;
2521   int changed_i3_dest = 0;
2522
2523   int maxreg;
2524   rtx temp;
2525   rtx link;
2526   rtx other_pat = 0;
2527   rtx new_other_notes;
2528   int i;
2529
2530   /* Only try four-insn combinations when there's high likelihood of
2531      success.  Look for simple insns, such as loads of constants or
2532      binary operations involving a constant.  */
2533   if (i0)
2534     {
2535       int i;
2536       int ngood = 0;
2537       int nshift = 0;
2538
2539       if (!flag_expensive_optimizations)
2540         return 0;
2541
2542       for (i = 0; i < 4; i++)
2543         {
2544           rtx insn = i == 0 ? i0 : i == 1 ? i1 : i == 2 ? i2 : i3;
2545           rtx set = single_set (insn);
2546           rtx src;
2547           if (!set)
2548             continue;
2549           src = SET_SRC (set);
2550           if (CONSTANT_P (src))
2551             {
2552               ngood += 2;
2553               break;
2554             }
2555           else if (BINARY_P (src) && CONSTANT_P (XEXP (src, 1)))
2556             ngood++;
2557           else if (GET_CODE (src) == ASHIFT || GET_CODE (src) == ASHIFTRT
2558                    || GET_CODE (src) == LSHIFTRT)
2559             nshift++;
2560         }
2561       if (ngood < 2 && nshift < 2)
2562         return 0;
2563     }
2564
2565   /* Exit early if one of the insns involved can't be used for
2566      combinations.  */
2567   if (cant_combine_insn_p (i3)
2568       || cant_combine_insn_p (i2)
2569       || (i1 && cant_combine_insn_p (i1))
2570       || (i0 && cant_combine_insn_p (i0))
2571       || likely_spilled_retval_p (i3))
2572     return 0;
2573
2574   combine_attempts++;
2575   undobuf.other_insn = 0;
2576
2577   /* Reset the hard register usage information.  */
2578   CLEAR_HARD_REG_SET (newpat_used_regs);
2579
2580   if (dump_file && (dump_flags & TDF_DETAILS))
2581     {
2582       if (i0)
2583         fprintf (dump_file, "\nTrying %d, %d, %d -> %d:\n",
2584                  INSN_UID (i0), INSN_UID (i1), INSN_UID (i2), INSN_UID (i3));
2585       else if (i1)
2586         fprintf (dump_file, "\nTrying %d, %d -> %d:\n",
2587                  INSN_UID (i1), INSN_UID (i2), INSN_UID (i3));
2588       else
2589         fprintf (dump_file, "\nTrying %d -> %d:\n",
2590                  INSN_UID (i2), INSN_UID (i3));
2591     }
2592
2593   /* If multiple insns feed into one of I2 or I3, they can be in any
2594      order.  To simplify the code below, reorder them in sequence.  */
2595   if (i0 && DF_INSN_LUID (i0) > DF_INSN_LUID (i2))
2596     temp = i2, i2 = i0, i0 = temp;
2597   if (i0 && DF_INSN_LUID (i0) > DF_INSN_LUID (i1))
2598     temp = i1, i1 = i0, i0 = temp;
2599   if (i1 && DF_INSN_LUID (i1) > DF_INSN_LUID (i2))
2600     temp = i1, i1 = i2, i2 = temp;
2601
2602   added_links_insn = 0;
2603
2604   /* First check for one important special case that the code below will
2605      not handle.  Namely, the case where I1 is zero, I2 is a PARALLEL
2606      and I3 is a SET whose SET_SRC is a SET_DEST in I2.  In that case,
2607      we may be able to replace that destination with the destination of I3.
2608      This occurs in the common code where we compute both a quotient and
2609      remainder into a structure, in which case we want to do the computation
2610      directly into the structure to avoid register-register copies.
2611
2612      Note that this case handles both multiple sets in I2 and also cases
2613      where I2 has a number of CLOBBERs inside the PARALLEL.
2614
2615      We make very conservative checks below and only try to handle the
2616      most common cases of this.  For example, we only handle the case
2617      where I2 and I3 are adjacent to avoid making difficult register
2618      usage tests.  */
2619
2620   if (i1 == 0 && NONJUMP_INSN_P (i3) && GET_CODE (PATTERN (i3)) == SET
2621       && REG_P (SET_SRC (PATTERN (i3)))
2622       && REGNO (SET_SRC (PATTERN (i3))) >= FIRST_PSEUDO_REGISTER
2623       && find_reg_note (i3, REG_DEAD, SET_SRC (PATTERN (i3)))
2624       && GET_CODE (PATTERN (i2)) == PARALLEL
2625       && ! side_effects_p (SET_DEST (PATTERN (i3)))
2626       /* If the dest of I3 is a ZERO_EXTRACT or STRICT_LOW_PART, the code
2627          below would need to check what is inside (and reg_overlap_mentioned_p
2628          doesn't support those codes anyway).  Don't allow those destinations;
2629          the resulting insn isn't likely to be recognized anyway.  */
2630       && GET_CODE (SET_DEST (PATTERN (i3))) != ZERO_EXTRACT
2631       && GET_CODE (SET_DEST (PATTERN (i3))) != STRICT_LOW_PART
2632       && ! reg_overlap_mentioned_p (SET_SRC (PATTERN (i3)),
2633                                     SET_DEST (PATTERN (i3)))
2634       && next_active_insn (i2) == i3)
2635     {
2636       rtx p2 = PATTERN (i2);
2637
2638       /* Make sure that the destination of I3,
2639          which we are going to substitute into one output of I2,
2640          is not used within another output of I2.  We must avoid making this:
2641          (parallel [(set (mem (reg 69)) ...)
2642                     (set (reg 69) ...)])
2643          which is not well-defined as to order of actions.
2644          (Besides, reload can't handle output reloads for this.)
2645
2646          The problem can also happen if the dest of I3 is a memory ref,
2647          if another dest in I2 is an indirect memory ref.  */
2648       for (i = 0; i < XVECLEN (p2, 0); i++)
2649         if ((GET_CODE (XVECEXP (p2, 0, i)) == SET
2650              || GET_CODE (XVECEXP (p2, 0, i)) == CLOBBER)
2651             && reg_overlap_mentioned_p (SET_DEST (PATTERN (i3)),
2652                                         SET_DEST (XVECEXP (p2, 0, i))))
2653           break;
2654
2655       if (i == XVECLEN (p2, 0))
2656         for (i = 0; i < XVECLEN (p2, 0); i++)
2657           if (GET_CODE (XVECEXP (p2, 0, i)) == SET
2658               && SET_DEST (XVECEXP (p2, 0, i)) == SET_SRC (PATTERN (i3)))
2659             {
2660               combine_merges++;
2661
2662               subst_insn = i3;
2663               subst_low_luid = DF_INSN_LUID (i2);
2664
2665               added_sets_2 = added_sets_1 = added_sets_0 = 0;
2666               i2src = SET_SRC (XVECEXP (p2, 0, i));
2667               i2dest = SET_DEST (XVECEXP (p2, 0, i));
2668               i2dest_killed = dead_or_set_p (i2, i2dest);
2669
2670               /* Replace the dest in I2 with our dest and make the resulting
2671                  insn the new pattern for I3.  Then skip to where we validate
2672                  the pattern.  Everything was set up above.  */
2673               SUBST (SET_DEST (XVECEXP (p2, 0, i)), SET_DEST (PATTERN (i3)));
2674               newpat = p2;
2675               i3_subst_into_i2 = 1;
2676               goto validate_replacement;
2677             }
2678     }
2679
2680   /* If I2 is setting a pseudo to a constant and I3 is setting some
2681      sub-part of it to another constant, merge them by making a new
2682      constant.  */
2683   if (i1 == 0
2684       && (temp = single_set (i2)) != 0
2685       && (CONST_INT_P (SET_SRC (temp))
2686           || GET_CODE (SET_SRC (temp)) == CONST_DOUBLE)
2687       && GET_CODE (PATTERN (i3)) == SET
2688       && (CONST_INT_P (SET_SRC (PATTERN (i3)))
2689           || GET_CODE (SET_SRC (PATTERN (i3))) == CONST_DOUBLE)
2690       && reg_subword_p (SET_DEST (PATTERN (i3)), SET_DEST (temp)))
2691     {
2692       rtx dest = SET_DEST (PATTERN (i3));
2693       int offset = -1;
2694       int width = 0;
2695
2696       if (GET_CODE (dest) == ZERO_EXTRACT)
2697         {
2698           if (CONST_INT_P (XEXP (dest, 1))
2699               && CONST_INT_P (XEXP (dest, 2)))
2700             {
2701               width = INTVAL (XEXP (dest, 1));
2702               offset = INTVAL (XEXP (dest, 2));
2703               dest = XEXP (dest, 0);
2704               if (BITS_BIG_ENDIAN)
2705                 offset = GET_MODE_BITSIZE (GET_MODE (dest)) - width - offset;
2706             }
2707         }
2708       else
2709         {
2710           if (GET_CODE (dest) == STRICT_LOW_PART)
2711             dest = XEXP (dest, 0);
2712           width = GET_MODE_BITSIZE (GET_MODE (dest));
2713           offset = 0;
2714         }
2715
2716       if (offset >= 0)
2717         {
2718           /* If this is the low part, we're done.  */
2719           if (subreg_lowpart_p (dest))
2720             ;
2721           /* Handle the case where inner is twice the size of outer.  */
2722           else if (GET_MODE_BITSIZE (GET_MODE (SET_DEST (temp)))
2723                    == 2 * GET_MODE_BITSIZE (GET_MODE (dest)))
2724             offset += GET_MODE_BITSIZE (GET_MODE (dest));
2725           /* Otherwise give up for now.  */
2726           else
2727             offset = -1;
2728         }
2729
2730       if (offset >= 0
2731           && (GET_MODE_BITSIZE (GET_MODE (SET_DEST (temp)))
2732               <= HOST_BITS_PER_DOUBLE_INT))
2733         {
2734           double_int m, o, i;
2735           rtx inner = SET_SRC (PATTERN (i3));
2736           rtx outer = SET_SRC (temp);
2737
2738           o = rtx_to_double_int (outer);
2739           i = rtx_to_double_int (inner);
2740
2741           m = double_int_mask (width);
2742           i = double_int_and (i, m);
2743           m = double_int_lshift (m, offset, HOST_BITS_PER_DOUBLE_INT, false);
2744           i = double_int_lshift (i, offset, HOST_BITS_PER_DOUBLE_INT, false);
2745           o = double_int_ior (double_int_and_not (o, m), i);
2746
2747           combine_merges++;
2748           subst_insn = i3;
2749           subst_low_luid = DF_INSN_LUID (i2);
2750           added_sets_2 = added_sets_1 = added_sets_0 = 0;
2751           i2dest = SET_DEST (temp);
2752           i2dest_killed = dead_or_set_p (i2, i2dest);
2753
2754           /* Replace the source in I2 with the new constant and make the
2755              resulting insn the new pattern for I3.  Then skip to where we
2756              validate the pattern.  Everything was set up above.  */
2757           SUBST (SET_SRC (temp),
2758                  immed_double_int_const (o, GET_MODE (SET_DEST (temp))));
2759
2760           newpat = PATTERN (i2);
2761
2762           /* The dest of I3 has been replaced with the dest of I2.  */
2763           changed_i3_dest = 1;
2764           goto validate_replacement;
2765         }
2766     }
2767
2768 #ifndef HAVE_cc0
2769   /* If we have no I1 and I2 looks like:
2770         (parallel [(set (reg:CC X) (compare:CC OP (const_int 0)))
2771                    (set Y OP)])
2772      make up a dummy I1 that is
2773         (set Y OP)
2774      and change I2 to be
2775         (set (reg:CC X) (compare:CC Y (const_int 0)))
2776
2777      (We can ignore any trailing CLOBBERs.)
2778
2779      This undoes a previous combination and allows us to match a branch-and-
2780      decrement insn.  */
2781
2782   if (i1 == 0 && GET_CODE (PATTERN (i2)) == PARALLEL
2783       && XVECLEN (PATTERN (i2), 0) >= 2
2784       && GET_CODE (XVECEXP (PATTERN (i2), 0, 0)) == SET
2785       && (GET_MODE_CLASS (GET_MODE (SET_DEST (XVECEXP (PATTERN (i2), 0, 0))))
2786           == MODE_CC)
2787       && GET_CODE (SET_SRC (XVECEXP (PATTERN (i2), 0, 0))) == COMPARE
2788       && XEXP (SET_SRC (XVECEXP (PATTERN (i2), 0, 0)), 1) == const0_rtx
2789       && GET_CODE (XVECEXP (PATTERN (i2), 0, 1)) == SET
2790       && REG_P (SET_DEST (XVECEXP (PATTERN (i2), 0, 1)))
2791       && rtx_equal_p (XEXP (SET_SRC (XVECEXP (PATTERN (i2), 0, 0)), 0),
2792                       SET_SRC (XVECEXP (PATTERN (i2), 0, 1))))
2793     {
2794       for (i = XVECLEN (PATTERN (i2), 0) - 1; i >= 2; i--)
2795         if (GET_CODE (XVECEXP (PATTERN (i2), 0, i)) != CLOBBER)
2796           break;
2797
2798       if (i == 1)
2799         {
2800           /* We make I1 with the same INSN_UID as I2.  This gives it
2801              the same DF_INSN_LUID for value tracking.  Our fake I1 will
2802              never appear in the insn stream so giving it the same INSN_UID
2803              as I2 will not cause a problem.  */
2804
2805           i1 = gen_rtx_INSN (VOIDmode, INSN_UID (i2), NULL_RTX, i2,
2806                              BLOCK_FOR_INSN (i2), XVECEXP (PATTERN (i2), 0, 1),
2807                              INSN_LOCATOR (i2), -1, NULL_RTX);
2808
2809           SUBST (PATTERN (i2), XVECEXP (PATTERN (i2), 0, 0));
2810           SUBST (XEXP (SET_SRC (PATTERN (i2)), 0),
2811                  SET_DEST (PATTERN (i1)));
2812         }
2813     }
2814 #endif
2815
2816   /* Verify that I2 and I1 are valid for combining.  */
2817   if (! can_combine_p (i2, i3, i0, i1, NULL_RTX, NULL_RTX, &i2dest, &i2src)
2818       || (i1 && ! can_combine_p (i1, i3, i0, NULL_RTX, i2, NULL_RTX,
2819                                  &i1dest, &i1src))
2820       || (i0 && ! can_combine_p (i0, i3, NULL_RTX, NULL_RTX, i1, i2,
2821                                  &i0dest, &i0src)))
2822     {
2823       undo_all ();
2824       return 0;
2825     }
2826
2827   /* Record whether I2DEST is used in I2SRC and similarly for the other
2828      cases.  Knowing this will help in register status updating below.  */
2829   i2dest_in_i2src = reg_overlap_mentioned_p (i2dest, i2src);
2830   i1dest_in_i1src = i1 && reg_overlap_mentioned_p (i1dest, i1src);
2831   i2dest_in_i1src = i1 && reg_overlap_mentioned_p (i2dest, i1src);
2832   i0dest_in_i0src = i0 && reg_overlap_mentioned_p (i0dest, i0src);
2833   i1dest_in_i0src = i0 && reg_overlap_mentioned_p (i1dest, i0src);
2834   i2dest_in_i0src = i0 && reg_overlap_mentioned_p (i2dest, i0src);
2835   i2dest_killed = dead_or_set_p (i2, i2dest);
2836   i1dest_killed = i1 && dead_or_set_p (i1, i1dest);
2837   i0dest_killed = i0 && dead_or_set_p (i0, i0dest);
2838
2839   /* For the earlier insns, determine which of the subsequent ones they
2840      feed.  */
2841   i1_feeds_i2_n = i1 && insn_a_feeds_b (i1, i2);
2842   i0_feeds_i1_n = i0 && insn_a_feeds_b (i0, i1);
2843   i0_feeds_i2_n = (i0 && (!i0_feeds_i1_n ? insn_a_feeds_b (i0, i2)
2844                           : (!reg_overlap_mentioned_p (i1dest, i0dest)
2845                              && reg_overlap_mentioned_p (i0dest, i2src))));
2846
2847   /* Ensure that I3's pattern can be the destination of combines.  */
2848   if (! combinable_i3pat (i3, &PATTERN (i3), i2dest, i1dest, i0dest,
2849                           i1 && i2dest_in_i1src && !i1_feeds_i2_n,
2850                           i0 && ((i2dest_in_i0src && !i0_feeds_i2_n)
2851                                  || (i1dest_in_i0src && !i0_feeds_i1_n)),
2852                           &i3dest_killed))
2853     {
2854       undo_all ();
2855       return 0;
2856     }
2857
2858   /* See if any of the insns is a MULT operation.  Unless one is, we will
2859      reject a combination that is, since it must be slower.  Be conservative
2860      here.  */
2861   if (GET_CODE (i2src) == MULT
2862       || (i1 != 0 && GET_CODE (i1src) == MULT)
2863       || (i0 != 0 && GET_CODE (i0src) == MULT)
2864       || (GET_CODE (PATTERN (i3)) == SET
2865           && GET_CODE (SET_SRC (PATTERN (i3))) == MULT))
2866     have_mult = 1;
2867
2868   /* If I3 has an inc, then give up if I1 or I2 uses the reg that is inc'd.
2869      We used to do this EXCEPT in one case: I3 has a post-inc in an
2870      output operand.  However, that exception can give rise to insns like
2871         mov r3,(r3)+
2872      which is a famous insn on the PDP-11 where the value of r3 used as the
2873      source was model-dependent.  Avoid this sort of thing.  */
2874
2875 #if 0
2876   if (!(GET_CODE (PATTERN (i3)) == SET
2877         && REG_P (SET_SRC (PATTERN (i3)))
2878         && MEM_P (SET_DEST (PATTERN (i3)))
2879         && (GET_CODE (XEXP (SET_DEST (PATTERN (i3)), 0)) == POST_INC
2880             || GET_CODE (XEXP (SET_DEST (PATTERN (i3)), 0)) == POST_DEC)))
2881     /* It's not the exception.  */
2882 #endif
2883 #ifdef AUTO_INC_DEC
2884     for (link = REG_NOTES (i3); link; link = XEXP (link, 1))
2885       if (REG_NOTE_KIND (link) == REG_INC
2886           && (reg_overlap_mentioned_p (XEXP (link, 0), PATTERN (i2))
2887               || (i1 != 0
2888                   && reg_overlap_mentioned_p (XEXP (link, 0), PATTERN (i1)))))
2889         {
2890           undo_all ();
2891           return 0;
2892         }
2893 #endif
2894
2895   /* See if the SETs in I1 or I2 need to be kept around in the merged
2896      instruction: whenever the value set there is still needed past I3.
2897      For the SETs in I2, this is easy: we see if I2DEST dies or is set in I3.
2898
2899      For the SET in I1, we have two cases:  If I1 and I2 independently
2900      feed into I3, the set in I1 needs to be kept around if I1DEST dies
2901      or is set in I3.  Otherwise (if I1 feeds I2 which feeds I3), the set
2902      in I1 needs to be kept around unless I1DEST dies or is set in either
2903      I2 or I3.  The same consideration applies to I0.  */
2904
2905   added_sets_2 = !dead_or_set_p (i3, i2dest);
2906
2907   if (i1)
2908     added_sets_1 = !(dead_or_set_p (i3, i1dest)
2909                      || (i1_feeds_i2_n && dead_or_set_p (i2, i1dest)));
2910   else
2911     added_sets_1 = 0;
2912
2913   if (i0)
2914     added_sets_0 =  !(dead_or_set_p (i3, i0dest)
2915                       || (i0_feeds_i2_n && dead_or_set_p (i2, i0dest))
2916                       || (i0_feeds_i1_n && dead_or_set_p (i1, i0dest)));
2917   else
2918     added_sets_0 = 0;
2919
2920   /* If the set in I2 needs to be kept around, we must make a copy of
2921      PATTERN (I2), so that when we substitute I1SRC for I1DEST in
2922      PATTERN (I2), we are only substituting for the original I1DEST, not into
2923      an already-substituted copy.  This also prevents making self-referential
2924      rtx.  If I2 is a PARALLEL, we just need the piece that assigns I2SRC to
2925      I2DEST.  */
2926
2927   if (added_sets_2)
2928     {
2929       if (GET_CODE (PATTERN (i2)) == PARALLEL)
2930         i2pat = gen_rtx_SET (VOIDmode, i2dest, copy_rtx (i2src));
2931       else
2932         i2pat = copy_rtx (PATTERN (i2));
2933     }
2934
2935   if (added_sets_1)
2936     {
2937       if (GET_CODE (PATTERN (i1)) == PARALLEL)
2938         i1pat = gen_rtx_SET (VOIDmode, i1dest, copy_rtx (i1src));
2939       else
2940         i1pat = copy_rtx (PATTERN (i1));
2941     }
2942
2943   if (added_sets_0)
2944     {
2945       if (GET_CODE (PATTERN (i0)) == PARALLEL)
2946         i0pat = gen_rtx_SET (VOIDmode, i0dest, copy_rtx (i0src));
2947       else
2948         i0pat = copy_rtx (PATTERN (i0));
2949     }
2950
2951   combine_merges++;
2952
2953   /* Substitute in the latest insn for the regs set by the earlier ones.  */
2954
2955   maxreg = max_reg_num ();
2956
2957   subst_insn = i3;
2958
2959 #ifndef HAVE_cc0
2960   /* Many machines that don't use CC0 have insns that can both perform an
2961      arithmetic operation and set the condition code.  These operations will
2962      be represented as a PARALLEL with the first element of the vector
2963      being a COMPARE of an arithmetic operation with the constant zero.
2964      The second element of the vector will set some pseudo to the result
2965      of the same arithmetic operation.  If we simplify the COMPARE, we won't
2966      match such a pattern and so will generate an extra insn.   Here we test
2967      for this case, where both the comparison and the operation result are
2968      needed, and make the PARALLEL by just replacing I2DEST in I3SRC with
2969      I2SRC.  Later we will make the PARALLEL that contains I2.  */
2970
2971   if (i1 == 0 && added_sets_2 && GET_CODE (PATTERN (i3)) == SET
2972       && GET_CODE (SET_SRC (PATTERN (i3))) == COMPARE
2973       && XEXP (SET_SRC (PATTERN (i3)), 1) == const0_rtx
2974       && rtx_equal_p (XEXP (SET_SRC (PATTERN (i3)), 0), i2dest))
2975     {
2976 #ifdef SELECT_CC_MODE
2977       rtx *cc_use;
2978       enum machine_mode compare_mode;
2979 #endif
2980
2981       newpat = PATTERN (i3);
2982       SUBST (XEXP (SET_SRC (newpat), 0), i2src);
2983
2984       i2_is_used = 1;
2985
2986 #ifdef SELECT_CC_MODE
2987       /* See if a COMPARE with the operand we substituted in should be done
2988          with the mode that is currently being used.  If not, do the same
2989          processing we do in `subst' for a SET; namely, if the destination
2990          is used only once, try to replace it with a register of the proper
2991          mode and also replace the COMPARE.  */
2992       if (undobuf.other_insn == 0
2993           && (cc_use = find_single_use (SET_DEST (newpat), i3,
2994                                         &undobuf.other_insn))
2995           && ((compare_mode = SELECT_CC_MODE (GET_CODE (*cc_use),
2996                                               i2src, const0_rtx))
2997               != GET_MODE (SET_DEST (newpat))))
2998         {
2999           if (can_change_dest_mode (SET_DEST (newpat), added_sets_2,
3000                                     compare_mode))
3001             {
3002               unsigned int regno = REGNO (SET_DEST (newpat));
3003               rtx new_dest;
3004
3005               if (regno < FIRST_PSEUDO_REGISTER)
3006                 new_dest = gen_rtx_REG (compare_mode, regno);
3007               else
3008                 {
3009                   SUBST_MODE (regno_reg_rtx[regno], compare_mode);
3010                   new_dest = regno_reg_rtx[regno];
3011                 }
3012
3013               SUBST (SET_DEST (newpat), new_dest);
3014               SUBST (XEXP (*cc_use, 0), new_dest);
3015               SUBST (SET_SRC (newpat),
3016                      gen_rtx_COMPARE (compare_mode, i2src, const0_rtx));
3017             }
3018           else
3019             undobuf.other_insn = 0;
3020         }
3021 #endif
3022     }
3023   else
3024 #endif
3025     {
3026       /* It is possible that the source of I2 or I1 may be performing
3027          an unneeded operation, such as a ZERO_EXTEND of something
3028          that is known to have the high part zero.  Handle that case
3029          by letting subst look at the innermost one of them.
3030
3031          Another way to do this would be to have a function that tries
3032          to simplify a single insn instead of merging two or more
3033          insns.  We don't do this because of the potential of infinite
3034          loops and because of the potential extra memory required.
3035          However, doing it the way we are is a bit of a kludge and
3036          doesn't catch all cases.
3037
3038          But only do this if -fexpensive-optimizations since it slows
3039          things down and doesn't usually win.
3040
3041          This is not done in the COMPARE case above because the
3042          unmodified I2PAT is used in the PARALLEL and so a pattern
3043          with a modified I2SRC would not match.  */
3044
3045       if (flag_expensive_optimizations)
3046         {
3047           /* Pass pc_rtx so no substitutions are done, just
3048              simplifications.  */
3049           if (i1)
3050             {
3051               subst_low_luid = DF_INSN_LUID (i1);
3052               i1src = subst (i1src, pc_rtx, pc_rtx, 0, 0);
3053             }
3054           else
3055             {
3056               subst_low_luid = DF_INSN_LUID (i2);
3057               i2src = subst (i2src, pc_rtx, pc_rtx, 0, 0);
3058             }
3059         }
3060
3061       n_occurrences = 0;                /* `subst' counts here */
3062
3063       /* If I1 feeds into I2 and I1DEST is in I1SRC, we need to make a
3064          unique copy of I2SRC each time we substitute it to avoid
3065          self-referential rtl.  */
3066
3067       subst_low_luid = DF_INSN_LUID (i2);
3068       newpat = subst (PATTERN (i3), i2dest, i2src, 0,
3069                       ((i1_feeds_i2_n && i1dest_in_i1src)
3070                        || (i0_feeds_i2_n && i0dest_in_i0src)));
3071       substed_i2 = 1;
3072
3073       /* Record whether i2's body now appears within i3's body.  */
3074       i2_is_used = n_occurrences;
3075     }
3076
3077   /* If we already got a failure, don't try to do more.  Otherwise,
3078      try to substitute in I1 if we have it.  */
3079
3080   if (i1 && GET_CODE (newpat) != CLOBBER)
3081     {
3082       /* Check that an autoincrement side-effect on I1 has not been lost.
3083          This happens if I1DEST is mentioned in I2 and dies there, and
3084          has disappeared from the new pattern.  */
3085       if ((FIND_REG_INC_NOTE (i1, NULL_RTX) != 0
3086            && i1_feeds_i2_n
3087            && dead_or_set_p (i2, i1dest)
3088            && !reg_overlap_mentioned_p (i1dest, newpat))
3089           /* Before we can do this substitution, we must redo the test done
3090              above (see detailed comments there) that ensures  that I1DEST
3091              isn't mentioned in any SETs in NEWPAT that are field assignments.  */
3092           || !combinable_i3pat (NULL_RTX, &newpat, i1dest, NULL_RTX, NULL_RTX,
3093                                 0, 0, 0))
3094         {
3095           undo_all ();
3096           return 0;
3097         }
3098
3099       n_occurrences = 0;
3100       subst_low_luid = DF_INSN_LUID (i1);
3101       newpat = subst (newpat, i1dest, i1src, 0,
3102                       i0_feeds_i1_n && i0dest_in_i0src);
3103       substed_i1 = 1;
3104       i1_is_used = n_occurrences;
3105     }
3106   if (i0 && GET_CODE (newpat) != CLOBBER)
3107     {
3108       if ((FIND_REG_INC_NOTE (i0, NULL_RTX) != 0
3109            && ((i0_feeds_i2_n && dead_or_set_p (i2, i0dest))
3110                || (i0_feeds_i1_n && dead_or_set_p (i1, i0dest)))
3111            && !reg_overlap_mentioned_p (i0dest, newpat))
3112           || !combinable_i3pat (NULL_RTX, &newpat, i0dest, NULL_RTX, NULL_RTX,
3113                                 0, 0, 0))
3114         {
3115           undo_all ();
3116           return 0;
3117         }
3118
3119       n_occurrences = 0;
3120       subst_low_luid = DF_INSN_LUID (i0);
3121       newpat = subst (newpat, i0dest, i0src, 0,
3122                       i0_feeds_i1_n && i0dest_in_i0src);
3123       substed_i0 = 1;
3124     }
3125
3126   /* Fail if an autoincrement side-effect has been duplicated.  Be careful
3127      to count all the ways that I2SRC and I1SRC can be used.  */
3128   if ((FIND_REG_INC_NOTE (i2, NULL_RTX) != 0
3129        && i2_is_used + added_sets_2 > 1)
3130       || (i1 != 0 && FIND_REG_INC_NOTE (i1, NULL_RTX) != 0
3131           && (i1_is_used + added_sets_1 + (added_sets_2 && i1_feeds_i2_n)
3132               > 1))
3133       || (i0 != 0 && FIND_REG_INC_NOTE (i0, NULL_RTX) != 0
3134           && (n_occurrences + added_sets_0
3135               + (added_sets_1 && i0_feeds_i1_n)
3136               + (added_sets_2 && i0_feeds_i2_n)
3137               > 1))
3138       /* Fail if we tried to make a new register.  */
3139       || max_reg_num () != maxreg
3140       /* Fail if we couldn't do something and have a CLOBBER.  */
3141       || GET_CODE (newpat) == CLOBBER
3142       /* Fail if this new pattern is a MULT and we didn't have one before
3143          at the outer level.  */
3144       || (GET_CODE (newpat) == SET && GET_CODE (SET_SRC (newpat)) == MULT
3145           && ! have_mult))
3146     {
3147       undo_all ();
3148       return 0;
3149     }
3150
3151   /* If the actions of the earlier insns must be kept
3152      in addition to substituting them into the latest one,
3153      we must make a new PARALLEL for the latest insn
3154      to hold additional the SETs.  */
3155
3156   if (added_sets_0 || added_sets_1 || added_sets_2)
3157     {
3158       int extra_sets = added_sets_0 + added_sets_1 + added_sets_2;
3159       combine_extras++;
3160
3161       if (GET_CODE (newpat) == PARALLEL)
3162         {
3163           rtvec old = XVEC (newpat, 0);
3164           total_sets = XVECLEN (newpat, 0) + extra_sets;
3165           newpat = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (total_sets));
3166           memcpy (XVEC (newpat, 0)->elem, &old->elem[0],
3167                   sizeof (old->elem[0]) * old->num_elem);
3168         }
3169       else
3170         {
3171           rtx old = newpat;
3172           total_sets = 1 + extra_sets;
3173           newpat = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (total_sets));
3174           XVECEXP (newpat, 0, 0) = old;
3175         }
3176
3177       if (added_sets_0)
3178         XVECEXP (newpat, 0, --total_sets) = i0pat;
3179
3180       if (added_sets_1)
3181         {
3182           rtx t = i1pat;
3183           if (i0_feeds_i1_n)
3184             t = subst (t, i0dest, i0src, 0, 0);
3185
3186           XVECEXP (newpat, 0, --total_sets) = t;
3187         }
3188       if (added_sets_2)
3189         {
3190           rtx t = i2pat;
3191           if (i0_feeds_i2_n)
3192             t = subst (t, i0dest, i0src, 0, 0);
3193           if (i1_feeds_i2_n)
3194             t = subst (t, i1dest, i1src, 0, 0);
3195
3196           XVECEXP (newpat, 0, --total_sets) = t;
3197         }
3198     }
3199
3200  validate_replacement:
3201
3202   /* Note which hard regs this insn has as inputs.  */
3203   mark_used_regs_combine (newpat);
3204
3205   /* If recog_for_combine fails, it strips existing clobbers.  If we'll
3206      consider splitting this pattern, we might need these clobbers.  */
3207   if (i1 && GET_CODE (newpat) == PARALLEL
3208       && GET_CODE (XVECEXP (newpat, 0, XVECLEN (newpat, 0) - 1)) == CLOBBER)
3209     {
3210       int len = XVECLEN (newpat, 0);
3211
3212       newpat_vec_with_clobbers = rtvec_alloc (len);
3213       for (i = 0; i < len; i++)
3214         RTVEC_ELT (newpat_vec_with_clobbers, i) = XVECEXP (newpat, 0, i);
3215     }
3216
3217   /* Is the result of combination a valid instruction?  */
3218   insn_code_number = recog_for_combine (&newpat, i3, &new_i3_notes);
3219
3220   /* If the result isn't valid, see if it is a PARALLEL of two SETs where
3221      the second SET's destination is a register that is unused and isn't
3222      marked as an instruction that might trap in an EH region.  In that case,
3223      we just need the first SET.   This can occur when simplifying a divmod
3224      insn.  We *must* test for this case here because the code below that
3225      splits two independent SETs doesn't handle this case correctly when it
3226      updates the register status.
3227
3228      It's pointless doing this if we originally had two sets, one from
3229      i3, and one from i2.  Combining then splitting the parallel results
3230      in the original i2 again plus an invalid insn (which we delete).
3231      The net effect is only to move instructions around, which makes
3232      debug info less accurate.
3233
3234      Also check the case where the first SET's destination is unused.
3235      That would not cause incorrect code, but does cause an unneeded
3236      insn to remain.  */
3237
3238   if (insn_code_number < 0
3239       && !(added_sets_2 && i1 == 0)
3240       && GET_CODE (newpat) == PARALLEL
3241       && XVECLEN (newpat, 0) == 2
3242       && GET_CODE (XVECEXP (newpat, 0, 0)) == SET
3243       && GET_CODE (XVECEXP (newpat, 0, 1)) == SET
3244       && asm_noperands (newpat) < 0)
3245     {
3246       rtx set0 = XVECEXP (newpat, 0, 0);
3247       rtx set1 = XVECEXP (newpat, 0, 1);
3248
3249       if (((REG_P (SET_DEST (set1))
3250             && find_reg_note (i3, REG_UNUSED, SET_DEST (set1)))
3251            || (GET_CODE (SET_DEST (set1)) == SUBREG
3252                && find_reg_note (i3, REG_UNUSED, SUBREG_REG (SET_DEST (set1)))))
3253           && insn_nothrow_p (i3)
3254           && !side_effects_p (SET_SRC (set1)))
3255         {
3256           newpat = set0;
3257           insn_code_number = recog_for_combine (&newpat, i3, &new_i3_notes);
3258         }
3259
3260       else if (((REG_P (SET_DEST (set0))
3261                  && find_reg_note (i3, REG_UNUSED, SET_DEST (set0)))
3262                 || (GET_CODE (SET_DEST (set0)) == SUBREG
3263                     && find_reg_note (i3, REG_UNUSED,
3264                                       SUBREG_REG (SET_DEST (set0)))))
3265                && insn_nothrow_p (i3)
3266                && !side_effects_p (SET_SRC (set0)))
3267         {
3268           newpat = set1;
3269           insn_code_number = recog_for_combine (&newpat, i3, &new_i3_notes);
3270
3271           if (insn_code_number >= 0)
3272             changed_i3_dest = 1;
3273         }
3274     }
3275
3276   /* If we were combining three insns and the result is a simple SET
3277      with no ASM_OPERANDS that wasn't recognized, try to split it into two
3278      insns.  There are two ways to do this.  It can be split using a
3279      machine-specific method (like when you have an addition of a large
3280      constant) or by combine in the function find_split_point.  */
3281
3282   if (i1 && insn_code_number < 0 && GET_CODE (newpat) == SET
3283       && asm_noperands (newpat) < 0)
3284     {
3285       rtx parallel, m_split, *split;
3286
3287       /* See if the MD file can split NEWPAT.  If it can't, see if letting it
3288          use I2DEST as a scratch register will help.  In the latter case,
3289          convert I2DEST to the mode of the source of NEWPAT if we can.  */
3290
3291       m_split = combine_split_insns (newpat, i3);
3292
3293       /* We can only use I2DEST as a scratch reg if it doesn't overlap any
3294          inputs of NEWPAT.  */
3295
3296       /* ??? If I2DEST is not safe, and I1DEST exists, then it would be
3297          possible to try that as a scratch reg.  This would require adding
3298          more code to make it work though.  */
3299
3300       if (m_split == 0 && ! reg_overlap_mentioned_p (i2dest, newpat))
3301         {
3302           enum machine_mode new_mode = GET_MODE (SET_DEST (newpat));
3303
3304           /* First try to split using the original register as a
3305              scratch register.  */
3306           parallel = gen_rtx_PARALLEL (VOIDmode,
3307                                        gen_rtvec (2, newpat,
3308                                                   gen_rtx_CLOBBER (VOIDmode,
3309                                                                    i2dest)));
3310           m_split = combine_split_insns (parallel, i3);
3311
3312           /* If that didn't work, try changing the mode of I2DEST if
3313              we can.  */
3314           if (m_split == 0
3315               && new_mode != GET_MODE (i2dest)
3316               && new_mode != VOIDmode
3317               && can_change_dest_mode (i2dest, added_sets_2, new_mode))
3318             {
3319               enum machine_mode old_mode = GET_MODE (i2dest);
3320               rtx ni2dest;
3321
3322               if (REGNO (i2dest) < FIRST_PSEUDO_REGISTER)
3323                 ni2dest = gen_rtx_REG (new_mode, REGNO (i2dest));
3324               else
3325                 {
3326                   SUBST_MODE (regno_reg_rtx[REGNO (i2dest)], new_mode);
3327                   ni2dest = regno_reg_rtx[REGNO (i2dest)];
3328                 }
3329
3330               parallel = (gen_rtx_PARALLEL
3331                           (VOIDmode,
3332                            gen_rtvec (2, newpat,
3333                                       gen_rtx_CLOBBER (VOIDmode,
3334                                                        ni2dest))));
3335               m_split = combine_split_insns (parallel, i3);
3336
3337               if (m_split == 0
3338                   && REGNO (i2dest) >= FIRST_PSEUDO_REGISTER)
3339                 {
3340                   struct undo *buf;
3341
3342                   adjust_reg_mode (regno_reg_rtx[REGNO (i2dest)], old_mode);
3343                   buf = undobuf.undos;
3344                   undobuf.undos = buf->next;
3345                   buf->next = undobuf.frees;
3346                   undobuf.frees = buf;
3347                 }
3348             }
3349
3350           i2scratch = m_split != 0;
3351         }
3352
3353       /* If recog_for_combine has discarded clobbers, try to use them
3354          again for the split.  */
3355       if (m_split == 0 && newpat_vec_with_clobbers)
3356         {
3357           parallel = gen_rtx_PARALLEL (VOIDmode, newpat_vec_with_clobbers);
3358           m_split = combine_split_insns (parallel, i3);
3359         }
3360
3361       if (m_split && NEXT_INSN (m_split) == NULL_RTX)
3362         {
3363           m_split = PATTERN (m_split);
3364           insn_code_number = recog_for_combine (&m_split, i3, &new_i3_notes);
3365           if (insn_code_number >= 0)
3366             newpat = m_split;
3367         }
3368       else if (m_split && NEXT_INSN (NEXT_INSN (m_split)) == NULL_RTX
3369                && (next_real_insn (i2) == i3
3370                    || ! use_crosses_set_p (PATTERN (m_split), DF_INSN_LUID (i2))))
3371         {
3372           rtx i2set, i3set;
3373           rtx newi3pat = PATTERN (NEXT_INSN (m_split));
3374           newi2pat = PATTERN (m_split);
3375
3376           i3set = single_set (NEXT_INSN (m_split));
3377           i2set = single_set (m_split);
3378
3379           i2_code_number = recog_for_combine (&newi2pat, i2, &new_i2_notes);
3380
3381           /* If I2 or I3 has multiple SETs, we won't know how to track
3382              register status, so don't use these insns.  If I2's destination
3383              is used between I2 and I3, we also can't use these insns.  */
3384
3385           if (i2_code_number >= 0 && i2set && i3set
3386               && (next_real_insn (i2) == i3
3387                   || ! reg_used_between_p (SET_DEST (i2set), i2, i3)))
3388             insn_code_number = recog_for_combine (&newi3pat, i3,
3389                                                   &new_i3_notes);
3390           if (insn_code_number >= 0)
3391             newpat = newi3pat;
3392
3393           /* It is possible that both insns now set the destination of I3.
3394              If so, we must show an extra use of it.  */
3395
3396           if (insn_code_number >= 0)
3397             {
3398               rtx new_i3_dest = SET_DEST (i3set);
3399               rtx new_i2_dest = SET_DEST (i2set);
3400
3401               while (GET_CODE (new_i3_dest) == ZERO_EXTRACT
3402                      || GET_CODE (new_i3_dest) == STRICT_LOW_PART
3403                      || GET_CODE (new_i3_dest) == SUBREG)
3404                 new_i3_dest = XEXP (new_i3_dest, 0);
3405
3406               while (GET_CODE (new_i2_dest) == ZERO_EXTRACT
3407                      || GET_CODE (new_i2_dest) == STRICT_LOW_PART
3408                      || GET_CODE (new_i2_dest) == SUBREG)
3409                 new_i2_dest = XEXP (new_i2_dest, 0);
3410
3411               if (REG_P (new_i3_dest)
3412                   && REG_P (new_i2_dest)
3413                   && REGNO (new_i3_dest) == REGNO (new_i2_dest))
3414                 INC_REG_N_SETS (REGNO (new_i2_dest), 1);
3415             }
3416         }
3417
3418       /* If we can split it and use I2DEST, go ahead and see if that
3419          helps things be recognized.  Verify that none of the registers
3420          are set between I2 and I3.  */
3421       if (insn_code_number < 0
3422           && (split = find_split_point (&newpat, i3, false)) != 0
3423 #ifdef HAVE_cc0
3424           && REG_P (i2dest)
3425 #endif
3426           /* We need I2DEST in the proper mode.  If it is a hard register
3427              or the only use of a pseudo, we can change its mode.
3428              Make sure we don't change a hard register to have a mode that
3429              isn't valid for it, or change the number of registers.  */
3430           && (GET_MODE (*split) == GET_MODE (i2dest)
3431               || GET_MODE (*split) == VOIDmode
3432               || can_change_dest_mode (i2dest, added_sets_2,
3433                                        GET_MODE (*split)))
3434           && (next_real_insn (i2) == i3
3435               || ! use_crosses_set_p (*split, DF_INSN_LUID (i2)))
3436           /* We can't overwrite I2DEST if its value is still used by
3437              NEWPAT.  */
3438           && ! reg_referenced_p (i2dest, newpat))
3439         {
3440           rtx newdest = i2dest;
3441           enum rtx_code split_code = GET_CODE (*split);
3442           enum machine_mode split_mode = GET_MODE (*split);
3443           bool subst_done = false;
3444           newi2pat = NULL_RTX;
3445
3446           i2scratch = true;
3447
3448           /* *SPLIT may be part of I2SRC, so make sure we have the
3449              original expression around for later debug processing.
3450              We should not need I2SRC any more in other cases.  */
3451           if (MAY_HAVE_DEBUG_INSNS)
3452             i2src = copy_rtx (i2src);
3453           else
3454             i2src = NULL;
3455
3456           /* Get NEWDEST as a register in the proper mode.  We have already
3457              validated that we can do this.  */
3458           if (GET_MODE (i2dest) != split_mode && split_mode != VOIDmode)
3459             {
3460               if (REGNO (i2dest) < FIRST_PSEUDO_REGISTER)
3461                 newdest = gen_rtx_REG (split_mode, REGNO (i2dest));
3462               else
3463                 {
3464                   SUBST_MODE (regno_reg_rtx[REGNO (i2dest)], split_mode);
3465                   newdest = regno_reg_rtx[REGNO (i2dest)];
3466                 }
3467             }
3468
3469           /* If *SPLIT is a (mult FOO (const_int pow2)), convert it to
3470              an ASHIFT.  This can occur if it was inside a PLUS and hence
3471              appeared to be a memory address.  This is a kludge.  */
3472           if (split_code == MULT
3473               && CONST_INT_P (XEXP (*split, 1))
3474               && INTVAL (XEXP (*split, 1)) > 0
3475               && (i = exact_log2 (INTVAL (XEXP (*split, 1)))) >= 0)
3476             {
3477               SUBST (*split, gen_rtx_ASHIFT (split_mode,
3478                                              XEXP (*split, 0), GEN_INT (i)));
3479               /* Update split_code because we may not have a multiply
3480                  anymore.  */
3481               split_code = GET_CODE (*split);
3482             }
3483
3484 #ifdef INSN_SCHEDULING
3485           /* If *SPLIT is a paradoxical SUBREG, when we split it, it should
3486              be written as a ZERO_EXTEND.  */
3487           if (split_code == SUBREG && MEM_P (SUBREG_REG (*split)))
3488             {
3489 #ifdef LOAD_EXTEND_OP
3490               /* Or as a SIGN_EXTEND if LOAD_EXTEND_OP says that that's
3491                  what it really is.  */
3492               if (LOAD_EXTEND_OP (GET_MODE (SUBREG_REG (*split)))
3493                   == SIGN_EXTEND)
3494                 SUBST (*split, gen_rtx_SIGN_EXTEND (split_mode,
3495                                                     SUBREG_REG (*split)));
3496               else
3497 #endif
3498                 SUBST (*split, gen_rtx_ZERO_EXTEND (split_mode,
3499                                                     SUBREG_REG (*split)));
3500             }
3501 #endif
3502
3503           /* Attempt to split binary operators using arithmetic identities.  */
3504           if (BINARY_P (SET_SRC (newpat))
3505               && split_mode == GET_MODE (SET_SRC (newpat))
3506               && ! side_effects_p (SET_SRC (newpat)))
3507             {
3508               rtx setsrc = SET_SRC (newpat);
3509               enum machine_mode mode = GET_MODE (setsrc);
3510               enum rtx_code code = GET_CODE (setsrc);
3511               rtx src_op0 = XEXP (setsrc, 0);
3512               rtx src_op1 = XEXP (setsrc, 1);
3513
3514               /* Split "X = Y op Y" as "Z = Y; X = Z op Z".  */
3515               if (rtx_equal_p (src_op0, src_op1))
3516                 {
3517                   newi2pat = gen_rtx_SET (VOIDmode, newdest, src_op0);
3518                   SUBST (XEXP (setsrc, 0), newdest);
3519                   SUBST (XEXP (setsrc, 1), newdest);
3520                   subst_done = true;
3521                 }
3522               /* Split "((P op Q) op R) op S" where op is PLUS or MULT.  */
3523               else if ((code == PLUS || code == MULT)
3524                        && GET_CODE (src_op0) == code
3525                        && GET_CODE (XEXP (src_op0, 0)) == code
3526                        && (INTEGRAL_MODE_P (mode)
3527                            || (FLOAT_MODE_P (mode)
3528                                && flag_unsafe_math_optimizations)))
3529                 {
3530                   rtx p = XEXP (XEXP (src_op0, 0), 0);
3531                   rtx q = XEXP (XEXP (src_op0, 0), 1);
3532                   rtx r = XEXP (src_op0, 1);
3533                   rtx s = src_op1;
3534
3535                   /* Split both "((X op Y) op X) op Y" and
3536                      "((X op Y) op Y) op X" as "T op T" where T is
3537                      "X op Y".  */
3538                   if ((rtx_equal_p (p,r) && rtx_equal_p (q,s))
3539                        || (rtx_equal_p (p,s) && rtx_equal_p (q,r)))
3540                     {
3541                       newi2pat = gen_rtx_SET (VOIDmode, newdest,
3542                                               XEXP (src_op0, 0));
3543                       SUBST (XEXP (setsrc, 0), newdest);
3544                       SUBST (XEXP (setsrc, 1), newdest);
3545                       subst_done = true;
3546                     }
3547                   /* Split "((X op X) op Y) op Y)" as "T op T" where
3548                      T is "X op Y".  */
3549                   else if (rtx_equal_p (p,q) && rtx_equal_p (r,s))
3550                     {
3551                       rtx tmp = simplify_gen_binary (code, mode, p, r);
3552                       newi2pat = gen_rtx_SET (VOIDmode, newdest, tmp);
3553                       SUBST (XEXP (setsrc, 0), newdest);
3554                       SUBST (XEXP (setsrc, 1), newdest);
3555                       subst_done = true;
3556                     }
3557                 }
3558             }
3559
3560           if (!subst_done)
3561             {
3562               newi2pat = gen_rtx_SET (VOIDmode, newdest, *split);
3563               SUBST (*split, newdest);
3564             }
3565
3566           i2_code_number = recog_for_combine (&newi2pat, i2, &new_i2_notes);
3567
3568           /* recog_for_combine might have added CLOBBERs to newi2pat.
3569              Make sure NEWPAT does not depend on the clobbered regs.  */
3570           if (GET_CODE (newi2pat) == PARALLEL)
3571             for (i = XVECLEN (newi2pat, 0) - 1; i >= 0; i--)
3572               if (GET_CODE (XVECEXP (newi2pat, 0, i)) == CLOBBER)
3573                 {
3574                   rtx reg = XEXP (XVECEXP (newi2pat, 0, i), 0);
3575                   if (reg_overlap_mentioned_p (reg, newpat))
3576                     {
3577                       undo_all ();
3578                       return 0;
3579                     }
3580                 }
3581
3582           /* If the split point was a MULT and we didn't have one before,
3583              don't use one now.  */
3584           if (i2_code_number >= 0 && ! (split_code == MULT && ! have_mult))
3585             insn_code_number = recog_for_combine (&newpat, i3, &new_i3_notes);
3586         }
3587     }
3588
3589   /* Check for a case where we loaded from memory in a narrow mode and
3590      then sign extended it, but we need both registers.  In that case,
3591      we have a PARALLEL with both loads from the same memory location.
3592      We can split this into a load from memory followed by a register-register
3593      copy.  This saves at least one insn, more if register allocation can
3594      eliminate the copy.
3595
3596      We cannot do this if the destination of the first assignment is a
3597      condition code register or cc0.  We eliminate this case by making sure
3598      the SET_DEST and SET_SRC have the same mode.
3599
3600      We cannot do this if the destination of the second assignment is
3601      a register that we have already assumed is zero-extended.  Similarly
3602      for a SUBREG of such a register.  */
3603
3604   else if (i1 && insn_code_number < 0 && asm_noperands (newpat) < 0
3605            && GET_CODE (newpat) == PARALLEL
3606            && XVECLEN (newpat, 0) == 2
3607            && GET_CODE (XVECEXP (newpat, 0, 0)) == SET
3608            && GET_CODE (SET_SRC (XVECEXP (newpat, 0, 0))) == SIGN_EXTEND
3609            && (GET_MODE (SET_DEST (XVECEXP (newpat, 0, 0)))
3610                == GET_MODE (SET_SRC (XVECEXP (newpat, 0, 0))))
3611            && GET_CODE (XVECEXP (newpat, 0, 1)) == SET
3612            && rtx_equal_p (SET_SRC (XVECEXP (newpat, 0, 1)),
3613                            XEXP (SET_SRC (XVECEXP (newpat, 0, 0)), 0))
3614            && ! use_crosses_set_p (SET_SRC (XVECEXP (newpat, 0, 1)),
3615                                    DF_INSN_LUID (i2))
3616            && GET_CODE (SET_DEST (XVECEXP (newpat, 0, 1))) != ZERO_EXTRACT
3617            && GET_CODE (SET_DEST (XVECEXP (newpat, 0, 1))) != STRICT_LOW_PART
3618            && ! (temp = SET_DEST (XVECEXP (newpat, 0, 1)),
3619                  (REG_P (temp)
3620                   && VEC_index (reg_stat_type, reg_stat,
3621                                 REGNO (temp))->nonzero_bits != 0
3622                   && GET_MODE_BITSIZE (GET_MODE (temp)) < BITS_PER_WORD
3623                   && GET_MODE_BITSIZE (GET_MODE (temp)) < HOST_BITS_PER_INT
3624                   && (VEC_index (reg_stat_type, reg_stat,
3625                                  REGNO (temp))->nonzero_bits
3626                       != GET_MODE_MASK (word_mode))))
3627            && ! (GET_CODE (SET_DEST (XVECEXP (newpat, 0, 1))) == SUBREG
3628                  && (temp = SUBREG_REG (SET_DEST (XVECEXP (newpat, 0, 1))),
3629                      (REG_P (temp)
3630                       && VEC_index (reg_stat_type, reg_stat,
3631                                     REGNO (temp))->nonzero_bits != 0
3632                       && GET_MODE_BITSIZE (GET_MODE (temp)) < BITS_PER_WORD
3633                       && GET_MODE_BITSIZE (GET_MODE (temp)) < HOST_BITS_PER_INT
3634                       && (VEC_index (reg_stat_type, reg_stat,
3635                                      REGNO (temp))->nonzero_bits
3636                           != GET_MODE_MASK (word_mode)))))
3637            && ! reg_overlap_mentioned_p (SET_DEST (XVECEXP (newpat, 0, 1)),
3638                                          SET_SRC (XVECEXP (newpat, 0, 1)))
3639            && ! find_reg_note (i3, REG_UNUSED,
3640                                SET_DEST (XVECEXP (newpat, 0, 0))))
3641     {
3642       rtx ni2dest;
3643
3644       newi2pat = XVECEXP (newpat, 0, 0);
3645       ni2dest = SET_DEST (XVECEXP (newpat, 0, 0));
3646       newpat = XVECEXP (newpat, 0, 1);
3647       SUBST (SET_SRC (newpat),
3648              gen_lowpart (GET_MODE (SET_SRC (newpat)), ni2dest));
3649       i2_code_number = recog_for_combine (&newi2pat, i2, &new_i2_notes);
3650
3651       if (i2_code_number >= 0)
3652         insn_code_number = recog_for_combine (&newpat, i3, &new_i3_notes);
3653
3654       if (insn_code_number >= 0)
3655         swap_i2i3 = 1;
3656     }
3657
3658   /* Similarly, check for a case where we have a PARALLEL of two independent
3659      SETs but we started with three insns.  In this case, we can do the sets
3660      as two separate insns.  This case occurs when some SET allows two
3661      other insns to combine, but the destination of that SET is still live.  */
3662
3663   else if (i1 && insn_code_number < 0 && asm_noperands (newpat) < 0
3664            && GET_CODE (newpat) == PARALLEL
3665            && XVECLEN (newpat, 0) == 2
3666            && GET_CODE (XVECEXP (newpat, 0, 0)) == SET
3667            && GET_CODE (SET_DEST (XVECEXP (newpat, 0, 0))) != ZERO_EXTRACT
3668            && GET_CODE (SET_DEST (XVECEXP (newpat, 0, 0))) != STRICT_LOW_PART
3669            && GET_CODE (XVECEXP (newpat, 0, 1)) == SET
3670            && GET_CODE (SET_DEST (XVECEXP (newpat, 0, 1))) != ZERO_EXTRACT
3671            && GET_CODE (SET_DEST (XVECEXP (newpat, 0, 1))) != STRICT_LOW_PART
3672            && ! reg_referenced_p (SET_DEST (XVECEXP (newpat, 0, 1)),
3673                                   XVECEXP (newpat, 0, 0))
3674            && ! reg_referenced_p (SET_DEST (XVECEXP (newpat, 0, 0)),
3675                                   XVECEXP (newpat, 0, 1))
3676            && ! (contains_muldiv (SET_SRC (XVECEXP (newpat, 0, 0)))
3677                  && contains_muldiv (SET_SRC (XVECEXP (newpat, 0, 1)))))
3678     {
3679       /* Normally, it doesn't matter which of the two is done first,
3680          but the one that references cc0 can't be the second, and
3681          one which uses any regs/memory set in between i2 and i3 can't
3682          be first.  */
3683       if (!use_crosses_set_p (SET_SRC (XVECEXP (newpat, 0, 1)),
3684                               DF_INSN_LUID (i2))
3685 #ifdef HAVE_cc0
3686           && !reg_referenced_p (cc0_rtx, XVECEXP (newpat, 0, 0))
3687 #endif
3688          )
3689         {
3690           newi2pat = XVECEXP (newpat, 0, 1);
3691           newpat = XVECEXP (newpat, 0, 0);
3692         }
3693       else if (!use_crosses_set_p (SET_SRC (XVECEXP (newpat, 0, 0)),
3694                                    DF_INSN_LUID (i2))
3695 #ifdef HAVE_cc0
3696                && !reg_referenced_p (cc0_rtx, XVECEXP (newpat, 0, 1))
3697 #endif
3698               )
3699         {
3700           newi2pat = XVECEXP (newpat, 0, 0);
3701           newpat = XVECEXP (newpat, 0, 1);
3702         }
3703       else
3704         {
3705           undo_all ();
3706           return 0;
3707         }
3708
3709       i2_code_number = recog_for_combine (&newi2pat, i2, &new_i2_notes);
3710
3711       if (i2_code_number >= 0)
3712         {
3713           /* recog_for_combine might have added CLOBBERs to newi2pat.
3714              Make sure NEWPAT does not depend on the clobbered regs.  */
3715           if (GET_CODE (newi2pat) == PARALLEL)
3716             {
3717               for (i = XVECLEN (newi2pat, 0) - 1; i >= 0; i--)
3718                 if (GET_CODE (XVECEXP (newi2pat, 0, i)) == CLOBBER)
3719                   {
3720                     rtx reg = XEXP (XVECEXP (newi2pat, 0, i), 0);
3721                     if (reg_overlap_mentioned_p (reg, newpat))
3722                       {
3723                         undo_all ();
3724                         return 0;
3725                       }
3726                   }
3727             }
3728
3729           insn_code_number = recog_for_combine (&newpat, i3, &new_i3_notes);
3730         }
3731     }
3732
3733   /* If it still isn't recognized, fail and change things back the way they
3734      were.  */
3735   if ((insn_code_number < 0
3736        /* Is the result a reasonable ASM_OPERANDS?  */
3737        && (! check_asm_operands (newpat) || added_sets_1 || added_sets_2)))
3738     {
3739       undo_all ();
3740       return 0;
3741     }
3742
3743   /* If we had to change another insn, make sure it is valid also.  */
3744   if (undobuf.other_insn)
3745     {
3746       CLEAR_HARD_REG_SET (newpat_used_regs);
3747
3748       other_pat = PATTERN (undobuf.other_insn);
3749       other_code_number = recog_for_combine (&other_pat, undobuf.other_insn,
3750                                              &new_other_notes);
3751
3752       if (other_code_number < 0 && ! check_asm_operands (other_pat))
3753         {
3754           undo_all ();
3755           return 0;
3756         }
3757     }
3758
3759 #ifdef HAVE_cc0
3760   /* If I2 is the CC0 setter and I3 is the CC0 user then check whether
3761      they are adjacent to each other or not.  */
3762   {
3763     rtx p = prev_nonnote_insn (i3);
3764     if (p && p != i2 && NONJUMP_INSN_P (p) && newi2pat
3765         && sets_cc0_p (newi2pat))
3766       {
3767         undo_all ();
3768         return 0;
3769       }
3770   }
3771 #endif
3772
3773   /* Only allow this combination if insn_rtx_costs reports that the
3774      replacement instructions are cheaper than the originals.  */
3775   if (!combine_validate_cost (i0, i1, i2, i3, newpat, newi2pat, other_pat))
3776     {
3777       undo_all ();
3778       return 0;
3779     }
3780
3781   if (MAY_HAVE_DEBUG_INSNS)
3782     {
3783       struct undo *undo;
3784
3785       for (undo = undobuf.undos; undo; undo = undo->next)
3786         if (undo->kind == UNDO_MODE)
3787           {
3788             rtx reg = *undo->where.r;
3789             enum machine_mode new_mode = GET_MODE (reg);
3790             enum machine_mode old_mode = undo->old_contents.m;
3791
3792             /* Temporarily revert mode back.  */
3793             adjust_reg_mode (reg, old_mode);
3794
3795             if (reg == i2dest && i2scratch)
3796               {
3797                 /* If we used i2dest as a scratch register with a
3798                    different mode, substitute it for the original
3799                    i2src while its original mode is temporarily
3800                    restored, and then clear i2scratch so that we don't
3801                    do it again later.  */
3802                 propagate_for_debug (i2, i3, reg, i2src);
3803                 i2scratch = false;
3804                 /* Put back the new mode.  */
3805                 adjust_reg_mode (reg, new_mode);
3806               }
3807             else
3808               {
3809                 rtx tempreg = gen_raw_REG (old_mode, REGNO (reg));
3810                 rtx first, last;
3811
3812                 if (reg == i2dest)
3813                   {
3814                     first = i2;
3815                     last = i3;
3816                   }
3817                 else
3818                   {
3819                     first = i3;
3820                     last = undobuf.other_insn;
3821                     gcc_assert (last);
3822                   }
3823
3824                 /* We're dealing with a reg that changed mode but not
3825                    meaning, so we want to turn it into a subreg for
3826                    the new mode.  However, because of REG sharing and
3827                    because its mode had already changed, we have to do
3828                    it in two steps.  First, replace any debug uses of
3829                    reg, with its original mode temporarily restored,
3830                    with this copy we have created; then, replace the
3831                    copy with the SUBREG of the original shared reg,
3832                    once again changed to the new mode.  */
3833                 propagate_for_debug (first, last, reg, tempreg);
3834                 adjust_reg_mode (reg, new_mode);
3835                 propagate_for_debug (first, last, tempreg,
3836                                      lowpart_subreg (old_mode, reg, new_mode));
3837               }
3838           }
3839     }
3840
3841   /* If we will be able to accept this, we have made a
3842      change to the destination of I3.  This requires us to
3843      do a few adjustments.  */
3844
3845   if (changed_i3_dest)
3846     {
3847       PATTERN (i3) = newpat;
3848       adjust_for_new_dest (i3);
3849     }
3850
3851   /* We now know that we can do this combination.  Merge the insns and
3852      update the status of registers and LOG_LINKS.  */
3853
3854   if (undobuf.other_insn)
3855     {
3856       rtx note, next;
3857
3858       PATTERN (undobuf.other_insn) = other_pat;
3859
3860       /* If any of the notes in OTHER_INSN were REG_UNUSED, ensure that they
3861          are still valid.  Then add any non-duplicate notes added by
3862          recog_for_combine.  */
3863       for (note = REG_NOTES (undobuf.other_insn); note; note = next)
3864         {
3865           next = XEXP (note, 1);
3866
3867           if (REG_NOTE_KIND (note) == REG_UNUSED
3868               && ! reg_set_p (XEXP (note, 0), PATTERN (undobuf.other_insn)))
3869             remove_note (undobuf.other_insn, note);
3870         }
3871
3872       distribute_notes (new_other_notes, undobuf.other_insn,
3873                         undobuf.other_insn, NULL_RTX, NULL_RTX, NULL_RTX,
3874                         NULL_RTX);
3875     }
3876
3877   if (swap_i2i3)
3878     {
3879       rtx insn;
3880       rtx link;
3881       rtx ni2dest;
3882
3883       /* I3 now uses what used to be its destination and which is now
3884          I2's destination.  This requires us to do a few adjustments.  */
3885       PATTERN (i3) = newpat;
3886       adjust_for_new_dest (i3);
3887
3888       /* We need a LOG_LINK from I3 to I2.  But we used to have one,
3889          so we still will.
3890
3891          However, some later insn might be using I2's dest and have
3892          a LOG_LINK pointing at I3.  We must remove this link.
3893          The simplest way to remove the link is to point it at I1,
3894          which we know will be a NOTE.  */
3895
3896       /* newi2pat is usually a SET here; however, recog_for_combine might
3897          have added some clobbers.  */
3898       if (GET_CODE (newi2pat) == PARALLEL)
3899         ni2dest = SET_DEST (XVECEXP (newi2pat, 0, 0));
3900       else
3901         ni2dest = SET_DEST (newi2pat);
3902
3903       for (insn = NEXT_INSN (i3);
3904            insn && (this_basic_block->next_bb == EXIT_BLOCK_PTR
3905                     || insn != BB_HEAD (this_basic_block->next_bb));
3906            insn = NEXT_INSN (insn))
3907         {
3908           if (INSN_P (insn) && reg_referenced_p (ni2dest, PATTERN (insn)))
3909             {
3910               for (link = LOG_LINKS (insn); link;
3911                    link = XEXP (link, 1))
3912                 if (XEXP (link, 0) == i3)
3913                   XEXP (link, 0) = i1;
3914
3915               break;
3916             }
3917         }
3918     }
3919
3920   {
3921     rtx i3notes, i2notes, i1notes = 0, i0notes = 0;
3922     rtx i3links, i2links, i1links = 0, i0links = 0;
3923     rtx midnotes = 0;
3924     int from_luid;
3925     unsigned int regno;
3926     /* Compute which registers we expect to eliminate.  newi2pat may be setting
3927        either i3dest or i2dest, so we must check it.  Also, i1dest may be the
3928        same as i3dest, in which case newi2pat may be setting i1dest.  */
3929     rtx elim_i2 = ((newi2pat && reg_set_p (i2dest, newi2pat))
3930                    || i2dest_in_i2src || i2dest_in_i1src || i2dest_in_i0src
3931                    || !i2dest_killed
3932                    ? 0 : i2dest);
3933     rtx elim_i1 = (i1 == 0 || i1dest_in_i1src || i1dest_in_i0src
3934                    || (newi2pat && reg_set_p (i1dest, newi2pat))
3935                    || !i1dest_killed
3936                    ? 0 : i1dest);
3937     rtx elim_i0 = (i0 == 0 || i0dest_in_i0src
3938                    || (newi2pat && reg_set_p (i0dest, newi2pat))
3939                    || !i0dest_killed
3940                    ? 0 : i0dest);
3941
3942     /* Get the old REG_NOTES and LOG_LINKS from all our insns and
3943        clear them.  */
3944     i3notes = REG_NOTES (i3), i3links = LOG_LINKS (i3);
3945     i2notes = REG_NOTES (i2), i2links = LOG_LINKS (i2);
3946     if (i1)
3947       i1notes = REG_NOTES (i1), i1links = LOG_LINKS (i1);
3948     if (i0)
3949       i0notes = REG_NOTES (i0), i0links = LOG_LINKS (i0);
3950
3951     /* Ensure that we do not have something that should not be shared but
3952        occurs multiple times in the new insns.  Check this by first
3953        resetting all the `used' flags and then copying anything is shared.  */
3954
3955     reset_used_flags (i3notes);
3956     reset_used_flags (i2notes);
3957     reset_used_flags (i1notes);
3958     reset_used_flags (i0notes);
3959     reset_used_flags (newpat);
3960     reset_used_flags (newi2pat);
3961     if (undobuf.other_insn)
3962       reset_used_flags (PATTERN (undobuf.other_insn));
3963
3964     i3notes = copy_rtx_if_shared (i3notes);
3965     i2notes = copy_rtx_if_shared (i2notes);
3966     i1notes = copy_rtx_if_shared (i1notes);
3967     i0notes = copy_rtx_if_shared (i0notes);
3968     newpat = copy_rtx_if_shared (newpat);
3969     newi2pat = copy_rtx_if_shared (newi2pat);
3970     if (undobuf.other_insn)
3971       reset_used_flags (PATTERN (undobuf.other_insn));
3972
3973     INSN_CODE (i3) = insn_code_number;
3974     PATTERN (i3) = newpat;
3975
3976     if (CALL_P (i3) && CALL_INSN_FUNCTION_USAGE (i3))
3977       {
3978         rtx call_usage = CALL_INSN_FUNCTION_USAGE (i3);
3979
3980         reset_used_flags (call_usage);
3981         call_usage = copy_rtx (call_usage);
3982
3983         if (substed_i2)
3984           {
3985             /* I2SRC must still be meaningful at this point.  Some splitting
3986                operations can invalidate I2SRC, but those operations do not
3987                apply to calls.  */
3988             gcc_assert (i2src);
3989             replace_rtx (call_usage, i2dest, i2src);
3990           }
3991
3992         if (substed_i1)
3993           replace_rtx (call_usage, i1dest, i1src);
3994         if (substed_i0)
3995           replace_rtx (call_usage, i0dest, i0src);
3996
3997         CALL_INSN_FUNCTION_USAGE (i3) = call_usage;
3998       }
3999
4000     if (undobuf.other_insn)
4001       INSN_CODE (undobuf.other_insn) = other_code_number;
4002
4003     /* We had one special case above where I2 had more than one set and
4004        we replaced a destination of one of those sets with the destination
4005        of I3.  In that case, we have to update LOG_LINKS of insns later
4006        in this basic block.  Note that this (expensive) case is rare.
4007
4008        Also, in this case, we must pretend that all REG_NOTEs for I2
4009        actually came from I3, so that REG_UNUSED notes from I2 will be
4010        properly handled.  */
4011
4012     if (i3_subst_into_i2)
4013       {
4014         for (i = 0; i < XVECLEN (PATTERN (i2), 0); i++)
4015           if ((GET_CODE (XVECEXP (PATTERN (i2), 0, i)) == SET
4016                || GET_CODE (XVECEXP (PATTERN (i2), 0, i)) == CLOBBER)
4017               && REG_P (SET_DEST (XVECEXP (PATTERN (i2), 0, i)))
4018               && SET_DEST (XVECEXP (PATTERN (i2), 0, i)) != i2dest
4019               && ! find_reg_note (i2, REG_UNUSED,
4020                                   SET_DEST (XVECEXP (PATTERN (i2), 0, i))))
4021             for (temp = NEXT_INSN (i2);
4022                  temp && (this_basic_block->next_bb == EXIT_BLOCK_PTR
4023                           || BB_HEAD (this_basic_block) != temp);
4024                  temp = NEXT_INSN (temp))
4025               if (temp != i3 && INSN_P (temp))
4026                 for (link = LOG_LINKS (temp); link; link = XEXP (link, 1))
4027                   if (XEXP (link, 0) == i2)
4028                     XEXP (link, 0) = i3;
4029
4030         if (i3notes)
4031           {
4032             rtx link = i3notes;
4033             while (XEXP (link, 1))
4034               link = XEXP (link, 1);
4035             XEXP (link, 1) = i2notes;
4036           }
4037         else
4038           i3notes = i2notes;
4039         i2notes = 0;
4040       }
4041
4042     LOG_LINKS (i3) = 0;
4043     REG_NOTES (i3) = 0;
4044     LOG_LINKS (i2) = 0;
4045     REG_NOTES (i2) = 0;
4046
4047     if (newi2pat)
4048       {
4049         if (MAY_HAVE_DEBUG_INSNS && i2scratch)
4050           propagate_for_debug (i2, i3, i2dest, i2src);
4051         INSN_CODE (i2) = i2_code_number;
4052         PATTERN (i2) = newi2pat;
4053       }
4054     else
4055       {
4056         if (MAY_HAVE_DEBUG_INSNS && i2src)
4057           propagate_for_debug (i2, i3, i2dest, i2src);
4058         SET_INSN_DELETED (i2);
4059       }
4060
4061     if (i1)
4062       {
4063         LOG_LINKS (i1) = 0;
4064         REG_NOTES (i1) = 0;
4065         if (MAY_HAVE_DEBUG_INSNS)
4066           propagate_for_debug (i1, i3, i1dest, i1src);
4067         SET_INSN_DELETED (i1);
4068       }
4069
4070     if (i0)
4071       {
4072         LOG_LINKS (i0) = 0;
4073         REG_NOTES (i0) = 0;
4074         if (MAY_HAVE_DEBUG_INSNS)
4075           propagate_for_debug (i0, i3, i0dest, i0src);
4076         SET_INSN_DELETED (i0);
4077       }
4078
4079     /* Get death notes for everything that is now used in either I3 or
4080        I2 and used to die in a previous insn.  If we built two new
4081        patterns, move from I1 to I2 then I2 to I3 so that we get the
4082        proper movement on registers that I2 modifies.  */
4083
4084     if (i0)
4085       from_luid = DF_INSN_LUID (i0);
4086     else if (i1)
4087       from_luid = DF_INSN_LUID (i1);
4088     else
4089       from_luid = DF_INSN_LUID (i2);
4090     if (newi2pat)
4091       move_deaths (newi2pat, NULL_RTX, from_luid, i2, &midnotes);
4092     move_deaths (newpat, newi2pat, from_luid, i3, &midnotes);
4093
4094     /* Distribute all the LOG_LINKS and REG_NOTES from I1, I2, and I3.  */
4095     if (i3notes)
4096       distribute_notes (i3notes, i3, i3, newi2pat ? i2 : NULL_RTX,
4097                         elim_i2, elim_i1, elim_i0);
4098     if (i2notes)
4099       distribute_notes (i2notes, i2, i3, newi2pat ? i2 : NULL_RTX,
4100                         elim_i2, elim_i1, elim_i0);
4101     if (i1notes)
4102       distribute_notes (i1notes, i1, i3, newi2pat ? i2 : NULL_RTX,
4103                         elim_i2, elim_i1, elim_i0);
4104     if (i0notes)
4105       distribute_notes (i0notes, i0, i3, newi2pat ? i2 : NULL_RTX,
4106                         elim_i2, elim_i1, elim_i0);
4107     if (midnotes)
4108       distribute_notes (midnotes, NULL_RTX, i3, newi2pat ? i2 : NULL_RTX,
4109                         elim_i2, elim_i1, elim_i0);
4110
4111     /* Distribute any notes added to I2 or I3 by recog_for_combine.  We
4112        know these are REG_UNUSED and want them to go to the desired insn,
4113        so we always pass it as i3.  */
4114
4115     if (newi2pat && new_i2_notes)
4116       distribute_notes (new_i2_notes, i2, i2, NULL_RTX, NULL_RTX, NULL_RTX,
4117                         NULL_RTX);
4118
4119     if (new_i3_notes)
4120       distribute_notes (new_i3_notes, i3, i3, NULL_RTX, NULL_RTX, NULL_RTX,
4121                         NULL_RTX);
4122
4123     /* If I3DEST was used in I3SRC, it really died in I3.  We may need to
4124        put a REG_DEAD note for it somewhere.  If NEWI2PAT exists and sets
4125        I3DEST, the death must be somewhere before I2, not I3.  If we passed I3
4126        in that case, it might delete I2.  Similarly for I2 and I1.
4127        Show an additional death due to the REG_DEAD note we make here.  If
4128        we discard it in distribute_notes, we will decrement it again.  */
4129
4130     if (i3dest_killed)
4131       {
4132         if (newi2pat && reg_set_p (i3dest_killed, newi2pat))
4133           distribute_notes (alloc_reg_note (REG_DEAD, i3dest_killed,
4134                                             NULL_RTX),
4135                             NULL_RTX, i2, NULL_RTX, elim_i2, elim_i1, elim_i0);
4136         else
4137           distribute_notes (alloc_reg_note (REG_DEAD, i3dest_killed,
4138                                             NULL_RTX),
4139                             NULL_RTX, i3, newi2pat ? i2 : NULL_RTX,
4140                             elim_i2, elim_i1, elim_i0);
4141       }
4142
4143     if (i2dest_in_i2src)
4144       {
4145         rtx new_note = alloc_reg_note (REG_DEAD, i2dest, NULL_RTX);
4146         if (newi2pat && reg_set_p (i2dest, newi2pat))
4147           distribute_notes (new_note,  NULL_RTX, i2, NULL_RTX, NULL_RTX,
4148                             NULL_RTX, NULL_RTX);
4149         else
4150           distribute_notes (new_note, NULL_RTX, i3, newi2pat ? i2 : NULL_RTX,
4151                             NULL_RTX, NULL_RTX, NULL_RTX);
4152       }
4153
4154     if (i1dest_in_i1src)
4155       {
4156         rtx new_note = alloc_reg_note (REG_DEAD, i1dest, NULL_RTX);
4157         if (newi2pat && reg_set_p (i1dest, newi2pat))
4158           distribute_notes (new_note, NULL_RTX, i2, NULL_RTX, NULL_RTX,
4159                             NULL_RTX, NULL_RTX);
4160         else
4161           distribute_notes (new_note, NULL_RTX, i3, newi2pat ? i2 : NULL_RTX,
4162                             NULL_RTX, NULL_RTX, NULL_RTX);
4163       }
4164
4165     if (i0dest_in_i0src)
4166       {
4167         rtx new_note = alloc_reg_note (REG_DEAD, i0dest, NULL_RTX);
4168         if (newi2pat && reg_set_p (i0dest, newi2pat))
4169           distribute_notes (new_note, NULL_RTX, i2, NULL_RTX, NULL_RTX,
4170                             NULL_RTX, NULL_RTX);
4171         else
4172           distribute_notes (new_note, NULL_RTX, i3, newi2pat ? i2 : NULL_RTX,
4173                             NULL_RTX, NULL_RTX, NULL_RTX);
4174       }
4175
4176     distribute_links (i3links);
4177     distribute_links (i2links);
4178     distribute_links (i1links);
4179     distribute_links (i0links);
4180
4181     if (REG_P (i2dest))
4182       {
4183         rtx link;
4184         rtx i2_insn = 0, i2_val = 0, set;
4185
4186         /* The insn that used to set this register doesn't exist, and
4187            this life of the register may not exist either.  See if one of
4188            I3's links points to an insn that sets I2DEST.  If it does,
4189            that is now the last known value for I2DEST. If we don't update
4190            this and I2 set the register to a value that depended on its old
4191            contents, we will get confused.  If this insn is used, thing
4192            will be set correctly in combine_instructions.  */
4193
4194         for (link = LOG_LINKS (i3); link; link = XEXP (link, 1))
4195           if ((set = single_set (XEXP (link, 0))) != 0
4196               && rtx_equal_p (i2dest, SET_DEST (set)))
4197             i2_insn = XEXP (link, 0), i2_val = SET_SRC (set);
4198
4199         record_value_for_reg (i2dest, i2_insn, i2_val);
4200
4201         /* If the reg formerly set in I2 died only once and that was in I3,
4202            zero its use count so it won't make `reload' do any work.  */
4203         if (! added_sets_2
4204             && (newi2pat == 0 || ! reg_mentioned_p (i2dest, newi2pat))
4205             && ! i2dest_in_i2src)
4206           {
4207             regno = REGNO (i2dest);
4208             INC_REG_N_SETS (regno, -1);
4209           }
4210       }
4211
4212     if (i1 && REG_P (i1dest))
4213       {
4214         rtx link;
4215         rtx i1_insn = 0, i1_val = 0, set;
4216
4217         for (link = LOG_LINKS (i3); link; link = XEXP (link, 1))
4218           if ((set = single_set (XEXP (link, 0))) != 0
4219               && rtx_equal_p (i1dest, SET_DEST (set)))
4220             i1_insn = XEXP (link, 0), i1_val = SET_SRC (set);
4221
4222         record_value_for_reg (i1dest, i1_insn, i1_val);
4223
4224         regno = REGNO (i1dest);
4225         if (! added_sets_1 && ! i1dest_in_i1src)
4226           INC_REG_N_SETS (regno, -1);
4227       }
4228
4229     if (i0 && REG_P (i0dest))
4230       {
4231         rtx link;
4232         rtx i0_insn = 0, i0_val = 0, set;
4233
4234         for (link = LOG_LINKS (i3); link; link = XEXP (link, 1))
4235           if ((set = single_set (XEXP (link, 0))) != 0
4236               && rtx_equal_p (i0dest, SET_DEST (set)))
4237             i0_insn = XEXP (link, 0), i0_val = SET_SRC (set);
4238
4239         record_value_for_reg (i0dest, i0_insn, i0_val);
4240
4241         regno = REGNO (i0dest);
4242         if (! added_sets_0 && ! i0dest_in_i0src)
4243           INC_REG_N_SETS (regno, -1);
4244       }
4245
4246     /* Update reg_stat[].nonzero_bits et al for any changes that may have
4247        been made to this insn.  The order of
4248        set_nonzero_bits_and_sign_copies() is important.  Because newi2pat
4249        can affect nonzero_bits of newpat */
4250     if (newi2pat)
4251       note_stores (newi2pat, set_nonzero_bits_and_sign_copies, NULL);
4252     note_stores (newpat, set_nonzero_bits_and_sign_copies, NULL);
4253   }
4254
4255   if (undobuf.other_insn != NULL_RTX)
4256     {
4257       if (dump_file)
4258         {
4259           fprintf (dump_file, "modifying other_insn ");
4260           dump_insn_slim (dump_file, undobuf.other_insn);
4261         }
4262       df_insn_rescan (undobuf.other_insn);
4263     }
4264
4265   if (i0 && !(NOTE_P(i0) && (NOTE_KIND (i0) == NOTE_INSN_DELETED)))
4266     {
4267       if (dump_file)
4268         {
4269           fprintf (dump_file, "modifying insn i1 ");
4270           dump_insn_slim (dump_file, i0);
4271         }
4272       df_insn_rescan (i0);
4273     }
4274
4275   if (i1 && !(NOTE_P(i1) && (NOTE_KIND (i1) == NOTE_INSN_DELETED)))
4276     {
4277       if (dump_file)
4278         {
4279           fprintf (dump_file, "modifying insn i1 ");
4280           dump_insn_slim (dump_file, i1);
4281         }
4282       df_insn_rescan (i1);
4283     }
4284
4285   if (i2 && !(NOTE_P(i2) && (NOTE_KIND (i2) == NOTE_INSN_DELETED)))
4286     {
4287       if (dump_file)
4288         {
4289           fprintf (dump_file, "modifying insn i2 ");
4290           dump_insn_slim (dump_file, i2);
4291         }
4292       df_insn_rescan (i2);
4293     }
4294
4295   if (i3 && !(NOTE_P(i3) && (NOTE_KIND (i3) == NOTE_INSN_DELETED)))
4296     {
4297       if (dump_file)
4298         {
4299           fprintf (dump_file, "modifying insn i3 ");
4300           dump_insn_slim (dump_file, i3);
4301         }
4302       df_insn_rescan (i3);
4303     }
4304
4305   /* Set new_direct_jump_p if a new return or simple jump instruction
4306      has been created.  Adjust the CFG accordingly.  */
4307
4308   if (returnjump_p (i3) || any_uncondjump_p (i3))
4309     {
4310       *new_direct_jump_p = 1;
4311       mark_jump_label (PATTERN (i3), i3, 0);
4312       update_cfg_for_uncondjump (i3);
4313     }
4314
4315   if (undobuf.other_insn != NULL_RTX
4316       && (returnjump_p (undobuf.other_insn)
4317           || any_uncondjump_p (undobuf.other_insn)))
4318     {
4319       *new_direct_jump_p = 1;
4320       update_cfg_for_uncondjump (undobuf.other_insn);
4321     }
4322
4323   /* A noop might also need cleaning up of CFG, if it comes from the
4324      simplification of a jump.  */
4325   if (GET_CODE (newpat) == SET
4326       && SET_SRC (newpat) == pc_rtx
4327       && SET_DEST (newpat) == pc_rtx)
4328     {
4329       *new_direct_jump_p = 1;
4330       update_cfg_for_uncondjump (i3);
4331     }
4332
4333   combine_successes++;
4334   undo_commit ();
4335
4336   if (added_links_insn
4337       && (newi2pat == 0 || DF_INSN_LUID (added_links_insn) < DF_INSN_LUID (i2))
4338       && DF_INSN_LUID (added_links_insn) < DF_INSN_LUID (i3))
4339     return added_links_insn;
4340   else
4341     return newi2pat ? i2 : i3;
4342 }
4343 \f
4344 /* Undo all the modifications recorded in undobuf.  */
4345
4346 static void
4347 undo_all (void)
4348 {
4349   struct undo *undo, *next;
4350
4351   for (undo = undobuf.undos; undo; undo = next)
4352     {
4353       next = undo->next;
4354       switch (undo->kind)
4355         {
4356         case UNDO_RTX:
4357           *undo->where.r = undo->old_contents.r;
4358           break;
4359         case UNDO_INT:
4360           *undo->where.i = undo->old_contents.i;
4361           break;
4362         case UNDO_MODE:
4363           adjust_reg_mode (*undo->where.r, undo->old_contents.m);
4364           break;
4365         default:
4366           gcc_unreachable ();
4367         }
4368
4369       undo->next = undobuf.frees;
4370       undobuf.frees = undo;
4371     }
4372
4373   undobuf.undos = 0;
4374 }
4375
4376 /* We've committed to accepting the changes we made.  Move all
4377    of the undos to the free list.  */
4378
4379 static void
4380 undo_commit (void)
4381 {
4382   struct undo *undo, *next;
4383
4384   for (undo = undobuf.undos; undo; undo = next)
4385     {
4386       next = undo->next;
4387       undo->next = undobuf.frees;
4388       undobuf.frees = undo;
4389     }
4390   undobuf.undos = 0;
4391 }
4392 \f
4393 /* Find the innermost point within the rtx at LOC, possibly LOC itself,
4394    where we have an arithmetic expression and return that point.  LOC will
4395    be inside INSN.
4396
4397    try_combine will call this function to see if an insn can be split into
4398    two insns.  */
4399
4400 static rtx *
4401 find_split_point (rtx *loc, rtx insn, bool set_src)
4402 {
4403   rtx x = *loc;
4404   enum rtx_code code = GET_CODE (x);
4405   rtx *split;
4406   unsigned HOST_WIDE_INT len = 0;
4407   HOST_WIDE_INT pos = 0;
4408   int unsignedp = 0;
4409   rtx inner = NULL_RTX;
4410
4411   /* First special-case some codes.  */
4412   switch (code)
4413     {
4414     case SUBREG:
4415 #ifdef INSN_SCHEDULING
4416       /* If we are making a paradoxical SUBREG invalid, it becomes a split
4417          point.  */
4418       if (MEM_P (SUBREG_REG (x)))
4419         return loc;
4420 #endif
4421       return find_split_point (&SUBREG_REG (x), insn, false);
4422
4423     case MEM:
4424 #ifdef HAVE_lo_sum
4425       /* If we have (mem (const ..)) or (mem (symbol_ref ...)), split it
4426          using LO_SUM and HIGH.  */
4427       if (GET_CODE (XEXP (x, 0)) == CONST
4428           || GET_CODE (XEXP (x, 0)) == SYMBOL_REF)
4429         {
4430           enum machine_mode address_mode
4431             = targetm.addr_space.address_mode (MEM_ADDR_SPACE (x));
4432
4433           SUBST (XEXP (x, 0),
4434                  gen_rtx_LO_SUM (address_mode,
4435                                  gen_rtx_HIGH (address_mode, XEXP (x, 0)),
4436                                  XEXP (x, 0)));
4437           return &XEXP (XEXP (x, 0), 0);
4438         }
4439 #endif
4440
4441       /* If we have a PLUS whose second operand is a constant and the
4442          address is not valid, perhaps will can split it up using
4443          the machine-specific way to split large constants.  We use
4444          the first pseudo-reg (one of the virtual regs) as a placeholder;
4445          it will not remain in the result.  */
4446       if (GET_CODE (XEXP (x, 0)) == PLUS
4447           && CONST_INT_P (XEXP (XEXP (x, 0), 1))
4448           && ! memory_address_addr_space_p (GET_MODE (x), XEXP (x, 0),
4449                                             MEM_ADDR_SPACE (x)))
4450         {
4451           rtx reg = regno_reg_rtx[FIRST_PSEUDO_REGISTER];
4452           rtx seq = combine_split_insns (gen_rtx_SET (VOIDmode, reg,
4453                                                       XEXP (x, 0)),
4454                                          subst_insn);
4455
4456           /* This should have produced two insns, each of which sets our
4457              placeholder.  If the source of the second is a valid address,
4458              we can make put both sources together and make a split point
4459              in the middle.  */
4460
4461           if (seq
4462               && NEXT_INSN (seq) != NULL_RTX
4463               && NEXT_INSN (NEXT_INSN (seq)) == NULL_RTX
4464               && NONJUMP_INSN_P (seq)
4465               && GET_CODE (PATTERN (seq)) == SET
4466               && SET_DEST (PATTERN (seq)) == reg
4467               && ! reg_mentioned_p (reg,
4468                                     SET_SRC (PATTERN (seq)))
4469               && NONJUMP_INSN_P (NEXT_INSN (seq))
4470               && GET_CODE (PATTERN (NEXT_INSN (seq))) == SET
4471               && SET_DEST (PATTERN (NEXT_INSN (seq))) == reg
4472               && memory_address_addr_space_p
4473                    (GET_MODE (x), SET_SRC (PATTERN (NEXT_INSN (seq))),
4474                     MEM_ADDR_SPACE (x)))
4475             {
4476               rtx src1 = SET_SRC (PATTERN (seq));
4477               rtx src2 = SET_SRC (PATTERN (NEXT_INSN (seq)));
4478
4479               /* Replace the placeholder in SRC2 with SRC1.  If we can
4480                  find where in SRC2 it was placed, that can become our
4481                  split point and we can replace this address with SRC2.
4482                  Just try two obvious places.  */
4483
4484               src2 = replace_rtx (src2, reg, src1);
4485               split = 0;
4486               if (XEXP (src2, 0) == src1)
4487                 split = &XEXP (src2, 0);
4488               else if (GET_RTX_FORMAT (GET_CODE (XEXP (src2, 0)))[0] == 'e'
4489                        && XEXP (XEXP (src2, 0), 0) == src1)
4490                 split = &XEXP (XEXP (src2, 0), 0);
4491
4492               if (split)
4493                 {
4494                   SUBST (XEXP (x, 0), src2);
4495                   return split;
4496                 }
4497             }
4498
4499           /* If that didn't work, perhaps the first operand is complex and
4500              needs to be computed separately, so make a split point there.
4501              This will occur on machines that just support REG + CONST
4502              and have a constant moved through some previous computation.  */
4503
4504           else if (!OBJECT_P (XEXP (XEXP (x, 0), 0))
4505                    && ! (GET_CODE (XEXP (XEXP (x, 0), 0)) == SUBREG
4506                          && OBJECT_P (SUBREG_REG (XEXP (XEXP (x, 0), 0)))))
4507             return &XEXP (XEXP (x, 0), 0);
4508         }
4509
4510       /* If we have a PLUS whose first operand is complex, try computing it
4511          separately by making a split there.  */
4512       if (GET_CODE (XEXP (x, 0)) == PLUS
4513           && ! memory_address_addr_space_p (GET_MODE (x), XEXP (x, 0),
4514                                             MEM_ADDR_SPACE (x))
4515           && ! OBJECT_P (XEXP (XEXP (x, 0), 0))
4516           && ! (GET_CODE (XEXP (XEXP (x, 0), 0)) == SUBREG
4517                 && OBJECT_P (SUBREG_REG (XEXP (XEXP (x, 0), 0)))))
4518         return &XEXP (XEXP (x, 0), 0);
4519       break;
4520
4521     case SET:
4522 #ifdef HAVE_cc0
4523       /* If SET_DEST is CC0 and SET_SRC is not an operand, a COMPARE, or a
4524          ZERO_EXTRACT, the most likely reason why this doesn't match is that
4525          we need to put the operand into a register.  So split at that
4526          point.  */
4527
4528       if (SET_DEST (x) == cc0_rtx
4529           && GET_CODE (SET_SRC (x)) != COMPARE
4530           && GET_CODE (SET_SRC (x)) != ZERO_EXTRACT
4531           && !OBJECT_P (SET_SRC (x))
4532           && ! (GET_CODE (SET_SRC (x)) == SUBREG
4533                 && OBJECT_P (SUBREG_REG (SET_SRC (x)))))
4534         return &SET_SRC (x);
4535 #endif
4536
4537       /* See if we can split SET_SRC as it stands.  */
4538       split = find_split_point (&SET_SRC (x), insn, true);
4539       if (split && split != &SET_SRC (x))
4540         return split;
4541
4542       /* See if we can split SET_DEST as it stands.  */
4543       split = find_split_point (&SET_DEST (x), insn, false);
4544       if (split && split != &SET_DEST (x))
4545         return split;
4546
4547       /* See if this is a bitfield assignment with everything constant.  If
4548          so, this is an IOR of an AND, so split it into that.  */
4549       if (GET_CODE (SET_DEST (x)) == ZERO_EXTRACT
4550           && (GET_MODE_BITSIZE (GET_MODE (XEXP (SET_DEST (x), 0)))
4551               <= HOST_BITS_PER_WIDE_INT)
4552           && CONST_INT_P (XEXP (SET_DEST (x), 1))
4553           && CONST_INT_P (XEXP (SET_DEST (x), 2))
4554           && CONST_INT_P (SET_SRC (x))
4555           && ((INTVAL (XEXP (SET_DEST (x), 1))
4556                + INTVAL (XEXP (SET_DEST (x), 2)))
4557               <= GET_MODE_BITSIZE (GET_MODE (XEXP (SET_DEST (x), 0))))
4558           && ! side_effects_p (XEXP (SET_DEST (x), 0)))
4559         {
4560           HOST_WIDE_INT pos = INTVAL (XEXP (SET_DEST (x), 2));
4561           unsigned HOST_WIDE_INT len = INTVAL (XEXP (SET_DEST (x), 1));
4562           unsigned HOST_WIDE_INT src = INTVAL (SET_SRC (x));
4563           rtx dest = XEXP (SET_DEST (x), 0);
4564           enum machine_mode mode = GET_MODE (dest);
4565           unsigned HOST_WIDE_INT mask = ((HOST_WIDE_INT) 1 << len) - 1;
4566           rtx or_mask;
4567
4568           if (BITS_BIG_ENDIAN)
4569             pos = GET_MODE_BITSIZE (mode) - len - pos;
4570
4571           or_mask = gen_int_mode (src << pos, mode);
4572           if (src == mask)
4573             SUBST (SET_SRC (x),
4574                    simplify_gen_binary (IOR, mode, dest, or_mask));
4575           else
4576             {
4577               rtx negmask = gen_int_mode (~(mask << pos), mode);
4578               SUBST (SET_SRC (x),
4579                      simplify_gen_binary (IOR, mode,
4580                                           simplify_gen_binary (AND, mode,
4581                                                                dest, negmask),
4582                                           or_mask));
4583             }
4584
4585           SUBST (SET_DEST (x), dest);
4586
4587           split = find_split_point (&SET_SRC (x), insn, true);
4588           if (split && split != &SET_SRC (x))
4589             return split;
4590         }
4591
4592       /* Otherwise, see if this is an operation that we can split into two.
4593          If so, try to split that.  */
4594       code = GET_CODE (SET_SRC (x));
4595
4596       switch (code)
4597         {
4598         case AND:
4599           /* If we are AND'ing with a large constant that is only a single
4600              bit and the result is only being used in a context where we
4601              need to know if it is zero or nonzero, replace it with a bit
4602              extraction.  This will avoid the large constant, which might
4603              have taken more than one insn to make.  If the constant were
4604              not a valid argument to the AND but took only one insn to make,
4605              this is no worse, but if it took more than one insn, it will
4606              be better.  */
4607
4608           if (CONST_INT_P (XEXP (SET_SRC (x), 1))
4609               && REG_P (XEXP (SET_SRC (x), 0))
4610               && (pos = exact_log2 (INTVAL (XEXP (SET_SRC (x), 1)))) >= 7
4611               && REG_P (SET_DEST (x))
4612               && (split = find_single_use (SET_DEST (x), insn, (rtx*) 0)) != 0
4613               && (GET_CODE (*split) == EQ || GET_CODE (*split) == NE)
4614               && XEXP (*split, 0) == SET_DEST (x)
4615               && XEXP (*split, 1) == const0_rtx)
4616             {
4617               rtx extraction = make_extraction (GET_MODE (SET_DEST (x)),
4618                                                 XEXP (SET_SRC (x), 0),
4619                                                 pos, NULL_RTX, 1, 1, 0, 0);
4620               if (extraction != 0)
4621                 {
4622                   SUBST (SET_SRC (x), extraction);
4623                   return find_split_point (loc, insn, false);
4624                 }
4625             }
4626           break;
4627
4628         case NE:
4629           /* If STORE_FLAG_VALUE is -1, this is (NE X 0) and only one bit of X
4630              is known to be on, this can be converted into a NEG of a shift.  */
4631           if (STORE_FLAG_VALUE == -1 && XEXP (SET_SRC (x), 1) == const0_rtx
4632               && GET_MODE (SET_SRC (x)) == GET_MODE (XEXP (SET_SRC (x), 0))
4633               && 1 <= (pos = exact_log2
4634                        (nonzero_bits (XEXP (SET_SRC (x), 0),
4635                                       GET_MODE (XEXP (SET_SRC (x), 0))))))
4636             {
4637               enum machine_mode mode = GET_MODE (XEXP (SET_SRC (x), 0));
4638
4639               SUBST (SET_SRC (x),
4640                      gen_rtx_NEG (mode,
4641                                   gen_rtx_LSHIFTRT (mode,
4642                                                     XEXP (SET_SRC (x), 0),
4643                                                     GEN_INT (pos))));
4644
4645               split = find_split_point (&SET_SRC (x), insn, true);
4646               if (split && split != &SET_SRC (x))
4647                 return split;
4648             }
4649           break;
4650
4651         case SIGN_EXTEND:
4652           inner = XEXP (SET_SRC (x), 0);
4653
4654           /* We can't optimize if either mode is a partial integer
4655              mode as we don't know how many bits are significant
4656              in those modes.  */
4657           if (GET_MODE_CLASS (GET_MODE (inner)) == MODE_PARTIAL_INT
4658               || GET_MODE_CLASS (GET_MODE (SET_SRC (x))) == MODE_PARTIAL_INT)
4659             break;
4660
4661           pos = 0;
4662           len = GET_MODE_BITSIZE (GET_MODE (inner));
4663           unsignedp = 0;
4664           break;
4665
4666         case SIGN_EXTRACT:
4667         case ZERO_EXTRACT:
4668           if (CONST_INT_P (XEXP (SET_SRC (x), 1))
4669               && CONST_INT_P (XEXP (SET_SRC (x), 2)))
4670             {
4671               inner = XEXP (SET_SRC (x), 0);
4672               len = INTVAL (XEXP (SET_SRC (x), 1));
4673               pos = INTVAL (XEXP (SET_SRC (x), 2));
4674
4675               if (BITS_BIG_ENDIAN)
4676                 pos = GET_MODE_BITSIZE (GET_MODE (inner)) - len - pos;
4677               unsignedp = (code == ZERO_EXTRACT);
4678             }
4679           break;
4680
4681         default:
4682           break;
4683         }
4684
4685       if (len && pos >= 0 && pos + len <= GET_MODE_BITSIZE (GET_MODE (inner)))
4686         {
4687           enum machine_mode mode = GET_MODE (SET_SRC (x));
4688
4689           /* For unsigned, we have a choice of a shift followed by an
4690              AND or two shifts.  Use two shifts for field sizes where the
4691              constant might be too large.  We assume here that we can
4692              always at least get 8-bit constants in an AND insn, which is
4693              true for every current RISC.  */
4694
4695           if (unsignedp && len <= 8)
4696             {
4697               SUBST (SET_SRC (x),
4698                      gen_rtx_AND (mode,
4699                                   gen_rtx_LSHIFTRT
4700                                   (mode, gen_lowpart (mode, inner),
4701                                    GEN_INT (pos)),
4702                                   GEN_INT (((HOST_WIDE_INT) 1 << len) - 1)));
4703
4704               split = find_split_point (&SET_SRC (x), insn, true);
4705               if (split && split != &SET_SRC (x))
4706                 return split;
4707             }
4708           else
4709             {
4710               SUBST (SET_SRC (x),
4711                      gen_rtx_fmt_ee
4712                      (unsignedp ? LSHIFTRT : ASHIFTRT, mode,
4713                       gen_rtx_ASHIFT (mode,
4714                                       gen_lowpart (mode, inner),
4715                                       GEN_INT (GET_MODE_BITSIZE (mode)
4716                                                - len - pos)),
4717                       GEN_INT (GET_MODE_BITSIZE (mode) - len)));
4718
4719               split = find_split_point (&SET_SRC (x), insn, true);
4720               if (split && split != &SET_SRC (x))
4721                 return split;
4722             }
4723         }
4724
4725       /* See if this is a simple operation with a constant as the second
4726          operand.  It might be that this constant is out of range and hence
4727          could be used as a split point.  */
4728       if (BINARY_P (SET_SRC (x))
4729           && CONSTANT_P (XEXP (SET_SRC (x), 1))
4730           && (OBJECT_P (XEXP (SET_SRC (x), 0))
4731               || (GET_CODE (XEXP (SET_SRC (x), 0)) == SUBREG
4732                   && OBJECT_P (SUBREG_REG (XEXP (SET_SRC (x), 0))))))
4733         return &XEXP (SET_SRC (x), 1);
4734
4735       /* Finally, see if this is a simple operation with its first operand
4736          not in a register.  The operation might require this operand in a
4737          register, so return it as a split point.  We can always do this
4738          because if the first operand were another operation, we would have
4739          already found it as a split point.  */
4740       if ((BINARY_P (SET_SRC (x)) || UNARY_P (SET_SRC (x)))
4741           && ! register_operand (XEXP (SET_SRC (x), 0), VOIDmode))
4742         return &XEXP (SET_SRC (x), 0);
4743
4744       return 0;
4745
4746     case AND:
4747     case IOR:
4748       /* We write NOR as (and (not A) (not B)), but if we don't have a NOR,
4749          it is better to write this as (not (ior A B)) so we can split it.
4750          Similarly for IOR.  */
4751       if (GET_CODE (XEXP (x, 0)) == NOT && GET_CODE (XEXP (x, 1)) == NOT)
4752         {
4753           SUBST (*loc,
4754                  gen_rtx_NOT (GET_MODE (x),
4755                               gen_rtx_fmt_ee (code == IOR ? AND : IOR,
4756                                               GET_MODE (x),
4757                                               XEXP (XEXP (x, 0), 0),
4758                                               XEXP (XEXP (x, 1), 0))));
4759           return find_split_point (loc, insn, set_src);
4760         }
4761
4762       /* Many RISC machines have a large set of logical insns.  If the
4763          second operand is a NOT, put it first so we will try to split the
4764          other operand first.  */
4765       if (GET_CODE (XEXP (x, 1)) == NOT)
4766         {
4767           rtx tem = XEXP (x, 0);
4768           SUBST (XEXP (x, 0), XEXP (x, 1));
4769           SUBST (XEXP (x, 1), tem);
4770         }
4771       break;
4772
4773     case PLUS:
4774     case MINUS:
4775       /* Canonicalization can produce (minus A (mult B C)), where C is a
4776          constant.  It may be better to try splitting (plus (mult B -C) A)
4777          instead if this isn't a multiply by a power of two.  */
4778       if (set_src && code == MINUS && GET_CODE (XEXP (x, 1)) == MULT
4779           && GET_CODE (XEXP (XEXP (x, 1), 1)) == CONST_INT
4780           && exact_log2 (INTVAL (XEXP (XEXP (x, 1), 1))) < 0)
4781         {
4782           enum machine_mode mode = GET_MODE (x);
4783           unsigned HOST_WIDE_INT this_int = INTVAL (XEXP (XEXP (x, 1), 1));
4784           HOST_WIDE_INT other_int = trunc_int_for_mode (-this_int, mode);
4785           SUBST (*loc, gen_rtx_PLUS (mode, gen_rtx_MULT (mode,
4786                                                          XEXP (XEXP (x, 1), 0),
4787                                                          GEN_INT (other_int)),
4788                                      XEXP (x, 0)));
4789           return find_split_point (loc, insn, set_src);
4790         }
4791
4792       /* Split at a multiply-accumulate instruction.  However if this is
4793          the SET_SRC, we likely do not have such an instruction and it's
4794          worthless to try this split.  */
4795       if (!set_src && GET_CODE (XEXP (x, 0)) == MULT)
4796         return loc;
4797
4798     default:
4799       break;
4800     }
4801
4802   /* Otherwise, select our actions depending on our rtx class.  */
4803   switch (GET_RTX_CLASS (code))
4804     {
4805     case RTX_BITFIELD_OPS:              /* This is ZERO_EXTRACT and SIGN_EXTRACT.  */
4806     case RTX_TERNARY:
4807       split = find_split_point (&XEXP (x, 2), insn, false);
4808       if (split)
4809         return split;
4810       /* ... fall through ...  */
4811     case RTX_BIN_ARITH:
4812     case RTX_COMM_ARITH:
4813     case RTX_COMPARE:
4814     case RTX_COMM_COMPARE:
4815       split = find_split_point (&XEXP (x, 1), insn, false);
4816       if (split)
4817         return split;
4818       /* ... fall through ...  */
4819     case RTX_UNARY:
4820       /* Some machines have (and (shift ...) ...) insns.  If X is not
4821          an AND, but XEXP (X, 0) is, use it as our split point.  */
4822       if (GET_CODE (x) != AND && GET_CODE (XEXP (x, 0)) == AND)
4823         return &XEXP (x, 0);
4824
4825       split = find_split_point (&XEXP (x, 0), insn, false);
4826       if (split)
4827         return split;
4828       return loc;
4829
4830     default:
4831       /* Otherwise, we don't have a split point.  */
4832       return 0;
4833     }
4834 }
4835 \f
4836 /* Throughout X, replace FROM with TO, and return the result.
4837    The result is TO if X is FROM;
4838    otherwise the result is X, but its contents may have been modified.
4839    If they were modified, a record was made in undobuf so that
4840    undo_all will (among other things) return X to its original state.
4841
4842    If the number of changes necessary is too much to record to undo,
4843    the excess changes are not made, so the result is invalid.
4844    The changes already made can still be undone.
4845    undobuf.num_undo is incremented for such changes, so by testing that
4846    the caller can tell whether the result is valid.
4847
4848    `n_occurrences' is incremented each time FROM is replaced.
4849
4850    IN_DEST is nonzero if we are processing the SET_DEST of a SET.
4851
4852    UNIQUE_COPY is nonzero if each substitution must be unique.  We do this
4853    by copying if `n_occurrences' is nonzero.  */
4854
4855 static rtx
4856 subst (rtx x, rtx from, rtx to, int in_dest, int unique_copy)
4857 {
4858   enum rtx_code code = GET_CODE (x);
4859   enum machine_mode op0_mode = VOIDmode;
4860   const char *fmt;
4861   int len, i;
4862   rtx new_rtx;
4863
4864 /* Two expressions are equal if they are identical copies of a shared
4865    RTX or if they are both registers with the same register number
4866    and mode.  */
4867
4868 #define COMBINE_RTX_EQUAL_P(X,Y)                        \
4869   ((X) == (Y)                                           \
4870    || (REG_P (X) && REG_P (Y)   \
4871        && REGNO (X) == REGNO (Y) && GET_MODE (X) == GET_MODE (Y)))
4872
4873   if (! in_dest && COMBINE_RTX_EQUAL_P (x, from))
4874     {
4875       n_occurrences++;
4876       return (unique_copy && n_occurrences > 1 ? copy_rtx (to) : to);
4877     }
4878
4879   /* If X and FROM are the same register but different modes, they
4880      will not have been seen as equal above.  However, the log links code
4881      will make a LOG_LINKS entry for that case.  If we do nothing, we
4882      will try to rerecognize our original insn and, when it succeeds,
4883      we will delete the feeding insn, which is incorrect.
4884
4885      So force this insn not to match in this (rare) case.  */
4886   if (! in_dest && code == REG && REG_P (from)
4887       && reg_overlap_mentioned_p (x, from))
4888     return gen_rtx_CLOBBER (GET_MODE (x), const0_rtx);
4889
4890   /* If this is an object, we are done unless it is a MEM or LO_SUM, both
4891      of which may contain things that can be combined.  */
4892   if (code != MEM && code != LO_SUM && OBJECT_P (x))
4893     return x;
4894
4895   /* It is possible to have a subexpression appear twice in the insn.
4896      Suppose that FROM is a register that appears within TO.
4897      Then, after that subexpression has been scanned once by `subst',
4898      the second time it is scanned, TO may be found.  If we were
4899      to scan TO here, we would find FROM within it and create a
4900      self-referent rtl structure which is completely wrong.  */
4901   if (COMBINE_RTX_EQUAL_P (x, to))
4902     return to;
4903
4904   /* Parallel asm_operands need special attention because all of the
4905      inputs are shared across the arms.  Furthermore, unsharing the
4906      rtl results in recognition failures.  Failure to handle this case
4907      specially can result in circular rtl.
4908
4909      Solve this by doing a normal pass across the first entry of the
4910      parallel, and only processing the SET_DESTs of the subsequent
4911      entries.  Ug.  */
4912
4913   if (code == PARALLEL
4914       && GET_CODE (XVECEXP (x, 0, 0)) == SET
4915       && GET_CODE (SET_SRC (XVECEXP (x, 0, 0))) == ASM_OPERANDS)
4916     {
4917       new_rtx = subst (XVECEXP (x, 0, 0), from, to, 0, unique_copy);
4918
4919       /* If this substitution failed, this whole thing fails.  */
4920       if (GET_CODE (new_rtx) == CLOBBER
4921           && XEXP (new_rtx, 0) == const0_rtx)
4922         return new_rtx;
4923
4924       SUBST (XVECEXP (x, 0, 0), new_rtx);
4925
4926       for (i = XVECLEN (x, 0) - 1; i >= 1; i--)
4927         {
4928           rtx dest = SET_DEST (XVECEXP (x, 0, i));
4929
4930           if (!REG_P (dest)
4931               && GET_CODE (dest) != CC0
4932               && GET_CODE (dest) != PC)
4933             {
4934               new_rtx = subst (dest, from, to, 0, unique_copy);
4935
4936               /* If this substitution failed, this whole thing fails.  */
4937               if (GET_CODE (new_rtx) == CLOBBER
4938                   && XEXP (new_rtx, 0) == const0_rtx)
4939                 return new_rtx;
4940
4941               SUBST (SET_DEST (XVECEXP (x, 0, i)), new_rtx);
4942             }
4943         }
4944     }
4945   else
4946     {
4947       len = GET_RTX_LENGTH (code);
4948       fmt = GET_RTX_FORMAT (code);
4949
4950       /* We don't need to process a SET_DEST that is a register, CC0,
4951          or PC, so set up to skip this common case.  All other cases
4952          where we want to suppress replacing something inside a
4953          SET_SRC are handled via the IN_DEST operand.  */
4954       if (code == SET
4955           && (REG_P (SET_DEST (x))
4956               || GET_CODE (SET_DEST (x)) == CC0
4957               || GET_CODE (SET_DEST (x)) == PC))
4958         fmt = "ie";
4959
4960       /* Get the mode of operand 0 in case X is now a SIGN_EXTEND of a
4961          constant.  */
4962       if (fmt[0] == 'e')
4963         op0_mode = GET_MODE (XEXP (x, 0));
4964
4965       for (i = 0; i < len; i++)
4966         {
4967           if (fmt[i] == 'E')
4968             {
4969               int j;
4970               for (j = XVECLEN (x, i) - 1; j >= 0; j--)
4971                 {
4972                   if (COMBINE_RTX_EQUAL_P (XVECEXP (x, i, j), from))
4973                     {
4974                       new_rtx = (unique_copy && n_occurrences
4975                              ? copy_rtx (to) : to);
4976                       n_occurrences++;
4977                     }
4978                   else
4979                     {
4980                       new_rtx = subst (XVECEXP (x, i, j), from, to, 0,
4981                                    unique_copy);
4982
4983                       /* If this substitution failed, this whole thing
4984                          fails.  */
4985                       if (GET_CODE (new_rtx) == CLOBBER
4986                           && XEXP (new_rtx, 0) == const0_rtx)
4987                         return new_rtx;
4988                     }
4989
4990                   SUBST (XVECEXP (x, i, j), new_rtx);
4991                 }
4992             }
4993           else if (fmt[i] == 'e')
4994             {
4995               /* If this is a register being set, ignore it.  */
4996               new_rtx = XEXP (x, i);
4997               if (in_dest
4998                   && i == 0
4999                   && (((code == SUBREG || code == ZERO_EXTRACT)
5000                        && REG_P (new_rtx))
5001                       || code == STRICT_LOW_PART))
5002                 ;
5003
5004               else if (COMBINE_RTX_EQUAL_P (XEXP (x, i), from))
5005                 {
5006                   /* In general, don't install a subreg involving two
5007                      modes not tieable.  It can worsen register
5008                      allocation, and can even make invalid reload
5009                      insns, since the reg inside may need to be copied
5010                      from in the outside mode, and that may be invalid
5011                      if it is an fp reg copied in integer mode.
5012
5013                      We allow two exceptions to this: It is valid if
5014                      it is inside another SUBREG and the mode of that
5015                      SUBREG and the mode of the inside of TO is
5016                      tieable and it is valid if X is a SET that copies
5017                      FROM to CC0.  */
5018
5019                   if (GET_CODE (to) == SUBREG
5020                       && ! MODES_TIEABLE_P (GET_MODE (to),
5021                                             GET_MODE (SUBREG_REG (to)))
5022                       && ! (code == SUBREG
5023                             && MODES_TIEABLE_P (GET_MODE (x),
5024                                                 GET_MODE (SUBREG_REG (to))))
5025 #ifdef HAVE_cc0
5026                       && ! (code == SET && i == 1 && XEXP (x, 0) == cc0_rtx)
5027 #endif
5028                       )
5029                     return gen_rtx_CLOBBER (VOIDmode, const0_rtx);
5030
5031 #ifdef CANNOT_CHANGE_MODE_CLASS
5032                   if (code == SUBREG
5033                       && REG_P (to)
5034                       && REGNO (to) < FIRST_PSEUDO_REGISTER
5035                       && REG_CANNOT_CHANGE_MODE_P (REGNO (to),
5036                                                    GET_MODE (to),
5037                                                    GET_MODE (x)))
5038                     return gen_rtx_CLOBBER (VOIDmode, const0_rtx);
5039 #endif
5040
5041                   new_rtx = (unique_copy && n_occurrences ? copy_rtx (to) : to);
5042                   n_occurrences++;
5043                 }
5044               else
5045                 /* If we are in a SET_DEST, suppress most cases unless we
5046                    have gone inside a MEM, in which case we want to
5047                    simplify the address.  We assume here that things that
5048                    are actually part of the destination have their inner
5049                    parts in the first expression.  This is true for SUBREG,
5050                    STRICT_LOW_PART, and ZERO_EXTRACT, which are the only
5051                    things aside from REG and MEM that should appear in a
5052                    SET_DEST.  */
5053                 new_rtx = subst (XEXP (x, i), from, to,
5054                              (((in_dest
5055                                 && (code == SUBREG || code == STRICT_LOW_PART
5056                                     || code == ZERO_EXTRACT))
5057                                || code == SET)
5058                               && i == 0), unique_copy);
5059
5060               /* If we found that we will have to reject this combination,
5061                  indicate that by returning the CLOBBER ourselves, rather than
5062                  an expression containing it.  This will speed things up as
5063                  well as prevent accidents where two CLOBBERs are considered
5064                  to be equal, thus producing an incorrect simplification.  */
5065
5066               if (GET_CODE (new_rtx) == CLOBBER && XEXP (new_rtx, 0) == const0_rtx)
5067                 return new_rtx;
5068
5069               if (GET_CODE (x) == SUBREG
5070                   && (CONST_INT_P (new_rtx)
5071                       || GET_CODE (new_rtx) == CONST_DOUBLE))
5072                 {
5073                   enum machine_mode mode = GET_MODE (x);
5074
5075                   x = simplify_subreg (GET_MODE (x), new_rtx,
5076                                        GET_MODE (SUBREG_REG (x)),
5077                                        SUBREG_BYTE (x));
5078                   if (! x)
5079                     x = gen_rtx_CLOBBER (mode, const0_rtx);
5080                 }
5081               else if (CONST_INT_P (new_rtx)
5082                        && GET_CODE (x) == ZERO_EXTEND)
5083                 {
5084                   x = simplify_unary_operation (ZERO_EXTEND, GET_MODE (x),
5085                                                 new_rtx, GET_MODE (XEXP (x, 0)));
5086                   gcc_assert (x);
5087                 }
5088               else
5089                 SUBST (XEXP (x, i), new_rtx);
5090             }
5091         }
5092     }
5093
5094   /* Check if we are loading something from the constant pool via float
5095      extension; in this case we would undo compress_float_constant
5096      optimization and degenerate constant load to an immediate value.  */
5097   if (GET_CODE (x) == FLOAT_EXTEND
5098       && MEM_P (XEXP (x, 0))
5099       && MEM_READONLY_P (XEXP (x, 0)))
5100     {
5101       rtx tmp = avoid_constant_pool_reference (x);
5102       if (x != tmp)
5103         return x;
5104     }
5105
5106   /* Try to simplify X.  If the simplification changed the code, it is likely
5107      that further simplification will help, so loop, but limit the number
5108      of repetitions that will be performed.  */
5109
5110   for (i = 0; i < 4; i++)
5111     {
5112       /* If X is sufficiently simple, don't bother trying to do anything
5113          with it.  */
5114       if (code != CONST_INT && code != REG && code != CLOBBER)
5115         x = combine_simplify_rtx (x, op0_mode, in_dest);
5116
5117       if (GET_CODE (x) == code)
5118         break;
5119
5120       code = GET_CODE (x);
5121
5122       /* We no longer know the original mode of operand 0 since we
5123          have changed the form of X)  */
5124       op0_mode = VOIDmode;
5125     }
5126
5127   return x;
5128 }
5129 \f
5130 /* Simplify X, a piece of RTL.  We just operate on the expression at the
5131    outer level; call `subst' to simplify recursively.  Return the new
5132    expression.
5133
5134    OP0_MODE is the original mode of XEXP (x, 0).  IN_DEST is nonzero
5135    if we are inside a SET_DEST.  */
5136
5137 static rtx
5138 combine_simplify_rtx (rtx x, enum machine_mode op0_mode, int in_dest)
5139 {
5140   enum rtx_code code = GET_CODE (x);
5141   enum machine_mode mode = GET_MODE (x);
5142   rtx temp;
5143   int i;
5144
5145   /* If this is a commutative operation, put a constant last and a complex
5146      expression first.  We don't need to do this for comparisons here.  */
5147   if (COMMUTATIVE_ARITH_P (x)
5148       && swap_commutative_operands_p (XEXP (x, 0), XEXP (x, 1)))
5149     {
5150       temp = XEXP (x, 0);
5151       SUBST (XEXP (x, 0), XEXP (x, 1));
5152       SUBST (XEXP (x, 1), temp);
5153     }
5154
5155   /* If this is a simple operation applied to an IF_THEN_ELSE, try
5156      applying it to the arms of the IF_THEN_ELSE.  This often simplifies
5157      things.  Check for cases where both arms are testing the same
5158      condition.
5159
5160      Don't do anything if all operands are very simple.  */
5161
5162   if ((BINARY_P (x)
5163        && ((!OBJECT_P (XEXP (x, 0))
5164             && ! (GET_CODE (XEXP (x, 0)) == SUBREG
5165                   && OBJECT_P (SUBREG_REG (XEXP (x, 0)))))
5166            || (!OBJECT_P (XEXP (x, 1))
5167                && ! (GET_CODE (XEXP (x, 1)) == SUBREG
5168                      && OBJECT_P (SUBREG_REG (XEXP (x, 1)))))))
5169       || (UNARY_P (x)
5170           && (!OBJECT_P (XEXP (x, 0))
5171                && ! (GET_CODE (XEXP (x, 0)) == SUBREG
5172                      && OBJECT_P (SUBREG_REG (XEXP (x, 0)))))))
5173     {
5174       rtx cond, true_rtx, false_rtx;
5175
5176       cond = if_then_else_cond (x, &true_rtx, &false_rtx);
5177       if (cond != 0
5178           /* If everything is a comparison, what we have is highly unlikely
5179              to be simpler, so don't use it.  */
5180           && ! (COMPARISON_P (x)
5181                 && (COMPARISON_P (true_rtx) || COMPARISON_P (false_rtx))))
5182         {
5183           rtx cop1 = const0_rtx;
5184           enum rtx_code cond_code = simplify_comparison (NE, &cond, &cop1);
5185
5186           if (cond_code == NE && COMPARISON_P (cond))
5187             return x;
5188
5189           /* Simplify the alternative arms; this may collapse the true and
5190              false arms to store-flag values.  Be careful to use copy_rtx
5191              here since true_rtx or false_rtx might share RTL with x as a
5192              result of the if_then_else_cond call above.  */
5193           true_rtx = subst (copy_rtx (true_rtx), pc_rtx, pc_rtx, 0, 0);
5194           false_rtx = subst (copy_rtx (false_rtx), pc_rtx, pc_rtx, 0, 0);
5195
5196           /* If true_rtx and false_rtx are not general_operands, an if_then_else
5197              is unlikely to be simpler.  */
5198           if (general_operand (true_rtx, VOIDmode)
5199               && general_operand (false_rtx, VOIDmode))
5200             {
5201               enum rtx_code reversed;
5202
5203               /* Restarting if we generate a store-flag expression will cause
5204                  us to loop.  Just drop through in this case.  */
5205
5206               /* If the result values are STORE_FLAG_VALUE and zero, we can
5207                  just make the comparison operation.  */
5208               if (true_rtx == const_true_rtx && false_rtx == const0_rtx)
5209                 x = simplify_gen_relational (cond_code, mode, VOIDmode,
5210                                              cond, cop1);
5211               else if (true_rtx == const0_rtx && false_rtx == const_true_rtx
5212                        && ((reversed = reversed_comparison_code_parts
5213                                         (cond_code, cond, cop1, NULL))
5214                            != UNKNOWN))
5215                 x = simplify_gen_relational (reversed, mode, VOIDmode,
5216                                              cond, cop1);
5217
5218               /* Likewise, we can make the negate of a comparison operation
5219                  if the result values are - STORE_FLAG_VALUE and zero.  */
5220               else if (CONST_INT_P (true_rtx)
5221                        && INTVAL (true_rtx) == - STORE_FLAG_VALUE
5222                        && false_rtx == const0_rtx)
5223                 x = simplify_gen_unary (NEG, mode,
5224                                         simplify_gen_relational (cond_code,
5225                                                                  mode, VOIDmode,
5226                                                                  cond, cop1),
5227                                         mode);
5228               else if (CONST_INT_P (false_rtx)
5229                        && INTVAL (false_rtx) == - STORE_FLAG_VALUE
5230                        && true_rtx == const0_rtx
5231                        && ((reversed = reversed_comparison_code_parts
5232                                         (cond_code, cond, cop1, NULL))
5233                            != UNKNOWN))
5234                 x = simplify_gen_unary (NEG, mode,
5235                                         simplify_gen_relational (reversed,
5236                                                                  mode, VOIDmode,
5237                                                                  cond, cop1),
5238                                         mode);
5239               else
5240                 return gen_rtx_IF_THEN_ELSE (mode,
5241                                              simplify_gen_relational (cond_code,
5242                                                                       mode,
5243                                                                       VOIDmode,
5244                                                                       cond,
5245                                                                       cop1),
5246                                              true_rtx, false_rtx);
5247
5248               code = GET_CODE (x);
5249               op0_mode = VOIDmode;
5250             }
5251         }
5252     }
5253
5254   /* Try to fold this expression in case we have constants that weren't
5255      present before.  */
5256   temp = 0;
5257   switch (GET_RTX_CLASS (code))
5258     {
5259     case RTX_UNARY:
5260       if (op0_mode == VOIDmode)
5261         op0_mode = GET_MODE (XEXP (x, 0));
5262       temp = simplify_unary_operation (code, mode, XEXP (x, 0), op0_mode);
5263       break;
5264     case RTX_COMPARE:
5265     case RTX_COMM_COMPARE:
5266       {
5267         enum machine_mode cmp_mode = GET_MODE (XEXP (x, 0));
5268         if (cmp_mode == VOIDmode)
5269           {
5270             cmp_mode = GET_MODE (XEXP (x, 1));
5271             if (cmp_mode == VOIDmode)
5272               cmp_mode = op0_mode;
5273           }
5274         temp = simplify_relational_operation (code, mode, cmp_mode,
5275                                               XEXP (x, 0), XEXP (x, 1));
5276       }
5277       break;
5278     case RTX_COMM_ARITH:
5279     case RTX_BIN_ARITH:
5280       temp = simplify_binary_operation (code, mode, XEXP (x, 0), XEXP (x, 1));
5281       break;
5282     case RTX_BITFIELD_OPS:
5283     case RTX_TERNARY:
5284       temp = simplify_ternary_operation (code, mode, op0_mode, XEXP (x, 0),
5285                                          XEXP (x, 1), XEXP (x, 2));
5286       break;
5287     default:
5288       break;
5289     }
5290
5291   if (temp)
5292     {
5293       x = temp;
5294       code = GET_CODE (temp);
5295       op0_mode = VOIDmode;
5296       mode = GET_MODE (temp);
5297     }
5298
5299   /* First see if we can apply the inverse distributive law.  */
5300   if (code == PLUS || code == MINUS
5301       || code == AND || code == IOR || code == XOR)
5302     {
5303       x = apply_distributive_law (x);
5304       code = GET_CODE (x);
5305       op0_mode = VOIDmode;
5306     }
5307
5308   /* If CODE is an associative operation not otherwise handled, see if we
5309      can associate some operands.  This can win if they are constants or
5310      if they are logically related (i.e. (a & b) & a).  */
5311   if ((code == PLUS || code == MINUS || code == MULT || code == DIV
5312        || code == AND || code == IOR || code == XOR
5313        || code == SMAX || code == SMIN || code == UMAX || code == UMIN)
5314       && ((INTEGRAL_MODE_P (mode) && code != DIV)
5315           || (flag_associative_math && FLOAT_MODE_P (mode))))
5316     {
5317       if (GET_CODE (XEXP (x, 0)) == code)
5318         {
5319           rtx other = XEXP (XEXP (x, 0), 0);
5320           rtx inner_op0 = XEXP (XEXP (x, 0), 1);
5321           rtx inner_op1 = XEXP (x, 1);
5322           rtx inner;
5323
5324           /* Make sure we pass the constant operand if any as the second
5325              one if this is a commutative operation.  */
5326           if (CONSTANT_P (inner_op0) && COMMUTATIVE_ARITH_P (x))
5327             {
5328               rtx tem = inner_op0;
5329               inner_op0 = inner_op1;
5330               inner_op1 = tem;
5331             }
5332           inner = simplify_binary_operation (code == MINUS ? PLUS
5333                                              : code == DIV ? MULT
5334                                              : code,
5335                                              mode, inner_op0, inner_op1);
5336
5337           /* For commutative operations, try the other pair if that one
5338              didn't simplify.  */
5339           if (inner == 0 && COMMUTATIVE_ARITH_P (x))
5340             {
5341               other = XEXP (XEXP (x, 0), 1);
5342               inner = simplify_binary_operation (code, mode,
5343                                                  XEXP (XEXP (x, 0), 0),
5344                                                  XEXP (x, 1));
5345             }
5346
5347           if (inner)
5348             return simplify_gen_binary (code, mode, other, inner);
5349         }
5350     }
5351
5352   /* A little bit of algebraic simplification here.  */
5353   switch (code)
5354     {
5355     case MEM:
5356       /* Ensure that our address has any ASHIFTs converted to MULT in case
5357          address-recognizing predicates are called later.  */
5358       temp = make_compound_operation (XEXP (x, 0), MEM);
5359       SUBST (XEXP (x, 0), temp);
5360       break;
5361
5362     case SUBREG:
5363       if (op0_mode == VOIDmode)
5364         op0_mode = GET_MODE (SUBREG_REG (x));
5365
5366       /* See if this can be moved to simplify_subreg.  */
5367       if (CONSTANT_P (SUBREG_REG (x))
5368           && subreg_lowpart_offset (mode, op0_mode) == SUBREG_BYTE (x)
5369              /* Don't call gen_lowpart if the inner mode
5370                 is VOIDmode and we cannot simplify it, as SUBREG without
5371                 inner mode is invalid.  */
5372           && (GET_MODE (SUBREG_REG (x)) != VOIDmode
5373               || gen_lowpart_common (mode, SUBREG_REG (x))))
5374         return gen_lowpart (mode, SUBREG_REG (x));
5375
5376       if (GET_MODE_CLASS (GET_MODE (SUBREG_REG (x))) == MODE_CC)
5377         break;
5378       {
5379         rtx temp;
5380         temp = simplify_subreg (mode, SUBREG_REG (x), op0_mode,
5381                                 SUBREG_BYTE (x));
5382         if (temp)
5383           return temp;
5384       }
5385
5386       /* Don't change the mode of the MEM if that would change the meaning
5387          of the address.  */
5388       if (MEM_P (SUBREG_REG (x))
5389           && (MEM_VOLATILE_P (SUBREG_REG (x))
5390               || mode_dependent_address_p (XEXP (SUBREG_REG (x), 0))))
5391         return gen_rtx_CLOBBER (mode, const0_rtx);
5392
5393       /* Note that we cannot do any narrowing for non-constants since
5394          we might have been counting on using the fact that some bits were
5395          zero.  We now do this in the SET.  */
5396
5397       break;
5398
5399     case NEG:
5400       temp = expand_compound_operation (XEXP (x, 0));
5401
5402       /* For C equal to the width of MODE minus 1, (neg (ashiftrt X C)) can be
5403          replaced by (lshiftrt X C).  This will convert
5404          (neg (sign_extract X 1 Y)) to (zero_extract X 1 Y).  */
5405
5406       if (GET_CODE (temp) == ASHIFTRT
5407           && CONST_INT_P (XEXP (temp, 1))
5408           && INTVAL (XEXP (temp, 1)) == GET_MODE_BITSIZE (mode) - 1)
5409         return simplify_shift_const (NULL_RTX, LSHIFTRT, mode, XEXP (temp, 0),
5410                                      INTVAL (XEXP (temp, 1)));
5411
5412       /* If X has only a single bit that might be nonzero, say, bit I, convert
5413          (neg X) to (ashiftrt (ashift X C-I) C-I) where C is the bitsize of
5414          MODE minus 1.  This will convert (neg (zero_extract X 1 Y)) to
5415          (sign_extract X 1 Y).  But only do this if TEMP isn't a register
5416          or a SUBREG of one since we'd be making the expression more
5417          complex if it was just a register.  */
5418
5419       if (!REG_P (temp)
5420           && ! (GET_CODE (temp) == SUBREG
5421                 && REG_P (SUBREG_REG (temp)))
5422           && (i = exact_log2 (nonzero_bits (temp, mode))) >= 0)
5423         {
5424           rtx temp1 = simplify_shift_const
5425             (NULL_RTX, ASHIFTRT, mode,
5426              simplify_shift_const (NULL_RTX, ASHIFT, mode, temp,
5427                                    GET_MODE_BITSIZE (mode) - 1 - i),
5428              GET_MODE_BITSIZE (mode) - 1 - i);
5429
5430           /* If all we did was surround TEMP with the two shifts, we
5431              haven't improved anything, so don't use it.  Otherwise,
5432              we are better off with TEMP1.  */
5433           if (GET_CODE (temp1) != ASHIFTRT
5434               || GET_CODE (XEXP (temp1, 0)) != ASHIFT
5435               || XEXP (XEXP (temp1, 0), 0) != temp)
5436             return temp1;
5437         }
5438       break;
5439
5440     case TRUNCATE:
5441       /* We can't handle truncation to a partial integer mode here
5442          because we don't know the real bitsize of the partial
5443          integer mode.  */
5444       if (GET_MODE_CLASS (mode) == MODE_PARTIAL_INT)
5445         break;
5446
5447       if (GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
5448         SUBST (XEXP (x, 0),
5449                force_to_mode (XEXP (x, 0), GET_MODE (XEXP (x, 0)),
5450                               GET_MODE_MASK (mode), 0));
5451
5452       /* We can truncate a constant value and return it.  */
5453       if (CONST_INT_P (XEXP (x, 0)))
5454         return gen_int_mode (INTVAL (XEXP (x, 0)), mode);
5455
5456       /* Similarly to what we do in simplify-rtx.c, a truncate of a register
5457          whose value is a comparison can be replaced with a subreg if
5458          STORE_FLAG_VALUE permits.  */
5459       if (GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
5460           && ((HOST_WIDE_INT) STORE_FLAG_VALUE & ~GET_MODE_MASK (mode)) == 0
5461           && (temp = get_last_value (XEXP (x, 0)))
5462           && COMPARISON_P (temp))
5463         return gen_lowpart (mode, XEXP (x, 0));
5464       break;
5465
5466     case CONST:
5467       /* (const (const X)) can become (const X).  Do it this way rather than
5468          returning the inner CONST since CONST can be shared with a
5469          REG_EQUAL note.  */
5470       if (GET_CODE (XEXP (x, 0)) == CONST)
5471         SUBST (XEXP (x, 0), XEXP (XEXP (x, 0), 0));
5472       break;
5473
5474 #ifdef HAVE_lo_sum
5475     case LO_SUM:
5476       /* Convert (lo_sum (high FOO) FOO) to FOO.  This is necessary so we
5477          can add in an offset.  find_split_point will split this address up
5478          again if it doesn't match.  */
5479       if (GET_CODE (XEXP (x, 0)) == HIGH
5480           && rtx_equal_p (XEXP (XEXP (x, 0), 0), XEXP (x, 1)))
5481         return XEXP (x, 1);
5482       break;
5483 #endif
5484
5485     case PLUS:
5486       /* (plus (xor (and <foo> (const_int pow2 - 1)) <c>) <-c>)
5487          when c is (const_int (pow2 + 1) / 2) is a sign extension of a
5488          bit-field and can be replaced by either a sign_extend or a
5489          sign_extract.  The `and' may be a zero_extend and the two
5490          <c>, -<c> constants may be reversed.  */
5491       if (GET_CODE (XEXP (x, 0)) == XOR
5492           && CONST_INT_P (XEXP (x, 1))
5493           && CONST_INT_P (XEXP (XEXP (x, 0), 1))
5494           && INTVAL (XEXP (x, 1)) == -INTVAL (XEXP (XEXP (x, 0), 1))
5495           && ((i = exact_log2 (INTVAL (XEXP (XEXP (x, 0), 1)))) >= 0
5496               || (i = exact_log2 (INTVAL (XEXP (x, 1)))) >= 0)
5497           && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
5498           && ((GET_CODE (XEXP (XEXP (x, 0), 0)) == AND
5499                && CONST_INT_P (XEXP (XEXP (XEXP (x, 0), 0), 1))
5500                && (INTVAL (XEXP (XEXP (XEXP (x, 0), 0), 1))
5501                    == ((HOST_WIDE_INT) 1 << (i + 1)) - 1))
5502               || (GET_CODE (XEXP (XEXP (x, 0), 0)) == ZERO_EXTEND
5503                   && (GET_MODE_BITSIZE (GET_MODE (XEXP (XEXP (XEXP (x, 0), 0), 0)))
5504                       == (unsigned int) i + 1))))
5505         return simplify_shift_const
5506           (NULL_RTX, ASHIFTRT, mode,
5507            simplify_shift_const (NULL_RTX, ASHIFT, mode,
5508                                  XEXP (XEXP (XEXP (x, 0), 0), 0),
5509                                  GET_MODE_BITSIZE (mode) - (i + 1)),
5510            GET_MODE_BITSIZE (mode) - (i + 1));
5511
5512       /* If only the low-order bit of X is possibly nonzero, (plus x -1)
5513          can become (ashiftrt (ashift (xor x 1) C) C) where C is
5514          the bitsize of the mode - 1.  This allows simplification of
5515          "a = (b & 8) == 0;"  */
5516       if (XEXP (x, 1) == constm1_rtx
5517           && !REG_P (XEXP (x, 0))
5518           && ! (GET_CODE (XEXP (x, 0)) == SUBREG
5519                 && REG_P (SUBREG_REG (XEXP (x, 0))))
5520           && nonzero_bits (XEXP (x, 0), mode) == 1)
5521         return simplify_shift_const (NULL_RTX, ASHIFTRT, mode,
5522            simplify_shift_const (NULL_RTX, ASHIFT, mode,
5523                                  gen_rtx_XOR (mode, XEXP (x, 0), const1_rtx),
5524                                  GET_MODE_BITSIZE (mode) - 1),
5525            GET_MODE_BITSIZE (mode) - 1);
5526
5527       /* If we are adding two things that have no bits in common, convert
5528          the addition into an IOR.  This will often be further simplified,
5529          for example in cases like ((a & 1) + (a & 2)), which can
5530          become a & 3.  */
5531
5532       if (GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
5533           && (nonzero_bits (XEXP (x, 0), mode)
5534               & nonzero_bits (XEXP (x, 1), mode)) == 0)
5535         {
5536           /* Try to simplify the expression further.  */
5537           rtx tor = simplify_gen_binary (IOR, mode, XEXP (x, 0), XEXP (x, 1));
5538           temp = combine_simplify_rtx (tor, mode, in_dest);
5539
5540           /* If we could, great.  If not, do not go ahead with the IOR
5541              replacement, since PLUS appears in many special purpose
5542              address arithmetic instructions.  */
5543           if (GET_CODE (temp) != CLOBBER && temp != tor)
5544             return temp;
5545         }
5546       break;
5547
5548     case MINUS:
5549       /* (minus <foo> (and <foo> (const_int -pow2))) becomes
5550          (and <foo> (const_int pow2-1))  */
5551       if (GET_CODE (XEXP (x, 1)) == AND
5552           && CONST_INT_P (XEXP (XEXP (x, 1), 1))
5553           && exact_log2 (-INTVAL (XEXP (XEXP (x, 1), 1))) >= 0
5554           && rtx_equal_p (XEXP (XEXP (x, 1), 0), XEXP (x, 0)))
5555         return simplify_and_const_int (NULL_RTX, mode, XEXP (x, 0),
5556                                        -INTVAL (XEXP (XEXP (x, 1), 1)) - 1);
5557       break;
5558
5559     case MULT:
5560       /* If we have (mult (plus A B) C), apply the distributive law and then
5561          the inverse distributive law to see if things simplify.  This
5562          occurs mostly in addresses, often when unrolling loops.  */
5563
5564       if (GET_CODE (XEXP (x, 0)) == PLUS)
5565         {
5566           rtx result = distribute_and_simplify_rtx (x, 0);
5567           if (result)
5568             return result;
5569         }
5570
5571       /* Try simplify a*(b/c) as (a*b)/c.  */
5572       if (FLOAT_MODE_P (mode) && flag_associative_math
5573           && GET_CODE (XEXP (x, 0)) == DIV)
5574         {
5575           rtx tem = simplify_binary_operation (MULT, mode,
5576                                                XEXP (XEXP (x, 0), 0),
5577                                                XEXP (x, 1));
5578           if (tem)
5579             return simplify_gen_binary (DIV, mode, tem, XEXP (XEXP (x, 0), 1));
5580         }
5581       break;
5582
5583     case UDIV:
5584       /* If this is a divide by a power of two, treat it as a shift if
5585          its first operand is a shift.  */
5586       if (CONST_INT_P (XEXP (x, 1))
5587           && (i = exact_log2 (INTVAL (XEXP (x, 1)))) >= 0
5588           && (GET_CODE (XEXP (x, 0)) == ASHIFT
5589               || GET_CODE (XEXP (x, 0)) == LSHIFTRT
5590               || GET_CODE (XEXP (x, 0)) == ASHIFTRT
5591               || GET_CODE (XEXP (x, 0)) == ROTATE
5592               || GET_CODE (XEXP (x, 0)) == ROTATERT))
5593         return simplify_shift_const (NULL_RTX, LSHIFTRT, mode, XEXP (x, 0), i);
5594       break;
5595
5596     case EQ:  case NE:
5597     case GT:  case GTU:  case GE:  case GEU:
5598     case LT:  case LTU:  case LE:  case LEU:
5599     case UNEQ:  case LTGT:
5600     case UNGT:  case UNGE:
5601     case UNLT:  case UNLE:
5602     case UNORDERED: case ORDERED:
5603       /* If the first operand is a condition code, we can't do anything
5604          with it.  */
5605       if (GET_CODE (XEXP (x, 0)) == COMPARE
5606           || (GET_MODE_CLASS (GET_MODE (XEXP (x, 0))) != MODE_CC
5607               && ! CC0_P (XEXP (x, 0))))
5608         {
5609           rtx op0 = XEXP (x, 0);
5610           rtx op1 = XEXP (x, 1);
5611           enum rtx_code new_code;
5612
5613           if (GET_CODE (op0) == COMPARE)
5614             op1 = XEXP (op0, 1), op0 = XEXP (op0, 0);
5615
5616           /* Simplify our comparison, if possible.  */
5617           new_code = simplify_comparison (code, &op0, &op1);
5618
5619           /* If STORE_FLAG_VALUE is 1, we can convert (ne x 0) to simply X
5620              if only the low-order bit is possibly nonzero in X (such as when
5621              X is a ZERO_EXTRACT of one bit).  Similarly, we can convert EQ to
5622              (xor X 1) or (minus 1 X); we use the former.  Finally, if X is
5623              known to be either 0 or -1, NE becomes a NEG and EQ becomes
5624              (plus X 1).
5625
5626              Remove any ZERO_EXTRACT we made when thinking this was a
5627              comparison.  It may now be simpler to use, e.g., an AND.  If a
5628              ZERO_EXTRACT is indeed appropriate, it will be placed back by
5629              the call to make_compound_operation in the SET case.  */
5630
5631           if (STORE_FLAG_VALUE == 1
5632               && new_code == NE && GET_MODE_CLASS (mode) == MODE_INT
5633               && op1 == const0_rtx
5634               && mode == GET_MODE (op0)
5635               && nonzero_bits (op0, mode) == 1)
5636             return gen_lowpart (mode,
5637                                 expand_compound_operation (op0));
5638
5639           else if (STORE_FLAG_VALUE == 1
5640                    && new_code == NE && GET_MODE_CLASS (mode) == MODE_INT
5641                    && op1 == const0_rtx
5642                    && mode == GET_MODE (op0)
5643                    && (num_sign_bit_copies (op0, mode)
5644                        == GET_MODE_BITSIZE (mode)))
5645             {
5646               op0 = expand_compound_operation (op0);
5647               return simplify_gen_unary (NEG, mode,
5648                                          gen_lowpart (mode, op0),
5649                                          mode);
5650             }
5651
5652           else if (STORE_FLAG_VALUE == 1
5653                    && new_code == EQ && GET_MODE_CLASS (mode) == MODE_INT
5654                    && op1 == const0_rtx
5655                    && mode == GET_MODE (op0)
5656                    && nonzero_bits (op0, mode) == 1)
5657             {
5658               op0 = expand_compound_operation (op0);
5659               return simplify_gen_binary (XOR, mode,
5660                                           gen_lowpart (mode, op0),
5661                                           const1_rtx);
5662             }
5663
5664           else if (STORE_FLAG_VALUE == 1
5665                    && new_code == EQ && GET_MODE_CLASS (mode) == MODE_INT
5666                    && op1 == const0_rtx
5667                    && mode == GET_MODE (op0)
5668                    && (num_sign_bit_copies (op0, mode)
5669                        == GET_MODE_BITSIZE (mode)))
5670             {
5671               op0 = expand_compound_operation (op0);
5672               return plus_constant (gen_lowpart (mode, op0), 1);
5673             }
5674
5675           /* If STORE_FLAG_VALUE is -1, we have cases similar to
5676              those above.  */
5677           if (STORE_FLAG_VALUE == -1
5678               && new_code == NE && GET_MODE_CLASS (mode) == MODE_INT
5679               && op1 == const0_rtx
5680               && (num_sign_bit_copies (op0, mode)
5681                   == GET_MODE_BITSIZE (mode)))
5682             return gen_lowpart (mode,
5683                                 expand_compound_operation (op0));
5684
5685           else if (STORE_FLAG_VALUE == -1
5686                    && new_code == NE && GET_MODE_CLASS (mode) == MODE_INT
5687                    && op1 == const0_rtx
5688                    && mode == GET_MODE (op0)
5689                    && nonzero_bits (op0, mode) == 1)
5690             {
5691               op0 = expand_compound_operation (op0);
5692               return simplify_gen_unary (NEG, mode,
5693                                          gen_lowpart (mode, op0),
5694                                          mode);
5695             }
5696
5697           else if (STORE_FLAG_VALUE == -1
5698                    && new_code == EQ && GET_MODE_CLASS (mode) == MODE_INT
5699                    && op1 == const0_rtx
5700                    && mode == GET_MODE (op0)
5701                    && (num_sign_bit_copies (op0, mode)
5702                        == GET_MODE_BITSIZE (mode)))
5703             {
5704               op0 = expand_compound_operation (op0);
5705               return simplify_gen_unary (NOT, mode,
5706                                          gen_lowpart (mode, op0),
5707                                          mode);
5708             }
5709
5710           /* If X is 0/1, (eq X 0) is X-1.  */
5711           else if (STORE_FLAG_VALUE == -1
5712                    && new_code == EQ && GET_MODE_CLASS (mode) == MODE_INT
5713                    && op1 == const0_rtx
5714                    && mode == GET_MODE (op0)
5715                    && nonzero_bits (op0, mode) == 1)
5716             {
5717               op0 = expand_compound_operation (op0);
5718               return plus_constant (gen_lowpart (mode, op0), -1);
5719             }
5720
5721           /* If STORE_FLAG_VALUE says to just test the sign bit and X has just
5722              one bit that might be nonzero, we can convert (ne x 0) to
5723              (ashift x c) where C puts the bit in the sign bit.  Remove any
5724              AND with STORE_FLAG_VALUE when we are done, since we are only
5725              going to test the sign bit.  */
5726           if (new_code == NE && GET_MODE_CLASS (mode) == MODE_INT
5727               && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
5728               && ((STORE_FLAG_VALUE & GET_MODE_MASK (mode))
5729                   == (unsigned HOST_WIDE_INT) 1 << (GET_MODE_BITSIZE (mode) - 1))
5730               && op1 == const0_rtx
5731               && mode == GET_MODE (op0)
5732               && (i = exact_log2 (nonzero_bits (op0, mode))) >= 0)
5733             {
5734               x = simplify_shift_const (NULL_RTX, ASHIFT, mode,
5735                                         expand_compound_operation (op0),
5736                                         GET_MODE_BITSIZE (mode) - 1 - i);
5737               if (GET_CODE (x) == AND && XEXP (x, 1) == const_true_rtx)
5738                 return XEXP (x, 0);
5739               else
5740                 return x;
5741             }
5742
5743           /* If the code changed, return a whole new comparison.  */
5744           if (new_code != code)
5745             return gen_rtx_fmt_ee (new_code, mode, op0, op1);
5746
5747           /* Otherwise, keep this operation, but maybe change its operands.
5748              This also converts (ne (compare FOO BAR) 0) to (ne FOO BAR).  */
5749           SUBST (XEXP (x, 0), op0);
5750           SUBST (XEXP (x, 1), op1);
5751         }
5752       break;
5753
5754     case IF_THEN_ELSE:
5755       return simplify_if_then_else (x);
5756
5757     case ZERO_EXTRACT:
5758     case SIGN_EXTRACT:
5759     case ZERO_EXTEND:
5760     case SIGN_EXTEND:
5761       /* If we are processing SET_DEST, we are done.  */
5762       if (in_dest)
5763         return x;
5764
5765       return expand_compound_operation (x);
5766
5767     case SET:
5768       return simplify_set (x);
5769
5770     case AND:
5771     case IOR:
5772       return simplify_logical (x);
5773
5774     case ASHIFT:
5775     case LSHIFTRT:
5776     case ASHIFTRT:
5777     case ROTATE:
5778     case ROTATERT:
5779       /* If this is a shift by a constant amount, simplify it.  */
5780       if (CONST_INT_P (XEXP (x, 1)))
5781         return simplify_shift_const (x, code, mode, XEXP (x, 0),
5782                                      INTVAL (XEXP (x, 1)));
5783
5784       else if (SHIFT_COUNT_TRUNCATED && !REG_P (XEXP (x, 1)))
5785         SUBST (XEXP (x, 1),
5786                force_to_mode (XEXP (x, 1), GET_MODE (XEXP (x, 1)),
5787                               ((HOST_WIDE_INT) 1
5788                                << exact_log2 (GET_MODE_BITSIZE (GET_MODE (x))))
5789                               - 1,
5790                               0));
5791       break;
5792
5793     default:
5794       break;
5795     }
5796
5797   return x;
5798 }
5799 \f
5800 /* Simplify X, an IF_THEN_ELSE expression.  Return the new expression.  */
5801
5802 static rtx
5803 simplify_if_then_else (rtx x)
5804 {
5805   enum machine_mode mode = GET_MODE (x);
5806   rtx cond = XEXP (x, 0);
5807   rtx true_rtx = XEXP (x, 1);
5808   rtx false_rtx = XEXP (x, 2);
5809   enum rtx_code true_code = GET_CODE (cond);
5810   int comparison_p = COMPARISON_P (cond);
5811   rtx temp;
5812   int i;
5813   enum rtx_code false_code;
5814   rtx reversed;
5815
5816   /* Simplify storing of the truth value.  */
5817   if (comparison_p && true_rtx == const_true_rtx && false_rtx == const0_rtx)
5818     return simplify_gen_relational (true_code, mode, VOIDmode,
5819                                     XEXP (cond, 0), XEXP (cond, 1));
5820
5821   /* Also when the truth value has to be reversed.  */
5822   if (comparison_p
5823       && true_rtx == const0_rtx && false_rtx == const_true_rtx
5824       && (reversed = reversed_comparison (cond, mode)))
5825     return reversed;
5826
5827   /* Sometimes we can simplify the arm of an IF_THEN_ELSE if a register used
5828      in it is being compared against certain values.  Get the true and false
5829      comparisons and see if that says anything about the value of each arm.  */
5830
5831   if (comparison_p
5832       && ((false_code = reversed_comparison_code (cond, NULL))
5833           != UNKNOWN)
5834       && REG_P (XEXP (cond, 0)))
5835     {
5836       HOST_WIDE_INT nzb;
5837       rtx from = XEXP (cond, 0);
5838       rtx true_val = XEXP (cond, 1);
5839       rtx false_val = true_val;
5840       int swapped = 0;
5841
5842       /* If FALSE_CODE is EQ, swap the codes and arms.  */
5843
5844       if (false_code == EQ)
5845         {
5846           swapped = 1, true_code = EQ, false_code = NE;
5847           temp = true_rtx, true_rtx = false_rtx, false_rtx = temp;
5848         }
5849
5850       /* If we are comparing against zero and the expression being tested has
5851          only a single bit that might be nonzero, that is its value when it is
5852          not equal to zero.  Similarly if it is known to be -1 or 0.  */
5853
5854       if (true_code == EQ && true_val == const0_rtx
5855           && exact_log2 (nzb = nonzero_bits (from, GET_MODE (from))) >= 0)
5856         {
5857           false_code = EQ;
5858           false_val = GEN_INT (trunc_int_for_mode (nzb, GET_MODE (from)));
5859         }
5860       else if (true_code == EQ && true_val == const0_rtx
5861                && (num_sign_bit_copies (from, GET_MODE (from))
5862                    == GET_MODE_BITSIZE (GET_MODE (from))))
5863         {
5864           false_code = EQ;
5865           false_val = constm1_rtx;
5866         }
5867
5868       /* Now simplify an arm if we know the value of the register in the
5869          branch and it is used in the arm.  Be careful due to the potential
5870          of locally-shared RTL.  */
5871
5872       if (reg_mentioned_p (from, true_rtx))
5873         true_rtx = subst (known_cond (copy_rtx (true_rtx), true_code,
5874                                       from, true_val),
5875                       pc_rtx, pc_rtx, 0, 0);
5876       if (reg_mentioned_p (from, false_rtx))
5877         false_rtx = subst (known_cond (copy_rtx (false_rtx), false_code,
5878                                    from, false_val),
5879                        pc_rtx, pc_rtx, 0, 0);
5880
5881       SUBST (XEXP (x, 1), swapped ? false_rtx : true_rtx);
5882       SUBST (XEXP (x, 2), swapped ? true_rtx : false_rtx);
5883
5884       true_rtx = XEXP (x, 1);
5885       false_rtx = XEXP (x, 2);
5886       true_code = GET_CODE (cond);
5887     }
5888
5889   /* If we have (if_then_else FOO (pc) (label_ref BAR)) and FOO can be
5890      reversed, do so to avoid needing two sets of patterns for
5891      subtract-and-branch insns.  Similarly if we have a constant in the true
5892      arm, the false arm is the same as the first operand of the comparison, or
5893      the false arm is more complicated than the true arm.  */
5894
5895   if (comparison_p
5896       && reversed_comparison_code (cond, NULL) != UNKNOWN
5897       && (true_rtx == pc_rtx
5898           || (CONSTANT_P (true_rtx)
5899               && !CONST_INT_P (false_rtx) && false_rtx != pc_rtx)
5900           || true_rtx == const0_rtx
5901           || (OBJECT_P (true_rtx) && !OBJECT_P (false_rtx))
5902           || (GET_CODE (true_rtx) == SUBREG && OBJECT_P (SUBREG_REG (true_rtx))
5903               && !OBJECT_P (false_rtx))
5904           || reg_mentioned_p (true_rtx, false_rtx)
5905           || rtx_equal_p (false_rtx, XEXP (cond, 0))))
5906     {
5907       true_code = reversed_comparison_code (cond, NULL);
5908       SUBST (XEXP (x, 0), reversed_comparison (cond, GET_MODE (cond)));
5909       SUBST (XEXP (x, 1), false_rtx);
5910       SUBST (XEXP (x, 2), true_rtx);
5911
5912       temp = true_rtx, true_rtx = false_rtx, false_rtx = temp;
5913       cond = XEXP (x, 0);
5914
5915       /* It is possible that the conditional has been simplified out.  */
5916       true_code = GET_CODE (cond);
5917       comparison_p = COMPARISON_P (cond);
5918     }
5919
5920   /* If the two arms are identical, we don't need the comparison.  */
5921
5922   if (rtx_equal_p (true_rtx, false_rtx) && ! side_effects_p (cond))
5923     return true_rtx;
5924
5925   /* Convert a == b ? b : a to "a".  */
5926   if (true_code == EQ && ! side_effects_p (cond)
5927       && !HONOR_NANS (mode)
5928       && rtx_equal_p (XEXP (cond, 0), false_rtx)
5929       && rtx_equal_p (XEXP (cond, 1), true_rtx))
5930     return false_rtx;
5931   else if (true_code == NE && ! side_effects_p (cond)
5932            && !HONOR_NANS (mode)
5933            && rtx_equal_p (XEXP (cond, 0), true_rtx)
5934            && rtx_equal_p (XEXP (cond, 1), false_rtx))
5935     return true_rtx;
5936
5937   /* Look for cases where we have (abs x) or (neg (abs X)).  */
5938
5939   if (GET_MODE_CLASS (mode) == MODE_INT
5940       && comparison_p
5941       && XEXP (cond, 1) == const0_rtx
5942       && GET_CODE (false_rtx) == NEG
5943       && rtx_equal_p (true_rtx, XEXP (false_rtx, 0))
5944       && rtx_equal_p (true_rtx, XEXP (cond, 0))
5945       && ! side_effects_p (true_rtx))
5946     switch (true_code)
5947       {
5948       case GT:
5949       case GE:
5950         return simplify_gen_unary (ABS, mode, true_rtx, mode);
5951       case LT:
5952       case LE:
5953         return
5954           simplify_gen_unary (NEG, mode,
5955                               simplify_gen_unary (ABS, mode, true_rtx, mode),
5956                               mode);
5957       default:
5958         break;
5959       }
5960
5961   /* Look for MIN or MAX.  */
5962
5963   if ((! FLOAT_MODE_P (mode) || flag_unsafe_math_optimizations)
5964       && comparison_p
5965       && rtx_equal_p (XEXP (cond, 0), true_rtx)
5966       && rtx_equal_p (XEXP (cond, 1), false_rtx)
5967       && ! side_effects_p (cond))
5968     switch (true_code)
5969       {
5970       case GE:
5971       case GT:
5972         return simplify_gen_binary (SMAX, mode, true_rtx, false_rtx);
5973       case LE:
5974       case LT:
5975         return simplify_gen_binary (SMIN, mode, true_rtx, false_rtx);
5976       case GEU:
5977       case GTU:
5978         return simplify_gen_binary (UMAX, mode, true_rtx, false_rtx);
5979       case LEU:
5980       case LTU:
5981         return simplify_gen_binary (UMIN, mode, true_rtx, false_rtx);
5982       default:
5983         break;
5984       }
5985
5986   /* If we have (if_then_else COND (OP Z C1) Z) and OP is an identity when its
5987      second operand is zero, this can be done as (OP Z (mult COND C2)) where
5988      C2 = C1 * STORE_FLAG_VALUE. Similarly if OP has an outer ZERO_EXTEND or
5989      SIGN_EXTEND as long as Z is already extended (so we don't destroy it).
5990      We can do this kind of thing in some cases when STORE_FLAG_VALUE is
5991      neither 1 or -1, but it isn't worth checking for.  */
5992
5993   if ((STORE_FLAG_VALUE == 1 || STORE_FLAG_VALUE == -1)
5994       && comparison_p
5995       && GET_MODE_CLASS (mode) == MODE_INT
5996       && ! side_effects_p (x))
5997     {
5998       rtx t = make_compound_operation (true_rtx, SET);
5999       rtx f = make_compound_operation (false_rtx, SET);
6000       rtx cond_op0 = XEXP (cond, 0);
6001       rtx cond_op1 = XEXP (cond, 1);
6002       enum rtx_code op = UNKNOWN, extend_op = UNKNOWN;
6003       enum machine_mode m = mode;
6004       rtx z = 0, c1 = NULL_RTX;
6005
6006       if ((GET_CODE (t) == PLUS || GET_CODE (t) == MINUS
6007            || GET_CODE (t) == IOR || GET_CODE (t) == XOR
6008            || GET_CODE (t) == ASHIFT
6009            || GET_CODE (t) == LSHIFTRT || GET_CODE (t) == ASHIFTRT)
6010           && rtx_equal_p (XEXP (t, 0), f))
6011         c1 = XEXP (t, 1), op = GET_CODE (t), z = f;
6012
6013       /* If an identity-zero op is commutative, check whether there
6014          would be a match if we swapped the operands.  */
6015       else if ((GET_CODE (t) == PLUS || GET_CODE (t) == IOR
6016                 || GET_CODE (t) == XOR)
6017                && rtx_equal_p (XEXP (t, 1), f))
6018         c1 = XEXP (t, 0), op = GET_CODE (t), z = f;
6019       else if (GET_CODE (t) == SIGN_EXTEND
6020                && (GET_CODE (XEXP (t, 0)) == PLUS
6021                    || GET_CODE (XEXP (t, 0)) == MINUS
6022                    || GET_CODE (XEXP (t, 0)) == IOR
6023                    || GET_CODE (XEXP (t, 0)) == XOR
6024                    || GET_CODE (XEXP (t, 0)) == ASHIFT
6025                    || GET_CODE (XEXP (t, 0)) == LSHIFTRT
6026                    || GET_CODE (XEXP (t, 0)) == ASHIFTRT)
6027                && GET_CODE (XEXP (XEXP (t, 0), 0)) == SUBREG
6028                && subreg_lowpart_p (XEXP (XEXP (t, 0), 0))
6029                && rtx_equal_p (SUBREG_REG (XEXP (XEXP (t, 0), 0)), f)
6030                && (num_sign_bit_copies (f, GET_MODE (f))
6031                    > (unsigned int)
6032                      (GET_MODE_BITSIZE (mode)
6033                       - GET_MODE_BITSIZE (GET_MODE (XEXP (XEXP (t, 0), 0))))))
6034         {
6035           c1 = XEXP (XEXP (t, 0), 1); z = f; op = GET_CODE (XEXP (t, 0));
6036           extend_op = SIGN_EXTEND;
6037           m = GET_MODE (XEXP (t, 0));
6038         }
6039       else if (GET_CODE (t) == SIGN_EXTEND
6040                && (GET_CODE (XEXP (t, 0)) == PLUS
6041                    || GET_CODE (XEXP (t, 0)) == IOR
6042                    || GET_CODE (XEXP (t, 0)) == XOR)
6043                && GET_CODE (XEXP (XEXP (t, 0), 1)) == SUBREG
6044                && subreg_lowpart_p (XEXP (XEXP (t, 0), 1))
6045                && rtx_equal_p (SUBREG_REG (XEXP (XEXP (t, 0), 1)), f)
6046                && (num_sign_bit_copies (f, GET_MODE (f))
6047                    > (unsigned int)
6048                      (GET_MODE_BITSIZE (mode)
6049                       - GET_MODE_BITSIZE (GET_MODE (XEXP (XEXP (t, 0), 1))))))
6050         {
6051           c1 = XEXP (XEXP (t, 0), 0); z = f; op = GET_CODE (XEXP (t, 0));
6052           extend_op = SIGN_EXTEND;
6053           m = GET_MODE (XEXP (t, 0));
6054         }
6055       else if (GET_CODE (t) == ZERO_EXTEND
6056                && (GET_CODE (XEXP (t, 0)) == PLUS
6057                    || GET_CODE (XEXP (t, 0)) == MINUS
6058                    || GET_CODE (XEXP (t, 0)) == IOR
6059                    || GET_CODE (XEXP (t, 0)) == XOR
6060                    || GET_CODE (XEXP (t, 0)) == ASHIFT
6061                    || GET_CODE (XEXP (t, 0)) == LSHIFTRT
6062                    || GET_CODE (XEXP (t, 0)) == ASHIFTRT)
6063                && GET_CODE (XEXP (XEXP (t, 0), 0)) == SUBREG
6064                && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
6065                && subreg_lowpart_p (XEXP (XEXP (t, 0), 0))
6066                && rtx_equal_p (SUBREG_REG (XEXP (XEXP (t, 0), 0)), f)
6067                && ((nonzero_bits (f, GET_MODE (f))
6068                     & ~GET_MODE_MASK (GET_MODE (XEXP (XEXP (t, 0), 0))))
6069                    == 0))
6070         {
6071           c1 = XEXP (XEXP (t, 0), 1); z = f; op = GET_CODE (XEXP (t, 0));
6072           extend_op = ZERO_EXTEND;
6073           m = GET_MODE (XEXP (t, 0));
6074         }
6075       else if (GET_CODE (t) == ZERO_EXTEND
6076                && (GET_CODE (XEXP (t, 0)) == PLUS
6077                    || GET_CODE (XEXP (t, 0)) == IOR
6078                    || GET_CODE (XEXP (t, 0)) == XOR)
6079                && GET_CODE (XEXP (XEXP (t, 0), 1)) == SUBREG
6080                && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
6081                && subreg_lowpart_p (XEXP (XEXP (t, 0), 1))
6082                && rtx_equal_p (SUBREG_REG (XEXP (XEXP (t, 0), 1)), f)
6083                && ((nonzero_bits (f, GET_MODE (f))
6084                     & ~GET_MODE_MASK (GET_MODE (XEXP (XEXP (t, 0), 1))))
6085                    == 0))
6086         {
6087           c1 = XEXP (XEXP (t, 0), 0); z = f; op = GET_CODE (XEXP (t, 0));
6088           extend_op = ZERO_EXTEND;
6089           m = GET_MODE (XEXP (t, 0));
6090         }
6091
6092       if (z)
6093         {
6094           temp = subst (simplify_gen_relational (true_code, m, VOIDmode,
6095                                                  cond_op0, cond_op1),
6096                         pc_rtx, pc_rtx, 0, 0);
6097           temp = simplify_gen_binary (MULT, m, temp,
6098                                       simplify_gen_binary (MULT, m, c1,
6099                                                            const_true_rtx));
6100           temp = subst (temp, pc_rtx, pc_rtx, 0, 0);
6101           temp = simplify_gen_binary (op, m, gen_lowpart (m, z), temp);
6102
6103           if (extend_op != UNKNOWN)
6104             temp = simplify_gen_unary (extend_op, mode, temp, m);
6105
6106           return temp;
6107         }
6108     }
6109
6110   /* If we have (if_then_else (ne A 0) C1 0) and either A is known to be 0 or
6111      1 and C1 is a single bit or A is known to be 0 or -1 and C1 is the
6112      negation of a single bit, we can convert this operation to a shift.  We
6113      can actually do this more generally, but it doesn't seem worth it.  */
6114
6115   if (true_code == NE && XEXP (cond, 1) == const0_rtx
6116       && false_rtx == const0_rtx && CONST_INT_P (true_rtx)
6117       && ((1 == nonzero_bits (XEXP (cond, 0), mode)
6118            && (i = exact_log2 (INTVAL (true_rtx))) >= 0)
6119           || ((num_sign_bit_copies (XEXP (cond, 0), mode)
6120                == GET_MODE_BITSIZE (mode))
6121               && (i = exact_log2 (-INTVAL (true_rtx))) >= 0)))
6122     return
6123       simplify_shift_const (NULL_RTX, ASHIFT, mode,
6124                             gen_lowpart (mode, XEXP (cond, 0)), i);
6125
6126   /* (IF_THEN_ELSE (NE REG 0) (0) (8)) is REG for nonzero_bits (REG) == 8.  */
6127   if (true_code == NE && XEXP (cond, 1) == const0_rtx
6128       && false_rtx == const0_rtx && CONST_INT_P (true_rtx)
6129       && GET_MODE (XEXP (cond, 0)) == mode
6130       && (INTVAL (true_rtx) & GET_MODE_MASK (mode))
6131           == nonzero_bits (XEXP (cond, 0), mode)
6132       && (i = exact_log2 (INTVAL (true_rtx) & GET_MODE_MASK (mode))) >= 0)
6133     return XEXP (cond, 0);
6134
6135   return x;
6136 }
6137 \f
6138 /* Simplify X, a SET expression.  Return the new expression.  */
6139
6140 static rtx
6141 simplify_set (rtx x)
6142 {
6143   rtx src = SET_SRC (x);
6144   rtx dest = SET_DEST (x);
6145   enum machine_mode mode
6146     = GET_MODE (src) != VOIDmode ? GET_MODE (src) : GET_MODE (dest);
6147   rtx other_insn;
6148   rtx *cc_use;
6149
6150   /* (set (pc) (return)) gets written as (return).  */
6151   if (GET_CODE (dest) == PC && GET_CODE (src) == RETURN)
6152     return src;
6153
6154   /* Now that we know for sure which bits of SRC we are using, see if we can
6155      simplify the expression for the object knowing that we only need the
6156      low-order bits.  */
6157
6158   if (GET_MODE_CLASS (mode) == MODE_INT
6159       && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
6160     {
6161       src = force_to_mode (src, mode, ~(HOST_WIDE_INT) 0, 0);
6162       SUBST (SET_SRC (x), src);
6163     }
6164
6165   /* If we are setting CC0 or if the source is a COMPARE, look for the use of
6166      the comparison result and try to simplify it unless we already have used
6167      undobuf.other_insn.  */
6168   if ((GET_MODE_CLASS (mode) == MODE_CC
6169        || GET_CODE (src) == COMPARE
6170        || CC0_P (dest))
6171       && (cc_use = find_single_use (dest, subst_insn, &other_insn)) != 0
6172       && (undobuf.other_insn == 0 || other_insn == undobuf.other_insn)
6173       && COMPARISON_P (*cc_use)
6174       && rtx_equal_p (XEXP (*cc_use, 0), dest))
6175     {
6176       enum rtx_code old_code = GET_CODE (*cc_use);
6177       enum rtx_code new_code;
6178       rtx op0, op1, tmp;
6179       int other_changed = 0;
6180       enum machine_mode compare_mode = GET_MODE (dest);
6181
6182       if (GET_CODE (src) == COMPARE)
6183         op0 = XEXP (src, 0), op1 = XEXP (src, 1);
6184       else
6185         op0 = src, op1 = CONST0_RTX (GET_MODE (src));
6186
6187       tmp = simplify_relational_operation (old_code, compare_mode, VOIDmode,
6188                                            op0, op1);
6189       if (!tmp)
6190         new_code = old_code;
6191       else if (!CONSTANT_P (tmp))
6192         {
6193           new_code = GET_CODE (tmp);
6194           op0 = XEXP (tmp, 0);
6195           op1 = XEXP (tmp, 1);
6196         }
6197       else
6198         {
6199           rtx pat = PATTERN (other_insn);
6200           undobuf.other_insn = other_insn;
6201           SUBST (*cc_use, tmp);
6202
6203           /* Attempt to simplify CC user.  */
6204           if (GET_CODE (pat) == SET)
6205             {
6206               rtx new_rtx = simplify_rtx (SET_SRC (pat));
6207               if (new_rtx != NULL_RTX)
6208                 SUBST (SET_SRC (pat), new_rtx);
6209             }
6210
6211           /* Convert X into a no-op move.  */
6212           SUBST (SET_DEST (x), pc_rtx);
6213           SUBST (SET_SRC (x), pc_rtx);
6214           return x;
6215         }
6216
6217       /* Simplify our comparison, if possible.  */
6218       new_code = simplify_comparison (new_code, &op0, &op1);
6219
6220 #ifdef SELECT_CC_MODE
6221       /* If this machine has CC modes other than CCmode, check to see if we
6222          need to use a different CC mode here.  */
6223       if (GET_MODE_CLASS (GET_MODE (op0)) == MODE_CC)
6224         compare_mode = GET_MODE (op0);
6225       else
6226         compare_mode = SELECT_CC_MODE (new_code, op0, op1);
6227
6228 #ifndef HAVE_cc0
6229       /* If the mode changed, we have to change SET_DEST, the mode in the
6230          compare, and the mode in the place SET_DEST is used.  If SET_DEST is
6231          a hard register, just build new versions with the proper mode.  If it
6232          is a pseudo, we lose unless it is only time we set the pseudo, in
6233          which case we can safely change its mode.  */
6234       if (compare_mode != GET_MODE (dest))
6235         {
6236           if (can_change_dest_mode (dest, 0, compare_mode))
6237             {
6238               unsigned int regno = REGNO (dest);
6239               rtx new_dest;
6240
6241               if (regno < FIRST_PSEUDO_REGISTER)
6242                 new_dest = gen_rtx_REG (compare_mode, regno);
6243               else
6244                 {
6245                   SUBST_MODE (regno_reg_rtx[regno], compare_mode);
6246                   new_dest = regno_reg_rtx[regno];
6247                 }
6248
6249               SUBST (SET_DEST (x), new_dest);
6250               SUBST (XEXP (*cc_use, 0), new_dest);
6251               other_changed = 1;
6252
6253               dest = new_dest;
6254             }
6255         }
6256 #endif  /* cc0 */
6257 #endif  /* SELECT_CC_MODE */
6258
6259       /* If the code changed, we have to build a new comparison in
6260          undobuf.other_insn.  */
6261       if (new_code != old_code)
6262         {
6263           int other_changed_previously = other_changed;
6264           unsigned HOST_WIDE_INT mask;
6265           rtx old_cc_use = *cc_use;
6266
6267           SUBST (*cc_use, gen_rtx_fmt_ee (new_code, GET_MODE (*cc_use),
6268                                           dest, const0_rtx));
6269           other_changed = 1;
6270
6271           /* If the only change we made was to change an EQ into an NE or
6272              vice versa, OP0 has only one bit that might be nonzero, and OP1
6273              is zero, check if changing the user of the condition code will
6274              produce a valid insn.  If it won't, we can keep the original code
6275              in that insn by surrounding our operation with an XOR.  */
6276
6277           if (((old_code == NE && new_code == EQ)
6278                || (old_code == EQ && new_code == NE))
6279               && ! other_changed_previously && op1 == const0_rtx
6280               && GET_MODE_BITSIZE (GET_MODE (op0)) <= HOST_BITS_PER_WIDE_INT
6281               && exact_log2 (mask = nonzero_bits (op0, GET_MODE (op0))) >= 0)
6282             {
6283               rtx pat = PATTERN (other_insn), note = 0;
6284
6285               if ((recog_for_combine (&pat, other_insn, &note) < 0
6286                    && ! check_asm_operands (pat)))
6287                 {
6288                   *cc_use = old_cc_use;
6289                   other_changed = 0;
6290
6291                   op0 = simplify_gen_binary (XOR, GET_MODE (op0),
6292                                              op0, GEN_INT (mask));
6293                 }
6294             }
6295         }
6296
6297       if (other_changed)
6298         undobuf.other_insn = other_insn;
6299
6300       /* Otherwise, if we didn't previously have a COMPARE in the
6301          correct mode, we need one.  */
6302       if (GET_CODE (src) != COMPARE || GET_MODE (src) != compare_mode)
6303         {
6304           SUBST (SET_SRC (x), gen_rtx_COMPARE (compare_mode, op0, op1));
6305           src = SET_SRC (x);
6306         }
6307       else if (GET_MODE (op0) == compare_mode && op1 == const0_rtx)
6308         {
6309           SUBST (SET_SRC (x), op0);
6310           src = SET_SRC (x);
6311         }
6312       /* Otherwise, update the COMPARE if needed.  */
6313       else if (XEXP (src, 0) != op0 || XEXP (src, 1) != op1)
6314         {
6315           SUBST (SET_SRC (x), gen_rtx_COMPARE (compare_mode, op0, op1));
6316           src = SET_SRC (x);
6317         }
6318     }
6319   else
6320     {
6321       /* Get SET_SRC in a form where we have placed back any
6322          compound expressions.  Then do the checks below.  */
6323       src = make_compound_operation (src, SET);
6324       SUBST (SET_SRC (x), src);
6325     }
6326
6327   /* If we have (set x (subreg:m1 (op:m2 ...) 0)) with OP being some operation,
6328      and X being a REG or (subreg (reg)), we may be able to convert this to
6329      (set (subreg:m2 x) (op)).
6330
6331      We can always do this if M1 is narrower than M2 because that means that
6332      we only care about the low bits of the result.
6333
6334      However, on machines without WORD_REGISTER_OPERATIONS defined, we cannot
6335      perform a narrower operation than requested since the high-order bits will
6336      be undefined.  On machine where it is defined, this transformation is safe
6337      as long as M1 and M2 have the same number of words.  */
6338
6339   if (GET_CODE (src) == SUBREG && subreg_lowpart_p (src)
6340       && !OBJECT_P (SUBREG_REG (src))
6341       && (((GET_MODE_SIZE (GET_MODE (src)) + (UNITS_PER_WORD - 1))
6342            / UNITS_PER_WORD)
6343           == ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (src)))
6344                + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD))
6345 #ifndef WORD_REGISTER_OPERATIONS
6346       && (GET_MODE_SIZE (GET_MODE (src))
6347         < GET_MODE_SIZE (GET_MODE (SUBREG_REG (src))))
6348 #endif
6349 #ifdef CANNOT_CHANGE_MODE_CLASS
6350       && ! (REG_P (dest) && REGNO (dest) < FIRST_PSEUDO_REGISTER
6351             && REG_CANNOT_CHANGE_MODE_P (REGNO (dest),
6352                                          GET_MODE (SUBREG_REG (src)),
6353                                          GET_MODE (src)))
6354 #endif
6355       && (REG_P (dest)
6356           || (GET_CODE (dest) == SUBREG
6357               && REG_P (SUBREG_REG (dest)))))
6358     {
6359       SUBST (SET_DEST (x),
6360              gen_lowpart (GET_MODE (SUBREG_REG (src)),
6361                                       dest));
6362       SUBST (SET_SRC (x), SUBREG_REG (src));
6363
6364       src = SET_SRC (x), dest = SET_DEST (x);
6365     }
6366
6367 #ifdef HAVE_cc0
6368   /* If we have (set (cc0) (subreg ...)), we try to remove the subreg
6369      in SRC.  */
6370   if (dest == cc0_rtx
6371       && GET_CODE (src) == SUBREG
6372       && subreg_lowpart_p (src)
6373       && (GET_MODE_BITSIZE (GET_MODE (src))
6374           < GET_MODE_BITSIZE (GET_MODE (SUBREG_REG (src)))))
6375     {
6376       rtx inner = SUBREG_REG (src);
6377       enum machine_mode inner_mode = GET_MODE (inner);
6378
6379       /* Here we make sure that we don't have a sign bit on.  */
6380       if (GET_MODE_BITSIZE (inner_mode) <= HOST_BITS_PER_WIDE_INT
6381           && (nonzero_bits (inner, inner_mode)
6382               < ((unsigned HOST_WIDE_INT) 1
6383                  << (GET_MODE_BITSIZE (GET_MODE (src)) - 1))))
6384         {
6385           SUBST (SET_SRC (x), inner);
6386           src = SET_SRC (x);
6387         }
6388     }
6389 #endif
6390
6391 #ifdef LOAD_EXTEND_OP
6392   /* If we have (set FOO (subreg:M (mem:N BAR) 0)) with M wider than N, this
6393      would require a paradoxical subreg.  Replace the subreg with a
6394      zero_extend to avoid the reload that would otherwise be required.  */
6395
6396   if (GET_CODE (src) == SUBREG && subreg_lowpart_p (src)
6397       && INTEGRAL_MODE_P (GET_MODE (SUBREG_REG (src)))
6398       && LOAD_EXTEND_OP (GET_MODE (SUBREG_REG (src))) != UNKNOWN
6399       && SUBREG_BYTE (src) == 0
6400       && (GET_MODE_SIZE (GET_MODE (src))
6401           > GET_MODE_SIZE (GET_MODE (SUBREG_REG (src))))
6402       && MEM_P (SUBREG_REG (src)))
6403     {
6404       SUBST (SET_SRC (x),
6405              gen_rtx_fmt_e (LOAD_EXTEND_OP (GET_MODE (SUBREG_REG (src))),
6406                             GET_MODE (src), SUBREG_REG (src)));
6407
6408       src = SET_SRC (x);
6409     }
6410 #endif
6411
6412   /* If we don't have a conditional move, SET_SRC is an IF_THEN_ELSE, and we
6413      are comparing an item known to be 0 or -1 against 0, use a logical
6414      operation instead. Check for one of the arms being an IOR of the other
6415      arm with some value.  We compute three terms to be IOR'ed together.  In
6416      practice, at most two will be nonzero.  Then we do the IOR's.  */
6417
6418   if (GET_CODE (dest) != PC
6419       && GET_CODE (src) == IF_THEN_ELSE
6420       && GET_MODE_CLASS (GET_MODE (src)) == MODE_INT
6421       && (GET_CODE (XEXP (src, 0)) == EQ || GET_CODE (XEXP (src, 0)) == NE)
6422       && XEXP (XEXP (src, 0), 1) == const0_rtx
6423       && GET_MODE (src) == GET_MODE (XEXP (XEXP (src, 0), 0))
6424 #ifdef HAVE_conditional_move
6425       && ! can_conditionally_move_p (GET_MODE (src))
6426 #endif
6427       && (num_sign_bit_copies (XEXP (XEXP (src, 0), 0),
6428                                GET_MODE (XEXP (XEXP (src, 0), 0)))
6429           == GET_MODE_BITSIZE (GET_MODE (XEXP (XEXP (src, 0), 0))))
6430       && ! side_effects_p (src))
6431     {
6432       rtx true_rtx = (GET_CODE (XEXP (src, 0)) == NE
6433                       ? XEXP (src, 1) : XEXP (src, 2));
6434       rtx false_rtx = (GET_CODE (XEXP (src, 0)) == NE
6435                    ? XEXP (src, 2) : XEXP (src, 1));
6436       rtx term1 = const0_rtx, term2, term3;
6437
6438       if (GET_CODE (true_rtx) == IOR
6439           && rtx_equal_p (XEXP (true_rtx, 0), false_rtx))
6440         term1 = false_rtx, true_rtx = XEXP (true_rtx, 1), false_rtx = const0_rtx;
6441       else if (GET_CODE (true_rtx) == IOR
6442                && rtx_equal_p (XEXP (true_rtx, 1), false_rtx))
6443         term1 = false_rtx, true_rtx = XEXP (true_rtx, 0), false_rtx = const0_rtx;
6444       else if (GET_CODE (false_rtx) == IOR
6445                && rtx_equal_p (XEXP (false_rtx, 0), true_rtx))
6446         term1 = true_rtx, false_rtx = XEXP (false_rtx, 1), true_rtx = const0_rtx;
6447       else if (GET_CODE (false_rtx) == IOR
6448                && rtx_equal_p (XEXP (false_rtx, 1), true_rtx))
6449         term1 = true_rtx, false_rtx = XEXP (false_rtx, 0), true_rtx = const0_rtx;
6450
6451       term2 = simplify_gen_binary (AND, GET_MODE (src),
6452                                    XEXP (XEXP (src, 0), 0), true_rtx);
6453       term3 = simplify_gen_binary (AND, GET_MODE (src),
6454                                    simplify_gen_unary (NOT, GET_MODE (src),
6455                                                        XEXP (XEXP (src, 0), 0),
6456                                                        GET_MODE (src)),
6457                                    false_rtx);
6458
6459       SUBST (SET_SRC (x),
6460              simplify_gen_binary (IOR, GET_MODE (src),
6461                                   simplify_gen_binary (IOR, GET_MODE (src),
6462                                                        term1, term2),
6463                                   term3));
6464
6465       src = SET_SRC (x);
6466     }
6467
6468   /* If either SRC or DEST is a CLOBBER of (const_int 0), make this
6469      whole thing fail.  */
6470   if (GET_CODE (src) == CLOBBER && XEXP (src, 0) == const0_rtx)
6471     return src;
6472   else if (GET_CODE (dest) == CLOBBER && XEXP (dest, 0) == const0_rtx)
6473     return dest;
6474   else
6475     /* Convert this into a field assignment operation, if possible.  */
6476     return make_field_assignment (x);
6477 }
6478 \f
6479 /* Simplify, X, and AND, IOR, or XOR operation, and return the simplified
6480    result.  */
6481
6482 static rtx
6483 simplify_logical (rtx x)
6484 {
6485   enum machine_mode mode = GET_MODE (x);
6486   rtx op0 = XEXP (x, 0);
6487   rtx op1 = XEXP (x, 1);
6488
6489   switch (GET_CODE (x))
6490     {
6491     case AND:
6492       /* We can call simplify_and_const_int only if we don't lose
6493          any (sign) bits when converting INTVAL (op1) to
6494          "unsigned HOST_WIDE_INT".  */
6495       if (CONST_INT_P (op1)
6496           && (GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
6497               || INTVAL (op1) > 0))
6498         {
6499           x = simplify_and_const_int (x, mode, op0, INTVAL (op1));
6500           if (GET_CODE (x) != AND)
6501             return x;
6502
6503           op0 = XEXP (x, 0);
6504           op1 = XEXP (x, 1);
6505         }
6506
6507       /* If we have any of (and (ior A B) C) or (and (xor A B) C),
6508          apply the distributive law and then the inverse distributive
6509          law to see if things simplify.  */
6510       if (GET_CODE (op0) == IOR || GET_CODE (op0) == XOR)
6511         {
6512           rtx result = distribute_and_simplify_rtx (x, 0);
6513           if (result)
6514             return result;
6515         }
6516       if (GET_CODE (op1) == IOR || GET_CODE (op1) == XOR)
6517         {
6518           rtx result = distribute_and_simplify_rtx (x, 1);
6519           if (result)
6520             return result;
6521         }
6522       break;
6523
6524     case IOR:
6525       /* If we have (ior (and A B) C), apply the distributive law and then
6526          the inverse distributive law to see if things simplify.  */
6527
6528       if (GET_CODE (op0) == AND)
6529         {
6530           rtx result = distribute_and_simplify_rtx (x, 0);
6531           if (result)
6532             return result;
6533         }
6534
6535       if (GET_CODE (op1) == AND)
6536         {
6537           rtx result = distribute_and_simplify_rtx (x, 1);
6538           if (result)
6539             return result;
6540         }
6541       break;
6542
6543     default:
6544       gcc_unreachable ();
6545     }
6546
6547   return x;
6548 }
6549 \f
6550 /* We consider ZERO_EXTRACT, SIGN_EXTRACT, and SIGN_EXTEND as "compound
6551    operations" because they can be replaced with two more basic operations.
6552    ZERO_EXTEND is also considered "compound" because it can be replaced with
6553    an AND operation, which is simpler, though only one operation.
6554
6555    The function expand_compound_operation is called with an rtx expression
6556    and will convert it to the appropriate shifts and AND operations,
6557    simplifying at each stage.
6558
6559    The function make_compound_operation is called to convert an expression
6560    consisting of shifts and ANDs into the equivalent compound expression.
6561    It is the inverse of this function, loosely speaking.  */
6562
6563 static rtx
6564 expand_compound_operation (rtx x)
6565 {
6566   unsigned HOST_WIDE_INT pos = 0, len;
6567   int unsignedp = 0;
6568   unsigned int modewidth;
6569   rtx tem;
6570
6571   switch (GET_CODE (x))
6572     {
6573     case ZERO_EXTEND:
6574       unsignedp = 1;
6575     case SIGN_EXTEND:
6576       /* We can't necessarily use a const_int for a multiword mode;
6577          it depends on implicitly extending the value.
6578          Since we don't know the right way to extend it,
6579          we can't tell whether the implicit way is right.
6580
6581          Even for a mode that is no wider than a const_int,
6582          we can't win, because we need to sign extend one of its bits through
6583          the rest of it, and we don't know which bit.  */
6584       if (CONST_INT_P (XEXP (x, 0)))
6585         return x;
6586
6587       /* Return if (subreg:MODE FROM 0) is not a safe replacement for
6588          (zero_extend:MODE FROM) or (sign_extend:MODE FROM).  It is for any MEM
6589          because (SUBREG (MEM...)) is guaranteed to cause the MEM to be
6590          reloaded. If not for that, MEM's would very rarely be safe.
6591
6592          Reject MODEs bigger than a word, because we might not be able
6593          to reference a two-register group starting with an arbitrary register
6594          (and currently gen_lowpart might crash for a SUBREG).  */
6595
6596       if (GET_MODE_SIZE (GET_MODE (XEXP (x, 0))) > UNITS_PER_WORD)
6597         return x;
6598
6599       /* Reject MODEs that aren't scalar integers because turning vector
6600          or complex modes into shifts causes problems.  */
6601
6602       if (! SCALAR_INT_MODE_P (GET_MODE (XEXP (x, 0))))
6603         return x;
6604
6605       len = GET_MODE_BITSIZE (GET_MODE (XEXP (x, 0)));
6606       /* If the inner object has VOIDmode (the only way this can happen
6607          is if it is an ASM_OPERANDS), we can't do anything since we don't
6608          know how much masking to do.  */
6609       if (len == 0)
6610         return x;
6611
6612       break;
6613
6614     case ZERO_EXTRACT:
6615       unsignedp = 1;
6616
6617       /* ... fall through ...  */
6618
6619     case SIGN_EXTRACT:
6620       /* If the operand is a CLOBBER, just return it.  */
6621       if (GET_CODE (XEXP (x, 0)) == CLOBBER)
6622         return XEXP (x, 0);
6623
6624       if (!CONST_INT_P (XEXP (x, 1))
6625           || !CONST_INT_P (XEXP (x, 2))
6626           || GET_MODE (XEXP (x, 0)) == VOIDmode)
6627         return x;
6628
6629       /* Reject MODEs that aren't scalar integers because turning vector
6630          or complex modes into shifts causes problems.  */
6631
6632       if (! SCALAR_INT_MODE_P (GET_MODE (XEXP (x, 0))))
6633         return x;
6634
6635       len = INTVAL (XEXP (x, 1));
6636       pos = INTVAL (XEXP (x, 2));
6637
6638       /* This should stay within the object being extracted, fail otherwise.  */
6639       if (len + pos > GET_MODE_BITSIZE (GET_MODE (XEXP (x, 0))))
6640         return x;
6641
6642       if (BITS_BIG_ENDIAN)
6643         pos = GET_MODE_BITSIZE (GET_MODE (XEXP (x, 0))) - len - pos;
6644
6645       break;
6646
6647     default:
6648       return x;
6649     }
6650   /* Convert sign extension to zero extension, if we know that the high
6651      bit is not set, as this is easier to optimize.  It will be converted
6652      back to cheaper alternative in make_extraction.  */
6653   if (GET_CODE (x) == SIGN_EXTEND
6654       && (GET_MODE_BITSIZE (GET_MODE (x)) <= HOST_BITS_PER_WIDE_INT
6655           && ((nonzero_bits (XEXP (x, 0), GET_MODE (XEXP (x, 0)))
6656                 & ~(((unsigned HOST_WIDE_INT)
6657                       GET_MODE_MASK (GET_MODE (XEXP (x, 0))))
6658                      >> 1))
6659                == 0)))
6660     {
6661       rtx temp = gen_rtx_ZERO_EXTEND (GET_MODE (x), XEXP (x, 0));
6662       rtx temp2 = expand_compound_operation (temp);
6663
6664       /* Make sure this is a profitable operation.  */
6665       if (rtx_cost (x, SET, optimize_this_for_speed_p)
6666           > rtx_cost (temp2, SET, optimize_this_for_speed_p))
6667        return temp2;
6668       else if (rtx_cost (x, SET, optimize_this_for_speed_p)
6669                > rtx_cost (temp, SET, optimize_this_for_speed_p))
6670        return temp;
6671       else
6672        return x;
6673     }
6674
6675   /* We can optimize some special cases of ZERO_EXTEND.  */
6676   if (GET_CODE (x) == ZERO_EXTEND)
6677     {
6678       /* (zero_extend:DI (truncate:SI foo:DI)) is just foo:DI if we
6679          know that the last value didn't have any inappropriate bits
6680          set.  */
6681       if (GET_CODE (XEXP (x, 0)) == TRUNCATE
6682           && GET_MODE (XEXP (XEXP (x, 0), 0)) == GET_MODE (x)
6683           && GET_MODE_BITSIZE (GET_MODE (x)) <= HOST_BITS_PER_WIDE_INT
6684           && (nonzero_bits (XEXP (XEXP (x, 0), 0), GET_MODE (x))
6685               & ~GET_MODE_MASK (GET_MODE (XEXP (x, 0)))) == 0)
6686         return XEXP (XEXP (x, 0), 0);
6687
6688       /* Likewise for (zero_extend:DI (subreg:SI foo:DI 0)).  */
6689       if (GET_CODE (XEXP (x, 0)) == SUBREG
6690           && GET_MODE (SUBREG_REG (XEXP (x, 0))) == GET_MODE (x)
6691           && subreg_lowpart_p (XEXP (x, 0))
6692           && GET_MODE_BITSIZE (GET_MODE (x)) <= HOST_BITS_PER_WIDE_INT
6693           && (nonzero_bits (SUBREG_REG (XEXP (x, 0)), GET_MODE (x))
6694               & ~GET_MODE_MASK (GET_MODE (XEXP (x, 0)))) == 0)
6695         return SUBREG_REG (XEXP (x, 0));
6696
6697       /* (zero_extend:DI (truncate:SI foo:DI)) is just foo:DI when foo
6698          is a comparison and STORE_FLAG_VALUE permits.  This is like
6699          the first case, but it works even when GET_MODE (x) is larger
6700          than HOST_WIDE_INT.  */
6701       if (GET_CODE (XEXP (x, 0)) == TRUNCATE
6702           && GET_MODE (XEXP (XEXP (x, 0), 0)) == GET_MODE (x)
6703           && COMPARISON_P (XEXP (XEXP (x, 0), 0))
6704           && (GET_MODE_BITSIZE (GET_MODE (XEXP (x, 0)))
6705               <= HOST_BITS_PER_WIDE_INT)
6706           && ((HOST_WIDE_INT) STORE_FLAG_VALUE
6707               & ~GET_MODE_MASK (GET_MODE (XEXP (x, 0)))) == 0)
6708         return XEXP (XEXP (x, 0), 0);
6709
6710       /* Likewise for (zero_extend:DI (subreg:SI foo:DI 0)).  */
6711       if (GET_CODE (XEXP (x, 0)) == SUBREG
6712           && GET_MODE (SUBREG_REG (XEXP (x, 0))) == GET_MODE (x)
6713           && subreg_lowpart_p (XEXP (x, 0))
6714           && COMPARISON_P (SUBREG_REG (XEXP (x, 0)))
6715           && (GET_MODE_BITSIZE (GET_MODE (XEXP (x, 0)))
6716               <= HOST_BITS_PER_WIDE_INT)
6717           && ((HOST_WIDE_INT) STORE_FLAG_VALUE
6718               & ~GET_MODE_MASK (GET_MODE (XEXP (x, 0)))) == 0)
6719         return SUBREG_REG (XEXP (x, 0));
6720
6721     }
6722
6723   /* If we reach here, we want to return a pair of shifts.  The inner
6724      shift is a left shift of BITSIZE - POS - LEN bits.  The outer
6725      shift is a right shift of BITSIZE - LEN bits.  It is arithmetic or
6726      logical depending on the value of UNSIGNEDP.
6727
6728      If this was a ZERO_EXTEND or ZERO_EXTRACT, this pair of shifts will be
6729      converted into an AND of a shift.
6730
6731      We must check for the case where the left shift would have a negative
6732      count.  This can happen in a case like (x >> 31) & 255 on machines
6733      that can't shift by a constant.  On those machines, we would first
6734      combine the shift with the AND to produce a variable-position
6735      extraction.  Then the constant of 31 would be substituted in to produce
6736      a such a position.  */
6737
6738   modewidth = GET_MODE_BITSIZE (GET_MODE (x));
6739   if (modewidth + len >= pos)
6740     {
6741       enum machine_mode mode = GET_MODE (x);
6742       tem = gen_lowpart (mode, XEXP (x, 0));
6743       if (!tem || GET_CODE (tem) == CLOBBER)
6744         return x;
6745       tem = simplify_shift_const (NULL_RTX, ASHIFT, mode,
6746                                   tem, modewidth - pos - len);
6747       tem = simplify_shift_const (NULL_RTX, unsignedp ? LSHIFTRT : ASHIFTRT,
6748                                   mode, tem, modewidth - len);
6749     }
6750   else if (unsignedp && len < HOST_BITS_PER_WIDE_INT)
6751     tem = simplify_and_const_int (NULL_RTX, GET_MODE (x),
6752                                   simplify_shift_const (NULL_RTX, LSHIFTRT,
6753                                                         GET_MODE (x),
6754                                                         XEXP (x, 0), pos),
6755                                   ((HOST_WIDE_INT) 1 << len) - 1);
6756   else
6757     /* Any other cases we can't handle.  */
6758     return x;
6759
6760   /* If we couldn't do this for some reason, return the original
6761      expression.  */
6762   if (GET_CODE (tem) == CLOBBER)
6763     return x;
6764
6765   return tem;
6766 }
6767 \f
6768 /* X is a SET which contains an assignment of one object into
6769    a part of another (such as a bit-field assignment, STRICT_LOW_PART,
6770    or certain SUBREGS). If possible, convert it into a series of
6771    logical operations.
6772
6773    We half-heartedly support variable positions, but do not at all
6774    support variable lengths.  */
6775
6776 static const_rtx
6777 expand_field_assignment (const_rtx x)
6778 {
6779   rtx inner;
6780   rtx pos;                      /* Always counts from low bit.  */
6781   int len;
6782   rtx mask, cleared, masked;
6783   enum machine_mode compute_mode;
6784
6785   /* Loop until we find something we can't simplify.  */
6786   while (1)
6787     {
6788       if (GET_CODE (SET_DEST (x)) == STRICT_LOW_PART
6789           && GET_CODE (XEXP (SET_DEST (x), 0)) == SUBREG)
6790         {
6791           inner = SUBREG_REG (XEXP (SET_DEST (x), 0));
6792           len = GET_MODE_BITSIZE (GET_MODE (XEXP (SET_DEST (x), 0)));
6793           pos = GEN_INT (subreg_lsb (XEXP (SET_DEST (x), 0)));
6794         }
6795       else if (GET_CODE (SET_DEST (x)) == ZERO_EXTRACT
6796                && CONST_INT_P (XEXP (SET_DEST (x), 1)))
6797         {
6798           inner = XEXP (SET_DEST (x), 0);
6799           len = INTVAL (XEXP (SET_DEST (x), 1));
6800           pos = XEXP (SET_DEST (x), 2);
6801
6802           /* A constant position should stay within the width of INNER.  */
6803           if (CONST_INT_P (pos)
6804               && INTVAL (pos) + len > GET_MODE_BITSIZE (GET_MODE (inner)))
6805             break;
6806
6807           if (BITS_BIG_ENDIAN)
6808             {
6809               if (CONST_INT_P (pos))
6810                 pos = GEN_INT (GET_MODE_BITSIZE (GET_MODE (inner)) - len
6811                                - INTVAL (pos));
6812               else if (GET_CODE (pos) == MINUS
6813                        && CONST_INT_P (XEXP (pos, 1))
6814                        && (INTVAL (XEXP (pos, 1))
6815                            == GET_MODE_BITSIZE (GET_MODE (inner)) - len))
6816                 /* If position is ADJUST - X, new position is X.  */
6817                 pos = XEXP (pos, 0);
6818               else
6819                 pos = simplify_gen_binary (MINUS, GET_MODE (pos),
6820                                            GEN_INT (GET_MODE_BITSIZE (
6821                                                     GET_MODE (inner))
6822                                                     - len),
6823                                            pos);
6824             }
6825         }
6826
6827       /* A SUBREG between two modes that occupy the same numbers of words
6828          can be done by moving the SUBREG to the source.  */
6829       else if (GET_CODE (SET_DEST (x)) == SUBREG
6830                /* We need SUBREGs to compute nonzero_bits properly.  */
6831                && nonzero_sign_valid
6832                && (((GET_MODE_SIZE (GET_MODE (SET_DEST (x)))
6833                      + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD)
6834                    == ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (SET_DEST (x))))
6835                         + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD)))
6836         {
6837           x = gen_rtx_SET (VOIDmode, SUBREG_REG (SET_DEST (x)),
6838                            gen_lowpart
6839                            (GET_MODE (SUBREG_REG (SET_DEST (x))),
6840                             SET_SRC (x)));
6841           continue;
6842         }
6843       else
6844         break;
6845
6846       while (GET_CODE (inner) == SUBREG && subreg_lowpart_p (inner))
6847         inner = SUBREG_REG (inner);
6848
6849       compute_mode = GET_MODE (inner);
6850
6851       /* Don't attempt bitwise arithmetic on non scalar integer modes.  */
6852       if (! SCALAR_INT_MODE_P (compute_mode))
6853         {
6854           enum machine_mode imode;
6855
6856           /* Don't do anything for vector or complex integral types.  */
6857           if (! FLOAT_MODE_P (compute_mode))
6858             break;
6859
6860           /* Try to find an integral mode to pun with.  */
6861           imode = mode_for_size (GET_MODE_BITSIZE (compute_mode), MODE_INT, 0);
6862           if (imode == BLKmode)
6863             break;
6864
6865           compute_mode = imode;
6866           inner = gen_lowpart (imode, inner);
6867         }
6868
6869       /* Compute a mask of LEN bits, if we can do this on the host machine.  */
6870       if (len >= HOST_BITS_PER_WIDE_INT)
6871         break;
6872
6873       /* Now compute the equivalent expression.  Make a copy of INNER
6874          for the SET_DEST in case it is a MEM into which we will substitute;
6875          we don't want shared RTL in that case.  */
6876       mask = GEN_INT (((HOST_WIDE_INT) 1 << len) - 1);
6877       cleared = simplify_gen_binary (AND, compute_mode,
6878                                      simplify_gen_unary (NOT, compute_mode,
6879                                        simplify_gen_binary (ASHIFT,
6880                                                             compute_mode,
6881                                                             mask, pos),
6882                                        compute_mode),
6883                                      inner);
6884       masked = simplify_gen_binary (ASHIFT, compute_mode,
6885                                     simplify_gen_binary (
6886                                       AND, compute_mode,
6887                                       gen_lowpart (compute_mode, SET_SRC (x)),
6888                                       mask),
6889                                     pos);
6890
6891       x = gen_rtx_SET (VOIDmode, copy_rtx (inner),
6892                        simplify_gen_binary (IOR, compute_mode,
6893                                             cleared, masked));
6894     }
6895
6896   return x;
6897 }
6898 \f
6899 /* Return an RTX for a reference to LEN bits of INNER.  If POS_RTX is nonzero,
6900    it is an RTX that represents a variable starting position; otherwise,
6901    POS is the (constant) starting bit position (counted from the LSB).
6902
6903    UNSIGNEDP is nonzero for an unsigned reference and zero for a
6904    signed reference.
6905
6906    IN_DEST is nonzero if this is a reference in the destination of a
6907    SET.  This is used when a ZERO_ or SIGN_EXTRACT isn't needed.  If nonzero,
6908    a STRICT_LOW_PART will be used, if zero, ZERO_EXTEND or SIGN_EXTEND will
6909    be used.
6910
6911    IN_COMPARE is nonzero if we are in a COMPARE.  This means that a
6912    ZERO_EXTRACT should be built even for bits starting at bit 0.
6913
6914    MODE is the desired mode of the result (if IN_DEST == 0).
6915
6916    The result is an RTX for the extraction or NULL_RTX if the target
6917    can't handle it.  */
6918
6919 static rtx
6920 make_extraction (enum machine_mode mode, rtx inner, HOST_WIDE_INT pos,
6921                  rtx pos_rtx, unsigned HOST_WIDE_INT len, int unsignedp,
6922                  int in_dest, int in_compare)
6923 {
6924   /* This mode describes the size of the storage area
6925      to fetch the overall value from.  Within that, we
6926      ignore the POS lowest bits, etc.  */
6927   enum machine_mode is_mode = GET_MODE (inner);
6928   enum machine_mode inner_mode;
6929   enum machine_mode wanted_inner_mode;
6930   enum machine_mode wanted_inner_reg_mode = word_mode;
6931   enum machine_mode pos_mode = word_mode;
6932   enum machine_mode extraction_mode = word_mode;
6933   enum machine_mode tmode = mode_for_size (len, MODE_INT, 1);
6934   rtx new_rtx = 0;
6935   rtx orig_pos_rtx = pos_rtx;
6936   HOST_WIDE_INT orig_pos;
6937
6938   if (GET_CODE (inner) == SUBREG && subreg_lowpart_p (inner))
6939     {
6940       /* If going from (subreg:SI (mem:QI ...)) to (mem:QI ...),
6941          consider just the QI as the memory to extract from.
6942          The subreg adds or removes high bits; its mode is
6943          irrelevant to the meaning of this extraction,
6944          since POS and LEN count from the lsb.  */
6945       if (MEM_P (SUBREG_REG (inner)))
6946         is_mode = GET_MODE (SUBREG_REG (inner));
6947       inner = SUBREG_REG (inner);
6948     }
6949   else if (GET_CODE (inner) == ASHIFT
6950            && CONST_INT_P (XEXP (inner, 1))
6951            && pos_rtx == 0 && pos == 0
6952            && len > (unsigned HOST_WIDE_INT) INTVAL (XEXP (inner, 1)))
6953     {
6954       /* We're extracting the least significant bits of an rtx
6955          (ashift X (const_int C)), where LEN > C.  Extract the
6956          least significant (LEN - C) bits of X, giving an rtx
6957          whose mode is MODE, then shift it left C times.  */
6958       new_rtx = make_extraction (mode, XEXP (inner, 0),
6959                              0, 0, len - INTVAL (XEXP (inner, 1)),
6960                              unsignedp, in_dest, in_compare);
6961       if (new_rtx != 0)
6962         return gen_rtx_ASHIFT (mode, new_rtx, XEXP (inner, 1));
6963     }
6964
6965   inner_mode = GET_MODE (inner);
6966
6967   if (pos_rtx && CONST_INT_P (pos_rtx))
6968     pos = INTVAL (pos_rtx), pos_rtx = 0;
6969
6970   /* See if this can be done without an extraction.  We never can if the
6971      width of the field is not the same as that of some integer mode. For
6972      registers, we can only avoid the extraction if the position is at the
6973      low-order bit and this is either not in the destination or we have the
6974      appropriate STRICT_LOW_PART operation available.
6975
6976      For MEM, we can avoid an extract if the field starts on an appropriate
6977      boundary and we can change the mode of the memory reference.  */
6978
6979   if (tmode != BLKmode
6980       && ((pos_rtx == 0 && (pos % BITS_PER_WORD) == 0
6981            && !MEM_P (inner)
6982            && (inner_mode == tmode
6983                || !REG_P (inner)
6984                || TRULY_NOOP_TRUNCATION (GET_MODE_BITSIZE (tmode),
6985                                          GET_MODE_BITSIZE (inner_mode))
6986                || reg_truncated_to_mode (tmode, inner))
6987            && (! in_dest
6988                || (REG_P (inner)
6989                    && have_insn_for (STRICT_LOW_PART, tmode))))
6990           || (MEM_P (inner) && pos_rtx == 0
6991               && (pos
6992                   % (STRICT_ALIGNMENT ? GET_MODE_ALIGNMENT (tmode)
6993                      : BITS_PER_UNIT)) == 0
6994               /* We can't do this if we are widening INNER_MODE (it
6995                  may not be aligned, for one thing).  */
6996               && GET_MODE_BITSIZE (inner_mode) >= GET_MODE_BITSIZE (tmode)
6997               && (inner_mode == tmode
6998                   || (! mode_dependent_address_p (XEXP (inner, 0))
6999                       && ! MEM_VOLATILE_P (inner))))))
7000     {
7001       /* If INNER is a MEM, make a new MEM that encompasses just the desired
7002          field.  If the original and current mode are the same, we need not
7003          adjust the offset.  Otherwise, we do if bytes big endian.
7004
7005          If INNER is not a MEM, get a piece consisting of just the field
7006          of interest (in this case POS % BITS_PER_WORD must be 0).  */
7007
7008       if (MEM_P (inner))
7009         {
7010           HOST_WIDE_INT offset;
7011
7012           /* POS counts from lsb, but make OFFSET count in memory order.  */
7013           if (BYTES_BIG_ENDIAN)
7014             offset = (GET_MODE_BITSIZE (is_mode) - len - pos) / BITS_PER_UNIT;
7015           else
7016             offset = pos / BITS_PER_UNIT;
7017
7018           new_rtx = adjust_address_nv (inner, tmode, offset);
7019         }
7020       else if (REG_P (inner))
7021         {
7022           if (tmode != inner_mode)
7023             {
7024               /* We can't call gen_lowpart in a DEST since we
7025                  always want a SUBREG (see below) and it would sometimes
7026                  return a new hard register.  */
7027               if (pos || in_dest)
7028                 {
7029                   HOST_WIDE_INT final_word = pos / BITS_PER_WORD;
7030
7031                   if (WORDS_BIG_ENDIAN
7032                       && GET_MODE_SIZE (inner_mode) > UNITS_PER_WORD)
7033                     final_word = ((GET_MODE_SIZE (inner_mode)
7034                                    - GET_MODE_SIZE (tmode))
7035                                   / UNITS_PER_WORD) - final_word;
7036
7037                   final_word *= UNITS_PER_WORD;
7038                   if (BYTES_BIG_ENDIAN &&
7039                       GET_MODE_SIZE (inner_mode) > GET_MODE_SIZE (tmode))
7040                     final_word += (GET_MODE_SIZE (inner_mode)
7041                                    - GET_MODE_SIZE (tmode)) % UNITS_PER_WORD;
7042
7043                   /* Avoid creating invalid subregs, for example when
7044                      simplifying (x>>32)&255.  */
7045                   if (!validate_subreg (tmode, inner_mode, inner, final_word))
7046                     return NULL_RTX;
7047
7048                   new_rtx = gen_rtx_SUBREG (tmode, inner, final_word);
7049                 }
7050               else
7051                 new_rtx = gen_lowpart (tmode, inner);
7052             }
7053           else
7054             new_rtx = inner;
7055         }
7056       else
7057         new_rtx = force_to_mode (inner, tmode,
7058                              len >= HOST_BITS_PER_WIDE_INT
7059                              ? ~(unsigned HOST_WIDE_INT) 0
7060                              : ((unsigned HOST_WIDE_INT) 1 << len) - 1,
7061                              0);
7062
7063       /* If this extraction is going into the destination of a SET,
7064          make a STRICT_LOW_PART unless we made a MEM.  */
7065
7066       if (in_dest)
7067         return (MEM_P (new_rtx) ? new_rtx
7068                 : (GET_CODE (new_rtx) != SUBREG
7069                    ? gen_rtx_CLOBBER (tmode, const0_rtx)
7070                    : gen_rtx_STRICT_LOW_PART (VOIDmode, new_rtx)));
7071
7072       if (mode == tmode)
7073         return new_rtx;
7074
7075       if (CONST_INT_P (new_rtx)
7076           || GET_CODE (new_rtx) == CONST_DOUBLE)
7077         return simplify_unary_operation (unsignedp ? ZERO_EXTEND : SIGN_EXTEND,
7078                                          mode, new_rtx, tmode);
7079
7080       /* If we know that no extraneous bits are set, and that the high
7081          bit is not set, convert the extraction to the cheaper of
7082          sign and zero extension, that are equivalent in these cases.  */
7083       if (flag_expensive_optimizations
7084           && (GET_MODE_BITSIZE (tmode) <= HOST_BITS_PER_WIDE_INT
7085               && ((nonzero_bits (new_rtx, tmode)
7086                    & ~(((unsigned HOST_WIDE_INT)
7087                         GET_MODE_MASK (tmode))
7088                        >> 1))
7089                   == 0)))
7090         {
7091           rtx temp = gen_rtx_ZERO_EXTEND (mode, new_rtx);
7092           rtx temp1 = gen_rtx_SIGN_EXTEND (mode, new_rtx);
7093
7094           /* Prefer ZERO_EXTENSION, since it gives more information to
7095              backends.  */
7096           if (rtx_cost (temp, SET, optimize_this_for_speed_p)
7097               <= rtx_cost (temp1, SET, optimize_this_for_speed_p))
7098             return temp;
7099           return temp1;
7100         }
7101
7102       /* Otherwise, sign- or zero-extend unless we already are in the
7103          proper mode.  */
7104
7105       return (gen_rtx_fmt_e (unsignedp ? ZERO_EXTEND : SIGN_EXTEND,
7106                              mode, new_rtx));
7107     }
7108
7109   /* Unless this is a COMPARE or we have a funny memory reference,
7110      don't do anything with zero-extending field extracts starting at
7111      the low-order bit since they are simple AND operations.  */
7112   if (pos_rtx == 0 && pos == 0 && ! in_dest
7113       && ! in_compare && unsignedp)
7114     return 0;
7115
7116   /* Unless INNER is not MEM, reject this if we would be spanning bytes or
7117      if the position is not a constant and the length is not 1.  In all
7118      other cases, we would only be going outside our object in cases when
7119      an original shift would have been undefined.  */
7120   if (MEM_P (inner)
7121       && ((pos_rtx == 0 && pos + len > GET_MODE_BITSIZE (is_mode))
7122           || (pos_rtx != 0 && len != 1)))
7123     return 0;
7124
7125   /* Get the mode to use should INNER not be a MEM, the mode for the position,
7126      and the mode for the result.  */
7127   if (in_dest && mode_for_extraction (EP_insv, -1) != MAX_MACHINE_MODE)
7128     {
7129       wanted_inner_reg_mode = mode_for_extraction (EP_insv, 0);
7130       pos_mode = mode_for_extraction (EP_insv, 2);
7131       extraction_mode = mode_for_extraction (EP_insv, 3);
7132     }
7133
7134   if (! in_dest && unsignedp
7135       && mode_for_extraction (EP_extzv, -1) != MAX_MACHINE_MODE)
7136     {
7137       wanted_inner_reg_mode = mode_for_extraction (EP_extzv, 1);
7138       pos_mode = mode_for_extraction (EP_extzv, 3);
7139       extraction_mode = mode_for_extraction (EP_extzv, 0);
7140     }
7141
7142   if (! in_dest && ! unsignedp
7143       && mode_for_extraction (EP_extv, -1) != MAX_MACHINE_MODE)
7144     {
7145       wanted_inner_reg_mode = mode_for_extraction (EP_extv, 1);
7146       pos_mode = mode_for_extraction (EP_extv, 3);
7147       extraction_mode = mode_for_extraction (EP_extv, 0);
7148     }
7149
7150   /* Never narrow an object, since that might not be safe.  */
7151
7152   if (mode != VOIDmode
7153       && GET_MODE_SIZE (extraction_mode) < GET_MODE_SIZE (mode))
7154     extraction_mode = mode;
7155
7156   if (pos_rtx && GET_MODE (pos_rtx) != VOIDmode
7157       && GET_MODE_SIZE (pos_mode) < GET_MODE_SIZE (GET_MODE (pos_rtx)))
7158     pos_mode = GET_MODE (pos_rtx);
7159
7160   /* If this is not from memory, the desired mode is the preferred mode
7161      for an extraction pattern's first input operand, or word_mode if there
7162      is none.  */
7163   if (!MEM_P (inner))
7164     wanted_inner_mode = wanted_inner_reg_mode;
7165   else
7166     {
7167       /* Be careful not to go beyond the extracted object and maintain the
7168          natural alignment of the memory.  */
7169       wanted_inner_mode = smallest_mode_for_size (len, MODE_INT);
7170       while (pos % GET_MODE_BITSIZE (wanted_inner_mode) + len
7171              > GET_MODE_BITSIZE (wanted_inner_mode))
7172         {
7173           wanted_inner_mode = GET_MODE_WIDER_MODE (wanted_inner_mode);
7174           gcc_assert (wanted_inner_mode != VOIDmode);
7175         }
7176
7177       /* If we have to change the mode of memory and cannot, the desired mode
7178          is EXTRACTION_MODE.  */
7179       if (inner_mode != wanted_inner_mode
7180           && (mode_dependent_address_p (XEXP (inner, 0))
7181               || MEM_VOLATILE_P (inner)
7182               || pos_rtx))
7183         wanted_inner_mode = extraction_mode;
7184     }
7185
7186   orig_pos = pos;
7187
7188   if (BITS_BIG_ENDIAN)
7189     {
7190       /* POS is passed as if BITS_BIG_ENDIAN == 0, so we need to convert it to
7191          BITS_BIG_ENDIAN style.  If position is constant, compute new
7192          position.  Otherwise, build subtraction.
7193          Note that POS is relative to the mode of the original argument.
7194          If it's a MEM we need to recompute POS relative to that.
7195          However, if we're extracting from (or inserting into) a register,
7196          we want to recompute POS relative to wanted_inner_mode.  */
7197       int width = (MEM_P (inner)
7198                    ? GET_MODE_BITSIZE (is_mode)
7199                    : GET_MODE_BITSIZE (wanted_inner_mode));
7200
7201       if (pos_rtx == 0)
7202         pos = width - len - pos;
7203       else
7204         pos_rtx
7205           = gen_rtx_MINUS (GET_MODE (pos_rtx), GEN_INT (width - len), pos_rtx);
7206       /* POS may be less than 0 now, but we check for that below.
7207          Note that it can only be less than 0 if !MEM_P (inner).  */
7208     }
7209
7210   /* If INNER has a wider mode, and this is a constant extraction, try to
7211      make it smaller and adjust the byte to point to the byte containing
7212      the value.  */
7213   if (wanted_inner_mode != VOIDmode
7214       && inner_mode != wanted_inner_mode
7215       && ! pos_rtx
7216       && GET_MODE_SIZE (wanted_inner_mode) < GET_MODE_SIZE (is_mode)
7217       && MEM_P (inner)
7218       && ! mode_dependent_address_p (XEXP (inner, 0))
7219       && ! MEM_VOLATILE_P (inner))
7220     {
7221       int offset = 0;
7222
7223       /* The computations below will be correct if the machine is big
7224          endian in both bits and bytes or little endian in bits and bytes.
7225          If it is mixed, we must adjust.  */
7226
7227       /* If bytes are big endian and we had a paradoxical SUBREG, we must
7228          adjust OFFSET to compensate.  */
7229       if (BYTES_BIG_ENDIAN
7230           && GET_MODE_SIZE (inner_mode) < GET_MODE_SIZE (is_mode))
7231         offset -= GET_MODE_SIZE (is_mode) - GET_MODE_SIZE (inner_mode);
7232
7233       /* We can now move to the desired byte.  */
7234       offset += (pos / GET_MODE_BITSIZE (wanted_inner_mode))
7235                 * GET_MODE_SIZE (wanted_inner_mode);
7236       pos %= GET_MODE_BITSIZE (wanted_inner_mode);
7237
7238       if (BYTES_BIG_ENDIAN != BITS_BIG_ENDIAN
7239           && is_mode != wanted_inner_mode)
7240         offset = (GET_MODE_SIZE (is_mode)
7241                   - GET_MODE_SIZE (wanted_inner_mode) - offset);
7242
7243       inner = adjust_address_nv (inner, wanted_inner_mode, offset);
7244     }
7245
7246   /* If INNER is not memory, get it into the proper mode.  If we are changing
7247      its mode, POS must be a constant and smaller than the size of the new
7248      mode.  */
7249   else if (!MEM_P (inner))
7250     {
7251       /* On the LHS, don't create paradoxical subregs implicitely truncating
7252          the register unless TRULY_NOOP_TRUNCATION.  */
7253       if (in_dest
7254           && !TRULY_NOOP_TRUNCATION (GET_MODE_BITSIZE (GET_MODE (inner)),
7255                                      GET_MODE_BITSIZE (wanted_inner_mode)))
7256         return NULL_RTX;
7257
7258       if (GET_MODE (inner) != wanted_inner_mode
7259           && (pos_rtx != 0
7260               || orig_pos + len > GET_MODE_BITSIZE (wanted_inner_mode)))
7261         return NULL_RTX;
7262
7263       if (orig_pos < 0)
7264         return NULL_RTX;
7265
7266       inner = force_to_mode (inner, wanted_inner_mode,
7267                              pos_rtx
7268                              || len + orig_pos >= HOST_BITS_PER_WIDE_INT
7269                              ? ~(unsigned HOST_WIDE_INT) 0
7270                              : ((((unsigned HOST_WIDE_INT) 1 << len) - 1)
7271                                 << orig_pos),
7272                              0);
7273     }
7274
7275   /* Adjust mode of POS_RTX, if needed.  If we want a wider mode, we
7276      have to zero extend.  Otherwise, we can just use a SUBREG.  */
7277   if (pos_rtx != 0
7278       && GET_MODE_SIZE (pos_mode) > GET_MODE_SIZE (GET_MODE (pos_rtx)))
7279     {
7280       rtx temp = gen_rtx_ZERO_EXTEND (pos_mode, pos_rtx);
7281
7282       /* If we know that no extraneous bits are set, and that the high
7283          bit is not set, convert extraction to cheaper one - either
7284          SIGN_EXTENSION or ZERO_EXTENSION, that are equivalent in these
7285          cases.  */
7286       if (flag_expensive_optimizations
7287           && (GET_MODE_BITSIZE (GET_MODE (pos_rtx)) <= HOST_BITS_PER_WIDE_INT
7288               && ((nonzero_bits (pos_rtx, GET_MODE (pos_rtx))
7289                    & ~(((unsigned HOST_WIDE_INT)
7290                         GET_MODE_MASK (GET_MODE (pos_rtx)))
7291                        >> 1))
7292                   == 0)))
7293         {
7294           rtx temp1 = gen_rtx_SIGN_EXTEND (pos_mode, pos_rtx);
7295
7296           /* Prefer ZERO_EXTENSION, since it gives more information to
7297              backends.  */
7298           if (rtx_cost (temp1, SET, optimize_this_for_speed_p)
7299               < rtx_cost (temp, SET, optimize_this_for_speed_p))
7300             temp = temp1;
7301         }
7302       pos_rtx = temp;
7303     }
7304   else if (pos_rtx != 0
7305            && GET_MODE_SIZE (pos_mode) < GET_MODE_SIZE (GET_MODE (pos_rtx)))
7306     pos_rtx = gen_lowpart (pos_mode, pos_rtx);
7307
7308   /* Make POS_RTX unless we already have it and it is correct.  If we don't
7309      have a POS_RTX but we do have an ORIG_POS_RTX, the latter must
7310      be a CONST_INT.  */
7311   if (pos_rtx == 0 && orig_pos_rtx != 0 && INTVAL (orig_pos_rtx) == pos)
7312     pos_rtx = orig_pos_rtx;
7313
7314   else if (pos_rtx == 0)
7315     pos_rtx = GEN_INT (pos);
7316
7317   /* Make the required operation.  See if we can use existing rtx.  */
7318   new_rtx = gen_rtx_fmt_eee (unsignedp ? ZERO_EXTRACT : SIGN_EXTRACT,
7319                          extraction_mode, inner, GEN_INT (len), pos_rtx);
7320   if (! in_dest)
7321     new_rtx = gen_lowpart (mode, new_rtx);
7322
7323   return new_rtx;
7324 }
7325 \f
7326 /* See if X contains an ASHIFT of COUNT or more bits that can be commuted
7327    with any other operations in X.  Return X without that shift if so.  */
7328
7329 static rtx
7330 extract_left_shift (rtx x, int count)
7331 {
7332   enum rtx_code code = GET_CODE (x);
7333   enum machine_mode mode = GET_MODE (x);
7334   rtx tem;
7335
7336   switch (code)
7337     {
7338     case ASHIFT:
7339       /* This is the shift itself.  If it is wide enough, we will return
7340          either the value being shifted if the shift count is equal to
7341          COUNT or a shift for the difference.  */
7342       if (CONST_INT_P (XEXP (x, 1))
7343           && INTVAL (XEXP (x, 1)) >= count)
7344         return simplify_shift_const (NULL_RTX, ASHIFT, mode, XEXP (x, 0),
7345                                      INTVAL (XEXP (x, 1)) - count);
7346       break;
7347
7348     case NEG:  case NOT:
7349       if ((tem = extract_left_shift (XEXP (x, 0), count)) != 0)
7350         return simplify_gen_unary (code, mode, tem, mode);
7351
7352       break;
7353
7354     case PLUS:  case IOR:  case XOR:  case AND:
7355       /* If we can safely shift this constant and we find the inner shift,
7356          make a new operation.  */
7357       if (CONST_INT_P (XEXP (x, 1))
7358           && (INTVAL (XEXP (x, 1)) & ((((HOST_WIDE_INT) 1 << count)) - 1)) == 0
7359           && (tem = extract_left_shift (XEXP (x, 0), count)) != 0)
7360         return simplify_gen_binary (code, mode, tem,
7361                                     GEN_INT (INTVAL (XEXP (x, 1)) >> count));
7362
7363       break;
7364
7365     default:
7366       break;
7367     }
7368
7369   return 0;
7370 }
7371 \f
7372 /* Look at the expression rooted at X.  Look for expressions
7373    equivalent to ZERO_EXTRACT, SIGN_EXTRACT, ZERO_EXTEND, SIGN_EXTEND.
7374    Form these expressions.
7375
7376    Return the new rtx, usually just X.
7377
7378    Also, for machines like the VAX that don't have logical shift insns,
7379    try to convert logical to arithmetic shift operations in cases where
7380    they are equivalent.  This undoes the canonicalizations to logical
7381    shifts done elsewhere.
7382
7383    We try, as much as possible, to re-use rtl expressions to save memory.
7384
7385    IN_CODE says what kind of expression we are processing.  Normally, it is
7386    SET.  In a memory address (inside a MEM, PLUS or minus, the latter two
7387    being kludges), it is MEM.  When processing the arguments of a comparison
7388    or a COMPARE against zero, it is COMPARE.  */
7389
7390 static rtx
7391 make_compound_operation (rtx x, enum rtx_code in_code)
7392 {
7393   enum rtx_code code = GET_CODE (x);
7394   enum machine_mode mode = GET_MODE (x);
7395   int mode_width = GET_MODE_BITSIZE (mode);
7396   rtx rhs, lhs;
7397   enum rtx_code next_code;
7398   int i, j;
7399   rtx new_rtx = 0;
7400   rtx tem;
7401   const char *fmt;
7402
7403   /* Select the code to be used in recursive calls.  Once we are inside an
7404      address, we stay there.  If we have a comparison, set to COMPARE,
7405      but once inside, go back to our default of SET.  */
7406
7407   next_code = (code == MEM ? MEM
7408                : ((code == PLUS || code == MINUS)
7409                   && SCALAR_INT_MODE_P (mode)) ? MEM
7410                : ((code == COMPARE || COMPARISON_P (x))
7411                   && XEXP (x, 1) == const0_rtx) ? COMPARE
7412                : in_code == COMPARE ? SET : in_code);
7413
7414   /* Process depending on the code of this operation.  If NEW is set
7415      nonzero, it will be returned.  */
7416
7417   switch (code)
7418     {
7419     case ASHIFT:
7420       /* Convert shifts by constants into multiplications if inside
7421          an address.  */
7422       if (in_code == MEM && CONST_INT_P (XEXP (x, 1))
7423           && INTVAL (XEXP (x, 1)) < HOST_BITS_PER_WIDE_INT
7424           && INTVAL (XEXP (x, 1)) >= 0)
7425         {
7426           HOST_WIDE_INT count = INTVAL (XEXP (x, 1));
7427           HOST_WIDE_INT multval = (HOST_WIDE_INT) 1 << count;
7428
7429           new_rtx = make_compound_operation (XEXP (x, 0), next_code);
7430           if (GET_CODE (new_rtx) == NEG)
7431             {
7432               new_rtx = XEXP (new_rtx, 0);
7433               multval = -multval;
7434             }
7435           multval = trunc_int_for_mode (multval, mode);
7436           new_rtx = gen_rtx_MULT (mode, new_rtx, GEN_INT (multval));
7437         }
7438       break;
7439
7440     case PLUS:
7441       lhs = XEXP (x, 0);
7442       rhs = XEXP (x, 1);
7443       lhs = make_compound_operation (lhs, next_code);
7444       rhs = make_compound_operation (rhs, next_code);
7445       if (GET_CODE (lhs) == MULT && GET_CODE (XEXP (lhs, 0)) == NEG
7446           && SCALAR_INT_MODE_P (mode))
7447         {
7448           tem = simplify_gen_binary (MULT, mode, XEXP (XEXP (lhs, 0), 0),
7449                                      XEXP (lhs, 1));
7450           new_rtx = simplify_gen_binary (MINUS, mode, rhs, tem);
7451         }
7452       else if (GET_CODE (lhs) == MULT
7453                && (CONST_INT_P (XEXP (lhs, 1)) && INTVAL (XEXP (lhs, 1)) < 0))
7454         {
7455           tem = simplify_gen_binary (MULT, mode, XEXP (lhs, 0),
7456                                      simplify_gen_unary (NEG, mode,
7457                                                          XEXP (lhs, 1),
7458                                                          mode));
7459           new_rtx = simplify_gen_binary (MINUS, mode, rhs, tem);
7460         }
7461       else
7462         {
7463           SUBST (XEXP (x, 0), lhs);
7464           SUBST (XEXP (x, 1), rhs);
7465           goto maybe_swap;
7466         }
7467       x = gen_lowpart (mode, new_rtx);
7468       goto maybe_swap;
7469
7470     case MINUS:
7471       lhs = XEXP (x, 0);
7472       rhs = XEXP (x, 1);
7473       lhs = make_compound_operation (lhs, next_code);
7474       rhs = make_compound_operation (rhs, next_code);
7475       if (GET_CODE (rhs) == MULT && GET_CODE (XEXP (rhs, 0)) == NEG
7476           && SCALAR_INT_MODE_P (mode))
7477         {
7478           tem = simplify_gen_binary (MULT, mode, XEXP (XEXP (rhs, 0), 0),
7479                                      XEXP (rhs, 1));
7480           new_rtx = simplify_gen_binary (PLUS, mode, tem, lhs);
7481         }
7482       else if (GET_CODE (rhs) == MULT
7483                && (CONST_INT_P (XEXP (rhs, 1)) && INTVAL (XEXP (rhs, 1)) < 0))
7484         {
7485           tem = simplify_gen_binary (MULT, mode, XEXP (rhs, 0),
7486                                      simplify_gen_unary (NEG, mode,
7487                                                          XEXP (rhs, 1),
7488                                                          mode));
7489           new_rtx = simplify_gen_binary (PLUS, mode, tem, lhs);
7490         }
7491       else
7492         {
7493           SUBST (XEXP (x, 0), lhs);
7494           SUBST (XEXP (x, 1), rhs);
7495           return x;
7496         }
7497       return gen_lowpart (mode, new_rtx);
7498
7499     case AND:
7500       /* If the second operand is not a constant, we can't do anything
7501          with it.  */
7502       if (!CONST_INT_P (XEXP (x, 1)))
7503         break;
7504
7505       /* If the constant is a power of two minus one and the first operand
7506          is a logical right shift, make an extraction.  */
7507       if (GET_CODE (XEXP (x, 0)) == LSHIFTRT
7508           && (i = exact_log2 (INTVAL (XEXP (x, 1)) + 1)) >= 0)
7509         {
7510           new_rtx = make_compound_operation (XEXP (XEXP (x, 0), 0), next_code);
7511           new_rtx = make_extraction (mode, new_rtx, 0, XEXP (XEXP (x, 0), 1), i, 1,
7512                                  0, in_code == COMPARE);
7513         }
7514
7515       /* Same as previous, but for (subreg (lshiftrt ...)) in first op.  */
7516       else if (GET_CODE (XEXP (x, 0)) == SUBREG
7517                && subreg_lowpart_p (XEXP (x, 0))
7518                && GET_CODE (SUBREG_REG (XEXP (x, 0))) == LSHIFTRT
7519                && (i = exact_log2 (INTVAL (XEXP (x, 1)) + 1)) >= 0)
7520         {
7521           new_rtx = make_compound_operation (XEXP (SUBREG_REG (XEXP (x, 0)), 0),
7522                                          next_code);
7523           new_rtx = make_extraction (GET_MODE (SUBREG_REG (XEXP (x, 0))), new_rtx, 0,
7524                                  XEXP (SUBREG_REG (XEXP (x, 0)), 1), i, 1,
7525                                  0, in_code == COMPARE);
7526         }
7527       /* Same as previous, but for (xor/ior (lshiftrt...) (lshiftrt...)).  */
7528       else if ((GET_CODE (XEXP (x, 0)) == XOR
7529                 || GET_CODE (XEXP (x, 0)) == IOR)
7530                && GET_CODE (XEXP (XEXP (x, 0), 0)) == LSHIFTRT
7531                && GET_CODE (XEXP (XEXP (x, 0), 1)) == LSHIFTRT
7532                && (i = exact_log2 (INTVAL (XEXP (x, 1)) + 1)) >= 0)
7533         {
7534           /* Apply the distributive law, and then try to make extractions.  */
7535           new_rtx = gen_rtx_fmt_ee (GET_CODE (XEXP (x, 0)), mode,
7536                                 gen_rtx_AND (mode, XEXP (XEXP (x, 0), 0),
7537                                              XEXP (x, 1)),
7538                                 gen_rtx_AND (mode, XEXP (XEXP (x, 0), 1),
7539                                              XEXP (x, 1)));
7540           new_rtx = make_compound_operation (new_rtx, in_code);
7541         }
7542
7543       /* If we are have (and (rotate X C) M) and C is larger than the number
7544          of bits in M, this is an extraction.  */
7545
7546       else if (GET_CODE (XEXP (x, 0)) == ROTATE
7547                && CONST_INT_P (XEXP (XEXP (x, 0), 1))
7548                && (i = exact_log2 (INTVAL (XEXP (x, 1)) + 1)) >= 0
7549                && i <= INTVAL (XEXP (XEXP (x, 0), 1)))
7550         {
7551           new_rtx = make_compound_operation (XEXP (XEXP (x, 0), 0), next_code);
7552           new_rtx = make_extraction (mode, new_rtx,
7553                                  (GET_MODE_BITSIZE (mode)
7554                                   - INTVAL (XEXP (XEXP (x, 0), 1))),
7555                                  NULL_RTX, i, 1, 0, in_code == COMPARE);
7556         }
7557
7558       /* On machines without logical shifts, if the operand of the AND is
7559          a logical shift and our mask turns off all the propagated sign
7560          bits, we can replace the logical shift with an arithmetic shift.  */
7561       else if (GET_CODE (XEXP (x, 0)) == LSHIFTRT
7562                && !have_insn_for (LSHIFTRT, mode)
7563                && have_insn_for (ASHIFTRT, mode)
7564                && CONST_INT_P (XEXP (XEXP (x, 0), 1))
7565                && INTVAL (XEXP (XEXP (x, 0), 1)) >= 0
7566                && INTVAL (XEXP (XEXP (x, 0), 1)) < HOST_BITS_PER_WIDE_INT
7567                && mode_width <= HOST_BITS_PER_WIDE_INT)
7568         {
7569           unsigned HOST_WIDE_INT mask = GET_MODE_MASK (mode);
7570
7571           mask >>= INTVAL (XEXP (XEXP (x, 0), 1));
7572           if ((INTVAL (XEXP (x, 1)) & ~mask) == 0)
7573             SUBST (XEXP (x, 0),
7574                    gen_rtx_ASHIFTRT (mode,
7575                                      make_compound_operation
7576                                      (XEXP (XEXP (x, 0), 0), next_code),
7577                                      XEXP (XEXP (x, 0), 1)));
7578         }
7579
7580       /* If the constant is one less than a power of two, this might be
7581          representable by an extraction even if no shift is present.
7582          If it doesn't end up being a ZERO_EXTEND, we will ignore it unless
7583          we are in a COMPARE.  */
7584       else if ((i = exact_log2 (INTVAL (XEXP (x, 1)) + 1)) >= 0)
7585         new_rtx = make_extraction (mode,
7586                                make_compound_operation (XEXP (x, 0),
7587                                                         next_code),
7588                                0, NULL_RTX, i, 1, 0, in_code == COMPARE);
7589
7590       /* If we are in a comparison and this is an AND with a power of two,
7591          convert this into the appropriate bit extract.  */
7592       else if (in_code == COMPARE
7593                && (i = exact_log2 (INTVAL (XEXP (x, 1)))) >= 0)
7594         new_rtx = make_extraction (mode,
7595                                make_compound_operation (XEXP (x, 0),
7596                                                         next_code),
7597                                i, NULL_RTX, 1, 1, 0, 1);
7598
7599       break;
7600
7601     case LSHIFTRT:
7602       /* If the sign bit is known to be zero, replace this with an
7603          arithmetic shift.  */
7604       if (have_insn_for (ASHIFTRT, mode)
7605           && ! have_insn_for (LSHIFTRT, mode)
7606           && mode_width <= HOST_BITS_PER_WIDE_INT
7607           && (nonzero_bits (XEXP (x, 0), mode) & (1 << (mode_width - 1))) == 0)
7608         {
7609           new_rtx = gen_rtx_ASHIFTRT (mode,
7610                                   make_compound_operation (XEXP (x, 0),
7611                                                            next_code),
7612                                   XEXP (x, 1));
7613           break;
7614         }
7615
7616       /* ... fall through ...  */
7617
7618     case ASHIFTRT:
7619       lhs = XEXP (x, 0);
7620       rhs = XEXP (x, 1);
7621
7622       /* If we have (ashiftrt (ashift foo C1) C2) with C2 >= C1,
7623          this is a SIGN_EXTRACT.  */
7624       if (CONST_INT_P (rhs)
7625           && GET_CODE (lhs) == ASHIFT
7626           && CONST_INT_P (XEXP (lhs, 1))
7627           && INTVAL (rhs) >= INTVAL (XEXP (lhs, 1))
7628           && INTVAL (rhs) < mode_width)
7629         {
7630           new_rtx = make_compound_operation (XEXP (lhs, 0), next_code);
7631           new_rtx = make_extraction (mode, new_rtx,
7632                                  INTVAL (rhs) - INTVAL (XEXP (lhs, 1)),
7633                                  NULL_RTX, mode_width - INTVAL (rhs),
7634                                  code == LSHIFTRT, 0, in_code == COMPARE);
7635           break;
7636         }
7637
7638       /* See if we have operations between an ASHIFTRT and an ASHIFT.
7639          If so, try to merge the shifts into a SIGN_EXTEND.  We could
7640          also do this for some cases of SIGN_EXTRACT, but it doesn't
7641          seem worth the effort; the case checked for occurs on Alpha.  */
7642
7643       if (!OBJECT_P (lhs)
7644           && ! (GET_CODE (lhs) == SUBREG
7645                 && (OBJECT_P (SUBREG_REG (lhs))))
7646           && CONST_INT_P (rhs)
7647           && INTVAL (rhs) < HOST_BITS_PER_WIDE_INT
7648           && INTVAL (rhs) < mode_width
7649           && (new_rtx = extract_left_shift (lhs, INTVAL (rhs))) != 0)
7650         new_rtx = make_extraction (mode, make_compound_operation (new_rtx, next_code),
7651                                0, NULL_RTX, mode_width - INTVAL (rhs),
7652                                code == LSHIFTRT, 0, in_code == COMPARE);
7653
7654       break;
7655
7656     case SUBREG:
7657       /* Call ourselves recursively on the inner expression.  If we are
7658          narrowing the object and it has a different RTL code from
7659          what it originally did, do this SUBREG as a force_to_mode.  */
7660       {
7661         rtx inner = SUBREG_REG (x), simplified;
7662
7663         tem = make_compound_operation (inner, in_code);
7664
7665         simplified
7666           = simplify_subreg (mode, tem, GET_MODE (inner), SUBREG_BYTE (x));
7667         if (simplified)
7668           tem = simplified;
7669
7670         if (GET_CODE (tem) != GET_CODE (inner)
7671             && GET_MODE_SIZE (mode) < GET_MODE_SIZE (GET_MODE (inner))
7672             && subreg_lowpart_p (x))
7673           {
7674             rtx newer = force_to_mode (tem, mode, ~(HOST_WIDE_INT) 0, 0);
7675
7676             /* If we have something other than a SUBREG, we might have
7677                done an expansion, so rerun ourselves.  */
7678             if (GET_CODE (newer) != SUBREG)
7679               newer = make_compound_operation (newer, in_code);
7680
7681             /* force_to_mode can expand compounds.  If it just re-expanded the
7682                compound, use gen_lowpart to convert to the desired mode.  */
7683             if (rtx_equal_p (newer, x)
7684                 /* Likewise if it re-expanded the compound only partially.
7685                    This happens for SUBREG of ZERO_EXTRACT if they extract
7686                    the same number of bits.  */
7687                 || (GET_CODE (newer) == SUBREG
7688                     && (GET_CODE (SUBREG_REG (newer)) == LSHIFTRT
7689                         || GET_CODE (SUBREG_REG (newer)) == ASHIFTRT)
7690                     && GET_CODE (inner) == AND
7691                     && rtx_equal_p (SUBREG_REG (newer), XEXP (inner, 0))))
7692               return gen_lowpart (GET_MODE (x), tem);
7693
7694             return newer;
7695           }
7696
7697         if (simplified)
7698           return tem;
7699       }
7700       break;
7701
7702     default:
7703       break;
7704     }
7705
7706   if (new_rtx)
7707     {
7708       x = gen_lowpart (mode, new_rtx);
7709       code = GET_CODE (x);
7710     }
7711
7712   /* Now recursively process each operand of this operation.  */
7713   fmt = GET_RTX_FORMAT (code);
7714   for (i = 0; i < GET_RTX_LENGTH (code); i++)
7715     if (fmt[i] == 'e')
7716       {
7717         new_rtx = make_compound_operation (XEXP (x, i), next_code);
7718         SUBST (XEXP (x, i), new_rtx);
7719       }
7720     else if (fmt[i] == 'E')
7721       for (j = 0; j < XVECLEN (x, i); j++)
7722         {
7723           new_rtx = make_compound_operation (XVECEXP (x, i, j), next_code);
7724           SUBST (XVECEXP (x, i, j), new_rtx);
7725         }
7726
7727  maybe_swap:
7728   /* If this is a commutative operation, the changes to the operands
7729      may have made it noncanonical.  */
7730   if (COMMUTATIVE_ARITH_P (x)
7731       && swap_commutative_operands_p (XEXP (x, 0), XEXP (x, 1)))
7732     {
7733       tem = XEXP (x, 0);
7734       SUBST (XEXP (x, 0), XEXP (x, 1));
7735       SUBST (XEXP (x, 1), tem);
7736     }
7737
7738   return x;
7739 }
7740 \f
7741 /* Given M see if it is a value that would select a field of bits
7742    within an item, but not the entire word.  Return -1 if not.
7743    Otherwise, return the starting position of the field, where 0 is the
7744    low-order bit.
7745
7746    *PLEN is set to the length of the field.  */
7747
7748 static int
7749 get_pos_from_mask (unsigned HOST_WIDE_INT m, unsigned HOST_WIDE_INT *plen)
7750 {
7751   /* Get the bit number of the first 1 bit from the right, -1 if none.  */
7752   int pos = m ? ctz_hwi (m) : -1;
7753   int len = 0;
7754
7755   if (pos >= 0)
7756     /* Now shift off the low-order zero bits and see if we have a
7757        power of two minus 1.  */
7758     len = exact_log2 ((m >> pos) + 1);
7759
7760   if (len <= 0)
7761     pos = -1;
7762
7763   *plen = len;
7764   return pos;
7765 }
7766 \f
7767 /* If X refers to a register that equals REG in value, replace these
7768    references with REG.  */
7769 static rtx
7770 canon_reg_for_combine (rtx x, rtx reg)
7771 {
7772   rtx op0, op1, op2;
7773   const char *fmt;
7774   int i;
7775   bool copied;
7776
7777   enum rtx_code code = GET_CODE (x);
7778   switch (GET_RTX_CLASS (code))
7779     {
7780     case RTX_UNARY:
7781       op0 = canon_reg_for_combine (XEXP (x, 0), reg);
7782       if (op0 != XEXP (x, 0))
7783         return simplify_gen_unary (GET_CODE (x), GET_MODE (x), op0,
7784                                    GET_MODE (reg));
7785       break;
7786
7787     case RTX_BIN_ARITH:
7788     case RTX_COMM_ARITH:
7789       op0 = canon_reg_for_combine (XEXP (x, 0), reg);
7790       op1 = canon_reg_for_combine (XEXP (x, 1), reg);
7791       if (op0 != XEXP (x, 0) || op1 != XEXP (x, 1))
7792         return simplify_gen_binary (GET_CODE (x), GET_MODE (x), op0, op1);
7793       break;
7794
7795     case RTX_COMPARE:
7796     case RTX_COMM_COMPARE:
7797       op0 = canon_reg_for_combine (XEXP (x, 0), reg);
7798       op1 = canon_reg_for_combine (XEXP (x, 1), reg);
7799       if (op0 != XEXP (x, 0) || op1 != XEXP (x, 1))
7800         return simplify_gen_relational (GET_CODE (x), GET_MODE (x),
7801                                         GET_MODE (op0), op0, op1);
7802       break;
7803
7804     case RTX_TERNARY:
7805     case RTX_BITFIELD_OPS:
7806       op0 = canon_reg_for_combine (XEXP (x, 0), reg);
7807       op1 = canon_reg_for_combine (XEXP (x, 1), reg);
7808       op2 = canon_reg_for_combine (XEXP (x, 2), reg);
7809       if (op0 != XEXP (x, 0) || op1 != XEXP (x, 1) || op2 != XEXP (x, 2))
7810         return simplify_gen_ternary (GET_CODE (x), GET_MODE (x),
7811                                      GET_MODE (op0), op0, op1, op2);
7812
7813     case RTX_OBJ:
7814       if (REG_P (x))
7815         {
7816           if (rtx_equal_p (get_last_value (reg), x)
7817               || rtx_equal_p (reg, get_last_value (x)))
7818             return reg;
7819           else
7820             break;
7821         }
7822
7823       /* fall through */
7824
7825     default:
7826       fmt = GET_RTX_FORMAT (code);
7827       copied = false;
7828       for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
7829         if (fmt[i] == 'e')
7830           {
7831             rtx op = canon_reg_for_combine (XEXP (x, i), reg);
7832             if (op != XEXP (x, i))
7833               {
7834                 if (!copied)
7835                   {
7836                     copied = true;
7837                     x = copy_rtx (x);
7838                   }
7839                 XEXP (x, i) = op;
7840               }
7841           }
7842         else if (fmt[i] == 'E')
7843           {
7844             int j;
7845             for (j = 0; j < XVECLEN (x, i); j++)
7846               {
7847                 rtx op = canon_reg_for_combine (XVECEXP (x, i, j), reg);
7848                 if (op != XVECEXP (x, i, j))
7849                   {
7850                     if (!copied)
7851                       {
7852                         copied = true;
7853                         x = copy_rtx (x);
7854                       }
7855                     XVECEXP (x, i, j) = op;
7856                   }
7857               }
7858           }
7859
7860       break;
7861     }
7862
7863   return x;
7864 }
7865
7866 /* Return X converted to MODE.  If the value is already truncated to
7867    MODE we can just return a subreg even though in the general case we
7868    would need an explicit truncation.  */
7869
7870 static rtx
7871 gen_lowpart_or_truncate (enum machine_mode mode, rtx x)
7872 {
7873   if (!CONST_INT_P (x)
7874       && GET_MODE_SIZE (mode) < GET_MODE_SIZE (GET_MODE (x))
7875       && !TRULY_NOOP_TRUNCATION (GET_MODE_BITSIZE (mode),
7876                                  GET_MODE_BITSIZE (GET_MODE (x)))
7877       && !(REG_P (x) && reg_truncated_to_mode (mode, x)))
7878     {
7879       /* Bit-cast X into an integer mode.  */
7880       if (!SCALAR_INT_MODE_P (GET_MODE (x)))
7881         x = gen_lowpart (int_mode_for_mode (GET_MODE (x)), x);
7882       x = simplify_gen_unary (TRUNCATE, int_mode_for_mode (mode),
7883                               x, GET_MODE (x));
7884     }
7885
7886   return gen_lowpart (mode, x);
7887 }
7888
7889 /* See if X can be simplified knowing that we will only refer to it in
7890    MODE and will only refer to those bits that are nonzero in MASK.
7891    If other bits are being computed or if masking operations are done
7892    that select a superset of the bits in MASK, they can sometimes be
7893    ignored.
7894
7895    Return a possibly simplified expression, but always convert X to
7896    MODE.  If X is a CONST_INT, AND the CONST_INT with MASK.
7897
7898    If JUST_SELECT is nonzero, don't optimize by noticing that bits in MASK
7899    are all off in X.  This is used when X will be complemented, by either
7900    NOT, NEG, or XOR.  */
7901
7902 static rtx
7903 force_to_mode (rtx x, enum machine_mode mode, unsigned HOST_WIDE_INT mask,
7904                int just_select)
7905 {
7906   enum rtx_code code = GET_CODE (x);
7907   int next_select = just_select || code == XOR || code == NOT || code == NEG;
7908   enum machine_mode op_mode;
7909   unsigned HOST_WIDE_INT fuller_mask, nonzero;
7910   rtx op0, op1, temp;
7911
7912   /* If this is a CALL or ASM_OPERANDS, don't do anything.  Some of the
7913      code below will do the wrong thing since the mode of such an
7914      expression is VOIDmode.
7915
7916      Also do nothing if X is a CLOBBER; this can happen if X was
7917      the return value from a call to gen_lowpart.  */
7918   if (code == CALL || code == ASM_OPERANDS || code == CLOBBER)
7919     return x;
7920
7921   /* We want to perform the operation is its present mode unless we know
7922      that the operation is valid in MODE, in which case we do the operation
7923      in MODE.  */
7924   op_mode = ((GET_MODE_CLASS (mode) == GET_MODE_CLASS (GET_MODE (x))
7925               && have_insn_for (code, mode))
7926              ? mode : GET_MODE (x));
7927
7928   /* It is not valid to do a right-shift in a narrower mode
7929      than the one it came in with.  */
7930   if ((code == LSHIFTRT || code == ASHIFTRT)
7931       && GET_MODE_BITSIZE (mode) < GET_MODE_BITSIZE (GET_MODE (x)))
7932     op_mode = GET_MODE (x);
7933
7934   /* Truncate MASK to fit OP_MODE.  */
7935   if (op_mode)
7936     mask &= GET_MODE_MASK (op_mode);
7937
7938   /* When we have an arithmetic operation, or a shift whose count we
7939      do not know, we need to assume that all bits up to the highest-order
7940      bit in MASK will be needed.  This is how we form such a mask.  */
7941   if (mask & ((unsigned HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT - 1)))
7942     fuller_mask = ~(unsigned HOST_WIDE_INT) 0;
7943   else
7944     fuller_mask = (((unsigned HOST_WIDE_INT) 1 << (floor_log2 (mask) + 1))
7945                    - 1);
7946
7947   /* Determine what bits of X are guaranteed to be (non)zero.  */
7948   nonzero = nonzero_bits (x, mode);
7949
7950   /* If none of the bits in X are needed, return a zero.  */
7951   if (!just_select && (nonzero & mask) == 0 && !side_effects_p (x))
7952     x = const0_rtx;
7953
7954   /* If X is a CONST_INT, return a new one.  Do this here since the
7955      test below will fail.  */
7956   if (CONST_INT_P (x))
7957     {
7958       if (SCALAR_INT_MODE_P (mode))
7959         return gen_int_mode (INTVAL (x) & mask, mode);
7960       else
7961         {
7962           x = GEN_INT (INTVAL (x) & mask);
7963           return gen_lowpart_common (mode, x);
7964         }
7965     }
7966
7967   /* If X is narrower than MODE and we want all the bits in X's mode, just
7968      get X in the proper mode.  */
7969   if (GET_MODE_SIZE (GET_MODE (x)) < GET_MODE_SIZE (mode)
7970       && (GET_MODE_MASK (GET_MODE (x)) & ~mask) == 0)
7971     return gen_lowpart (mode, x);
7972
7973   /* We can ignore the effect of a SUBREG if it narrows the mode or
7974      if the constant masks to zero all the bits the mode doesn't have.  */
7975   if (GET_CODE (x) == SUBREG
7976       && subreg_lowpart_p (x)
7977       && ((GET_MODE_SIZE (GET_MODE (x))
7978            < GET_MODE_SIZE (GET_MODE (SUBREG_REG (x))))
7979           || (0 == (mask
7980                     & GET_MODE_MASK (GET_MODE (x))
7981                     & ~GET_MODE_MASK (GET_MODE (SUBREG_REG (x)))))))
7982     return force_to_mode (SUBREG_REG (x), mode, mask, next_select);
7983
7984   /* The arithmetic simplifications here only work for scalar integer modes.  */
7985   if (!SCALAR_INT_MODE_P (mode) || !SCALAR_INT_MODE_P (GET_MODE (x)))
7986     return gen_lowpart_or_truncate (mode, x);
7987
7988   switch (code)
7989     {
7990     case CLOBBER:
7991       /* If X is a (clobber (const_int)), return it since we know we are
7992          generating something that won't match.  */
7993       return x;
7994
7995     case SIGN_EXTEND:
7996     case ZERO_EXTEND:
7997     case ZERO_EXTRACT:
7998     case SIGN_EXTRACT:
7999       x = expand_compound_operation (x);
8000       if (GET_CODE (x) != code)
8001         return force_to_mode (x, mode, mask, next_select);
8002       break;
8003
8004     case TRUNCATE:
8005       /* Similarly for a truncate.  */
8006       return force_to_mode (XEXP (x, 0), mode, mask, next_select);
8007
8008     case AND:
8009       /* If this is an AND with a constant, convert it into an AND
8010          whose constant is the AND of that constant with MASK.  If it
8011          remains an AND of MASK, delete it since it is redundant.  */
8012
8013       if (CONST_INT_P (XEXP (x, 1)))
8014         {
8015           x = simplify_and_const_int (x, op_mode, XEXP (x, 0),
8016                                       mask & INTVAL (XEXP (x, 1)));
8017
8018           /* If X is still an AND, see if it is an AND with a mask that
8019              is just some low-order bits.  If so, and it is MASK, we don't
8020              need it.  */
8021
8022           if (GET_CODE (x) == AND && CONST_INT_P (XEXP (x, 1))
8023               && ((INTVAL (XEXP (x, 1)) & GET_MODE_MASK (GET_MODE (x)))
8024                   == mask))
8025             x = XEXP (x, 0);
8026
8027           /* If it remains an AND, try making another AND with the bits
8028              in the mode mask that aren't in MASK turned on.  If the
8029              constant in the AND is wide enough, this might make a
8030              cheaper constant.  */
8031
8032           if (GET_CODE (x) == AND && CONST_INT_P (XEXP (x, 1))
8033               && GET_MODE_MASK (GET_MODE (x)) != mask
8034               && GET_MODE_BITSIZE (GET_MODE (x)) <= HOST_BITS_PER_WIDE_INT)
8035             {
8036               HOST_WIDE_INT cval = (INTVAL (XEXP (x, 1))
8037                                     | (GET_MODE_MASK (GET_MODE (x)) & ~mask));
8038               int width = GET_MODE_BITSIZE (GET_MODE (x));
8039               rtx y;
8040
8041               /* If MODE is narrower than HOST_WIDE_INT and CVAL is a negative
8042                  number, sign extend it.  */
8043               if (width > 0 && width < HOST_BITS_PER_WIDE_INT
8044                   && (cval & ((HOST_WIDE_INT) 1 << (width - 1))) != 0)
8045                 cval |= (HOST_WIDE_INT) -1 << width;
8046
8047               y = simplify_gen_binary (AND, GET_MODE (x),
8048                                        XEXP (x, 0), GEN_INT (cval));
8049               if (rtx_cost (y, SET, optimize_this_for_speed_p)
8050                   < rtx_cost (x, SET, optimize_this_for_speed_p))
8051                 x = y;
8052             }
8053
8054           break;
8055         }
8056
8057       goto binop;
8058
8059     case PLUS:
8060       /* In (and (plus FOO C1) M), if M is a mask that just turns off
8061          low-order bits (as in an alignment operation) and FOO is already
8062          aligned to that boundary, mask C1 to that boundary as well.
8063          This may eliminate that PLUS and, later, the AND.  */
8064
8065       {
8066         unsigned int width = GET_MODE_BITSIZE (mode);
8067         unsigned HOST_WIDE_INT smask = mask;
8068
8069         /* If MODE is narrower than HOST_WIDE_INT and mask is a negative
8070            number, sign extend it.  */
8071
8072         if (width < HOST_BITS_PER_WIDE_INT
8073             && (smask & ((HOST_WIDE_INT) 1 << (width - 1))) != 0)
8074           smask |= (HOST_WIDE_INT) -1 << width;
8075
8076         if (CONST_INT_P (XEXP (x, 1))
8077             && exact_log2 (- smask) >= 0
8078             && (nonzero_bits (XEXP (x, 0), mode) & ~smask) == 0
8079             && (INTVAL (XEXP (x, 1)) & ~smask) != 0)
8080           return force_to_mode (plus_constant (XEXP (x, 0),
8081                                                (INTVAL (XEXP (x, 1)) & smask)),
8082                                 mode, smask, next_select);
8083       }
8084
8085       /* ... fall through ...  */
8086
8087     case MULT:
8088       /* For PLUS, MINUS and MULT, we need any bits less significant than the
8089          most significant bit in MASK since carries from those bits will
8090          affect the bits we are interested in.  */
8091       mask = fuller_mask;
8092       goto binop;
8093
8094     case MINUS:
8095       /* If X is (minus C Y) where C's least set bit is larger than any bit
8096          in the mask, then we may replace with (neg Y).  */
8097       if (CONST_INT_P (XEXP (x, 0))
8098           && (((unsigned HOST_WIDE_INT) (INTVAL (XEXP (x, 0))
8099                                         & -INTVAL (XEXP (x, 0))))
8100               > mask))
8101         {
8102           x = simplify_gen_unary (NEG, GET_MODE (x), XEXP (x, 1),
8103                                   GET_MODE (x));
8104           return force_to_mode (x, mode, mask, next_select);
8105         }
8106
8107       /* Similarly, if C contains every bit in the fuller_mask, then we may
8108          replace with (not Y).  */
8109       if (CONST_INT_P (XEXP (x, 0))
8110           && ((INTVAL (XEXP (x, 0)) | (HOST_WIDE_INT) fuller_mask)
8111               == INTVAL (XEXP (x, 0))))
8112         {
8113           x = simplify_gen_unary (NOT, GET_MODE (x),
8114                                   XEXP (x, 1), GET_MODE (x));
8115           return force_to_mode (x, mode, mask, next_select);
8116         }
8117
8118       mask = fuller_mask;
8119       goto binop;
8120
8121     case IOR:
8122     case XOR:
8123       /* If X is (ior (lshiftrt FOO C1) C2), try to commute the IOR and
8124          LSHIFTRT so we end up with an (and (lshiftrt (ior ...) ...) ...)
8125          operation which may be a bitfield extraction.  Ensure that the
8126          constant we form is not wider than the mode of X.  */
8127
8128       if (GET_CODE (XEXP (x, 0)) == LSHIFTRT
8129           && CONST_INT_P (XEXP (XEXP (x, 0), 1))
8130           && INTVAL (XEXP (XEXP (x, 0), 1)) >= 0
8131           && INTVAL (XEXP (XEXP (x, 0), 1)) < HOST_BITS_PER_WIDE_INT
8132           && CONST_INT_P (XEXP (x, 1))
8133           && ((INTVAL (XEXP (XEXP (x, 0), 1))
8134                + floor_log2 (INTVAL (XEXP (x, 1))))
8135               < GET_MODE_BITSIZE (GET_MODE (x)))
8136           && (INTVAL (XEXP (x, 1))
8137               & ~nonzero_bits (XEXP (x, 0), GET_MODE (x))) == 0)
8138         {
8139           temp = GEN_INT ((INTVAL (XEXP (x, 1)) & mask)
8140                           << INTVAL (XEXP (XEXP (x, 0), 1)));
8141           temp = simplify_gen_binary (GET_CODE (x), GET_MODE (x),
8142                                       XEXP (XEXP (x, 0), 0), temp);
8143           x = simplify_gen_binary (LSHIFTRT, GET_MODE (x), temp,
8144                                    XEXP (XEXP (x, 0), 1));
8145           return force_to_mode (x, mode, mask, next_select);
8146         }
8147
8148     binop:
8149       /* For most binary operations, just propagate into the operation and
8150          change the mode if we have an operation of that mode.  */
8151
8152       op0 = force_to_mode (XEXP (x, 0), mode, mask, next_select);
8153       op1 = force_to_mode (XEXP (x, 1), mode, mask, next_select);
8154
8155       /* If we ended up truncating both operands, truncate the result of the
8156          operation instead.  */
8157       if (GET_CODE (op0) == TRUNCATE
8158           && GET_CODE (op1) == TRUNCATE)
8159         {
8160           op0 = XEXP (op0, 0);
8161           op1 = XEXP (op1, 0);
8162         }
8163
8164       op0 = gen_lowpart_or_truncate (op_mode, op0);
8165       op1 = gen_lowpart_or_truncate (op_mode, op1);
8166
8167       if (op_mode != GET_MODE (x) || op0 != XEXP (x, 0) || op1 != XEXP (x, 1))
8168         x = simplify_gen_binary (code, op_mode, op0, op1);
8169       break;
8170
8171     case ASHIFT:
8172       /* For left shifts, do the same, but just for the first operand.
8173          However, we cannot do anything with shifts where we cannot
8174          guarantee that the counts are smaller than the size of the mode
8175          because such a count will have a different meaning in a
8176          wider mode.  */
8177
8178       if (! (CONST_INT_P (XEXP (x, 1))
8179              && INTVAL (XEXP (x, 1)) >= 0
8180              && INTVAL (XEXP (x, 1)) < GET_MODE_BITSIZE (mode))
8181           && ! (GET_MODE (XEXP (x, 1)) != VOIDmode
8182                 && (nonzero_bits (XEXP (x, 1), GET_MODE (XEXP (x, 1)))
8183                     < (unsigned HOST_WIDE_INT) GET_MODE_BITSIZE (mode))))
8184         break;
8185
8186       /* If the shift count is a constant and we can do arithmetic in
8187          the mode of the shift, refine which bits we need.  Otherwise, use the
8188          conservative form of the mask.  */
8189       if (CONST_INT_P (XEXP (x, 1))
8190           && INTVAL (XEXP (x, 1)) >= 0
8191           && INTVAL (XEXP (x, 1)) < GET_MODE_BITSIZE (op_mode)
8192           && GET_MODE_BITSIZE (op_mode) <= HOST_BITS_PER_WIDE_INT)
8193         mask >>= INTVAL (XEXP (x, 1));
8194       else
8195         mask = fuller_mask;
8196
8197       op0 = gen_lowpart_or_truncate (op_mode,
8198                                      force_to_mode (XEXP (x, 0), op_mode,
8199                                                     mask, next_select));
8200
8201       if (op_mode != GET_MODE (x) || op0 != XEXP (x, 0))
8202         x = simplify_gen_binary (code, op_mode, op0, XEXP (x, 1));
8203       break;
8204
8205     case LSHIFTRT:
8206       /* Here we can only do something if the shift count is a constant,
8207          this shift constant is valid for the host, and we can do arithmetic
8208          in OP_MODE.  */
8209
8210       if (CONST_INT_P (XEXP (x, 1))
8211           && INTVAL (XEXP (x, 1)) < HOST_BITS_PER_WIDE_INT
8212           && GET_MODE_BITSIZE (op_mode) <= HOST_BITS_PER_WIDE_INT)
8213         {
8214           rtx inner = XEXP (x, 0);
8215           unsigned HOST_WIDE_INT inner_mask;
8216
8217           /* Select the mask of the bits we need for the shift operand.  */
8218           inner_mask = mask << INTVAL (XEXP (x, 1));
8219
8220           /* We can only change the mode of the shift if we can do arithmetic
8221              in the mode of the shift and INNER_MASK is no wider than the
8222              width of X's mode.  */
8223           if ((inner_mask & ~GET_MODE_MASK (GET_MODE (x))) != 0)
8224             op_mode = GET_MODE (x);
8225
8226           inner = force_to_mode (inner, op_mode, inner_mask, next_select);
8227
8228           if (GET_MODE (x) != op_mode || inner != XEXP (x, 0))
8229             x = simplify_gen_binary (LSHIFTRT, op_mode, inner, XEXP (x, 1));
8230         }
8231
8232       /* If we have (and (lshiftrt FOO C1) C2) where the combination of the
8233          shift and AND produces only copies of the sign bit (C2 is one less
8234          than a power of two), we can do this with just a shift.  */
8235
8236       if (GET_CODE (x) == LSHIFTRT
8237           && CONST_INT_P (XEXP (x, 1))
8238           /* The shift puts one of the sign bit copies in the least significant
8239              bit.  */
8240           && ((INTVAL (XEXP (x, 1))
8241                + num_sign_bit_copies (XEXP (x, 0), GET_MODE (XEXP (x, 0))))
8242               >= GET_MODE_BITSIZE (GET_MODE (x)))
8243           && exact_log2 (mask + 1) >= 0
8244           /* Number of bits left after the shift must be more than the mask
8245              needs.  */
8246           && ((INTVAL (XEXP (x, 1)) + exact_log2 (mask + 1))
8247               <= GET_MODE_BITSIZE (GET_MODE (x)))
8248           /* Must be more sign bit copies than the mask needs.  */
8249           && ((int) num_sign_bit_copies (XEXP (x, 0), GET_MODE (XEXP (x, 0)))
8250               >= exact_log2 (mask + 1)))
8251         x = simplify_gen_binary (LSHIFTRT, GET_MODE (x), XEXP (x, 0),
8252                                  GEN_INT (GET_MODE_BITSIZE (GET_MODE (x))
8253                                           - exact_log2 (mask + 1)));
8254
8255       goto shiftrt;
8256
8257     case ASHIFTRT:
8258       /* If we are just looking for the sign bit, we don't need this shift at
8259          all, even if it has a variable count.  */
8260       if (GET_MODE_BITSIZE (GET_MODE (x)) <= HOST_BITS_PER_WIDE_INT
8261           && (mask == ((unsigned HOST_WIDE_INT) 1
8262                        << (GET_MODE_BITSIZE (GET_MODE (x)) - 1))))
8263         return force_to_mode (XEXP (x, 0), mode, mask, next_select);
8264
8265       /* If this is a shift by a constant, get a mask that contains those bits
8266          that are not copies of the sign bit.  We then have two cases:  If
8267          MASK only includes those bits, this can be a logical shift, which may
8268          allow simplifications.  If MASK is a single-bit field not within
8269          those bits, we are requesting a copy of the sign bit and hence can
8270          shift the sign bit to the appropriate location.  */
8271
8272       if (CONST_INT_P (XEXP (x, 1)) && INTVAL (XEXP (x, 1)) >= 0
8273           && INTVAL (XEXP (x, 1)) < HOST_BITS_PER_WIDE_INT)
8274         {
8275           int i;
8276
8277           /* If the considered data is wider than HOST_WIDE_INT, we can't
8278              represent a mask for all its bits in a single scalar.
8279              But we only care about the lower bits, so calculate these.  */
8280
8281           if (GET_MODE_BITSIZE (GET_MODE (x)) > HOST_BITS_PER_WIDE_INT)
8282             {
8283               nonzero = ~(HOST_WIDE_INT) 0;
8284
8285               /* GET_MODE_BITSIZE (GET_MODE (x)) - INTVAL (XEXP (x, 1))
8286                  is the number of bits a full-width mask would have set.
8287                  We need only shift if these are fewer than nonzero can
8288                  hold.  If not, we must keep all bits set in nonzero.  */
8289
8290               if (GET_MODE_BITSIZE (GET_MODE (x)) - INTVAL (XEXP (x, 1))
8291                   < HOST_BITS_PER_WIDE_INT)
8292                 nonzero >>= INTVAL (XEXP (x, 1))
8293                             + HOST_BITS_PER_WIDE_INT
8294                             - GET_MODE_BITSIZE (GET_MODE (x)) ;
8295             }
8296           else
8297             {
8298               nonzero = GET_MODE_MASK (GET_MODE (x));
8299               nonzero >>= INTVAL (XEXP (x, 1));
8300             }
8301
8302           if ((mask & ~nonzero) == 0)
8303             {
8304               x = simplify_shift_const (NULL_RTX, LSHIFTRT, GET_MODE (x),
8305                                         XEXP (x, 0), INTVAL (XEXP (x, 1)));
8306               if (GET_CODE (x) != ASHIFTRT)
8307                 return force_to_mode (x, mode, mask, next_select);
8308             }
8309
8310           else if ((i = exact_log2 (mask)) >= 0)
8311             {
8312               x = simplify_shift_const
8313                   (NULL_RTX, LSHIFTRT, GET_MODE (x), XEXP (x, 0),
8314                    GET_MODE_BITSIZE (GET_MODE (x)) - 1 - i);
8315
8316               if (GET_CODE (x) != ASHIFTRT)
8317                 return force_to_mode (x, mode, mask, next_select);
8318             }
8319         }
8320
8321       /* If MASK is 1, convert this to an LSHIFTRT.  This can be done
8322          even if the shift count isn't a constant.  */
8323       if (mask == 1)
8324         x = simplify_gen_binary (LSHIFTRT, GET_MODE (x),
8325                                  XEXP (x, 0), XEXP (x, 1));
8326
8327     shiftrt:
8328
8329       /* If this is a zero- or sign-extension operation that just affects bits
8330          we don't care about, remove it.  Be sure the call above returned
8331          something that is still a shift.  */
8332
8333       if ((GET_CODE (x) == LSHIFTRT || GET_CODE (x) == ASHIFTRT)
8334           && CONST_INT_P (XEXP (x, 1))
8335           && INTVAL (XEXP (x, 1)) >= 0
8336           && (INTVAL (XEXP (x, 1))
8337               <= GET_MODE_BITSIZE (GET_MODE (x)) - (floor_log2 (mask) + 1))
8338           && GET_CODE (XEXP (x, 0)) == ASHIFT
8339           && XEXP (XEXP (x, 0), 1) == XEXP (x, 1))
8340         return force_to_mode (XEXP (XEXP (x, 0), 0), mode, mask,
8341                               next_select);
8342
8343       break;
8344
8345     case ROTATE:
8346     case ROTATERT:
8347       /* If the shift count is constant and we can do computations
8348          in the mode of X, compute where the bits we care about are.
8349          Otherwise, we can't do anything.  Don't change the mode of
8350          the shift or propagate MODE into the shift, though.  */
8351       if (CONST_INT_P (XEXP (x, 1))
8352           && INTVAL (XEXP (x, 1)) >= 0)
8353         {
8354           temp = simplify_binary_operation (code == ROTATE ? ROTATERT : ROTATE,
8355                                             GET_MODE (x), GEN_INT (mask),
8356                                             XEXP (x, 1));
8357           if (temp && CONST_INT_P (temp))
8358             SUBST (XEXP (x, 0),
8359                    force_to_mode (XEXP (x, 0), GET_MODE (x),
8360                                   INTVAL (temp), next_select));
8361         }
8362       break;
8363
8364     case NEG:
8365       /* If we just want the low-order bit, the NEG isn't needed since it
8366          won't change the low-order bit.  */
8367       if (mask == 1)
8368         return force_to_mode (XEXP (x, 0), mode, mask, just_select);
8369
8370       /* We need any bits less significant than the most significant bit in
8371          MASK since carries from those bits will affect the bits we are
8372          interested in.  */
8373       mask = fuller_mask;
8374       goto unop;
8375
8376     case NOT:
8377       /* (not FOO) is (xor FOO CONST), so if FOO is an LSHIFTRT, we can do the
8378          same as the XOR case above.  Ensure that the constant we form is not
8379          wider than the mode of X.  */
8380
8381       if (GET_CODE (XEXP (x, 0)) == LSHIFTRT
8382           && CONST_INT_P (XEXP (XEXP (x, 0), 1))
8383           && INTVAL (XEXP (XEXP (x, 0), 1)) >= 0
8384           && (INTVAL (XEXP (XEXP (x, 0), 1)) + floor_log2 (mask)
8385               < GET_MODE_BITSIZE (GET_MODE (x)))
8386           && INTVAL (XEXP (XEXP (x, 0), 1)) < HOST_BITS_PER_WIDE_INT)
8387         {
8388           temp = gen_int_mode (mask << INTVAL (XEXP (XEXP (x, 0), 1)),
8389                                GET_MODE (x));
8390           temp = simplify_gen_binary (XOR, GET_MODE (x),
8391                                       XEXP (XEXP (x, 0), 0), temp);
8392           x = simplify_gen_binary (LSHIFTRT, GET_MODE (x),
8393                                    temp, XEXP (XEXP (x, 0), 1));
8394
8395           return force_to_mode (x, mode, mask, next_select);
8396         }
8397
8398       /* (and (not FOO) CONST) is (not (or FOO (not CONST))), so we must
8399          use the full mask inside the NOT.  */
8400       mask = fuller_mask;
8401
8402     unop:
8403       op0 = gen_lowpart_or_truncate (op_mode,
8404                                      force_to_mode (XEXP (x, 0), mode, mask,
8405                                                     next_select));
8406       if (op_mode != GET_MODE (x) || op0 != XEXP (x, 0))
8407         x = simplify_gen_unary (code, op_mode, op0, op_mode);
8408       break;
8409
8410     case NE:
8411       /* (and (ne FOO 0) CONST) can be (and FOO CONST) if CONST is included
8412          in STORE_FLAG_VALUE and FOO has a single bit that might be nonzero,
8413          which is equal to STORE_FLAG_VALUE.  */
8414       if ((mask & ~STORE_FLAG_VALUE) == 0 && XEXP (x, 1) == const0_rtx
8415           && GET_MODE (XEXP (x, 0)) == mode
8416           && exact_log2 (nonzero_bits (XEXP (x, 0), mode)) >= 0
8417           && (nonzero_bits (XEXP (x, 0), mode)
8418               == (unsigned HOST_WIDE_INT) STORE_FLAG_VALUE))
8419         return force_to_mode (XEXP (x, 0), mode, mask, next_select);
8420
8421       break;
8422
8423     case IF_THEN_ELSE:
8424       /* We have no way of knowing if the IF_THEN_ELSE can itself be
8425          written in a narrower mode.  We play it safe and do not do so.  */
8426
8427       SUBST (XEXP (x, 1),
8428              gen_lowpart_or_truncate (GET_MODE (x),
8429                                       force_to_mode (XEXP (x, 1), mode,
8430                                                      mask, next_select)));
8431       SUBST (XEXP (x, 2),
8432              gen_lowpart_or_truncate (GET_MODE (x),
8433                                       force_to_mode (XEXP (x, 2), mode,
8434                                                      mask, next_select)));
8435       break;
8436
8437     default:
8438       break;
8439     }
8440
8441   /* Ensure we return a value of the proper mode.  */
8442   return gen_lowpart_or_truncate (mode, x);
8443 }
8444 \f
8445 /* Return nonzero if X is an expression that has one of two values depending on
8446    whether some other value is zero or nonzero.  In that case, we return the
8447    value that is being tested, *PTRUE is set to the value if the rtx being
8448    returned has a nonzero value, and *PFALSE is set to the other alternative.
8449
8450    If we return zero, we set *PTRUE and *PFALSE to X.  */
8451
8452 static rtx
8453 if_then_else_cond (rtx x, rtx *ptrue, rtx *pfalse)
8454 {
8455   enum machine_mode mode = GET_MODE (x);
8456   enum rtx_code code = GET_CODE (x);
8457   rtx cond0, cond1, true0, true1, false0, false1;
8458   unsigned HOST_WIDE_INT nz;
8459
8460   /* If we are comparing a value against zero, we are done.  */
8461   if ((code == NE || code == EQ)
8462       && XEXP (x, 1) == const0_rtx)
8463     {
8464       *ptrue = (code == NE) ? const_true_rtx : const0_rtx;
8465       *pfalse = (code == NE) ? const0_rtx : const_true_rtx;
8466       return XEXP (x, 0);
8467     }
8468
8469   /* If this is a unary operation whose operand has one of two values, apply
8470      our opcode to compute those values.  */
8471   else if (UNARY_P (x)
8472            && (cond0 = if_then_else_cond (XEXP (x, 0), &true0, &false0)) != 0)
8473     {
8474       *ptrue = simplify_gen_unary (code, mode, true0, GET_MODE (XEXP (x, 0)));
8475       *pfalse = simplify_gen_unary (code, mode, false0,
8476                                     GET_MODE (XEXP (x, 0)));
8477       return cond0;
8478     }
8479
8480   /* If this is a COMPARE, do nothing, since the IF_THEN_ELSE we would
8481      make can't possibly match and would suppress other optimizations.  */
8482   else if (code == COMPARE)
8483     ;
8484
8485   /* If this is a binary operation, see if either side has only one of two
8486      values.  If either one does or if both do and they are conditional on
8487      the same value, compute the new true and false values.  */
8488   else if (BINARY_P (x))
8489     {
8490       cond0 = if_then_else_cond (XEXP (x, 0), &true0, &false0);
8491       cond1 = if_then_else_cond (XEXP (x, 1), &true1, &false1);
8492
8493       if ((cond0 != 0 || cond1 != 0)
8494           && ! (cond0 != 0 && cond1 != 0 && ! rtx_equal_p (cond0, cond1)))
8495         {
8496           /* If if_then_else_cond returned zero, then true/false are the
8497              same rtl.  We must copy one of them to prevent invalid rtl
8498              sharing.  */
8499           if (cond0 == 0)
8500             true0 = copy_rtx (true0);
8501           else if (cond1 == 0)
8502             true1 = copy_rtx (true1);
8503
8504           if (COMPARISON_P (x))
8505             {
8506               *ptrue = simplify_gen_relational (code, mode, VOIDmode,
8507                                                 true0, true1);
8508               *pfalse = simplify_gen_relational (code, mode, VOIDmode,
8509                                                  false0, false1);
8510              }
8511           else
8512             {
8513               *ptrue = simplify_gen_binary (code, mode, true0, true1);
8514               *pfalse = simplify_gen_binary (code, mode, false0, false1);
8515             }
8516
8517           return cond0 ? cond0 : cond1;
8518         }
8519
8520       /* See if we have PLUS, IOR, XOR, MINUS or UMAX, where one of the
8521          operands is zero when the other is nonzero, and vice-versa,
8522          and STORE_FLAG_VALUE is 1 or -1.  */
8523
8524       if ((STORE_FLAG_VALUE == 1 || STORE_FLAG_VALUE == -1)
8525           && (code == PLUS || code == IOR || code == XOR || code == MINUS
8526               || code == UMAX)
8527           && GET_CODE (XEXP (x, 0)) == MULT && GET_CODE (XEXP (x, 1)) == MULT)
8528         {
8529           rtx op0 = XEXP (XEXP (x, 0), 1);
8530           rtx op1 = XEXP (XEXP (x, 1), 1);
8531
8532           cond0 = XEXP (XEXP (x, 0), 0);
8533           cond1 = XEXP (XEXP (x, 1), 0);
8534
8535           if (COMPARISON_P (cond0)
8536               && COMPARISON_P (cond1)
8537               && ((GET_CODE (cond0) == reversed_comparison_code (cond1, NULL)
8538                    && rtx_equal_p (XEXP (cond0, 0), XEXP (cond1, 0))
8539                    && rtx_equal_p (XEXP (cond0, 1), XEXP (cond1, 1)))
8540                   || ((swap_condition (GET_CODE (cond0))
8541                        == reversed_comparison_code (cond1, NULL))
8542                       && rtx_equal_p (XEXP (cond0, 0), XEXP (cond1, 1))
8543                       && rtx_equal_p (XEXP (cond0, 1), XEXP (cond1, 0))))
8544               && ! side_effects_p (x))
8545             {
8546               *ptrue = simplify_gen_binary (MULT, mode, op0, const_true_rtx);
8547               *pfalse = simplify_gen_binary (MULT, mode,
8548                                              (code == MINUS
8549                                               ? simplify_gen_unary (NEG, mode,
8550                                                                     op1, mode)
8551                                               : op1),
8552                                               const_true_rtx);
8553               return cond0;
8554             }
8555         }
8556
8557       /* Similarly for MULT, AND and UMIN, except that for these the result
8558          is always zero.  */
8559       if ((STORE_FLAG_VALUE == 1 || STORE_FLAG_VALUE == -1)
8560           && (code == MULT || code == AND || code == UMIN)
8561           && GET_CODE (XEXP (x, 0)) == MULT && GET_CODE (XEXP (x, 1)) == MULT)
8562         {
8563           cond0 = XEXP (XEXP (x, 0), 0);
8564           cond1 = XEXP (XEXP (x, 1), 0);
8565
8566           if (COMPARISON_P (cond0)
8567               && COMPARISON_P (cond1)
8568               && ((GET_CODE (cond0) == reversed_comparison_code (cond1, NULL)
8569                    && rtx_equal_p (XEXP (cond0, 0), XEXP (cond1, 0))
8570                    && rtx_equal_p (XEXP (cond0, 1), XEXP (cond1, 1)))
8571                   || ((swap_condition (GET_CODE (cond0))
8572                        == reversed_comparison_code (cond1, NULL))
8573                       && rtx_equal_p (XEXP (cond0, 0), XEXP (cond1, 1))
8574                       && rtx_equal_p (XEXP (cond0, 1), XEXP (cond1, 0))))
8575               && ! side_effects_p (x))
8576             {
8577               *ptrue = *pfalse = const0_rtx;
8578               return cond0;
8579             }
8580         }
8581     }
8582
8583   else if (code == IF_THEN_ELSE)
8584     {
8585       /* If we have IF_THEN_ELSE already, extract the condition and
8586          canonicalize it if it is NE or EQ.  */
8587       cond0 = XEXP (x, 0);
8588       *ptrue = XEXP (x, 1), *pfalse = XEXP (x, 2);
8589       if (GET_CODE (cond0) == NE && XEXP (cond0, 1) == const0_rtx)
8590         return XEXP (cond0, 0);
8591       else if (GET_CODE (cond0) == EQ && XEXP (cond0, 1) == const0_rtx)
8592         {
8593           *ptrue = XEXP (x, 2), *pfalse = XEXP (x, 1);
8594           return XEXP (cond0, 0);
8595         }
8596       else
8597         return cond0;
8598     }
8599
8600   /* If X is a SUBREG, we can narrow both the true and false values
8601      if the inner expression, if there is a condition.  */
8602   else if (code == SUBREG
8603            && 0 != (cond0 = if_then_else_cond (SUBREG_REG (x),
8604                                                &true0, &false0)))
8605     {
8606       true0 = simplify_gen_subreg (mode, true0,
8607                                    GET_MODE (SUBREG_REG (x)), SUBREG_BYTE (x));
8608       false0 = simplify_gen_subreg (mode, false0,
8609                                     GET_MODE (SUBREG_REG (x)), SUBREG_BYTE (x));
8610       if (true0 && false0)
8611         {
8612           *ptrue = true0;
8613           *pfalse = false0;
8614           return cond0;
8615         }
8616     }
8617
8618   /* If X is a constant, this isn't special and will cause confusions
8619      if we treat it as such.  Likewise if it is equivalent to a constant.  */
8620   else if (CONSTANT_P (x)
8621            || ((cond0 = get_last_value (x)) != 0 && CONSTANT_P (cond0)))
8622     ;
8623
8624   /* If we're in BImode, canonicalize on 0 and STORE_FLAG_VALUE, as that
8625      will be least confusing to the rest of the compiler.  */
8626   else if (mode == BImode)
8627     {
8628       *ptrue = GEN_INT (STORE_FLAG_VALUE), *pfalse = const0_rtx;
8629       return x;
8630     }
8631
8632   /* If X is known to be either 0 or -1, those are the true and
8633      false values when testing X.  */
8634   else if (x == constm1_rtx || x == const0_rtx
8635            || (mode != VOIDmode
8636                && num_sign_bit_copies (x, mode) == GET_MODE_BITSIZE (mode)))
8637     {
8638       *ptrue = constm1_rtx, *pfalse = const0_rtx;
8639       return x;
8640     }
8641
8642   /* Likewise for 0 or a single bit.  */
8643   else if (SCALAR_INT_MODE_P (mode)
8644            && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
8645            && exact_log2 (nz = nonzero_bits (x, mode)) >= 0)
8646     {
8647       *ptrue = gen_int_mode (nz, mode), *pfalse = const0_rtx;
8648       return x;
8649     }
8650
8651   /* Otherwise fail; show no condition with true and false values the same.  */
8652   *ptrue = *pfalse = x;
8653   return 0;
8654 }
8655 \f
8656 /* Return the value of expression X given the fact that condition COND
8657    is known to be true when applied to REG as its first operand and VAL
8658    as its second.  X is known to not be shared and so can be modified in
8659    place.
8660
8661    We only handle the simplest cases, and specifically those cases that
8662    arise with IF_THEN_ELSE expressions.  */
8663
8664 static rtx
8665 known_cond (rtx x, enum rtx_code cond, rtx reg, rtx val)
8666 {
8667   enum rtx_code code = GET_CODE (x);
8668   rtx temp;
8669   const char *fmt;
8670   int i, j;
8671
8672   if (side_effects_p (x))
8673     return x;
8674
8675   /* If either operand of the condition is a floating point value,
8676      then we have to avoid collapsing an EQ comparison.  */
8677   if (cond == EQ
8678       && rtx_equal_p (x, reg)
8679       && ! FLOAT_MODE_P (GET_MODE (x))
8680       && ! FLOAT_MODE_P (GET_MODE (val)))
8681     return val;
8682
8683   if (cond == UNEQ && rtx_equal_p (x, reg))
8684     return val;
8685
8686   /* If X is (abs REG) and we know something about REG's relationship
8687      with zero, we may be able to simplify this.  */
8688
8689   if (code == ABS && rtx_equal_p (XEXP (x, 0), reg) && val == const0_rtx)
8690     switch (cond)
8691       {
8692       case GE:  case GT:  case EQ:
8693         return XEXP (x, 0);
8694       case LT:  case LE:
8695         return simplify_gen_unary (NEG, GET_MODE (XEXP (x, 0)),
8696                                    XEXP (x, 0),
8697                                    GET_MODE (XEXP (x, 0)));
8698       default:
8699         break;
8700       }
8701
8702   /* The only other cases we handle are MIN, MAX, and comparisons if the
8703      operands are the same as REG and VAL.  */
8704
8705   else if (COMPARISON_P (x) || COMMUTATIVE_ARITH_P (x))
8706     {
8707       if (rtx_equal_p (XEXP (x, 0), val))
8708         cond = swap_condition (cond), temp = val, val = reg, reg = temp;
8709
8710       if (rtx_equal_p (XEXP (x, 0), reg) && rtx_equal_p (XEXP (x, 1), val))
8711         {
8712           if (COMPARISON_P (x))
8713             {
8714               if (comparison_dominates_p (cond, code))
8715                 return const_true_rtx;
8716
8717               code = reversed_comparison_code (x, NULL);
8718               if (code != UNKNOWN
8719                   && comparison_dominates_p (cond, code))
8720                 return const0_rtx;
8721               else
8722                 return x;
8723             }
8724           else if (code == SMAX || code == SMIN
8725                    || code == UMIN || code == UMAX)
8726             {
8727               int unsignedp = (code == UMIN || code == UMAX);
8728
8729               /* Do not reverse the condition when it is NE or EQ.
8730                  This is because we cannot conclude anything about
8731                  the value of 'SMAX (x, y)' when x is not equal to y,
8732                  but we can when x equals y.  */
8733               if ((code == SMAX || code == UMAX)
8734                   && ! (cond == EQ || cond == NE))
8735                 cond = reverse_condition (cond);
8736
8737               switch (cond)
8738                 {
8739                 case GE:   case GT:
8740                   return unsignedp ? x : XEXP (x, 1);
8741                 case LE:   case LT:
8742                   return unsignedp ? x : XEXP (x, 0);
8743                 case GEU:  case GTU:
8744                   return unsignedp ? XEXP (x, 1) : x;
8745                 case LEU:  case LTU:
8746                   return unsignedp ? XEXP (x, 0) : x;
8747                 default:
8748                   break;
8749                 }
8750             }
8751         }
8752     }
8753   else if (code == SUBREG)
8754     {
8755       enum machine_mode inner_mode = GET_MODE (SUBREG_REG (x));
8756       rtx new_rtx, r = known_cond (SUBREG_REG (x), cond, reg, val);
8757
8758       if (SUBREG_REG (x) != r)
8759         {
8760           /* We must simplify subreg here, before we lose track of the
8761              original inner_mode.  */
8762           new_rtx = simplify_subreg (GET_MODE (x), r,
8763                                  inner_mode, SUBREG_BYTE (x));
8764           if (new_rtx)
8765             return new_rtx;
8766           else
8767             SUBST (SUBREG_REG (x), r);
8768         }
8769
8770       return x;
8771     }
8772   /* We don't have to handle SIGN_EXTEND here, because even in the
8773      case of replacing something with a modeless CONST_INT, a
8774      CONST_INT is already (supposed to be) a valid sign extension for
8775      its narrower mode, which implies it's already properly
8776      sign-extended for the wider mode.  Now, for ZERO_EXTEND, the
8777      story is different.  */
8778   else if (code == ZERO_EXTEND)
8779     {
8780       enum machine_mode inner_mode = GET_MODE (XEXP (x, 0));
8781       rtx new_rtx, r = known_cond (XEXP (x, 0), cond, reg, val);
8782
8783       if (XEXP (x, 0) != r)
8784         {
8785           /* We must simplify the zero_extend here, before we lose
8786              track of the original inner_mode.  */
8787           new_rtx = simplify_unary_operation (ZERO_EXTEND, GET_MODE (x),
8788                                           r, inner_mode);
8789           if (new_rtx)
8790             return new_rtx;
8791           else
8792             SUBST (XEXP (x, 0), r);
8793         }
8794
8795       return x;
8796     }
8797
8798   fmt = GET_RTX_FORMAT (code);
8799   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
8800     {
8801       if (fmt[i] == 'e')
8802         SUBST (XEXP (x, i), known_cond (XEXP (x, i), cond, reg, val));
8803       else if (fmt[i] == 'E')
8804         for (j = XVECLEN (x, i) - 1; j >= 0; j--)
8805           SUBST (XVECEXP (x, i, j), known_cond (XVECEXP (x, i, j),
8806                                                 cond, reg, val));
8807     }
8808
8809   return x;
8810 }
8811 \f
8812 /* See if X and Y are equal for the purposes of seeing if we can rewrite an
8813    assignment as a field assignment.  */
8814
8815 static int
8816 rtx_equal_for_field_assignment_p (rtx x, rtx y)
8817 {
8818   if (x == y || rtx_equal_p (x, y))
8819     return 1;
8820
8821   if (x == 0 || y == 0 || GET_MODE (x) != GET_MODE (y))
8822     return 0;
8823
8824   /* Check for a paradoxical SUBREG of a MEM compared with the MEM.
8825      Note that all SUBREGs of MEM are paradoxical; otherwise they
8826      would have been rewritten.  */
8827   if (MEM_P (x) && GET_CODE (y) == SUBREG
8828       && MEM_P (SUBREG_REG (y))
8829       && rtx_equal_p (SUBREG_REG (y),
8830                       gen_lowpart (GET_MODE (SUBREG_REG (y)), x)))
8831     return 1;
8832
8833   if (MEM_P (y) && GET_CODE (x) == SUBREG
8834       && MEM_P (SUBREG_REG (x))
8835       && rtx_equal_p (SUBREG_REG (x),
8836                       gen_lowpart (GET_MODE (SUBREG_REG (x)), y)))
8837     return 1;
8838
8839   /* We used to see if get_last_value of X and Y were the same but that's
8840      not correct.  In one direction, we'll cause the assignment to have
8841      the wrong destination and in the case, we'll import a register into this
8842      insn that might have already have been dead.   So fail if none of the
8843      above cases are true.  */
8844   return 0;
8845 }
8846 \f
8847 /* See if X, a SET operation, can be rewritten as a bit-field assignment.
8848    Return that assignment if so.
8849
8850    We only handle the most common cases.  */
8851
8852 static rtx
8853 make_field_assignment (rtx x)
8854 {
8855   rtx dest = SET_DEST (x);
8856   rtx src = SET_SRC (x);
8857   rtx assign;
8858   rtx rhs, lhs;
8859   HOST_WIDE_INT c1;
8860   HOST_WIDE_INT pos;
8861   unsigned HOST_WIDE_INT len;
8862   rtx other;
8863   enum machine_mode mode;
8864
8865   /* If SRC was (and (not (ashift (const_int 1) POS)) DEST), this is
8866      a clear of a one-bit field.  We will have changed it to
8867      (and (rotate (const_int -2) POS) DEST), so check for that.  Also check
8868      for a SUBREG.  */
8869
8870   if (GET_CODE (src) == AND && GET_CODE (XEXP (src, 0)) == ROTATE
8871       && CONST_INT_P (XEXP (XEXP (src, 0), 0))
8872       && INTVAL (XEXP (XEXP (src, 0), 0)) == -2
8873       && rtx_equal_for_field_assignment_p (dest, XEXP (src, 1)))
8874     {
8875       assign = make_extraction (VOIDmode, dest, 0, XEXP (XEXP (src, 0), 1),
8876                                 1, 1, 1, 0);
8877       if (assign != 0)
8878         return gen_rtx_SET (VOIDmode, assign, const0_rtx);
8879       return x;
8880     }
8881
8882   if (GET_CODE (src) == AND && GET_CODE (XEXP (src, 0)) == SUBREG
8883       && subreg_lowpart_p (XEXP (src, 0))
8884       && (GET_MODE_SIZE (GET_MODE (XEXP (src, 0)))
8885           < GET_MODE_SIZE (GET_MODE (SUBREG_REG (XEXP (src, 0)))))
8886       && GET_CODE (SUBREG_REG (XEXP (src, 0))) == ROTATE
8887       && CONST_INT_P (XEXP (SUBREG_REG (XEXP (src, 0)), 0))
8888       && INTVAL (XEXP (SUBREG_REG (XEXP (src, 0)), 0)) == -2
8889       && rtx_equal_for_field_assignment_p (dest, XEXP (src, 1)))
8890     {
8891       assign = make_extraction (VOIDmode, dest, 0,
8892                                 XEXP (SUBREG_REG (XEXP (src, 0)), 1),
8893                                 1, 1, 1, 0);
8894       if (assign != 0)
8895         return gen_rtx_SET (VOIDmode, assign, const0_rtx);
8896       return x;
8897     }
8898
8899   /* If SRC is (ior (ashift (const_int 1) POS) DEST), this is a set of a
8900      one-bit field.  */
8901   if (GET_CODE (src) == IOR && GET_CODE (XEXP (src, 0)) == ASHIFT
8902       && XEXP (XEXP (src, 0), 0) == const1_rtx
8903       && rtx_equal_for_field_assignment_p (dest, XEXP (src, 1)))
8904     {
8905       assign = make_extraction (VOIDmode, dest, 0, XEXP (XEXP (src, 0), 1),
8906                                 1, 1, 1, 0);
8907       if (assign != 0)
8908         return gen_rtx_SET (VOIDmode, assign, const1_rtx);
8909       return x;
8910     }
8911
8912   /* If DEST is already a field assignment, i.e. ZERO_EXTRACT, and the
8913      SRC is an AND with all bits of that field set, then we can discard
8914      the AND.  */
8915   if (GET_CODE (dest) == ZERO_EXTRACT
8916       && CONST_INT_P (XEXP (dest, 1))
8917       && GET_CODE (src) == AND
8918       && CONST_INT_P (XEXP (src, 1)))
8919     {
8920       HOST_WIDE_INT width = INTVAL (XEXP (dest, 1));
8921       unsigned HOST_WIDE_INT and_mask = INTVAL (XEXP (src, 1));
8922       unsigned HOST_WIDE_INT ze_mask;
8923
8924       if (width >= HOST_BITS_PER_WIDE_INT)
8925         ze_mask = -1;
8926       else
8927         ze_mask = ((unsigned HOST_WIDE_INT)1 << width) - 1;
8928
8929       /* Complete overlap.  We can remove the source AND.  */
8930       if ((and_mask & ze_mask) == ze_mask)
8931         return gen_rtx_SET (VOIDmode, dest, XEXP (src, 0));
8932
8933       /* Partial overlap.  We can reduce the source AND.  */
8934       if ((and_mask & ze_mask) != and_mask)
8935         {
8936           mode = GET_MODE (src);
8937           src = gen_rtx_AND (mode, XEXP (src, 0),
8938                              gen_int_mode (and_mask & ze_mask, mode));
8939           return gen_rtx_SET (VOIDmode, dest, src);
8940         }
8941     }
8942
8943   /* The other case we handle is assignments into a constant-position
8944      field.  They look like (ior/xor (and DEST C1) OTHER).  If C1 represents
8945      a mask that has all one bits except for a group of zero bits and
8946      OTHER is known to have zeros where C1 has ones, this is such an
8947      assignment.  Compute the position and length from C1.  Shift OTHER
8948      to the appropriate position, force it to the required mode, and
8949      make the extraction.  Check for the AND in both operands.  */
8950
8951   if (GET_CODE (src) != IOR && GET_CODE (src) != XOR)
8952     return x;
8953
8954   rhs = expand_compound_operation (XEXP (src, 0));
8955   lhs = expand_compound_operation (XEXP (src, 1));
8956
8957   if (GET_CODE (rhs) == AND
8958       && CONST_INT_P (XEXP (rhs, 1))
8959       && rtx_equal_for_field_assignment_p (XEXP (rhs, 0), dest))
8960     c1 = INTVAL (XEXP (rhs, 1)), other = lhs;
8961   else if (GET_CODE (lhs) == AND
8962            && CONST_INT_P (XEXP (lhs, 1))
8963            && rtx_equal_for_field_assignment_p (XEXP (lhs, 0), dest))
8964     c1 = INTVAL (XEXP (lhs, 1)), other = rhs;
8965   else
8966     return x;
8967
8968   pos = get_pos_from_mask ((~c1) & GET_MODE_MASK (GET_MODE (dest)), &len);
8969   if (pos < 0 || pos + len > GET_MODE_BITSIZE (GET_MODE (dest))
8970       || GET_MODE_BITSIZE (GET_MODE (dest)) > HOST_BITS_PER_WIDE_INT
8971       || (c1 & nonzero_bits (other, GET_MODE (dest))) != 0)
8972     return x;
8973
8974   assign = make_extraction (VOIDmode, dest, pos, NULL_RTX, len, 1, 1, 0);
8975   if (assign == 0)
8976     return x;
8977
8978   /* The mode to use for the source is the mode of the assignment, or of
8979      what is inside a possible STRICT_LOW_PART.  */
8980   mode = (GET_CODE (assign) == STRICT_LOW_PART
8981           ? GET_MODE (XEXP (assign, 0)) : GET_MODE (assign));
8982
8983   /* Shift OTHER right POS places and make it the source, restricting it
8984      to the proper length and mode.  */
8985
8986   src = canon_reg_for_combine (simplify_shift_const (NULL_RTX, LSHIFTRT,
8987                                                      GET_MODE (src),
8988                                                      other, pos),
8989                                dest);
8990   src = force_to_mode (src, mode,
8991                        GET_MODE_BITSIZE (mode) >= HOST_BITS_PER_WIDE_INT
8992                        ? ~(unsigned HOST_WIDE_INT) 0
8993                        : ((unsigned HOST_WIDE_INT) 1 << len) - 1,
8994                        0);
8995
8996   /* If SRC is masked by an AND that does not make a difference in
8997      the value being stored, strip it.  */
8998   if (GET_CODE (assign) == ZERO_EXTRACT
8999       && CONST_INT_P (XEXP (assign, 1))
9000       && INTVAL (XEXP (assign, 1)) < HOST_BITS_PER_WIDE_INT
9001       && GET_CODE (src) == AND
9002       && CONST_INT_P (XEXP (src, 1))
9003       && ((unsigned HOST_WIDE_INT) INTVAL (XEXP (src, 1))
9004           == ((unsigned HOST_WIDE_INT) 1 << INTVAL (XEXP (assign, 1))) - 1))
9005     src = XEXP (src, 0);
9006
9007   return gen_rtx_SET (VOIDmode, assign, src);
9008 }
9009 \f
9010 /* See if X is of the form (+ (* a c) (* b c)) and convert to (* (+ a b) c)
9011    if so.  */
9012
9013 static rtx
9014 apply_distributive_law (rtx x)
9015 {
9016   enum rtx_code code = GET_CODE (x);
9017   enum rtx_code inner_code;
9018   rtx lhs, rhs, other;
9019   rtx tem;
9020
9021   /* Distributivity is not true for floating point as it can change the
9022      value.  So we don't do it unless -funsafe-math-optimizations.  */
9023   if (FLOAT_MODE_P (GET_MODE (x))
9024       && ! flag_unsafe_math_optimizations)
9025     return x;
9026
9027   /* The outer operation can only be one of the following:  */
9028   if (code != IOR && code != AND && code != XOR
9029       && code != PLUS && code != MINUS)
9030     return x;
9031
9032   lhs = XEXP (x, 0);
9033   rhs = XEXP (x, 1);
9034
9035   /* If either operand is a primitive we can't do anything, so get out
9036      fast.  */
9037   if (OBJECT_P (lhs) || OBJECT_P (rhs))
9038     return x;
9039
9040   lhs = expand_compound_operation (lhs);
9041   rhs = expand_compound_operation (rhs);
9042   inner_code = GET_CODE (lhs);
9043   if (inner_code != GET_CODE (rhs))
9044     return x;
9045
9046   /* See if the inner and outer operations distribute.  */
9047   switch (inner_code)
9048     {
9049     case LSHIFTRT:
9050     case ASHIFTRT:
9051     case AND:
9052     case IOR:
9053       /* These all distribute except over PLUS.  */
9054       if (code == PLUS || code == MINUS)
9055         return x;
9056       break;
9057
9058     case MULT:
9059       if (code != PLUS && code != MINUS)
9060         return x;
9061       break;
9062
9063     case ASHIFT:
9064       /* This is also a multiply, so it distributes over everything.  */
9065       break;
9066
9067     case SUBREG:
9068       /* Non-paradoxical SUBREGs distributes over all operations,
9069          provided the inner modes and byte offsets are the same, this
9070          is an extraction of a low-order part, we don't convert an fp
9071          operation to int or vice versa, this is not a vector mode,
9072          and we would not be converting a single-word operation into a
9073          multi-word operation.  The latter test is not required, but
9074          it prevents generating unneeded multi-word operations.  Some
9075          of the previous tests are redundant given the latter test,
9076          but are retained because they are required for correctness.
9077
9078          We produce the result slightly differently in this case.  */
9079
9080       if (GET_MODE (SUBREG_REG (lhs)) != GET_MODE (SUBREG_REG (rhs))
9081           || SUBREG_BYTE (lhs) != SUBREG_BYTE (rhs)
9082           || ! subreg_lowpart_p (lhs)
9083           || (GET_MODE_CLASS (GET_MODE (lhs))
9084               != GET_MODE_CLASS (GET_MODE (SUBREG_REG (lhs))))
9085           || (GET_MODE_SIZE (GET_MODE (lhs))
9086               > GET_MODE_SIZE (GET_MODE (SUBREG_REG (lhs))))
9087           || VECTOR_MODE_P (GET_MODE (lhs))
9088           || GET_MODE_SIZE (GET_MODE (SUBREG_REG (lhs))) > UNITS_PER_WORD
9089           /* Result might need to be truncated.  Don't change mode if
9090              explicit truncation is needed.  */
9091           || !TRULY_NOOP_TRUNCATION
9092                (GET_MODE_BITSIZE (GET_MODE (x)),
9093                 GET_MODE_BITSIZE (GET_MODE (SUBREG_REG (lhs)))))
9094         return x;
9095
9096       tem = simplify_gen_binary (code, GET_MODE (SUBREG_REG (lhs)),
9097                                  SUBREG_REG (lhs), SUBREG_REG (rhs));
9098       return gen_lowpart (GET_MODE (x), tem);
9099
9100     default:
9101       return x;
9102     }
9103
9104   /* Set LHS and RHS to the inner operands (A and B in the example
9105      above) and set OTHER to the common operand (C in the example).
9106      There is only one way to do this unless the inner operation is
9107      commutative.  */
9108   if (COMMUTATIVE_ARITH_P (lhs)
9109       && rtx_equal_p (XEXP (lhs, 0), XEXP (rhs, 0)))
9110     other = XEXP (lhs, 0), lhs = XEXP (lhs, 1), rhs = XEXP (rhs, 1);
9111   else if (COMMUTATIVE_ARITH_P (lhs)
9112            && rtx_equal_p (XEXP (lhs, 0), XEXP (rhs, 1)))
9113     other = XEXP (lhs, 0), lhs = XEXP (lhs, 1), rhs = XEXP (rhs, 0);
9114   else if (COMMUTATIVE_ARITH_P (lhs)
9115            && rtx_equal_p (XEXP (lhs, 1), XEXP (rhs, 0)))
9116     other = XEXP (lhs, 1), lhs = XEXP (lhs, 0), rhs = XEXP (rhs, 1);
9117   else if (rtx_equal_p (XEXP (lhs, 1), XEXP (rhs, 1)))
9118     other = XEXP (lhs, 1), lhs = XEXP (lhs, 0), rhs = XEXP (rhs, 0);
9119   else
9120     return x;
9121
9122   /* Form the new inner operation, seeing if it simplifies first.  */
9123   tem = simplify_gen_binary (code, GET_MODE (x), lhs, rhs);
9124
9125   /* There is one exception to the general way of distributing:
9126      (a | c) ^ (b | c) -> (a ^ b) & ~c  */
9127   if (code == XOR && inner_code == IOR)
9128     {
9129       inner_code = AND;
9130       other = simplify_gen_unary (NOT, GET_MODE (x), other, GET_MODE (x));
9131     }
9132
9133   /* We may be able to continuing distributing the result, so call
9134      ourselves recursively on the inner operation before forming the
9135      outer operation, which we return.  */
9136   return simplify_gen_binary (inner_code, GET_MODE (x),
9137                               apply_distributive_law (tem), other);
9138 }
9139
9140 /* See if X is of the form (* (+ A B) C), and if so convert to
9141    (+ (* A C) (* B C)) and try to simplify.
9142
9143    Most of the time, this results in no change.  However, if some of
9144    the operands are the same or inverses of each other, simplifications
9145    will result.
9146
9147    For example, (and (ior A B) (not B)) can occur as the result of
9148    expanding a bit field assignment.  When we apply the distributive
9149    law to this, we get (ior (and (A (not B))) (and (B (not B)))),
9150    which then simplifies to (and (A (not B))).
9151
9152    Note that no checks happen on the validity of applying the inverse
9153    distributive law.  This is pointless since we can do it in the
9154    few places where this routine is called.
9155
9156    N is the index of the term that is decomposed (the arithmetic operation,
9157    i.e. (+ A B) in the first example above).  !N is the index of the term that
9158    is distributed, i.e. of C in the first example above.  */
9159 static rtx
9160 distribute_and_simplify_rtx (rtx x, int n)
9161 {
9162   enum machine_mode mode;
9163   enum rtx_code outer_code, inner_code;
9164   rtx decomposed, distributed, inner_op0, inner_op1, new_op0, new_op1, tmp;
9165
9166   /* Distributivity is not true for floating point as it can change the
9167      value.  So we don't do it unless -funsafe-math-optimizations.  */
9168   if (FLOAT_MODE_P (GET_MODE (x))
9169       && ! flag_unsafe_math_optimizations)
9170     return NULL_RTX;
9171
9172   decomposed = XEXP (x, n);
9173   if (!ARITHMETIC_P (decomposed))
9174     return NULL_RTX;
9175
9176   mode = GET_MODE (x);
9177   outer_code = GET_CODE (x);
9178   distributed = XEXP (x, !n);
9179
9180   inner_code = GET_CODE (decomposed);
9181   inner_op0 = XEXP (decomposed, 0);
9182   inner_op1 = XEXP (decomposed, 1);
9183
9184   /* Special case (and (xor B C) (not A)), which is equivalent to
9185      (xor (ior A B) (ior A C))  */
9186   if (outer_code == AND && inner_code == XOR && GET_CODE (distributed) == NOT)
9187     {
9188       distributed = XEXP (distributed, 0);
9189       outer_code = IOR;
9190     }
9191
9192   if (n == 0)
9193     {
9194       /* Distribute the second term.  */
9195       new_op0 = simplify_gen_binary (outer_code, mode, inner_op0, distributed);
9196       new_op1 = simplify_gen_binary (outer_code, mode, inner_op1, distributed);
9197     }
9198   else
9199     {
9200       /* Distribute the first term.  */
9201       new_op0 = simplify_gen_binary (outer_code, mode, distributed, inner_op0);
9202       new_op1 = simplify_gen_binary (outer_code, mode, distributed, inner_op1);
9203     }
9204
9205   tmp = apply_distributive_law (simplify_gen_binary (inner_code, mode,
9206                                                      new_op0, new_op1));
9207   if (GET_CODE (tmp) != outer_code
9208       && rtx_cost (tmp, SET, optimize_this_for_speed_p)
9209          < rtx_cost (x, SET, optimize_this_for_speed_p))
9210     return tmp;
9211
9212   return NULL_RTX;
9213 }
9214 \f
9215 /* Simplify a logical `and' of VAROP with the constant CONSTOP, to be done
9216    in MODE.  Return an equivalent form, if different from (and VAROP
9217    (const_int CONSTOP)).  Otherwise, return NULL_RTX.  */
9218
9219 static rtx
9220 simplify_and_const_int_1 (enum machine_mode mode, rtx varop,
9221                           unsigned HOST_WIDE_INT constop)
9222 {
9223   unsigned HOST_WIDE_INT nonzero;
9224   unsigned HOST_WIDE_INT orig_constop;
9225   rtx orig_varop;
9226   int i;
9227
9228   orig_varop = varop;
9229   orig_constop = constop;
9230   if (GET_CODE (varop) == CLOBBER)
9231     return NULL_RTX;
9232
9233   /* Simplify VAROP knowing that we will be only looking at some of the
9234      bits in it.
9235
9236      Note by passing in CONSTOP, we guarantee that the bits not set in
9237      CONSTOP are not significant and will never be examined.  We must
9238      ensure that is the case by explicitly masking out those bits
9239      before returning.  */
9240   varop = force_to_mode (varop, mode, constop, 0);
9241
9242   /* If VAROP is a CLOBBER, we will fail so return it.  */
9243   if (GET_CODE (varop) == CLOBBER)
9244     return varop;
9245
9246   /* If VAROP is a CONST_INT, then we need to apply the mask in CONSTOP
9247      to VAROP and return the new constant.  */
9248   if (CONST_INT_P (varop))
9249     return gen_int_mode (INTVAL (varop) & constop, mode);
9250
9251   /* See what bits may be nonzero in VAROP.  Unlike the general case of
9252      a call to nonzero_bits, here we don't care about bits outside
9253      MODE.  */
9254
9255   nonzero = nonzero_bits (varop, mode) & GET_MODE_MASK (mode);
9256
9257   /* Turn off all bits in the constant that are known to already be zero.
9258      Thus, if the AND isn't needed at all, we will have CONSTOP == NONZERO_BITS
9259      which is tested below.  */
9260
9261   constop &= nonzero;
9262
9263   /* If we don't have any bits left, return zero.  */
9264   if (constop == 0)
9265     return const0_rtx;
9266
9267   /* If VAROP is a NEG of something known to be zero or 1 and CONSTOP is
9268      a power of two, we can replace this with an ASHIFT.  */
9269   if (GET_CODE (varop) == NEG && nonzero_bits (XEXP (varop, 0), mode) == 1
9270       && (i = exact_log2 (constop)) >= 0)
9271     return simplify_shift_const (NULL_RTX, ASHIFT, mode, XEXP (varop, 0), i);
9272
9273   /* If VAROP is an IOR or XOR, apply the AND to both branches of the IOR
9274      or XOR, then try to apply the distributive law.  This may eliminate
9275      operations if either branch can be simplified because of the AND.
9276      It may also make some cases more complex, but those cases probably
9277      won't match a pattern either with or without this.  */
9278
9279   if (GET_CODE (varop) == IOR || GET_CODE (varop) == XOR)
9280     return
9281       gen_lowpart
9282         (mode,
9283          apply_distributive_law
9284          (simplify_gen_binary (GET_CODE (varop), GET_MODE (varop),
9285                                simplify_and_const_int (NULL_RTX,
9286                                                        GET_MODE (varop),
9287                                                        XEXP (varop, 0),
9288                                                        constop),
9289                                simplify_and_const_int (NULL_RTX,
9290                                                        GET_MODE (varop),
9291                                                        XEXP (varop, 1),
9292                                                        constop))));
9293
9294   /* If VAROP is PLUS, and the constant is a mask of low bits, distribute
9295      the AND and see if one of the operands simplifies to zero.  If so, we
9296      may eliminate it.  */
9297
9298   if (GET_CODE (varop) == PLUS
9299       && exact_log2 (constop + 1) >= 0)
9300     {
9301       rtx o0, o1;
9302
9303       o0 = simplify_and_const_int (NULL_RTX, mode, XEXP (varop, 0), constop);
9304       o1 = simplify_and_const_int (NULL_RTX, mode, XEXP (varop, 1), constop);
9305       if (o0 == const0_rtx)
9306         return o1;
9307       if (o1 == const0_rtx)
9308         return o0;
9309     }
9310
9311   /* Make a SUBREG if necessary.  If we can't make it, fail.  */
9312   varop = gen_lowpart (mode, varop);
9313   if (varop == NULL_RTX || GET_CODE (varop) == CLOBBER)
9314     return NULL_RTX;
9315
9316   /* If we are only masking insignificant bits, return VAROP.  */
9317   if (constop == nonzero)
9318     return varop;
9319
9320   if (varop == orig_varop && constop == orig_constop)
9321     return NULL_RTX;
9322
9323   /* Otherwise, return an AND.  */
9324   return simplify_gen_binary (AND, mode, varop, gen_int_mode (constop, mode));
9325 }
9326
9327
9328 /* We have X, a logical `and' of VAROP with the constant CONSTOP, to be done
9329    in MODE.
9330
9331    Return an equivalent form, if different from X.  Otherwise, return X.  If
9332    X is zero, we are to always construct the equivalent form.  */
9333
9334 static rtx
9335 simplify_and_const_int (rtx x, enum machine_mode mode, rtx varop,
9336                         unsigned HOST_WIDE_INT constop)
9337 {
9338   rtx tem = simplify_and_const_int_1 (mode, varop, constop);
9339   if (tem)
9340     return tem;
9341
9342   if (!x)
9343     x = simplify_gen_binary (AND, GET_MODE (varop), varop,
9344                              gen_int_mode (constop, mode));
9345   if (GET_MODE (x) != mode)
9346     x = gen_lowpart (mode, x);
9347   return x;
9348 }
9349 \f
9350 /* Given a REG, X, compute which bits in X can be nonzero.
9351    We don't care about bits outside of those defined in MODE.
9352
9353    For most X this is simply GET_MODE_MASK (GET_MODE (MODE)), but if X is
9354    a shift, AND, or zero_extract, we can do better.  */
9355
9356 static rtx
9357 reg_nonzero_bits_for_combine (const_rtx x, enum machine_mode mode,
9358                               const_rtx known_x ATTRIBUTE_UNUSED,
9359                               enum machine_mode known_mode ATTRIBUTE_UNUSED,
9360                               unsigned HOST_WIDE_INT known_ret ATTRIBUTE_UNUSED,
9361                               unsigned HOST_WIDE_INT *nonzero)
9362 {
9363   rtx tem;
9364   reg_stat_type *rsp;
9365
9366   /* If X is a register whose nonzero bits value is current, use it.
9367      Otherwise, if X is a register whose value we can find, use that
9368      value.  Otherwise, use the previously-computed global nonzero bits
9369      for this register.  */
9370
9371   rsp = VEC_index (reg_stat_type, reg_stat, REGNO (x));
9372   if (rsp->last_set_value != 0
9373       && (rsp->last_set_mode == mode
9374           || (GET_MODE_CLASS (rsp->last_set_mode) == MODE_INT
9375               && GET_MODE_CLASS (mode) == MODE_INT))
9376       && ((rsp->last_set_label >= label_tick_ebb_start
9377            && rsp->last_set_label < label_tick)
9378           || (rsp->last_set_label == label_tick
9379               && DF_INSN_LUID (rsp->last_set) < subst_low_luid)
9380           || (REGNO (x) >= FIRST_PSEUDO_REGISTER
9381               && REG_N_SETS (REGNO (x)) == 1
9382               && !REGNO_REG_SET_P
9383                   (DF_LR_IN (ENTRY_BLOCK_PTR->next_bb), REGNO (x)))))
9384     {
9385       *nonzero &= rsp->last_set_nonzero_bits;
9386       return NULL;
9387     }
9388
9389   tem = get_last_value (x);
9390
9391   if (tem)
9392     {
9393 #ifdef SHORT_IMMEDIATES_SIGN_EXTEND
9394       /* If X is narrower than MODE and TEM is a non-negative
9395          constant that would appear negative in the mode of X,
9396          sign-extend it for use in reg_nonzero_bits because some
9397          machines (maybe most) will actually do the sign-extension
9398          and this is the conservative approach.
9399
9400          ??? For 2.5, try to tighten up the MD files in this regard
9401          instead of this kludge.  */
9402
9403       if (GET_MODE_BITSIZE (GET_MODE (x)) < GET_MODE_BITSIZE (mode)
9404           && CONST_INT_P (tem)
9405           && INTVAL (tem) > 0
9406           && 0 != (INTVAL (tem)
9407                    & ((HOST_WIDE_INT) 1
9408                       << (GET_MODE_BITSIZE (GET_MODE (x)) - 1))))
9409         tem = GEN_INT (INTVAL (tem)
9410                        | ((HOST_WIDE_INT) (-1)
9411                           << GET_MODE_BITSIZE (GET_MODE (x))));
9412 #endif
9413       return tem;
9414     }
9415   else if (nonzero_sign_valid && rsp->nonzero_bits)
9416     {
9417       unsigned HOST_WIDE_INT mask = rsp->nonzero_bits;
9418
9419       if (GET_MODE_BITSIZE (GET_MODE (x)) < GET_MODE_BITSIZE (mode))
9420         /* We don't know anything about the upper bits.  */
9421         mask |= GET_MODE_MASK (mode) ^ GET_MODE_MASK (GET_MODE (x));
9422       *nonzero &= mask;
9423     }
9424
9425   return NULL;
9426 }
9427
9428 /* Return the number of bits at the high-order end of X that are known to
9429    be equal to the sign bit.  X will be used in mode MODE; if MODE is
9430    VOIDmode, X will be used in its own mode.  The returned value  will always
9431    be between 1 and the number of bits in MODE.  */
9432
9433 static rtx
9434 reg_num_sign_bit_copies_for_combine (const_rtx x, enum machine_mode mode,
9435                                      const_rtx known_x ATTRIBUTE_UNUSED,
9436                                      enum machine_mode known_mode
9437                                      ATTRIBUTE_UNUSED,
9438                                      unsigned int known_ret ATTRIBUTE_UNUSED,
9439                                      unsigned int *result)
9440 {
9441   rtx tem;
9442   reg_stat_type *rsp;
9443
9444   rsp = VEC_index (reg_stat_type, reg_stat, REGNO (x));
9445   if (rsp->last_set_value != 0
9446       && rsp->last_set_mode == mode
9447       && ((rsp->last_set_label >= label_tick_ebb_start
9448            && rsp->last_set_label < label_tick)
9449           || (rsp->last_set_label == label_tick
9450               && DF_INSN_LUID (rsp->last_set) < subst_low_luid)
9451           || (REGNO (x) >= FIRST_PSEUDO_REGISTER
9452               && REG_N_SETS (REGNO (x)) == 1
9453               && !REGNO_REG_SET_P
9454                   (DF_LR_IN (ENTRY_BLOCK_PTR->next_bb), REGNO (x)))))
9455     {
9456       *result = rsp->last_set_sign_bit_copies;
9457       return NULL;
9458     }
9459
9460   tem = get_last_value (x);
9461   if (tem != 0)
9462     return tem;
9463
9464   if (nonzero_sign_valid && rsp->sign_bit_copies != 0
9465       && GET_MODE_BITSIZE (GET_MODE (x)) == GET_MODE_BITSIZE (mode))
9466     *result = rsp->sign_bit_copies;
9467
9468   return NULL;
9469 }
9470 \f
9471 /* Return the number of "extended" bits there are in X, when interpreted
9472    as a quantity in MODE whose signedness is indicated by UNSIGNEDP.  For
9473    unsigned quantities, this is the number of high-order zero bits.
9474    For signed quantities, this is the number of copies of the sign bit
9475    minus 1.  In both case, this function returns the number of "spare"
9476    bits.  For example, if two quantities for which this function returns
9477    at least 1 are added, the addition is known not to overflow.
9478
9479    This function will always return 0 unless called during combine, which
9480    implies that it must be called from a define_split.  */
9481
9482 unsigned int
9483 extended_count (const_rtx x, enum machine_mode mode, int unsignedp)
9484 {
9485   if (nonzero_sign_valid == 0)
9486     return 0;
9487
9488   return (unsignedp
9489           ? (GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
9490              ? (unsigned int) (GET_MODE_BITSIZE (mode) - 1
9491                                - floor_log2 (nonzero_bits (x, mode)))
9492              : 0)
9493           : num_sign_bit_copies (x, mode) - 1);
9494 }
9495 \f
9496 /* This function is called from `simplify_shift_const' to merge two
9497    outer operations.  Specifically, we have already found that we need
9498    to perform operation *POP0 with constant *PCONST0 at the outermost
9499    position.  We would now like to also perform OP1 with constant CONST1
9500    (with *POP0 being done last).
9501
9502    Return 1 if we can do the operation and update *POP0 and *PCONST0 with
9503    the resulting operation.  *PCOMP_P is set to 1 if we would need to
9504    complement the innermost operand, otherwise it is unchanged.
9505
9506    MODE is the mode in which the operation will be done.  No bits outside
9507    the width of this mode matter.  It is assumed that the width of this mode
9508    is smaller than or equal to HOST_BITS_PER_WIDE_INT.
9509
9510    If *POP0 or OP1 are UNKNOWN, it means no operation is required.  Only NEG, PLUS,
9511    IOR, XOR, and AND are supported.  We may set *POP0 to SET if the proper
9512    result is simply *PCONST0.
9513
9514    If the resulting operation cannot be expressed as one operation, we
9515    return 0 and do not change *POP0, *PCONST0, and *PCOMP_P.  */
9516
9517 static int
9518 merge_outer_ops (enum rtx_code *pop0, HOST_WIDE_INT *pconst0, enum rtx_code op1, HOST_WIDE_INT const1, enum machine_mode mode, int *pcomp_p)
9519 {
9520   enum rtx_code op0 = *pop0;
9521   HOST_WIDE_INT const0 = *pconst0;
9522
9523   const0 &= GET_MODE_MASK (mode);
9524   const1 &= GET_MODE_MASK (mode);
9525
9526   /* If OP0 is an AND, clear unimportant bits in CONST1.  */
9527   if (op0 == AND)
9528     const1 &= const0;
9529
9530   /* If OP0 or OP1 is UNKNOWN, this is easy.  Similarly if they are the same or
9531      if OP0 is SET.  */
9532
9533   if (op1 == UNKNOWN || op0 == SET)
9534     return 1;
9535
9536   else if (op0 == UNKNOWN)
9537     op0 = op1, const0 = const1;
9538
9539   else if (op0 == op1)
9540     {
9541       switch (op0)
9542         {
9543         case AND:
9544           const0 &= const1;
9545           break;
9546         case IOR:
9547           const0 |= const1;
9548           break;
9549         case XOR:
9550           const0 ^= const1;
9551           break;
9552         case PLUS:
9553           const0 += const1;
9554           break;
9555         case NEG:
9556           op0 = UNKNOWN;
9557           break;
9558         default:
9559           break;
9560         }
9561     }
9562
9563   /* Otherwise, if either is a PLUS or NEG, we can't do anything.  */
9564   else if (op0 == PLUS || op1 == PLUS || op0 == NEG || op1 == NEG)
9565     return 0;
9566
9567   /* If the two constants aren't the same, we can't do anything.  The
9568      remaining six cases can all be done.  */
9569   else if (const0 != const1)
9570     return 0;
9571
9572   else
9573     switch (op0)
9574       {
9575       case IOR:
9576         if (op1 == AND)
9577           /* (a & b) | b == b */
9578           op0 = SET;
9579         else /* op1 == XOR */
9580           /* (a ^ b) | b == a | b */
9581           {;}
9582         break;
9583
9584       case XOR:
9585         if (op1 == AND)
9586           /* (a & b) ^ b == (~a) & b */
9587           op0 = AND, *pcomp_p = 1;
9588         else /* op1 == IOR */
9589           /* (a | b) ^ b == a & ~b */
9590           op0 = AND, const0 = ~const0;
9591         break;
9592
9593       case AND:
9594         if (op1 == IOR)
9595           /* (a | b) & b == b */
9596         op0 = SET;
9597         else /* op1 == XOR */
9598           /* (a ^ b) & b) == (~a) & b */
9599           *pcomp_p = 1;
9600         break;
9601       default:
9602         break;
9603       }
9604
9605   /* Check for NO-OP cases.  */
9606   const0 &= GET_MODE_MASK (mode);
9607   if (const0 == 0
9608       && (op0 == IOR || op0 == XOR || op0 == PLUS))
9609     op0 = UNKNOWN;
9610   else if (const0 == 0 && op0 == AND)
9611     op0 = SET;
9612   else if ((unsigned HOST_WIDE_INT) const0 == GET_MODE_MASK (mode)
9613            && op0 == AND)
9614     op0 = UNKNOWN;
9615
9616   *pop0 = op0;
9617
9618   /* ??? Slightly redundant with the above mask, but not entirely.
9619      Moving this above means we'd have to sign-extend the mode mask
9620      for the final test.  */
9621   if (op0 != UNKNOWN && op0 != NEG)
9622     *pconst0 = trunc_int_for_mode (const0, mode);
9623
9624   return 1;
9625 }
9626 \f
9627 /* A helper to simplify_shift_const_1 to determine the mode we can perform
9628    the shift in.  The original shift operation CODE is performed on OP in
9629    ORIG_MODE.  Return the wider mode MODE if we can perform the operation
9630    in that mode.  Return ORIG_MODE otherwise.  We can also assume that the
9631    result of the shift is subject to operation OUTER_CODE with operand
9632    OUTER_CONST.  */
9633
9634 static enum machine_mode
9635 try_widen_shift_mode (enum rtx_code code, rtx op, int count,
9636                       enum machine_mode orig_mode, enum machine_mode mode,
9637                       enum rtx_code outer_code, HOST_WIDE_INT outer_const)
9638 {
9639   if (orig_mode == mode)
9640     return mode;
9641   gcc_assert (GET_MODE_BITSIZE (mode) > GET_MODE_BITSIZE (orig_mode));
9642
9643   /* In general we can't perform in wider mode for right shift and rotate.  */
9644   switch (code)
9645     {
9646     case ASHIFTRT:
9647       /* We can still widen if the bits brought in from the left are identical
9648          to the sign bit of ORIG_MODE.  */
9649       if (num_sign_bit_copies (op, mode)
9650           > (unsigned) (GET_MODE_BITSIZE (mode)
9651                         - GET_MODE_BITSIZE (orig_mode)))
9652         return mode;
9653       return orig_mode;
9654
9655     case LSHIFTRT:
9656       /* Similarly here but with zero bits.  */
9657       if (GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
9658           && (nonzero_bits (op, mode) & ~GET_MODE_MASK (orig_mode)) == 0)
9659         return mode;
9660
9661       /* We can also widen if the bits brought in will be masked off.  This
9662          operation is performed in ORIG_MODE.  */
9663       if (outer_code == AND)
9664         {
9665           int care_bits = low_bitmask_len (orig_mode, outer_const);
9666
9667           if (care_bits >= 0
9668               && GET_MODE_BITSIZE (orig_mode) - care_bits >= count)
9669             return mode;
9670         }
9671       /* fall through */
9672
9673     case ROTATE:
9674       return orig_mode;
9675
9676     case ROTATERT:
9677       gcc_unreachable ();
9678
9679     default:
9680       return mode;
9681     }
9682 }
9683
9684 /* Simplify a shift of VAROP by COUNT bits.  CODE says what kind of shift.
9685    The result of the shift is RESULT_MODE.  Return NULL_RTX if we cannot
9686    simplify it.  Otherwise, return a simplified value.
9687
9688    The shift is normally computed in the widest mode we find in VAROP, as
9689    long as it isn't a different number of words than RESULT_MODE.  Exceptions
9690    are ASHIFTRT and ROTATE, which are always done in their original mode.  */
9691
9692 static rtx
9693 simplify_shift_const_1 (enum rtx_code code, enum machine_mode result_mode,
9694                         rtx varop, int orig_count)
9695 {
9696   enum rtx_code orig_code = code;
9697   rtx orig_varop = varop;
9698   int count;
9699   enum machine_mode mode = result_mode;
9700   enum machine_mode shift_mode, tmode;
9701   unsigned int mode_words
9702     = (GET_MODE_SIZE (mode) + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD;
9703   /* We form (outer_op (code varop count) (outer_const)).  */
9704   enum rtx_code outer_op = UNKNOWN;
9705   HOST_WIDE_INT outer_const = 0;
9706   int complement_p = 0;
9707   rtx new_rtx, x;
9708
9709   /* Make sure and truncate the "natural" shift on the way in.  We don't
9710      want to do this inside the loop as it makes it more difficult to
9711      combine shifts.  */
9712   if (SHIFT_COUNT_TRUNCATED)
9713     orig_count &= GET_MODE_BITSIZE (mode) - 1;
9714
9715   /* If we were given an invalid count, don't do anything except exactly
9716      what was requested.  */
9717
9718   if (orig_count < 0 || orig_count >= (int) GET_MODE_BITSIZE (mode))
9719     return NULL_RTX;
9720
9721   count = orig_count;
9722
9723   /* Unless one of the branches of the `if' in this loop does a `continue',
9724      we will `break' the loop after the `if'.  */
9725
9726   while (count != 0)
9727     {
9728       /* If we have an operand of (clobber (const_int 0)), fail.  */
9729       if (GET_CODE (varop) == CLOBBER)
9730         return NULL_RTX;
9731
9732       /* Convert ROTATERT to ROTATE.  */
9733       if (code == ROTATERT)
9734         {
9735           unsigned int bitsize = GET_MODE_BITSIZE (result_mode);;
9736           code = ROTATE;
9737           if (VECTOR_MODE_P (result_mode))
9738             count = bitsize / GET_MODE_NUNITS (result_mode) - count;
9739           else
9740             count = bitsize - count;
9741         }
9742
9743       shift_mode = try_widen_shift_mode (code, varop, count, result_mode,
9744                                          mode, outer_op, outer_const);
9745
9746       /* Handle cases where the count is greater than the size of the mode
9747          minus 1.  For ASHIFT, use the size minus one as the count (this can
9748          occur when simplifying (lshiftrt (ashiftrt ..))).  For rotates,
9749          take the count modulo the size.  For other shifts, the result is
9750          zero.
9751
9752          Since these shifts are being produced by the compiler by combining
9753          multiple operations, each of which are defined, we know what the
9754          result is supposed to be.  */
9755
9756       if (count > (GET_MODE_BITSIZE (shift_mode) - 1))
9757         {
9758           if (code == ASHIFTRT)
9759             count = GET_MODE_BITSIZE (shift_mode) - 1;
9760           else if (code == ROTATE || code == ROTATERT)
9761             count %= GET_MODE_BITSIZE (shift_mode);
9762           else
9763             {
9764               /* We can't simply return zero because there may be an
9765                  outer op.  */
9766               varop = const0_rtx;
9767               count = 0;
9768               break;
9769             }
9770         }
9771
9772       /* If we discovered we had to complement VAROP, leave.  Making a NOT
9773          here would cause an infinite loop.  */
9774       if (complement_p)
9775         break;
9776
9777       /* An arithmetic right shift of a quantity known to be -1 or 0
9778          is a no-op.  */
9779       if (code == ASHIFTRT
9780           && (num_sign_bit_copies (varop, shift_mode)
9781               == GET_MODE_BITSIZE (shift_mode)))
9782         {
9783           count = 0;
9784           break;
9785         }
9786
9787       /* If we are doing an arithmetic right shift and discarding all but
9788          the sign bit copies, this is equivalent to doing a shift by the
9789          bitsize minus one.  Convert it into that shift because it will often
9790          allow other simplifications.  */
9791
9792       if (code == ASHIFTRT
9793           && (count + num_sign_bit_copies (varop, shift_mode)
9794               >= GET_MODE_BITSIZE (shift_mode)))
9795         count = GET_MODE_BITSIZE (shift_mode) - 1;
9796
9797       /* We simplify the tests below and elsewhere by converting
9798          ASHIFTRT to LSHIFTRT if we know the sign bit is clear.
9799          `make_compound_operation' will convert it to an ASHIFTRT for
9800          those machines (such as VAX) that don't have an LSHIFTRT.  */
9801       if (GET_MODE_BITSIZE (shift_mode) <= HOST_BITS_PER_WIDE_INT
9802           && code == ASHIFTRT
9803           && ((nonzero_bits (varop, shift_mode)
9804                & ((HOST_WIDE_INT) 1 << (GET_MODE_BITSIZE (shift_mode) - 1)))
9805               == 0))
9806         code = LSHIFTRT;
9807
9808       if (((code == LSHIFTRT
9809             && GET_MODE_BITSIZE (shift_mode) <= HOST_BITS_PER_WIDE_INT
9810             && !(nonzero_bits (varop, shift_mode) >> count))
9811            || (code == ASHIFT
9812                && GET_MODE_BITSIZE (shift_mode) <= HOST_BITS_PER_WIDE_INT
9813                && !((nonzero_bits (varop, shift_mode) << count)
9814                     & GET_MODE_MASK (shift_mode))))
9815           && !side_effects_p (varop))
9816         varop = const0_rtx;
9817
9818       switch (GET_CODE (varop))
9819         {
9820         case SIGN_EXTEND:
9821         case ZERO_EXTEND:
9822         case SIGN_EXTRACT:
9823         case ZERO_EXTRACT:
9824           new_rtx = expand_compound_operation (varop);
9825           if (new_rtx != varop)
9826             {
9827               varop = new_rtx;
9828               continue;
9829             }
9830           break;
9831
9832         case MEM:
9833           /* If we have (xshiftrt (mem ...) C) and C is MODE_WIDTH
9834              minus the width of a smaller mode, we can do this with a
9835              SIGN_EXTEND or ZERO_EXTEND from the narrower memory location.  */
9836           if ((code == ASHIFTRT || code == LSHIFTRT)
9837               && ! mode_dependent_address_p (XEXP (varop, 0))
9838               && ! MEM_VOLATILE_P (varop)
9839               && (tmode = mode_for_size (GET_MODE_BITSIZE (mode) - count,
9840                                          MODE_INT, 1)) != BLKmode)
9841             {
9842               new_rtx = adjust_address_nv (varop, tmode,
9843                                        BYTES_BIG_ENDIAN ? 0
9844                                        : count / BITS_PER_UNIT);
9845
9846               varop = gen_rtx_fmt_e (code == ASHIFTRT ? SIGN_EXTEND
9847                                      : ZERO_EXTEND, mode, new_rtx);
9848               count = 0;
9849               continue;
9850             }
9851           break;
9852
9853         case SUBREG:
9854           /* If VAROP is a SUBREG, strip it as long as the inner operand has
9855              the same number of words as what we've seen so far.  Then store
9856              the widest mode in MODE.  */
9857           if (subreg_lowpart_p (varop)
9858               && (GET_MODE_SIZE (GET_MODE (SUBREG_REG (varop)))
9859                   > GET_MODE_SIZE (GET_MODE (varop)))
9860               && (unsigned int) ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (varop)))
9861                                   + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD)
9862                  == mode_words
9863               && GET_MODE_CLASS (GET_MODE (varop)) == MODE_INT
9864               && GET_MODE_CLASS (GET_MODE (SUBREG_REG (varop))) == MODE_INT)
9865             {
9866               varop = SUBREG_REG (varop);
9867               if (GET_MODE_SIZE (GET_MODE (varop)) > GET_MODE_SIZE (mode))
9868                 mode = GET_MODE (varop);
9869               continue;
9870             }
9871           break;
9872
9873         case MULT:
9874           /* Some machines use MULT instead of ASHIFT because MULT
9875              is cheaper.  But it is still better on those machines to
9876              merge two shifts into one.  */
9877           if (CONST_INT_P (XEXP (varop, 1))
9878               && exact_log2 (INTVAL (XEXP (varop, 1))) >= 0)
9879             {
9880               varop
9881                 = simplify_gen_binary (ASHIFT, GET_MODE (varop),
9882                                        XEXP (varop, 0),
9883                                        GEN_INT (exact_log2 (
9884                                                 INTVAL (XEXP (varop, 1)))));
9885               continue;
9886             }
9887           break;
9888
9889         case UDIV:
9890           /* Similar, for when divides are cheaper.  */
9891           if (CONST_INT_P (XEXP (varop, 1))
9892               && exact_log2 (INTVAL (XEXP (varop, 1))) >= 0)
9893             {
9894               varop
9895                 = simplify_gen_binary (LSHIFTRT, GET_MODE (varop),
9896                                        XEXP (varop, 0),
9897                                        GEN_INT (exact_log2 (
9898                                                 INTVAL (XEXP (varop, 1)))));
9899               continue;
9900             }
9901           break;
9902
9903         case ASHIFTRT:
9904           /* If we are extracting just the sign bit of an arithmetic
9905              right shift, that shift is not needed.  However, the sign
9906              bit of a wider mode may be different from what would be
9907              interpreted as the sign bit in a narrower mode, so, if
9908              the result is narrower, don't discard the shift.  */
9909           if (code == LSHIFTRT
9910               && count == (GET_MODE_BITSIZE (result_mode) - 1)
9911               && (GET_MODE_BITSIZE (result_mode)
9912                   >= GET_MODE_BITSIZE (GET_MODE (varop))))
9913             {
9914               varop = XEXP (varop, 0);
9915               continue;
9916             }
9917
9918           /* ... fall through ...  */
9919
9920         case LSHIFTRT:
9921         case ASHIFT:
9922         case ROTATE:
9923           /* Here we have two nested shifts.  The result is usually the
9924              AND of a new shift with a mask.  We compute the result below.  */
9925           if (CONST_INT_P (XEXP (varop, 1))
9926               && INTVAL (XEXP (varop, 1)) >= 0
9927               && INTVAL (XEXP (varop, 1)) < GET_MODE_BITSIZE (GET_MODE (varop))
9928               && GET_MODE_BITSIZE (result_mode) <= HOST_BITS_PER_WIDE_INT
9929               && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
9930               && !VECTOR_MODE_P (result_mode))
9931             {
9932               enum rtx_code first_code = GET_CODE (varop);
9933               unsigned int first_count = INTVAL (XEXP (varop, 1));
9934               unsigned HOST_WIDE_INT mask;
9935               rtx mask_rtx;
9936
9937               /* We have one common special case.  We can't do any merging if
9938                  the inner code is an ASHIFTRT of a smaller mode.  However, if
9939                  we have (ashift:M1 (subreg:M1 (ashiftrt:M2 FOO C1) 0) C2)
9940                  with C2 == GET_MODE_BITSIZE (M1) - GET_MODE_BITSIZE (M2),
9941                  we can convert it to
9942                  (ashiftrt:M1 (ashift:M1 (and:M1 (subreg:M1 FOO 0 C2) C3) C1).
9943                  This simplifies certain SIGN_EXTEND operations.  */
9944               if (code == ASHIFT && first_code == ASHIFTRT
9945                   && count == (GET_MODE_BITSIZE (result_mode)
9946                                - GET_MODE_BITSIZE (GET_MODE (varop))))
9947                 {
9948                   /* C3 has the low-order C1 bits zero.  */
9949
9950                   mask = (GET_MODE_MASK (mode)
9951                           & ~(((HOST_WIDE_INT) 1 << first_count) - 1));
9952
9953                   varop = simplify_and_const_int (NULL_RTX, result_mode,
9954                                                   XEXP (varop, 0), mask);
9955                   varop = simplify_shift_const (NULL_RTX, ASHIFT, result_mode,
9956                                                 varop, count);
9957                   count = first_count;
9958                   code = ASHIFTRT;
9959                   continue;
9960                 }
9961
9962               /* If this was (ashiftrt (ashift foo C1) C2) and FOO has more
9963                  than C1 high-order bits equal to the sign bit, we can convert
9964                  this to either an ASHIFT or an ASHIFTRT depending on the
9965                  two counts.
9966
9967                  We cannot do this if VAROP's mode is not SHIFT_MODE.  */
9968
9969               if (code == ASHIFTRT && first_code == ASHIFT
9970                   && GET_MODE (varop) == shift_mode
9971                   && (num_sign_bit_copies (XEXP (varop, 0), shift_mode)
9972                       > first_count))
9973                 {
9974                   varop = XEXP (varop, 0);
9975                   count -= first_count;
9976                   if (count < 0)
9977                     {
9978                       count = -count;
9979                       code = ASHIFT;
9980                     }
9981
9982                   continue;
9983                 }
9984
9985               /* There are some cases we can't do.  If CODE is ASHIFTRT,
9986                  we can only do this if FIRST_CODE is also ASHIFTRT.
9987
9988                  We can't do the case when CODE is ROTATE and FIRST_CODE is
9989                  ASHIFTRT.
9990
9991                  If the mode of this shift is not the mode of the outer shift,
9992                  we can't do this if either shift is a right shift or ROTATE.
9993
9994                  Finally, we can't do any of these if the mode is too wide
9995                  unless the codes are the same.
9996
9997                  Handle the case where the shift codes are the same
9998                  first.  */
9999
10000               if (code == first_code)
10001                 {
10002                   if (GET_MODE (varop) != result_mode
10003                       && (code == ASHIFTRT || code == LSHIFTRT
10004                           || code == ROTATE))
10005                     break;
10006
10007                   count += first_count;
10008                   varop = XEXP (varop, 0);
10009                   continue;
10010                 }
10011
10012               if (code == ASHIFTRT
10013                   || (code == ROTATE && first_code == ASHIFTRT)
10014                   || GET_MODE_BITSIZE (mode) > HOST_BITS_PER_WIDE_INT
10015                   || (GET_MODE (varop) != result_mode
10016                       && (first_code == ASHIFTRT || first_code == LSHIFTRT
10017                           || first_code == ROTATE
10018                           || code == ROTATE)))
10019                 break;
10020
10021               /* To compute the mask to apply after the shift, shift the
10022                  nonzero bits of the inner shift the same way the
10023                  outer shift will.  */
10024
10025               mask_rtx = GEN_INT (nonzero_bits (varop, GET_MODE (varop)));
10026
10027               mask_rtx
10028                 = simplify_const_binary_operation (code, result_mode, mask_rtx,
10029                                                    GEN_INT (count));
10030
10031               /* Give up if we can't compute an outer operation to use.  */
10032               if (mask_rtx == 0
10033                   || !CONST_INT_P (mask_rtx)
10034                   || ! merge_outer_ops (&outer_op, &outer_const, AND,
10035                                         INTVAL (mask_rtx),
10036                                         result_mode, &complement_p))
10037                 break;
10038
10039               /* If the shifts are in the same direction, we add the
10040                  counts.  Otherwise, we subtract them.  */
10041               if ((code == ASHIFTRT || code == LSHIFTRT)
10042                   == (first_code == ASHIFTRT || first_code == LSHIFTRT))
10043                 count += first_count;
10044               else
10045                 count -= first_count;
10046
10047               /* If COUNT is positive, the new shift is usually CODE,
10048                  except for the two exceptions below, in which case it is
10049                  FIRST_CODE.  If the count is negative, FIRST_CODE should
10050                  always be used  */
10051               if (count > 0
10052                   && ((first_code == ROTATE && code == ASHIFT)
10053                       || (first_code == ASHIFTRT && code == LSHIFTRT)))
10054                 code = first_code;
10055               else if (count < 0)
10056                 code = first_code, count = -count;
10057
10058               varop = XEXP (varop, 0);
10059               continue;
10060             }
10061
10062           /* If we have (A << B << C) for any shift, we can convert this to
10063              (A << C << B).  This wins if A is a constant.  Only try this if
10064              B is not a constant.  */
10065
10066           else if (GET_CODE (varop) == code
10067                    && CONST_INT_P (XEXP (varop, 0))
10068                    && !CONST_INT_P (XEXP (varop, 1)))
10069             {
10070               rtx new_rtx = simplify_const_binary_operation (code, mode,
10071                                                          XEXP (varop, 0),
10072                                                          GEN_INT (count));
10073               varop = gen_rtx_fmt_ee (code, mode, new_rtx, XEXP (varop, 1));
10074               count = 0;
10075               continue;
10076             }
10077           break;
10078
10079         case NOT:
10080           if (VECTOR_MODE_P (mode))
10081             break;
10082
10083           /* Make this fit the case below.  */
10084           varop = gen_rtx_XOR (mode, XEXP (varop, 0),
10085                                GEN_INT (GET_MODE_MASK (mode)));
10086           continue;
10087
10088         case IOR:
10089         case AND:
10090         case XOR:
10091           /* If we have (xshiftrt (ior (plus X (const_int -1)) X) C)
10092              with C the size of VAROP - 1 and the shift is logical if
10093              STORE_FLAG_VALUE is 1 and arithmetic if STORE_FLAG_VALUE is -1,
10094              we have an (le X 0) operation.   If we have an arithmetic shift
10095              and STORE_FLAG_VALUE is 1 or we have a logical shift with
10096              STORE_FLAG_VALUE of -1, we have a (neg (le X 0)) operation.  */
10097
10098           if (GET_CODE (varop) == IOR && GET_CODE (XEXP (varop, 0)) == PLUS
10099               && XEXP (XEXP (varop, 0), 1) == constm1_rtx
10100               && (STORE_FLAG_VALUE == 1 || STORE_FLAG_VALUE == -1)
10101               && (code == LSHIFTRT || code == ASHIFTRT)
10102               && count == (GET_MODE_BITSIZE (GET_MODE (varop)) - 1)
10103               && rtx_equal_p (XEXP (XEXP (varop, 0), 0), XEXP (varop, 1)))
10104             {
10105               count = 0;
10106               varop = gen_rtx_LE (GET_MODE (varop), XEXP (varop, 1),
10107                                   const0_rtx);
10108
10109               if (STORE_FLAG_VALUE == 1 ? code == ASHIFTRT : code == LSHIFTRT)
10110                 varop = gen_rtx_NEG (GET_MODE (varop), varop);
10111
10112               continue;
10113             }
10114
10115           /* If we have (shift (logical)), move the logical to the outside
10116              to allow it to possibly combine with another logical and the
10117              shift to combine with another shift.  This also canonicalizes to
10118              what a ZERO_EXTRACT looks like.  Also, some machines have
10119              (and (shift)) insns.  */
10120
10121           if (CONST_INT_P (XEXP (varop, 1))
10122               /* We can't do this if we have (ashiftrt (xor))  and the
10123                  constant has its sign bit set in shift_mode.  */
10124               && !(code == ASHIFTRT && GET_CODE (varop) == XOR
10125                    && 0 > trunc_int_for_mode (INTVAL (XEXP (varop, 1)),
10126                                               shift_mode))
10127               && (new_rtx = simplify_const_binary_operation (code, result_mode,
10128                                                          XEXP (varop, 1),
10129                                                          GEN_INT (count))) != 0
10130               && CONST_INT_P (new_rtx)
10131               && merge_outer_ops (&outer_op, &outer_const, GET_CODE (varop),
10132                                   INTVAL (new_rtx), result_mode, &complement_p))
10133             {
10134               varop = XEXP (varop, 0);
10135               continue;
10136             }
10137
10138           /* If we can't do that, try to simplify the shift in each arm of the
10139              logical expression, make a new logical expression, and apply
10140              the inverse distributive law.  This also can't be done
10141              for some (ashiftrt (xor)).  */
10142           if (CONST_INT_P (XEXP (varop, 1))
10143              && !(code == ASHIFTRT && GET_CODE (varop) == XOR
10144                   && 0 > trunc_int_for_mode (INTVAL (XEXP (varop, 1)),
10145                                              shift_mode)))
10146             {
10147               rtx lhs = simplify_shift_const (NULL_RTX, code, shift_mode,
10148                                               XEXP (varop, 0), count);
10149               rtx rhs = simplify_shift_const (NULL_RTX, code, shift_mode,
10150                                               XEXP (varop, 1), count);
10151
10152               varop = simplify_gen_binary (GET_CODE (varop), shift_mode,
10153                                            lhs, rhs);
10154               varop = apply_distributive_law (varop);
10155
10156               count = 0;
10157               continue;
10158             }
10159           break;
10160
10161         case EQ:
10162           /* Convert (lshiftrt (eq FOO 0) C) to (xor FOO 1) if STORE_FLAG_VALUE
10163              says that the sign bit can be tested, FOO has mode MODE, C is
10164              GET_MODE_BITSIZE (MODE) - 1, and FOO has only its low-order bit
10165              that may be nonzero.  */
10166           if (code == LSHIFTRT
10167               && XEXP (varop, 1) == const0_rtx
10168               && GET_MODE (XEXP (varop, 0)) == result_mode
10169               && count == (GET_MODE_BITSIZE (result_mode) - 1)
10170               && GET_MODE_BITSIZE (result_mode) <= HOST_BITS_PER_WIDE_INT
10171               && STORE_FLAG_VALUE == -1
10172               && nonzero_bits (XEXP (varop, 0), result_mode) == 1
10173               && merge_outer_ops (&outer_op, &outer_const, XOR,
10174                                   (HOST_WIDE_INT) 1, result_mode,
10175                                   &complement_p))
10176             {
10177               varop = XEXP (varop, 0);
10178               count = 0;
10179               continue;
10180             }
10181           break;
10182
10183         case NEG:
10184           /* (lshiftrt (neg A) C) where A is either 0 or 1 and C is one less
10185              than the number of bits in the mode is equivalent to A.  */
10186           if (code == LSHIFTRT
10187               && count == (GET_MODE_BITSIZE (result_mode) - 1)
10188               && nonzero_bits (XEXP (varop, 0), result_mode) == 1)
10189             {
10190               varop = XEXP (varop, 0);
10191               count = 0;
10192               continue;
10193             }
10194
10195           /* NEG commutes with ASHIFT since it is multiplication.  Move the
10196              NEG outside to allow shifts to combine.  */
10197           if (code == ASHIFT
10198               && merge_outer_ops (&outer_op, &outer_const, NEG,
10199                                   (HOST_WIDE_INT) 0, result_mode,
10200                                   &complement_p))
10201             {
10202               varop = XEXP (varop, 0);
10203               continue;
10204             }
10205           break;
10206
10207         case PLUS:
10208           /* (lshiftrt (plus A -1) C) where A is either 0 or 1 and C
10209              is one less than the number of bits in the mode is
10210              equivalent to (xor A 1).  */
10211           if (code == LSHIFTRT
10212               && count == (GET_MODE_BITSIZE (result_mode) - 1)
10213               && XEXP (varop, 1) == constm1_rtx
10214               && nonzero_bits (XEXP (varop, 0), result_mode) == 1
10215               && merge_outer_ops (&outer_op, &outer_const, XOR,
10216                                   (HOST_WIDE_INT) 1, result_mode,
10217                                   &complement_p))
10218             {
10219               count = 0;
10220               varop = XEXP (varop, 0);
10221               continue;
10222             }
10223
10224           /* If we have (xshiftrt (plus FOO BAR) C), and the only bits
10225              that might be nonzero in BAR are those being shifted out and those
10226              bits are known zero in FOO, we can replace the PLUS with FOO.
10227              Similarly in the other operand order.  This code occurs when
10228              we are computing the size of a variable-size array.  */
10229
10230           if ((code == ASHIFTRT || code == LSHIFTRT)
10231               && count < HOST_BITS_PER_WIDE_INT
10232               && nonzero_bits (XEXP (varop, 1), result_mode) >> count == 0
10233               && (nonzero_bits (XEXP (varop, 1), result_mode)
10234                   & nonzero_bits (XEXP (varop, 0), result_mode)) == 0)
10235             {
10236               varop = XEXP (varop, 0);
10237               continue;
10238             }
10239           else if ((code == ASHIFTRT || code == LSHIFTRT)
10240                    && count < HOST_BITS_PER_WIDE_INT
10241                    && GET_MODE_BITSIZE (result_mode) <= HOST_BITS_PER_WIDE_INT
10242                    && 0 == (nonzero_bits (XEXP (varop, 0), result_mode)
10243                             >> count)
10244                    && 0 == (nonzero_bits (XEXP (varop, 0), result_mode)
10245                             & nonzero_bits (XEXP (varop, 1),
10246                                                  result_mode)))
10247             {
10248               varop = XEXP (varop, 1);
10249               continue;
10250             }
10251
10252           /* (ashift (plus foo C) N) is (plus (ashift foo N) C').  */
10253           if (code == ASHIFT
10254               && CONST_INT_P (XEXP (varop, 1))
10255               && (new_rtx = simplify_const_binary_operation (ASHIFT, result_mode,
10256                                                          XEXP (varop, 1),
10257                                                          GEN_INT (count))) != 0
10258               && CONST_INT_P (new_rtx)
10259               && merge_outer_ops (&outer_op, &outer_const, PLUS,
10260                                   INTVAL (new_rtx), result_mode, &complement_p))
10261             {
10262               varop = XEXP (varop, 0);
10263               continue;
10264             }
10265
10266           /* Check for 'PLUS signbit', which is the canonical form of 'XOR
10267              signbit', and attempt to change the PLUS to an XOR and move it to
10268              the outer operation as is done above in the AND/IOR/XOR case
10269              leg for shift(logical). See details in logical handling above
10270              for reasoning in doing so.  */
10271           if (code == LSHIFTRT
10272               && CONST_INT_P (XEXP (varop, 1))
10273               && mode_signbit_p (result_mode, XEXP (varop, 1))
10274               && (new_rtx = simplify_const_binary_operation (code, result_mode,
10275                                                          XEXP (varop, 1),
10276                                                          GEN_INT (count))) != 0
10277               && CONST_INT_P (new_rtx)
10278               && merge_outer_ops (&outer_op, &outer_const, XOR,
10279                                   INTVAL (new_rtx), result_mode, &complement_p))
10280             {
10281               varop = XEXP (varop, 0);
10282               continue;
10283             }
10284
10285           break;
10286
10287         case MINUS:
10288           /* If we have (xshiftrt (minus (ashiftrt X C)) X) C)
10289              with C the size of VAROP - 1 and the shift is logical if
10290              STORE_FLAG_VALUE is 1 and arithmetic if STORE_FLAG_VALUE is -1,
10291              we have a (gt X 0) operation.  If the shift is arithmetic with
10292              STORE_FLAG_VALUE of 1 or logical with STORE_FLAG_VALUE == -1,
10293              we have a (neg (gt X 0)) operation.  */
10294
10295           if ((STORE_FLAG_VALUE == 1 || STORE_FLAG_VALUE == -1)
10296               && GET_CODE (XEXP (varop, 0)) == ASHIFTRT
10297               && count == (GET_MODE_BITSIZE (GET_MODE (varop)) - 1)
10298               && (code == LSHIFTRT || code == ASHIFTRT)
10299               && CONST_INT_P (XEXP (XEXP (varop, 0), 1))
10300               && INTVAL (XEXP (XEXP (varop, 0), 1)) == count
10301               && rtx_equal_p (XEXP (XEXP (varop, 0), 0), XEXP (varop, 1)))
10302             {
10303               count = 0;
10304               varop = gen_rtx_GT (GET_MODE (varop), XEXP (varop, 1),
10305                                   const0_rtx);
10306
10307               if (STORE_FLAG_VALUE == 1 ? code == ASHIFTRT : code == LSHIFTRT)
10308                 varop = gen_rtx_NEG (GET_MODE (varop), varop);
10309
10310               continue;
10311             }
10312           break;
10313
10314         case TRUNCATE:
10315           /* Change (lshiftrt (truncate (lshiftrt))) to (truncate (lshiftrt))
10316              if the truncate does not affect the value.  */
10317           if (code == LSHIFTRT
10318               && GET_CODE (XEXP (varop, 0)) == LSHIFTRT
10319               && CONST_INT_P (XEXP (XEXP (varop, 0), 1))
10320               && (INTVAL (XEXP (XEXP (varop, 0), 1))
10321                   >= (GET_MODE_BITSIZE (GET_MODE (XEXP (varop, 0)))
10322                       - GET_MODE_BITSIZE (GET_MODE (varop)))))
10323             {
10324               rtx varop_inner = XEXP (varop, 0);
10325
10326               varop_inner
10327                 = gen_rtx_LSHIFTRT (GET_MODE (varop_inner),
10328                                     XEXP (varop_inner, 0),
10329                                     GEN_INT
10330                                     (count + INTVAL (XEXP (varop_inner, 1))));
10331               varop = gen_rtx_TRUNCATE (GET_MODE (varop), varop_inner);
10332               count = 0;
10333               continue;
10334             }
10335           break;
10336
10337         default:
10338           break;
10339         }
10340
10341       break;
10342     }
10343
10344   shift_mode = try_widen_shift_mode (code, varop, count, result_mode, mode,
10345                                      outer_op, outer_const);
10346
10347   /* We have now finished analyzing the shift.  The result should be
10348      a shift of type CODE with SHIFT_MODE shifting VAROP COUNT places.  If
10349      OUTER_OP is non-UNKNOWN, it is an operation that needs to be applied
10350      to the result of the shift.  OUTER_CONST is the relevant constant,
10351      but we must turn off all bits turned off in the shift.  */
10352
10353   if (outer_op == UNKNOWN
10354       && orig_code == code && orig_count == count
10355       && varop == orig_varop
10356       && shift_mode == GET_MODE (varop))
10357     return NULL_RTX;
10358
10359   /* Make a SUBREG if necessary.  If we can't make it, fail.  */
10360   varop = gen_lowpart (shift_mode, varop);
10361   if (varop == NULL_RTX || GET_CODE (varop) == CLOBBER)
10362     return NULL_RTX;
10363
10364   /* If we have an outer operation and we just made a shift, it is
10365      possible that we could have simplified the shift were it not
10366      for the outer operation.  So try to do the simplification
10367      recursively.  */
10368
10369   if (outer_op != UNKNOWN)
10370     x = simplify_shift_const_1 (code, shift_mode, varop, count);
10371   else
10372     x = NULL_RTX;
10373
10374   if (x == NULL_RTX)
10375     x = simplify_gen_binary (code, shift_mode, varop, GEN_INT (count));
10376
10377   /* If we were doing an LSHIFTRT in a wider mode than it was originally,
10378      turn off all the bits that the shift would have turned off.  */
10379   if (orig_code == LSHIFTRT && result_mode != shift_mode)
10380     x = simplify_and_const_int (NULL_RTX, shift_mode, x,
10381                                 GET_MODE_MASK (result_mode) >> orig_count);
10382
10383   /* Do the remainder of the processing in RESULT_MODE.  */
10384   x = gen_lowpart_or_truncate (result_mode, x);
10385
10386   /* If COMPLEMENT_P is set, we have to complement X before doing the outer
10387      operation.  */
10388   if (complement_p)
10389     x = simplify_gen_unary (NOT, result_mode, x, result_mode);
10390
10391   if (outer_op != UNKNOWN)
10392     {
10393       if (GET_RTX_CLASS (outer_op) != RTX_UNARY
10394           && GET_MODE_BITSIZE (result_mode) < HOST_BITS_PER_WIDE_INT)
10395         outer_const = trunc_int_for_mode (outer_const, result_mode);
10396
10397       if (outer_op == AND)
10398         x = simplify_and_const_int (NULL_RTX, result_mode, x, outer_const);
10399       else if (outer_op == SET)
10400         {
10401           /* This means that we have determined that the result is
10402              equivalent to a constant.  This should be rare.  */
10403           if (!side_effects_p (x))
10404             x = GEN_INT (outer_const);
10405         }
10406       else if (GET_RTX_CLASS (outer_op) == RTX_UNARY)
10407         x = simplify_gen_unary (outer_op, result_mode, x, result_mode);
10408       else
10409         x = simplify_gen_binary (outer_op, result_mode, x,
10410                                  GEN_INT (outer_const));
10411     }
10412
10413   return x;
10414 }
10415
10416 /* Simplify a shift of VAROP by COUNT bits.  CODE says what kind of shift.
10417    The result of the shift is RESULT_MODE.  If we cannot simplify it,
10418    return X or, if it is NULL, synthesize the expression with
10419    simplify_gen_binary.  Otherwise, return a simplified value.
10420
10421    The shift is normally computed in the widest mode we find in VAROP, as
10422    long as it isn't a different number of words than RESULT_MODE.  Exceptions
10423    are ASHIFTRT and ROTATE, which are always done in their original mode.  */
10424
10425 static rtx
10426 simplify_shift_const (rtx x, enum rtx_code code, enum machine_mode result_mode,
10427                       rtx varop, int count)
10428 {
10429   rtx tem = simplify_shift_const_1 (code, result_mode, varop, count);
10430   if (tem)
10431     return tem;
10432
10433   if (!x)
10434     x = simplify_gen_binary (code, GET_MODE (varop), varop, GEN_INT (count));
10435   if (GET_MODE (x) != result_mode)
10436     x = gen_lowpart (result_mode, x);
10437   return x;
10438 }
10439
10440 \f
10441 /* Like recog, but we receive the address of a pointer to a new pattern.
10442    We try to match the rtx that the pointer points to.
10443    If that fails, we may try to modify or replace the pattern,
10444    storing the replacement into the same pointer object.
10445
10446    Modifications include deletion or addition of CLOBBERs.
10447
10448    PNOTES is a pointer to a location where any REG_UNUSED notes added for
10449    the CLOBBERs are placed.
10450
10451    The value is the final insn code from the pattern ultimately matched,
10452    or -1.  */
10453
10454 static int
10455 recog_for_combine (rtx *pnewpat, rtx insn, rtx *pnotes)
10456 {
10457   rtx pat = *pnewpat;
10458   int insn_code_number;
10459   int num_clobbers_to_add = 0;
10460   int i;
10461   rtx notes = 0;
10462   rtx old_notes, old_pat;
10463
10464   /* If PAT is a PARALLEL, check to see if it contains the CLOBBER
10465      we use to indicate that something didn't match.  If we find such a
10466      thing, force rejection.  */
10467   if (GET_CODE (pat) == PARALLEL)
10468     for (i = XVECLEN (pat, 0) - 1; i >= 0; i--)
10469       if (GET_CODE (XVECEXP (pat, 0, i)) == CLOBBER
10470           && XEXP (XVECEXP (pat, 0, i), 0) == const0_rtx)
10471         return -1;
10472
10473   old_pat = PATTERN (insn);
10474   old_notes = REG_NOTES (insn);
10475   PATTERN (insn) = pat;
10476   REG_NOTES (insn) = 0;
10477
10478   insn_code_number = recog (pat, insn, &num_clobbers_to_add);
10479   if (dump_file && (dump_flags & TDF_DETAILS))
10480     {
10481       if (insn_code_number < 0)
10482         fputs ("Failed to match this instruction:\n", dump_file);
10483       else
10484         fputs ("Successfully matched this instruction:\n", dump_file);
10485       print_rtl_single (dump_file, pat);
10486     }
10487
10488   /* If it isn't, there is the possibility that we previously had an insn
10489      that clobbered some register as a side effect, but the combined
10490      insn doesn't need to do that.  So try once more without the clobbers
10491      unless this represents an ASM insn.  */
10492
10493   if (insn_code_number < 0 && ! check_asm_operands (pat)
10494       && GET_CODE (pat) == PARALLEL)
10495     {
10496       int pos;
10497
10498       for (pos = 0, i = 0; i < XVECLEN (pat, 0); i++)
10499         if (GET_CODE (XVECEXP (pat, 0, i)) != CLOBBER)
10500           {
10501             if (i != pos)
10502               SUBST (XVECEXP (pat, 0, pos), XVECEXP (pat, 0, i));
10503             pos++;
10504           }
10505
10506       SUBST_INT (XVECLEN (pat, 0), pos);
10507
10508       if (pos == 1)
10509         pat = XVECEXP (pat, 0, 0);
10510
10511       PATTERN (insn) = pat;
10512       insn_code_number = recog (pat, insn, &num_clobbers_to_add);
10513       if (dump_file && (dump_flags & TDF_DETAILS))
10514         {
10515           if (insn_code_number < 0)
10516             fputs ("Failed to match this instruction:\n", dump_file);
10517           else
10518             fputs ("Successfully matched this instruction:\n", dump_file);
10519           print_rtl_single (dump_file, pat);
10520         }
10521     }
10522   PATTERN (insn) = old_pat;
10523   REG_NOTES (insn) = old_notes;
10524
10525   /* Recognize all noop sets, these will be killed by followup pass.  */
10526   if (insn_code_number < 0 && GET_CODE (pat) == SET && set_noop_p (pat))
10527     insn_code_number = NOOP_MOVE_INSN_CODE, num_clobbers_to_add = 0;
10528
10529   /* If we had any clobbers to add, make a new pattern than contains
10530      them.  Then check to make sure that all of them are dead.  */
10531   if (num_clobbers_to_add)
10532     {
10533       rtx newpat = gen_rtx_PARALLEL (VOIDmode,
10534                                      rtvec_alloc (GET_CODE (pat) == PARALLEL
10535                                                   ? (XVECLEN (pat, 0)
10536                                                      + num_clobbers_to_add)
10537                                                   : num_clobbers_to_add + 1));
10538
10539       if (GET_CODE (pat) == PARALLEL)
10540         for (i = 0; i < XVECLEN (pat, 0); i++)
10541           XVECEXP (newpat, 0, i) = XVECEXP (pat, 0, i);
10542       else
10543         XVECEXP (newpat, 0, 0) = pat;
10544
10545       add_clobbers (newpat, insn_code_number);
10546
10547       for (i = XVECLEN (newpat, 0) - num_clobbers_to_add;
10548            i < XVECLEN (newpat, 0); i++)
10549         {
10550           if (REG_P (XEXP (XVECEXP (newpat, 0, i), 0))
10551               && ! reg_dead_at_p (XEXP (XVECEXP (newpat, 0, i), 0), insn))
10552             return -1;
10553           if (GET_CODE (XEXP (XVECEXP (newpat, 0, i), 0)) != SCRATCH)
10554             {
10555               gcc_assert (REG_P (XEXP (XVECEXP (newpat, 0, i), 0)));
10556               notes = alloc_reg_note (REG_UNUSED,
10557                                       XEXP (XVECEXP (newpat, 0, i), 0), notes);
10558             }
10559         }
10560       pat = newpat;
10561     }
10562
10563   *pnewpat = pat;
10564   *pnotes = notes;
10565
10566   return insn_code_number;
10567 }
10568 \f
10569 /* Like gen_lowpart_general but for use by combine.  In combine it
10570    is not possible to create any new pseudoregs.  However, it is
10571    safe to create invalid memory addresses, because combine will
10572    try to recognize them and all they will do is make the combine
10573    attempt fail.
10574
10575    If for some reason this cannot do its job, an rtx
10576    (clobber (const_int 0)) is returned.
10577    An insn containing that will not be recognized.  */
10578
10579 static rtx
10580 gen_lowpart_for_combine (enum machine_mode omode, rtx x)
10581 {
10582   enum machine_mode imode = GET_MODE (x);
10583   unsigned int osize = GET_MODE_SIZE (omode);
10584   unsigned int isize = GET_MODE_SIZE (imode);
10585   rtx result;
10586
10587   if (omode == imode)
10588     return x;
10589
10590   /* Return identity if this is a CONST or symbolic reference.  */
10591   if (omode == Pmode
10592       && (GET_CODE (x) == CONST
10593           || GET_CODE (x) == SYMBOL_REF
10594           || GET_CODE (x) == LABEL_REF))
10595     return x;
10596
10597   /* We can only support MODE being wider than a word if X is a
10598      constant integer or has a mode the same size.  */
10599   if (GET_MODE_SIZE (omode) > UNITS_PER_WORD
10600       && ! ((imode == VOIDmode
10601              && (CONST_INT_P (x)
10602                  || GET_CODE (x) == CONST_DOUBLE))
10603             || isize == osize))
10604     goto fail;
10605
10606   /* X might be a paradoxical (subreg (mem)).  In that case, gen_lowpart
10607      won't know what to do.  So we will strip off the SUBREG here and
10608      process normally.  */
10609   if (GET_CODE (x) == SUBREG && MEM_P (SUBREG_REG (x)))
10610     {
10611       x = SUBREG_REG (x);
10612
10613       /* For use in case we fall down into the address adjustments
10614          further below, we need to adjust the known mode and size of
10615          x; imode and isize, since we just adjusted x.  */
10616       imode = GET_MODE (x);
10617
10618       if (imode == omode)
10619         return x;
10620
10621       isize = GET_MODE_SIZE (imode);
10622     }
10623
10624   result = gen_lowpart_common (omode, x);
10625
10626   if (result)
10627     return result;
10628
10629   if (MEM_P (x))
10630     {
10631       int offset = 0;
10632
10633       /* Refuse to work on a volatile memory ref or one with a mode-dependent
10634          address.  */
10635       if (MEM_VOLATILE_P (x) || mode_dependent_address_p (XEXP (x, 0)))
10636         goto fail;
10637
10638       /* If we want to refer to something bigger than the original memref,
10639          generate a paradoxical subreg instead.  That will force a reload
10640          of the original memref X.  */
10641       if (isize < osize)
10642         return gen_rtx_SUBREG (omode, x, 0);
10643
10644       if (WORDS_BIG_ENDIAN)
10645         offset = MAX (isize, UNITS_PER_WORD) - MAX (osize, UNITS_PER_WORD);
10646
10647       /* Adjust the address so that the address-after-the-data is
10648          unchanged.  */
10649       if (BYTES_BIG_ENDIAN)
10650         offset -= MIN (UNITS_PER_WORD, osize) - MIN (UNITS_PER_WORD, isize);
10651
10652       return adjust_address_nv (x, omode, offset);
10653     }
10654
10655   /* If X is a comparison operator, rewrite it in a new mode.  This
10656      probably won't match, but may allow further simplifications.  */
10657   else if (COMPARISON_P (x))
10658     return gen_rtx_fmt_ee (GET_CODE (x), omode, XEXP (x, 0), XEXP (x, 1));
10659
10660   /* If we couldn't simplify X any other way, just enclose it in a
10661      SUBREG.  Normally, this SUBREG won't match, but some patterns may
10662      include an explicit SUBREG or we may simplify it further in combine.  */
10663   else
10664     {
10665       int offset = 0;
10666       rtx res;
10667
10668       offset = subreg_lowpart_offset (omode, imode);
10669       if (imode == VOIDmode)
10670         {
10671           imode = int_mode_for_mode (omode);
10672           x = gen_lowpart_common (imode, x);
10673           if (x == NULL)
10674             goto fail;
10675         }
10676       res = simplify_gen_subreg (omode, x, imode, offset);
10677       if (res)
10678         return res;
10679     }
10680
10681  fail:
10682   return gen_rtx_CLOBBER (omode, const0_rtx);
10683 }
10684 \f
10685 /* Simplify a comparison between *POP0 and *POP1 where CODE is the
10686    comparison code that will be tested.
10687
10688    The result is a possibly different comparison code to use.  *POP0 and
10689    *POP1 may be updated.
10690
10691    It is possible that we might detect that a comparison is either always
10692    true or always false.  However, we do not perform general constant
10693    folding in combine, so this knowledge isn't useful.  Such tautologies
10694    should have been detected earlier.  Hence we ignore all such cases.  */
10695
10696 static enum rtx_code
10697 simplify_comparison (enum rtx_code code, rtx *pop0, rtx *pop1)
10698 {
10699   rtx op0 = *pop0;
10700   rtx op1 = *pop1;
10701   rtx tem, tem1;
10702   int i;
10703   enum machine_mode mode, tmode;
10704
10705   /* Try a few ways of applying the same transformation to both operands.  */
10706   while (1)
10707     {
10708 #ifndef WORD_REGISTER_OPERATIONS
10709       /* The test below this one won't handle SIGN_EXTENDs on these machines,
10710          so check specially.  */
10711       if (code != GTU && code != GEU && code != LTU && code != LEU
10712           && GET_CODE (op0) == ASHIFTRT && GET_CODE (op1) == ASHIFTRT
10713           && GET_CODE (XEXP (op0, 0)) == ASHIFT
10714           && GET_CODE (XEXP (op1, 0)) == ASHIFT
10715           && GET_CODE (XEXP (XEXP (op0, 0), 0)) == SUBREG
10716           && GET_CODE (XEXP (XEXP (op1, 0), 0)) == SUBREG
10717           && (GET_MODE (SUBREG_REG (XEXP (XEXP (op0, 0), 0)))
10718               == GET_MODE (SUBREG_REG (XEXP (XEXP (op1, 0), 0))))
10719           && CONST_INT_P (XEXP (op0, 1))
10720           && XEXP (op0, 1) == XEXP (op1, 1)
10721           && XEXP (op0, 1) == XEXP (XEXP (op0, 0), 1)
10722           && XEXP (op0, 1) == XEXP (XEXP (op1, 0), 1)
10723           && (INTVAL (XEXP (op0, 1))
10724               == (GET_MODE_BITSIZE (GET_MODE (op0))
10725                   - (GET_MODE_BITSIZE
10726                      (GET_MODE (SUBREG_REG (XEXP (XEXP (op0, 0), 0))))))))
10727         {
10728           op0 = SUBREG_REG (XEXP (XEXP (op0, 0), 0));
10729           op1 = SUBREG_REG (XEXP (XEXP (op1, 0), 0));
10730         }
10731 #endif
10732
10733       /* If both operands are the same constant shift, see if we can ignore the
10734          shift.  We can if the shift is a rotate or if the bits shifted out of
10735          this shift are known to be zero for both inputs and if the type of
10736          comparison is compatible with the shift.  */
10737       if (GET_CODE (op0) == GET_CODE (op1)
10738           && GET_MODE_BITSIZE (GET_MODE (op0)) <= HOST_BITS_PER_WIDE_INT
10739           && ((GET_CODE (op0) == ROTATE && (code == NE || code == EQ))
10740               || ((GET_CODE (op0) == LSHIFTRT || GET_CODE (op0) == ASHIFT)
10741                   && (code != GT && code != LT && code != GE && code != LE))
10742               || (GET_CODE (op0) == ASHIFTRT
10743                   && (code != GTU && code != LTU
10744                       && code != GEU && code != LEU)))
10745           && CONST_INT_P (XEXP (op0, 1))
10746           && INTVAL (XEXP (op0, 1)) >= 0
10747           && INTVAL (XEXP (op0, 1)) < HOST_BITS_PER_WIDE_INT
10748           && XEXP (op0, 1) == XEXP (op1, 1))
10749         {
10750           enum machine_mode mode = GET_MODE (op0);
10751           unsigned HOST_WIDE_INT mask = GET_MODE_MASK (mode);
10752           int shift_count = INTVAL (XEXP (op0, 1));
10753
10754           if (GET_CODE (op0) == LSHIFTRT || GET_CODE (op0) == ASHIFTRT)
10755             mask &= (mask >> shift_count) << shift_count;
10756           else if (GET_CODE (op0) == ASHIFT)
10757             mask = (mask & (mask << shift_count)) >> shift_count;
10758
10759           if ((nonzero_bits (XEXP (op0, 0), mode) & ~mask) == 0
10760               && (nonzero_bits (XEXP (op1, 0), mode) & ~mask) == 0)
10761             op0 = XEXP (op0, 0), op1 = XEXP (op1, 0);
10762           else
10763             break;
10764         }
10765
10766       /* If both operands are AND's of a paradoxical SUBREG by constant, the
10767          SUBREGs are of the same mode, and, in both cases, the AND would
10768          be redundant if the comparison was done in the narrower mode,
10769          do the comparison in the narrower mode (e.g., we are AND'ing with 1
10770          and the operand's possibly nonzero bits are 0xffffff01; in that case
10771          if we only care about QImode, we don't need the AND).  This case
10772          occurs if the output mode of an scc insn is not SImode and
10773          STORE_FLAG_VALUE == 1 (e.g., the 386).
10774
10775          Similarly, check for a case where the AND's are ZERO_EXTEND
10776          operations from some narrower mode even though a SUBREG is not
10777          present.  */
10778
10779       else if (GET_CODE (op0) == AND && GET_CODE (op1) == AND
10780                && CONST_INT_P (XEXP (op0, 1))
10781                && CONST_INT_P (XEXP (op1, 1)))
10782         {
10783           rtx inner_op0 = XEXP (op0, 0);
10784           rtx inner_op1 = XEXP (op1, 0);
10785           HOST_WIDE_INT c0 = INTVAL (XEXP (op0, 1));
10786           HOST_WIDE_INT c1 = INTVAL (XEXP (op1, 1));
10787           int changed = 0;
10788
10789           if (GET_CODE (inner_op0) == SUBREG && GET_CODE (inner_op1) == SUBREG
10790               && (GET_MODE_SIZE (GET_MODE (inner_op0))
10791                   > GET_MODE_SIZE (GET_MODE (SUBREG_REG (inner_op0))))
10792               && (GET_MODE (SUBREG_REG (inner_op0))
10793                   == GET_MODE (SUBREG_REG (inner_op1)))
10794               && (GET_MODE_BITSIZE (GET_MODE (SUBREG_REG (inner_op0)))
10795                   <= HOST_BITS_PER_WIDE_INT)
10796               && (0 == ((~c0) & nonzero_bits (SUBREG_REG (inner_op0),
10797                                              GET_MODE (SUBREG_REG (inner_op0)))))
10798               && (0 == ((~c1) & nonzero_bits (SUBREG_REG (inner_op1),
10799                                              GET_MODE (SUBREG_REG (inner_op1))))))
10800             {
10801               op0 = SUBREG_REG (inner_op0);
10802               op1 = SUBREG_REG (inner_op1);
10803
10804               /* The resulting comparison is always unsigned since we masked
10805                  off the original sign bit.  */
10806               code = unsigned_condition (code);
10807
10808               changed = 1;
10809             }
10810
10811           else if (c0 == c1)
10812             for (tmode = GET_CLASS_NARROWEST_MODE
10813                  (GET_MODE_CLASS (GET_MODE (op0)));
10814                  tmode != GET_MODE (op0); tmode = GET_MODE_WIDER_MODE (tmode))
10815               if ((unsigned HOST_WIDE_INT) c0 == GET_MODE_MASK (tmode))
10816                 {
10817                   op0 = gen_lowpart (tmode, inner_op0);
10818                   op1 = gen_lowpart (tmode, inner_op1);
10819                   code = unsigned_condition (code);
10820                   changed = 1;
10821                   break;
10822                 }
10823
10824           if (! changed)
10825             break;
10826         }
10827
10828       /* If both operands are NOT, we can strip off the outer operation
10829          and adjust the comparison code for swapped operands; similarly for
10830          NEG, except that this must be an equality comparison.  */
10831       else if ((GET_CODE (op0) == NOT && GET_CODE (op1) == NOT)
10832                || (GET_CODE (op0) == NEG && GET_CODE (op1) == NEG
10833                    && (code == EQ || code == NE)))
10834         op0 = XEXP (op0, 0), op1 = XEXP (op1, 0), code = swap_condition (code);
10835
10836       else
10837         break;
10838     }
10839
10840   /* If the first operand is a constant, swap the operands and adjust the
10841      comparison code appropriately, but don't do this if the second operand
10842      is already a constant integer.  */
10843   if (swap_commutative_operands_p (op0, op1))
10844     {
10845       tem = op0, op0 = op1, op1 = tem;
10846       code = swap_condition (code);
10847     }
10848
10849   /* We now enter a loop during which we will try to simplify the comparison.
10850      For the most part, we only are concerned with comparisons with zero,
10851      but some things may really be comparisons with zero but not start
10852      out looking that way.  */
10853
10854   while (CONST_INT_P (op1))
10855     {
10856       enum machine_mode mode = GET_MODE (op0);
10857       unsigned int mode_width = GET_MODE_BITSIZE (mode);
10858       unsigned HOST_WIDE_INT mask = GET_MODE_MASK (mode);
10859       int equality_comparison_p;
10860       int sign_bit_comparison_p;
10861       int unsigned_comparison_p;
10862       HOST_WIDE_INT const_op;
10863
10864       /* We only want to handle integral modes.  This catches VOIDmode,
10865          CCmode, and the floating-point modes.  An exception is that we
10866          can handle VOIDmode if OP0 is a COMPARE or a comparison
10867          operation.  */
10868
10869       if (GET_MODE_CLASS (mode) != MODE_INT
10870           && ! (mode == VOIDmode
10871                 && (GET_CODE (op0) == COMPARE || COMPARISON_P (op0))))
10872         break;
10873
10874       /* Get the constant we are comparing against and turn off all bits
10875          not on in our mode.  */
10876       const_op = INTVAL (op1);
10877       if (mode != VOIDmode)
10878         const_op = trunc_int_for_mode (const_op, mode);
10879       op1 = GEN_INT (const_op);
10880
10881       /* If we are comparing against a constant power of two and the value
10882          being compared can only have that single bit nonzero (e.g., it was
10883          `and'ed with that bit), we can replace this with a comparison
10884          with zero.  */
10885       if (const_op
10886           && (code == EQ || code == NE || code == GE || code == GEU
10887               || code == LT || code == LTU)
10888           && mode_width <= HOST_BITS_PER_WIDE_INT
10889           && exact_log2 (const_op) >= 0
10890           && nonzero_bits (op0, mode) == (unsigned HOST_WIDE_INT) const_op)
10891         {
10892           code = (code == EQ || code == GE || code == GEU ? NE : EQ);
10893           op1 = const0_rtx, const_op = 0;
10894         }
10895
10896       /* Similarly, if we are comparing a value known to be either -1 or
10897          0 with -1, change it to the opposite comparison against zero.  */
10898
10899       if (const_op == -1
10900           && (code == EQ || code == NE || code == GT || code == LE
10901               || code == GEU || code == LTU)
10902           && num_sign_bit_copies (op0, mode) == mode_width)
10903         {
10904           code = (code == EQ || code == LE || code == GEU ? NE : EQ);
10905           op1 = const0_rtx, const_op = 0;
10906         }
10907
10908       /* Do some canonicalizations based on the comparison code.  We prefer
10909          comparisons against zero and then prefer equality comparisons.
10910          If we can reduce the size of a constant, we will do that too.  */
10911
10912       switch (code)
10913         {
10914         case LT:
10915           /* < C is equivalent to <= (C - 1) */
10916           if (const_op > 0)
10917             {
10918               const_op -= 1;
10919               op1 = GEN_INT (const_op);
10920               code = LE;
10921               /* ... fall through to LE case below.  */
10922             }
10923           else
10924             break;
10925
10926         case LE:
10927           /* <= C is equivalent to < (C + 1); we do this for C < 0  */
10928           if (const_op < 0)
10929             {
10930               const_op += 1;
10931               op1 = GEN_INT (const_op);
10932               code = LT;
10933             }
10934
10935           /* If we are doing a <= 0 comparison on a value known to have
10936              a zero sign bit, we can replace this with == 0.  */
10937           else if (const_op == 0
10938                    && mode_width <= HOST_BITS_PER_WIDE_INT
10939                    && (nonzero_bits (op0, mode)
10940                        & ((HOST_WIDE_INT) 1 << (mode_width - 1))) == 0)
10941             code = EQ;
10942           break;
10943
10944         case GE:
10945           /* >= C is equivalent to > (C - 1).  */
10946           if (const_op > 0)
10947             {
10948               const_op -= 1;
10949               op1 = GEN_INT (const_op);
10950               code = GT;
10951               /* ... fall through to GT below.  */
10952             }
10953           else
10954             break;
10955
10956         case GT:
10957           /* > C is equivalent to >= (C + 1); we do this for C < 0.  */
10958           if (const_op < 0)
10959             {
10960               const_op += 1;
10961               op1 = GEN_INT (const_op);
10962               code = GE;
10963             }
10964
10965           /* If we are doing a > 0 comparison on a value known to have
10966              a zero sign bit, we can replace this with != 0.  */
10967           else if (const_op == 0
10968                    && mode_width <= HOST_BITS_PER_WIDE_INT
10969                    && (nonzero_bits (op0, mode)
10970                        & ((HOST_WIDE_INT) 1 << (mode_width - 1))) == 0)
10971             code = NE;
10972           break;
10973
10974         case LTU:
10975           /* < C is equivalent to <= (C - 1).  */
10976           if (const_op > 0)
10977             {
10978               const_op -= 1;
10979               op1 = GEN_INT (const_op);
10980               code = LEU;
10981               /* ... fall through ...  */
10982             }
10983
10984           /* (unsigned) < 0x80000000 is equivalent to >= 0.  */
10985           else if ((mode_width <= HOST_BITS_PER_WIDE_INT)
10986                    && (const_op == (HOST_WIDE_INT) 1 << (mode_width - 1)))
10987             {
10988               const_op = 0, op1 = const0_rtx;
10989               code = GE;
10990               break;
10991             }
10992           else
10993             break;
10994
10995         case LEU:
10996           /* unsigned <= 0 is equivalent to == 0 */
10997           if (const_op == 0)
10998             code = EQ;
10999
11000           /* (unsigned) <= 0x7fffffff is equivalent to >= 0.  */
11001           else if ((mode_width <= HOST_BITS_PER_WIDE_INT)
11002                    && (const_op == ((HOST_WIDE_INT) 1 << (mode_width - 1)) - 1))
11003             {
11004               const_op = 0, op1 = const0_rtx;
11005               code = GE;
11006             }
11007           break;
11008
11009         case GEU:
11010           /* >= C is equivalent to > (C - 1).  */
11011           if (const_op > 1)
11012             {
11013               const_op -= 1;
11014               op1 = GEN_INT (const_op);
11015               code = GTU;
11016               /* ... fall through ...  */
11017             }
11018
11019           /* (unsigned) >= 0x80000000 is equivalent to < 0.  */
11020           else if ((mode_width <= HOST_BITS_PER_WIDE_INT)
11021                    && (const_op == (HOST_WIDE_INT) 1 << (mode_width - 1)))
11022             {
11023               const_op = 0, op1 = const0_rtx;
11024               code = LT;
11025               break;
11026             }
11027           else
11028             break;
11029
11030         case GTU:
11031           /* unsigned > 0 is equivalent to != 0 */
11032           if (const_op == 0)
11033             code = NE;
11034
11035           /* (unsigned) > 0x7fffffff is equivalent to < 0.  */
11036           else if ((mode_width <= HOST_BITS_PER_WIDE_INT)
11037                    && (const_op == ((HOST_WIDE_INT) 1 << (mode_width - 1)) - 1))
11038             {
11039               const_op = 0, op1 = const0_rtx;
11040               code = LT;
11041             }
11042           break;
11043
11044         default:
11045           break;
11046         }
11047
11048       /* Compute some predicates to simplify code below.  */
11049
11050       equality_comparison_p = (code == EQ || code == NE);
11051       sign_bit_comparison_p = ((code == LT || code == GE) && const_op == 0);
11052       unsigned_comparison_p = (code == LTU || code == LEU || code == GTU
11053                                || code == GEU);
11054
11055       /* If this is a sign bit comparison and we can do arithmetic in
11056          MODE, say that we will only be needing the sign bit of OP0.  */
11057       if (sign_bit_comparison_p
11058           && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
11059         op0 = force_to_mode (op0, mode,
11060                              ((HOST_WIDE_INT) 1
11061                               << (GET_MODE_BITSIZE (mode) - 1)),
11062                              0);
11063
11064       /* Now try cases based on the opcode of OP0.  If none of the cases
11065          does a "continue", we exit this loop immediately after the
11066          switch.  */
11067
11068       switch (GET_CODE (op0))
11069         {
11070         case ZERO_EXTRACT:
11071           /* If we are extracting a single bit from a variable position in
11072              a constant that has only a single bit set and are comparing it
11073              with zero, we can convert this into an equality comparison
11074              between the position and the location of the single bit.  */
11075           /* Except we can't if SHIFT_COUNT_TRUNCATED is set, since we might
11076              have already reduced the shift count modulo the word size.  */
11077           if (!SHIFT_COUNT_TRUNCATED
11078               && CONST_INT_P (XEXP (op0, 0))
11079               && XEXP (op0, 1) == const1_rtx
11080               && equality_comparison_p && const_op == 0
11081               && (i = exact_log2 (INTVAL (XEXP (op0, 0)))) >= 0)
11082             {
11083               if (BITS_BIG_ENDIAN)
11084                 {
11085                   enum machine_mode new_mode
11086                     = mode_for_extraction (EP_extzv, 1);
11087                   if (new_mode == MAX_MACHINE_MODE)
11088                     i = BITS_PER_WORD - 1 - i;
11089                   else
11090                     {
11091                       mode = new_mode;
11092                       i = (GET_MODE_BITSIZE (mode) - 1 - i);
11093                     }
11094                 }
11095
11096               op0 = XEXP (op0, 2);
11097               op1 = GEN_INT (i);
11098               const_op = i;
11099
11100               /* Result is nonzero iff shift count is equal to I.  */
11101               code = reverse_condition (code);
11102               continue;
11103             }
11104
11105           /* ... fall through ...  */
11106
11107         case SIGN_EXTRACT:
11108           tem = expand_compound_operation (op0);
11109           if (tem != op0)
11110             {
11111               op0 = tem;
11112               continue;
11113             }
11114           break;
11115
11116         case NOT:
11117           /* If testing for equality, we can take the NOT of the constant.  */
11118           if (equality_comparison_p
11119               && (tem = simplify_unary_operation (NOT, mode, op1, mode)) != 0)
11120             {
11121               op0 = XEXP (op0, 0);
11122               op1 = tem;
11123               continue;
11124             }
11125
11126           /* If just looking at the sign bit, reverse the sense of the
11127              comparison.  */
11128           if (sign_bit_comparison_p)
11129             {
11130               op0 = XEXP (op0, 0);
11131               code = (code == GE ? LT : GE);
11132               continue;
11133             }
11134           break;
11135
11136         case NEG:
11137           /* If testing for equality, we can take the NEG of the constant.  */
11138           if (equality_comparison_p
11139               && (tem = simplify_unary_operation (NEG, mode, op1, mode)) != 0)
11140             {
11141               op0 = XEXP (op0, 0);
11142               op1 = tem;
11143               continue;
11144             }
11145
11146           /* The remaining cases only apply to comparisons with zero.  */
11147           if (const_op != 0)
11148             break;
11149
11150           /* When X is ABS or is known positive,
11151              (neg X) is < 0 if and only if X != 0.  */
11152
11153           if (sign_bit_comparison_p
11154               && (GET_CODE (XEXP (op0, 0)) == ABS
11155                   || (mode_width <= HOST_BITS_PER_WIDE_INT
11156                       && (nonzero_bits (XEXP (op0, 0), mode)
11157                           & ((HOST_WIDE_INT) 1 << (mode_width - 1))) == 0)))
11158             {
11159               op0 = XEXP (op0, 0);
11160               code = (code == LT ? NE : EQ);
11161               continue;
11162             }
11163
11164           /* If we have NEG of something whose two high-order bits are the
11165              same, we know that "(-a) < 0" is equivalent to "a > 0".  */
11166           if (num_sign_bit_copies (op0, mode) >= 2)
11167             {
11168               op0 = XEXP (op0, 0);
11169               code = swap_condition (code);
11170               continue;
11171             }
11172           break;
11173
11174         case ROTATE:
11175           /* If we are testing equality and our count is a constant, we
11176              can perform the inverse operation on our RHS.  */
11177           if (equality_comparison_p && CONST_INT_P (XEXP (op0, 1))
11178               && (tem = simplify_binary_operation (ROTATERT, mode,
11179                                                    op1, XEXP (op0, 1))) != 0)
11180             {
11181               op0 = XEXP (op0, 0);
11182               op1 = tem;
11183               continue;
11184             }
11185
11186           /* If we are doing a < 0 or >= 0 comparison, it means we are testing
11187              a particular bit.  Convert it to an AND of a constant of that
11188              bit.  This will be converted into a ZERO_EXTRACT.  */
11189           if (const_op == 0 && sign_bit_comparison_p
11190               && CONST_INT_P (XEXP (op0, 1))
11191               && mode_width <= HOST_BITS_PER_WIDE_INT)
11192             {
11193               op0 = simplify_and_const_int (NULL_RTX, mode, XEXP (op0, 0),
11194                                             ((HOST_WIDE_INT) 1
11195                                              << (mode_width - 1
11196                                                  - INTVAL (XEXP (op0, 1)))));
11197               code = (code == LT ? NE : EQ);
11198               continue;
11199             }
11200
11201           /* Fall through.  */
11202
11203         case ABS:
11204           /* ABS is ignorable inside an equality comparison with zero.  */
11205           if (const_op == 0 && equality_comparison_p)
11206             {
11207               op0 = XEXP (op0, 0);
11208               continue;
11209             }
11210           break;
11211
11212         case SIGN_EXTEND:
11213           /* Can simplify (compare (zero/sign_extend FOO) CONST) to
11214              (compare FOO CONST) if CONST fits in FOO's mode and we
11215              are either testing inequality or have an unsigned
11216              comparison with ZERO_EXTEND or a signed comparison with
11217              SIGN_EXTEND.  But don't do it if we don't have a compare
11218              insn of the given mode, since we'd have to revert it
11219              later on, and then we wouldn't know whether to sign- or
11220              zero-extend.  */
11221           mode = GET_MODE (XEXP (op0, 0));
11222           if (mode != VOIDmode && GET_MODE_CLASS (mode) == MODE_INT
11223               && ! unsigned_comparison_p
11224               && (GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
11225               && ((unsigned HOST_WIDE_INT) const_op
11226                   < (((unsigned HOST_WIDE_INT) 1
11227                       << (GET_MODE_BITSIZE (mode) - 1))))
11228               && have_insn_for (COMPARE, mode))
11229             {
11230               op0 = XEXP (op0, 0);
11231               continue;
11232             }
11233           break;
11234
11235         case SUBREG:
11236           /* Check for the case where we are comparing A - C1 with C2, that is
11237
11238                (subreg:MODE (plus (A) (-C1))) op (C2)
11239
11240              with C1 a constant, and try to lift the SUBREG, i.e. to do the
11241              comparison in the wider mode.  One of the following two conditions
11242              must be true in order for this to be valid:
11243
11244                1. The mode extension results in the same bit pattern being added
11245                   on both sides and the comparison is equality or unsigned.  As
11246                   C2 has been truncated to fit in MODE, the pattern can only be
11247                   all 0s or all 1s.
11248
11249                2. The mode extension results in the sign bit being copied on
11250                   each side.
11251
11252              The difficulty here is that we have predicates for A but not for
11253              (A - C1) so we need to check that C1 is within proper bounds so
11254              as to perturbate A as little as possible.  */
11255
11256           if (mode_width <= HOST_BITS_PER_WIDE_INT
11257               && subreg_lowpart_p (op0)
11258               && GET_MODE_BITSIZE (GET_MODE (SUBREG_REG (op0))) > mode_width
11259               && GET_CODE (SUBREG_REG (op0)) == PLUS
11260               && CONST_INT_P (XEXP (SUBREG_REG (op0), 1)))
11261             {
11262               enum machine_mode inner_mode = GET_MODE (SUBREG_REG (op0));
11263               rtx a = XEXP (SUBREG_REG (op0), 0);
11264               HOST_WIDE_INT c1 = -INTVAL (XEXP (SUBREG_REG (op0), 1));
11265
11266               if ((c1 > 0
11267                    && (unsigned HOST_WIDE_INT) c1
11268                        < (unsigned HOST_WIDE_INT) 1 << (mode_width - 1)
11269                    && (equality_comparison_p || unsigned_comparison_p)
11270                    /* (A - C1) zero-extends if it is positive and sign-extends
11271                       if it is negative, C2 both zero- and sign-extends.  */
11272                    && ((0 == (nonzero_bits (a, inner_mode)
11273                               & ~GET_MODE_MASK (mode))
11274                         && const_op >= 0)
11275                        /* (A - C1) sign-extends if it is positive and 1-extends
11276                           if it is negative, C2 both sign- and 1-extends.  */
11277                        || (num_sign_bit_copies (a, inner_mode)
11278                            > (unsigned int) (GET_MODE_BITSIZE (inner_mode)
11279                                              - mode_width)
11280                            && const_op < 0)))
11281                   || ((unsigned HOST_WIDE_INT) c1
11282                        < (unsigned HOST_WIDE_INT) 1 << (mode_width - 2)
11283                       /* (A - C1) always sign-extends, like C2.  */
11284                       && num_sign_bit_copies (a, inner_mode)
11285                          > (unsigned int) (GET_MODE_BITSIZE (inner_mode)
11286                                            - (mode_width - 1))))
11287                 {
11288                   op0 = SUBREG_REG (op0);
11289                   continue;
11290                 }
11291             }
11292
11293           /* If the inner mode is narrower and we are extracting the low part,
11294              we can treat the SUBREG as if it were a ZERO_EXTEND.  */
11295           if (subreg_lowpart_p (op0)
11296               && GET_MODE_BITSIZE (GET_MODE (SUBREG_REG (op0))) < mode_width)
11297             /* Fall through */ ;
11298           else
11299             break;
11300
11301           /* ... fall through ...  */
11302
11303         case ZERO_EXTEND:
11304           mode = GET_MODE (XEXP (op0, 0));
11305           if (mode != VOIDmode && GET_MODE_CLASS (mode) == MODE_INT
11306               && (unsigned_comparison_p || equality_comparison_p)
11307               && (GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
11308               && ((unsigned HOST_WIDE_INT) const_op < GET_MODE_MASK (mode))
11309               && have_insn_for (COMPARE, mode))
11310             {
11311               op0 = XEXP (op0, 0);
11312               continue;
11313             }
11314           break;
11315
11316         case PLUS:
11317           /* (eq (plus X A) B) -> (eq X (minus B A)).  We can only do
11318              this for equality comparisons due to pathological cases involving
11319              overflows.  */
11320           if (equality_comparison_p
11321               && 0 != (tem = simplify_binary_operation (MINUS, mode,
11322                                                         op1, XEXP (op0, 1))))
11323             {
11324               op0 = XEXP (op0, 0);
11325               op1 = tem;
11326               continue;
11327             }
11328
11329           /* (plus (abs X) (const_int -1)) is < 0 if and only if X == 0.  */
11330           if (const_op == 0 && XEXP (op0, 1) == constm1_rtx
11331               && GET_CODE (XEXP (op0, 0)) == ABS && sign_bit_comparison_p)
11332             {
11333               op0 = XEXP (XEXP (op0, 0), 0);
11334               code = (code == LT ? EQ : NE);
11335               continue;
11336             }
11337           break;
11338
11339         case MINUS:
11340           /* We used to optimize signed comparisons against zero, but that
11341              was incorrect.  Unsigned comparisons against zero (GTU, LEU)
11342              arrive here as equality comparisons, or (GEU, LTU) are
11343              optimized away.  No need to special-case them.  */
11344
11345           /* (eq (minus A B) C) -> (eq A (plus B C)) or
11346              (eq B (minus A C)), whichever simplifies.  We can only do
11347              this for equality comparisons due to pathological cases involving
11348              overflows.  */
11349           if (equality_comparison_p
11350               && 0 != (tem = simplify_binary_operation (PLUS, mode,
11351                                                         XEXP (op0, 1), op1)))
11352             {
11353               op0 = XEXP (op0, 0);
11354               op1 = tem;
11355               continue;
11356             }
11357
11358           if (equality_comparison_p
11359               && 0 != (tem = simplify_binary_operation (MINUS, mode,
11360                                                         XEXP (op0, 0), op1)))
11361             {
11362               op0 = XEXP (op0, 1);
11363               op1 = tem;
11364               continue;
11365             }
11366
11367           /* The sign bit of (minus (ashiftrt X C) X), where C is the number
11368              of bits in X minus 1, is one iff X > 0.  */
11369           if (sign_bit_comparison_p && GET_CODE (XEXP (op0, 0)) == ASHIFTRT
11370               && CONST_INT_P (XEXP (XEXP (op0, 0), 1))
11371               && (unsigned HOST_WIDE_INT) INTVAL (XEXP (XEXP (op0, 0), 1))
11372                  == mode_width - 1
11373               && rtx_equal_p (XEXP (XEXP (op0, 0), 0), XEXP (op0, 1)))
11374             {
11375               op0 = XEXP (op0, 1);
11376               code = (code == GE ? LE : GT);
11377               continue;
11378             }
11379           break;
11380
11381         case XOR:
11382           /* (eq (xor A B) C) -> (eq A (xor B C)).  This is a simplification
11383              if C is zero or B is a constant.  */
11384           if (equality_comparison_p
11385               && 0 != (tem = simplify_binary_operation (XOR, mode,
11386                                                         XEXP (op0, 1), op1)))
11387             {
11388               op0 = XEXP (op0, 0);
11389               op1 = tem;
11390               continue;
11391             }
11392           break;
11393
11394         case EQ:  case NE:
11395         case UNEQ:  case LTGT:
11396         case LT:  case LTU:  case UNLT:  case LE:  case LEU:  case UNLE:
11397         case GT:  case GTU:  case UNGT:  case GE:  case GEU:  case UNGE:
11398         case UNORDERED: case ORDERED:
11399           /* We can't do anything if OP0 is a condition code value, rather
11400              than an actual data value.  */
11401           if (const_op != 0
11402               || CC0_P (XEXP (op0, 0))
11403               || GET_MODE_CLASS (GET_MODE (XEXP (op0, 0))) == MODE_CC)
11404             break;
11405
11406           /* Get the two operands being compared.  */
11407           if (GET_CODE (XEXP (op0, 0)) == COMPARE)
11408             tem = XEXP (XEXP (op0, 0), 0), tem1 = XEXP (XEXP (op0, 0), 1);
11409           else
11410             tem = XEXP (op0, 0), tem1 = XEXP (op0, 1);
11411
11412           /* Check for the cases where we simply want the result of the
11413              earlier test or the opposite of that result.  */
11414           if (code == NE || code == EQ
11415               || (GET_MODE_BITSIZE (GET_MODE (op0)) <= HOST_BITS_PER_WIDE_INT
11416                   && GET_MODE_CLASS (GET_MODE (op0)) == MODE_INT
11417                   && (STORE_FLAG_VALUE
11418                       & (((HOST_WIDE_INT) 1
11419                           << (GET_MODE_BITSIZE (GET_MODE (op0)) - 1))))
11420                   && (code == LT || code == GE)))
11421             {
11422               enum rtx_code new_code;
11423               if (code == LT || code == NE)
11424                 new_code = GET_CODE (op0);
11425               else
11426                 new_code = reversed_comparison_code (op0, NULL);
11427
11428               if (new_code != UNKNOWN)
11429                 {
11430                   code = new_code;
11431                   op0 = tem;
11432                   op1 = tem1;
11433                   continue;
11434                 }
11435             }
11436           break;
11437
11438         case IOR:
11439           /* The sign bit of (ior (plus X (const_int -1)) X) is nonzero
11440              iff X <= 0.  */
11441           if (sign_bit_comparison_p && GET_CODE (XEXP (op0, 0)) == PLUS
11442               && XEXP (XEXP (op0, 0), 1) == constm1_rtx
11443               && rtx_equal_p (XEXP (XEXP (op0, 0), 0), XEXP (op0, 1)))
11444             {
11445               op0 = XEXP (op0, 1);
11446               code = (code == GE ? GT : LE);
11447               continue;
11448             }
11449           break;
11450
11451         case AND:
11452           /* Convert (and (xshift 1 X) Y) to (and (lshiftrt Y X) 1).  This
11453              will be converted to a ZERO_EXTRACT later.  */
11454           if (const_op == 0 && equality_comparison_p
11455               && GET_CODE (XEXP (op0, 0)) == ASHIFT
11456               && XEXP (XEXP (op0, 0), 0) == const1_rtx)
11457             {
11458               op0 = simplify_and_const_int
11459                 (NULL_RTX, mode, gen_rtx_LSHIFTRT (mode,
11460                                                    XEXP (op0, 1),
11461                                                    XEXP (XEXP (op0, 0), 1)),
11462                  (HOST_WIDE_INT) 1);
11463               continue;
11464             }
11465
11466           /* If we are comparing (and (lshiftrt X C1) C2) for equality with
11467              zero and X is a comparison and C1 and C2 describe only bits set
11468              in STORE_FLAG_VALUE, we can compare with X.  */
11469           if (const_op == 0 && equality_comparison_p
11470               && mode_width <= HOST_BITS_PER_WIDE_INT
11471               && CONST_INT_P (XEXP (op0, 1))
11472               && GET_CODE (XEXP (op0, 0)) == LSHIFTRT
11473               && CONST_INT_P (XEXP (XEXP (op0, 0), 1))
11474               && INTVAL (XEXP (XEXP (op0, 0), 1)) >= 0
11475               && INTVAL (XEXP (XEXP (op0, 0), 1)) < HOST_BITS_PER_WIDE_INT)
11476             {
11477               mask = ((INTVAL (XEXP (op0, 1)) & GET_MODE_MASK (mode))
11478                       << INTVAL (XEXP (XEXP (op0, 0), 1)));
11479               if ((~STORE_FLAG_VALUE & mask) == 0
11480                   && (COMPARISON_P (XEXP (XEXP (op0, 0), 0))
11481                       || ((tem = get_last_value (XEXP (XEXP (op0, 0), 0))) != 0
11482                           && COMPARISON_P (tem))))
11483                 {
11484                   op0 = XEXP (XEXP (op0, 0), 0);
11485                   continue;
11486                 }
11487             }
11488
11489           /* If we are doing an equality comparison of an AND of a bit equal
11490              to the sign bit, replace this with a LT or GE comparison of
11491              the underlying value.  */
11492           if (equality_comparison_p
11493               && const_op == 0
11494               && CONST_INT_P (XEXP (op0, 1))
11495               && mode_width <= HOST_BITS_PER_WIDE_INT
11496               && ((INTVAL (XEXP (op0, 1)) & GET_MODE_MASK (mode))
11497                   == (unsigned HOST_WIDE_INT) 1 << (mode_width - 1)))
11498             {
11499               op0 = XEXP (op0, 0);
11500               code = (code == EQ ? GE : LT);
11501               continue;
11502             }
11503
11504           /* If this AND operation is really a ZERO_EXTEND from a narrower
11505              mode, the constant fits within that mode, and this is either an
11506              equality or unsigned comparison, try to do this comparison in
11507              the narrower mode.
11508
11509              Note that in:
11510
11511              (ne:DI (and:DI (reg:DI 4) (const_int 0xffffffff)) (const_int 0))
11512              -> (ne:DI (reg:SI 4) (const_int 0))
11513
11514              unless TRULY_NOOP_TRUNCATION allows it or the register is
11515              known to hold a value of the required mode the
11516              transformation is invalid.  */
11517           if ((equality_comparison_p || unsigned_comparison_p)
11518               && CONST_INT_P (XEXP (op0, 1))
11519               && (i = exact_log2 ((INTVAL (XEXP (op0, 1))
11520                                    & GET_MODE_MASK (mode))
11521                                   + 1)) >= 0
11522               && const_op >> i == 0
11523               && (tmode = mode_for_size (i, MODE_INT, 1)) != BLKmode
11524               && (TRULY_NOOP_TRUNCATION (GET_MODE_BITSIZE (tmode),
11525                                          GET_MODE_BITSIZE (GET_MODE (op0)))
11526                   || (REG_P (XEXP (op0, 0))
11527                       && reg_truncated_to_mode (tmode, XEXP (op0, 0)))))
11528             {
11529               op0 = gen_lowpart (tmode, XEXP (op0, 0));
11530               continue;
11531             }
11532
11533           /* If this is (and:M1 (subreg:M2 X 0) (const_int C1)) where C1
11534              fits in both M1 and M2 and the SUBREG is either paradoxical
11535              or represents the low part, permute the SUBREG and the AND
11536              and try again.  */
11537           if (GET_CODE (XEXP (op0, 0)) == SUBREG)
11538             {
11539               unsigned HOST_WIDE_INT c1;
11540               tmode = GET_MODE (SUBREG_REG (XEXP (op0, 0)));
11541               /* Require an integral mode, to avoid creating something like
11542                  (AND:SF ...).  */
11543               if (SCALAR_INT_MODE_P (tmode)
11544                   /* It is unsafe to commute the AND into the SUBREG if the
11545                      SUBREG is paradoxical and WORD_REGISTER_OPERATIONS is
11546                      not defined.  As originally written the upper bits
11547                      have a defined value due to the AND operation.
11548                      However, if we commute the AND inside the SUBREG then
11549                      they no longer have defined values and the meaning of
11550                      the code has been changed.  */
11551                   && (0
11552 #ifdef WORD_REGISTER_OPERATIONS
11553                       || (mode_width > GET_MODE_BITSIZE (tmode)
11554                           && mode_width <= BITS_PER_WORD)
11555 #endif
11556                       || (mode_width <= GET_MODE_BITSIZE (tmode)
11557                           && subreg_lowpart_p (XEXP (op0, 0))))
11558                   && CONST_INT_P (XEXP (op0, 1))
11559                   && mode_width <= HOST_BITS_PER_WIDE_INT
11560                   && GET_MODE_BITSIZE (tmode) <= HOST_BITS_PER_WIDE_INT
11561                   && ((c1 = INTVAL (XEXP (op0, 1))) & ~mask) == 0
11562                   && (c1 & ~GET_MODE_MASK (tmode)) == 0
11563                   && c1 != mask
11564                   && c1 != GET_MODE_MASK (tmode))
11565                 {
11566                   op0 = simplify_gen_binary (AND, tmode,
11567                                              SUBREG_REG (XEXP (op0, 0)),
11568                                              gen_int_mode (c1, tmode));
11569                   op0 = gen_lowpart (mode, op0);
11570                   continue;
11571                 }
11572             }
11573
11574           /* Convert (ne (and (not X) 1) 0) to (eq (and X 1) 0).  */
11575           if (const_op == 0 && equality_comparison_p
11576               && XEXP (op0, 1) == const1_rtx
11577               && GET_CODE (XEXP (op0, 0)) == NOT)
11578             {
11579               op0 = simplify_and_const_int
11580                 (NULL_RTX, mode, XEXP (XEXP (op0, 0), 0), (HOST_WIDE_INT) 1);
11581               code = (code == NE ? EQ : NE);
11582               continue;
11583             }
11584
11585           /* Convert (ne (and (lshiftrt (not X)) 1) 0) to
11586              (eq (and (lshiftrt X) 1) 0).
11587              Also handle the case where (not X) is expressed using xor.  */
11588           if (const_op == 0 && equality_comparison_p
11589               && XEXP (op0, 1) == const1_rtx
11590               && GET_CODE (XEXP (op0, 0)) == LSHIFTRT)
11591             {
11592               rtx shift_op = XEXP (XEXP (op0, 0), 0);
11593               rtx shift_count = XEXP (XEXP (op0, 0), 1);
11594
11595               if (GET_CODE (shift_op) == NOT
11596                   || (GET_CODE (shift_op) == XOR
11597                       && CONST_INT_P (XEXP (shift_op, 1))
11598                       && CONST_INT_P (shift_count)
11599                       && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
11600                       && (INTVAL (XEXP (shift_op, 1))
11601                           == (HOST_WIDE_INT) 1 << INTVAL (shift_count))))
11602                 {
11603                   op0 = simplify_and_const_int
11604                     (NULL_RTX, mode,
11605                      gen_rtx_LSHIFTRT (mode, XEXP (shift_op, 0), shift_count),
11606                      (HOST_WIDE_INT) 1);
11607                   code = (code == NE ? EQ : NE);
11608                   continue;
11609                 }
11610             }
11611           break;
11612
11613         case ASHIFT:
11614           /* If we have (compare (ashift FOO N) (const_int C)) and
11615              the high order N bits of FOO (N+1 if an inequality comparison)
11616              are known to be zero, we can do this by comparing FOO with C
11617              shifted right N bits so long as the low-order N bits of C are
11618              zero.  */
11619           if (CONST_INT_P (XEXP (op0, 1))
11620               && INTVAL (XEXP (op0, 1)) >= 0
11621               && ((INTVAL (XEXP (op0, 1)) + ! equality_comparison_p)
11622                   < HOST_BITS_PER_WIDE_INT)
11623               && ((const_op
11624                    & (((HOST_WIDE_INT) 1 << INTVAL (XEXP (op0, 1))) - 1)) == 0)
11625               && mode_width <= HOST_BITS_PER_WIDE_INT
11626               && (nonzero_bits (XEXP (op0, 0), mode)
11627                   & ~(mask >> (INTVAL (XEXP (op0, 1))
11628                                + ! equality_comparison_p))) == 0)
11629             {
11630               /* We must perform a logical shift, not an arithmetic one,
11631                  as we want the top N bits of C to be zero.  */
11632               unsigned HOST_WIDE_INT temp = const_op & GET_MODE_MASK (mode);
11633
11634               temp >>= INTVAL (XEXP (op0, 1));
11635               op1 = gen_int_mode (temp, mode);
11636               op0 = XEXP (op0, 0);
11637               continue;
11638             }
11639
11640           /* If we are doing a sign bit comparison, it means we are testing
11641              a particular bit.  Convert it to the appropriate AND.  */
11642           if (sign_bit_comparison_p && CONST_INT_P (XEXP (op0, 1))
11643               && mode_width <= HOST_BITS_PER_WIDE_INT)
11644             {
11645               op0 = simplify_and_const_int (NULL_RTX, mode, XEXP (op0, 0),
11646                                             ((HOST_WIDE_INT) 1
11647                                              << (mode_width - 1
11648                                                  - INTVAL (XEXP (op0, 1)))));
11649               code = (code == LT ? NE : EQ);
11650               continue;
11651             }
11652
11653           /* If this an equality comparison with zero and we are shifting
11654              the low bit to the sign bit, we can convert this to an AND of the
11655              low-order bit.  */
11656           if (const_op == 0 && equality_comparison_p
11657               && CONST_INT_P (XEXP (op0, 1))
11658               && (unsigned HOST_WIDE_INT) INTVAL (XEXP (op0, 1))
11659                  == mode_width - 1)
11660             {
11661               op0 = simplify_and_const_int (NULL_RTX, mode, XEXP (op0, 0),
11662                                             (HOST_WIDE_INT) 1);
11663               continue;
11664             }
11665           break;
11666
11667         case ASHIFTRT:
11668           /* If this is an equality comparison with zero, we can do this
11669              as a logical shift, which might be much simpler.  */
11670           if (equality_comparison_p && const_op == 0
11671               && CONST_INT_P (XEXP (op0, 1)))
11672             {
11673               op0 = simplify_shift_const (NULL_RTX, LSHIFTRT, mode,
11674                                           XEXP (op0, 0),
11675                                           INTVAL (XEXP (op0, 1)));
11676               continue;
11677             }
11678
11679           /* If OP0 is a sign extension and CODE is not an unsigned comparison,
11680              do the comparison in a narrower mode.  */
11681           if (! unsigned_comparison_p
11682               && CONST_INT_P (XEXP (op0, 1))
11683               && GET_CODE (XEXP (op0, 0)) == ASHIFT
11684               && XEXP (op0, 1) == XEXP (XEXP (op0, 0), 1)
11685               && (tmode = mode_for_size (mode_width - INTVAL (XEXP (op0, 1)),
11686                                          MODE_INT, 1)) != BLKmode
11687               && (((unsigned HOST_WIDE_INT) const_op
11688                    + (GET_MODE_MASK (tmode) >> 1) + 1)
11689                   <= GET_MODE_MASK (tmode)))
11690             {
11691               op0 = gen_lowpart (tmode, XEXP (XEXP (op0, 0), 0));
11692               continue;
11693             }
11694
11695           /* Likewise if OP0 is a PLUS of a sign extension with a
11696              constant, which is usually represented with the PLUS
11697              between the shifts.  */
11698           if (! unsigned_comparison_p
11699               && CONST_INT_P (XEXP (op0, 1))
11700               && GET_CODE (XEXP (op0, 0)) == PLUS
11701               && CONST_INT_P (XEXP (XEXP (op0, 0), 1))
11702               && GET_CODE (XEXP (XEXP (op0, 0), 0)) == ASHIFT
11703               && XEXP (op0, 1) == XEXP (XEXP (XEXP (op0, 0), 0), 1)
11704               && (tmode = mode_for_size (mode_width - INTVAL (XEXP (op0, 1)),
11705                                          MODE_INT, 1)) != BLKmode
11706               && (((unsigned HOST_WIDE_INT) const_op
11707                    + (GET_MODE_MASK (tmode) >> 1) + 1)
11708                   <= GET_MODE_MASK (tmode)))
11709             {
11710               rtx inner = XEXP (XEXP (XEXP (op0, 0), 0), 0);
11711               rtx add_const = XEXP (XEXP (op0, 0), 1);
11712               rtx new_const = simplify_gen_binary (ASHIFTRT, GET_MODE (op0),
11713                                                    add_const, XEXP (op0, 1));
11714
11715               op0 = simplify_gen_binary (PLUS, tmode,
11716                                          gen_lowpart (tmode, inner),
11717                                          new_const);
11718               continue;
11719             }
11720
11721           /* ... fall through ...  */
11722         case LSHIFTRT:
11723           /* If we have (compare (xshiftrt FOO N) (const_int C)) and
11724              the low order N bits of FOO are known to be zero, we can do this
11725              by comparing FOO with C shifted left N bits so long as no
11726              overflow occurs.  Even if the low order N bits of FOO aren't known
11727              to be zero, if the comparison is >= or < we can use the same
11728              optimization and for > or <= by setting all the low
11729              order N bits in the comparison constant.  */
11730           if (CONST_INT_P (XEXP (op0, 1))
11731               && INTVAL (XEXP (op0, 1)) > 0
11732               && INTVAL (XEXP (op0, 1)) < HOST_BITS_PER_WIDE_INT
11733               && mode_width <= HOST_BITS_PER_WIDE_INT
11734               && (((unsigned HOST_WIDE_INT) const_op
11735                    + (GET_CODE (op0) != LSHIFTRT
11736                       ? ((GET_MODE_MASK (mode) >> INTVAL (XEXP (op0, 1)) >> 1)
11737                          + 1)
11738                       : 0))
11739                   <= GET_MODE_MASK (mode) >> INTVAL (XEXP (op0, 1))))
11740             {
11741               unsigned HOST_WIDE_INT low_bits
11742                 = (nonzero_bits (XEXP (op0, 0), mode)
11743                    & (((unsigned HOST_WIDE_INT) 1
11744                        << INTVAL (XEXP (op0, 1))) - 1));
11745               if (low_bits == 0 || !equality_comparison_p)
11746                 {
11747                   /* If the shift was logical, then we must make the condition
11748                      unsigned.  */
11749                   if (GET_CODE (op0) == LSHIFTRT)
11750                     code = unsigned_condition (code);
11751
11752                   const_op <<= INTVAL (XEXP (op0, 1));
11753                   if (low_bits != 0
11754                       && (code == GT || code == GTU
11755                           || code == LE || code == LEU))
11756                     const_op
11757                       |= (((HOST_WIDE_INT) 1 << INTVAL (XEXP (op0, 1))) - 1);
11758                   op1 = GEN_INT (const_op);
11759                   op0 = XEXP (op0, 0);
11760                   continue;
11761                 }
11762             }
11763
11764           /* If we are using this shift to extract just the sign bit, we
11765              can replace this with an LT or GE comparison.  */
11766           if (const_op == 0
11767               && (equality_comparison_p || sign_bit_comparison_p)
11768               && CONST_INT_P (XEXP (op0, 1))
11769               && (unsigned HOST_WIDE_INT) INTVAL (XEXP (op0, 1))
11770                  == mode_width - 1)
11771             {
11772               op0 = XEXP (op0, 0);
11773               code = (code == NE || code == GT ? LT : GE);
11774               continue;
11775             }
11776           break;
11777
11778         default:
11779           break;
11780         }
11781
11782       break;
11783     }
11784
11785   /* Now make any compound operations involved in this comparison.  Then,
11786      check for an outmost SUBREG on OP0 that is not doing anything or is
11787      paradoxical.  The latter transformation must only be performed when
11788      it is known that the "extra" bits will be the same in op0 and op1 or
11789      that they don't matter.  There are three cases to consider:
11790
11791      1. SUBREG_REG (op0) is a register.  In this case the bits are don't
11792      care bits and we can assume they have any convenient value.  So
11793      making the transformation is safe.
11794
11795      2. SUBREG_REG (op0) is a memory and LOAD_EXTEND_OP is not defined.
11796      In this case the upper bits of op0 are undefined.  We should not make
11797      the simplification in that case as we do not know the contents of
11798      those bits.
11799
11800      3. SUBREG_REG (op0) is a memory and LOAD_EXTEND_OP is defined and not
11801      UNKNOWN.  In that case we know those bits are zeros or ones.  We must
11802      also be sure that they are the same as the upper bits of op1.
11803
11804      We can never remove a SUBREG for a non-equality comparison because
11805      the sign bit is in a different place in the underlying object.  */
11806
11807   op0 = make_compound_operation (op0, op1 == const0_rtx ? COMPARE : SET);
11808   op1 = make_compound_operation (op1, SET);
11809
11810   if (GET_CODE (op0) == SUBREG && subreg_lowpart_p (op0)
11811       && GET_MODE_CLASS (GET_MODE (op0)) == MODE_INT
11812       && GET_MODE_CLASS (GET_MODE (SUBREG_REG (op0))) == MODE_INT
11813       && (code == NE || code == EQ))
11814     {
11815       if (GET_MODE_SIZE (GET_MODE (op0))
11816           > GET_MODE_SIZE (GET_MODE (SUBREG_REG (op0))))
11817         {
11818           /* For paradoxical subregs, allow case 1 as above.  Case 3 isn't
11819              implemented.  */
11820           if (REG_P (SUBREG_REG (op0)))
11821             {
11822               op0 = SUBREG_REG (op0);
11823               op1 = gen_lowpart (GET_MODE (op0), op1);
11824             }
11825         }
11826       else if ((GET_MODE_BITSIZE (GET_MODE (SUBREG_REG (op0)))
11827                 <= HOST_BITS_PER_WIDE_INT)
11828                && (nonzero_bits (SUBREG_REG (op0),
11829                                  GET_MODE (SUBREG_REG (op0)))
11830                    & ~GET_MODE_MASK (GET_MODE (op0))) == 0)
11831         {
11832           tem = gen_lowpart (GET_MODE (SUBREG_REG (op0)), op1);
11833
11834           if ((nonzero_bits (tem, GET_MODE (SUBREG_REG (op0)))
11835                & ~GET_MODE_MASK (GET_MODE (op0))) == 0)
11836             op0 = SUBREG_REG (op0), op1 = tem;
11837         }
11838     }
11839
11840   /* We now do the opposite procedure: Some machines don't have compare
11841      insns in all modes.  If OP0's mode is an integer mode smaller than a
11842      word and we can't do a compare in that mode, see if there is a larger
11843      mode for which we can do the compare.  There are a number of cases in
11844      which we can use the wider mode.  */
11845
11846   mode = GET_MODE (op0);
11847   if (mode != VOIDmode && GET_MODE_CLASS (mode) == MODE_INT
11848       && GET_MODE_SIZE (mode) < UNITS_PER_WORD
11849       && ! have_insn_for (COMPARE, mode))
11850     for (tmode = GET_MODE_WIDER_MODE (mode);
11851          (tmode != VOIDmode
11852           && GET_MODE_BITSIZE (tmode) <= HOST_BITS_PER_WIDE_INT);
11853          tmode = GET_MODE_WIDER_MODE (tmode))
11854       if (have_insn_for (COMPARE, tmode))
11855         {
11856           int zero_extended;
11857
11858           /* If this is a test for negative, we can make an explicit
11859              test of the sign bit.  Test this first so we can use
11860              a paradoxical subreg to extend OP0.  */
11861
11862           if (op1 == const0_rtx && (code == LT || code == GE)
11863               && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
11864             {
11865               op0 = simplify_gen_binary (AND, tmode,
11866                                          gen_lowpart (tmode, op0),
11867                                          GEN_INT ((HOST_WIDE_INT) 1
11868                                                   << (GET_MODE_BITSIZE (mode)
11869                                                       - 1)));
11870               code = (code == LT) ? NE : EQ;
11871               break;
11872             }
11873
11874           /* If the only nonzero bits in OP0 and OP1 are those in the
11875              narrower mode and this is an equality or unsigned comparison,
11876              we can use the wider mode.  Similarly for sign-extended
11877              values, in which case it is true for all comparisons.  */
11878           zero_extended = ((code == EQ || code == NE
11879                             || code == GEU || code == GTU
11880                             || code == LEU || code == LTU)
11881                            && (nonzero_bits (op0, tmode)
11882                                & ~GET_MODE_MASK (mode)) == 0
11883                            && ((CONST_INT_P (op1)
11884                                 || (nonzero_bits (op1, tmode)
11885                                     & ~GET_MODE_MASK (mode)) == 0)));
11886
11887           if (zero_extended
11888               || ((num_sign_bit_copies (op0, tmode)
11889                    > (unsigned int) (GET_MODE_BITSIZE (tmode)
11890                                      - GET_MODE_BITSIZE (mode)))
11891                   && (num_sign_bit_copies (op1, tmode)
11892                       > (unsigned int) (GET_MODE_BITSIZE (tmode)
11893                                         - GET_MODE_BITSIZE (mode)))))
11894             {
11895               /* If OP0 is an AND and we don't have an AND in MODE either,
11896                  make a new AND in the proper mode.  */
11897               if (GET_CODE (op0) == AND
11898                   && !have_insn_for (AND, mode))
11899                 op0 = simplify_gen_binary (AND, tmode,
11900                                            gen_lowpart (tmode,
11901                                                         XEXP (op0, 0)),
11902                                            gen_lowpart (tmode,
11903                                                         XEXP (op0, 1)));
11904               else
11905                 {
11906                   if (zero_extended)
11907                     {
11908                       op0 = simplify_gen_unary (ZERO_EXTEND, tmode, op0, mode);
11909                       op1 = simplify_gen_unary (ZERO_EXTEND, tmode, op1, mode);
11910                     }
11911                   else
11912                     {
11913                       op0 = simplify_gen_unary (SIGN_EXTEND, tmode, op0, mode);
11914                       op1 = simplify_gen_unary (SIGN_EXTEND, tmode, op1, mode);
11915                     }
11916                   break;
11917                 }
11918             }
11919         }
11920
11921 #ifdef CANONICALIZE_COMPARISON
11922   /* If this machine only supports a subset of valid comparisons, see if we
11923      can convert an unsupported one into a supported one.  */
11924   CANONICALIZE_COMPARISON (code, op0, op1);
11925 #endif
11926
11927   *pop0 = op0;
11928   *pop1 = op1;
11929
11930   return code;
11931 }
11932 \f
11933 /* Utility function for record_value_for_reg.  Count number of
11934    rtxs in X.  */
11935 static int
11936 count_rtxs (rtx x)
11937 {
11938   enum rtx_code code = GET_CODE (x);
11939   const char *fmt;
11940   int i, j, ret = 1;
11941
11942   if (GET_RTX_CLASS (code) == '2'
11943       || GET_RTX_CLASS (code) == 'c')
11944     {
11945       rtx x0 = XEXP (x, 0);
11946       rtx x1 = XEXP (x, 1);
11947
11948       if (x0 == x1)
11949         return 1 + 2 * count_rtxs (x0);
11950
11951       if ((GET_RTX_CLASS (GET_CODE (x1)) == '2'
11952            || GET_RTX_CLASS (GET_CODE (x1)) == 'c')
11953           && (x0 == XEXP (x1, 0) || x0 == XEXP (x1, 1)))
11954         return 2 + 2 * count_rtxs (x0)
11955                + count_rtxs (x == XEXP (x1, 0)
11956                              ? XEXP (x1, 1) : XEXP (x1, 0));
11957
11958       if ((GET_RTX_CLASS (GET_CODE (x0)) == '2'
11959            || GET_RTX_CLASS (GET_CODE (x0)) == 'c')
11960           && (x1 == XEXP (x0, 0) || x1 == XEXP (x0, 1)))
11961         return 2 + 2 * count_rtxs (x1)
11962                + count_rtxs (x == XEXP (x0, 0)
11963                              ? XEXP (x0, 1) : XEXP (x0, 0));
11964     }
11965
11966   fmt = GET_RTX_FORMAT (code);
11967   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
11968     if (fmt[i] == 'e')
11969       ret += count_rtxs (XEXP (x, i));
11970     else if (fmt[i] == 'E')
11971       for (j = 0; j < XVECLEN (x, i); j++)
11972         ret += count_rtxs (XVECEXP (x, i, j));
11973
11974   return ret;
11975 }
11976 \f
11977 /* Utility function for following routine.  Called when X is part of a value
11978    being stored into last_set_value.  Sets last_set_table_tick
11979    for each register mentioned.  Similar to mention_regs in cse.c  */
11980
11981 static void
11982 update_table_tick (rtx x)
11983 {
11984   enum rtx_code code = GET_CODE (x);
11985   const char *fmt = GET_RTX_FORMAT (code);
11986   int i, j;
11987
11988   if (code == REG)
11989     {
11990       unsigned int regno = REGNO (x);
11991       unsigned int endregno = END_REGNO (x);
11992       unsigned int r;
11993
11994       for (r = regno; r < endregno; r++)
11995         {
11996           reg_stat_type *rsp = VEC_index (reg_stat_type, reg_stat, r);
11997           rsp->last_set_table_tick = label_tick;
11998         }
11999
12000       return;
12001     }
12002
12003   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
12004     if (fmt[i] == 'e')
12005       {
12006         /* Check for identical subexpressions.  If x contains
12007            identical subexpression we only have to traverse one of
12008            them.  */
12009         if (i == 0 && ARITHMETIC_P (x))
12010           {
12011             /* Note that at this point x1 has already been
12012                processed.  */
12013             rtx x0 = XEXP (x, 0);
12014             rtx x1 = XEXP (x, 1);
12015
12016             /* If x0 and x1 are identical then there is no need to
12017                process x0.  */
12018             if (x0 == x1)
12019               break;
12020
12021             /* If x0 is identical to a subexpression of x1 then while
12022                processing x1, x0 has already been processed.  Thus we
12023                are done with x.  */
12024             if (ARITHMETIC_P (x1)
12025                 && (x0 == XEXP (x1, 0) || x0 == XEXP (x1, 1)))
12026               break;
12027
12028             /* If x1 is identical to a subexpression of x0 then we
12029                still have to process the rest of x0.  */
12030             if (ARITHMETIC_P (x0)
12031                 && (x1 == XEXP (x0, 0) || x1 == XEXP (x0, 1)))
12032               {
12033                 update_table_tick (XEXP (x0, x1 == XEXP (x0, 0) ? 1 : 0));
12034                 break;
12035               }
12036           }
12037
12038         update_table_tick (XEXP (x, i));
12039       }
12040     else if (fmt[i] == 'E')
12041       for (j = 0; j < XVECLEN (x, i); j++)
12042         update_table_tick (XVECEXP (x, i, j));
12043 }
12044
12045 /* Record that REG is set to VALUE in insn INSN.  If VALUE is zero, we
12046    are saying that the register is clobbered and we no longer know its
12047    value.  If INSN is zero, don't update reg_stat[].last_set; this is
12048    only permitted with VALUE also zero and is used to invalidate the
12049    register.  */
12050
12051 static void
12052 record_value_for_reg (rtx reg, rtx insn, rtx value)
12053 {
12054   unsigned int regno = REGNO (reg);
12055   unsigned int endregno = END_REGNO (reg);
12056   unsigned int i;
12057   reg_stat_type *rsp;
12058
12059   /* If VALUE contains REG and we have a previous value for REG, substitute
12060      the previous value.  */
12061   if (value && insn && reg_overlap_mentioned_p (reg, value))
12062     {
12063       rtx tem;
12064
12065       /* Set things up so get_last_value is allowed to see anything set up to
12066          our insn.  */
12067       subst_low_luid = DF_INSN_LUID (insn);
12068       tem = get_last_value (reg);
12069
12070       /* If TEM is simply a binary operation with two CLOBBERs as operands,
12071          it isn't going to be useful and will take a lot of time to process,
12072          so just use the CLOBBER.  */
12073
12074       if (tem)
12075         {
12076           if (ARITHMETIC_P (tem)
12077               && GET_CODE (XEXP (tem, 0)) == CLOBBER
12078               && GET_CODE (XEXP (tem, 1)) == CLOBBER)
12079             tem = XEXP (tem, 0);
12080           else if (count_occurrences (value, reg, 1) >= 2)
12081             {
12082               /* If there are two or more occurrences of REG in VALUE,
12083                  prevent the value from growing too much.  */
12084               if (count_rtxs (tem) > MAX_LAST_VALUE_RTL)
12085                 tem = gen_rtx_CLOBBER (GET_MODE (tem), const0_rtx);
12086             }
12087
12088           value = replace_rtx (copy_rtx (value), reg, tem);
12089         }
12090     }
12091
12092   /* For each register modified, show we don't know its value, that
12093      we don't know about its bitwise content, that its value has been
12094      updated, and that we don't know the location of the death of the
12095      register.  */
12096   for (i = regno; i < endregno; i++)
12097     {
12098       rsp = VEC_index (reg_stat_type, reg_stat, i);
12099
12100       if (insn)
12101         rsp->last_set = insn;
12102
12103       rsp->last_set_value = 0;
12104       rsp->last_set_mode = VOIDmode;
12105       rsp->last_set_nonzero_bits = 0;
12106       rsp->last_set_sign_bit_copies = 0;
12107       rsp->last_death = 0;
12108       rsp->truncated_to_mode = VOIDmode;
12109     }
12110
12111   /* Mark registers that are being referenced in this value.  */
12112   if (value)
12113     update_table_tick (value);
12114
12115   /* Now update the status of each register being set.
12116      If someone is using this register in this block, set this register
12117      to invalid since we will get confused between the two lives in this
12118      basic block.  This makes using this register always invalid.  In cse, we
12119      scan the table to invalidate all entries using this register, but this
12120      is too much work for us.  */
12121
12122   for (i = regno; i < endregno; i++)
12123     {
12124       rsp = VEC_index (reg_stat_type, reg_stat, i);
12125       rsp->last_set_label = label_tick;
12126       if (!insn
12127           || (value && rsp->last_set_table_tick >= label_tick_ebb_start))
12128         rsp->last_set_invalid = 1;
12129       else
12130         rsp->last_set_invalid = 0;
12131     }
12132
12133   /* The value being assigned might refer to X (like in "x++;").  In that
12134      case, we must replace it with (clobber (const_int 0)) to prevent
12135      infinite loops.  */
12136   rsp = VEC_index (reg_stat_type, reg_stat, regno);
12137   if (value && !get_last_value_validate (&value, insn, label_tick, 0))
12138     {
12139       value = copy_rtx (value);
12140       if (!get_last_value_validate (&value, insn, label_tick, 1))
12141         value = 0;
12142     }
12143
12144   /* For the main register being modified, update the value, the mode, the
12145      nonzero bits, and the number of sign bit copies.  */
12146
12147   rsp->last_set_value = value;
12148
12149   if (value)
12150     {
12151       enum machine_mode mode = GET_MODE (reg);
12152       subst_low_luid = DF_INSN_LUID (insn);
12153       rsp->last_set_mode = mode;
12154       if (GET_MODE_CLASS (mode) == MODE_INT
12155           && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
12156         mode = nonzero_bits_mode;
12157       rsp->last_set_nonzero_bits = nonzero_bits (value, mode);
12158       rsp->last_set_sign_bit_copies
12159         = num_sign_bit_copies (value, GET_MODE (reg));
12160     }
12161 }
12162
12163 /* Called via note_stores from record_dead_and_set_regs to handle one
12164    SET or CLOBBER in an insn.  DATA is the instruction in which the
12165    set is occurring.  */
12166
12167 static void
12168 record_dead_and_set_regs_1 (rtx dest, const_rtx setter, void *data)
12169 {
12170   rtx record_dead_insn = (rtx) data;
12171
12172   if (GET_CODE (dest) == SUBREG)
12173     dest = SUBREG_REG (dest);
12174
12175   if (!record_dead_insn)
12176     {
12177       if (REG_P (dest))
12178         record_value_for_reg (dest, NULL_RTX, NULL_RTX);
12179       return;
12180     }
12181
12182   if (REG_P (dest))
12183     {
12184       /* If we are setting the whole register, we know its value.  Otherwise
12185          show that we don't know the value.  We can handle SUBREG in
12186          some cases.  */
12187       if (GET_CODE (setter) == SET && dest == SET_DEST (setter))
12188         record_value_for_reg (dest, record_dead_insn, SET_SRC (setter));
12189       else if (GET_CODE (setter) == SET
12190                && GET_CODE (SET_DEST (setter)) == SUBREG
12191                && SUBREG_REG (SET_DEST (setter)) == dest
12192                && GET_MODE_BITSIZE (GET_MODE (dest)) <= BITS_PER_WORD
12193                && subreg_lowpart_p (SET_DEST (setter)))
12194         record_value_for_reg (dest, record_dead_insn,
12195                               gen_lowpart (GET_MODE (dest),
12196                                                        SET_SRC (setter)));
12197       else
12198         record_value_for_reg (dest, record_dead_insn, NULL_RTX);
12199     }
12200   else if (MEM_P (dest)
12201            /* Ignore pushes, they clobber nothing.  */
12202            && ! push_operand (dest, GET_MODE (dest)))
12203     mem_last_set = DF_INSN_LUID (record_dead_insn);
12204 }
12205
12206 /* Update the records of when each REG was most recently set or killed
12207    for the things done by INSN.  This is the last thing done in processing
12208    INSN in the combiner loop.
12209
12210    We update reg_stat[], in particular fields last_set, last_set_value,
12211    last_set_mode, last_set_nonzero_bits, last_set_sign_bit_copies,
12212    last_death, and also the similar information mem_last_set (which insn
12213    most recently modified memory) and last_call_luid (which insn was the
12214    most recent subroutine call).  */
12215
12216 static void
12217 record_dead_and_set_regs (rtx insn)
12218 {
12219   rtx link;
12220   unsigned int i;
12221
12222   for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
12223     {
12224       if (REG_NOTE_KIND (link) == REG_DEAD
12225           && REG_P (XEXP (link, 0)))
12226         {
12227           unsigned int regno = REGNO (XEXP (link, 0));
12228           unsigned int endregno = END_REGNO (XEXP (link, 0));
12229
12230           for (i = regno; i < endregno; i++)
12231             {
12232               reg_stat_type *rsp;
12233
12234               rsp = VEC_index (reg_stat_type, reg_stat, i);
12235               rsp->last_death = insn;
12236             }
12237         }
12238       else if (REG_NOTE_KIND (link) == REG_INC)
12239         record_value_for_reg (XEXP (link, 0), insn, NULL_RTX);
12240     }
12241
12242   if (CALL_P (insn))
12243     {
12244       for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
12245         if (TEST_HARD_REG_BIT (regs_invalidated_by_call, i))
12246           {
12247             reg_stat_type *rsp;
12248
12249             rsp = VEC_index (reg_stat_type, reg_stat, i);
12250             rsp->last_set_invalid = 1;
12251             rsp->last_set = insn;
12252             rsp->last_set_value = 0;
12253             rsp->last_set_mode = VOIDmode;
12254             rsp->last_set_nonzero_bits = 0;
12255             rsp->last_set_sign_bit_copies = 0;
12256             rsp->last_death = 0;
12257             rsp->truncated_to_mode = VOIDmode;
12258           }
12259
12260       last_call_luid = mem_last_set = DF_INSN_LUID (insn);
12261
12262       /* We can't combine into a call pattern.  Remember, though, that
12263          the return value register is set at this LUID.  We could
12264          still replace a register with the return value from the
12265          wrong subroutine call!  */
12266       note_stores (PATTERN (insn), record_dead_and_set_regs_1, NULL_RTX);
12267     }
12268   else
12269     note_stores (PATTERN (insn), record_dead_and_set_regs_1, insn);
12270 }
12271
12272 /* If a SUBREG has the promoted bit set, it is in fact a property of the
12273    register present in the SUBREG, so for each such SUBREG go back and
12274    adjust nonzero and sign bit information of the registers that are
12275    known to have some zero/sign bits set.
12276
12277    This is needed because when combine blows the SUBREGs away, the
12278    information on zero/sign bits is lost and further combines can be
12279    missed because of that.  */
12280
12281 static void
12282 record_promoted_value (rtx insn, rtx subreg)
12283 {
12284   rtx links, set;
12285   unsigned int regno = REGNO (SUBREG_REG (subreg));
12286   enum machine_mode mode = GET_MODE (subreg);
12287
12288   if (GET_MODE_BITSIZE (mode) > HOST_BITS_PER_WIDE_INT)
12289     return;
12290
12291   for (links = LOG_LINKS (insn); links;)
12292     {
12293       reg_stat_type *rsp;
12294
12295       insn = XEXP (links, 0);
12296       set = single_set (insn);
12297
12298       if (! set || !REG_P (SET_DEST (set))
12299           || REGNO (SET_DEST (set)) != regno
12300           || GET_MODE (SET_DEST (set)) != GET_MODE (SUBREG_REG (subreg)))
12301         {
12302           links = XEXP (links, 1);
12303           continue;
12304         }
12305
12306       rsp = VEC_index (reg_stat_type, reg_stat, regno);
12307       if (rsp->last_set == insn)
12308         {
12309           if (SUBREG_PROMOTED_UNSIGNED_P (subreg) > 0)
12310             rsp->last_set_nonzero_bits &= GET_MODE_MASK (mode);
12311         }
12312
12313       if (REG_P (SET_SRC (set)))
12314         {
12315           regno = REGNO (SET_SRC (set));
12316           links = LOG_LINKS (insn);
12317         }
12318       else
12319         break;
12320     }
12321 }
12322
12323 /* Check if X, a register, is known to contain a value already
12324    truncated to MODE.  In this case we can use a subreg to refer to
12325    the truncated value even though in the generic case we would need
12326    an explicit truncation.  */
12327
12328 static bool
12329 reg_truncated_to_mode (enum machine_mode mode, const_rtx x)
12330 {
12331   reg_stat_type *rsp = VEC_index (reg_stat_type, reg_stat, REGNO (x));
12332   enum machine_mode truncated = rsp->truncated_to_mode;
12333
12334   if (truncated == 0
12335       || rsp->truncation_label < label_tick_ebb_start)
12336     return false;
12337   if (GET_MODE_SIZE (truncated) <= GET_MODE_SIZE (mode))
12338     return true;
12339   if (TRULY_NOOP_TRUNCATION (GET_MODE_BITSIZE (mode),
12340                              GET_MODE_BITSIZE (truncated)))
12341     return true;
12342   return false;
12343 }
12344
12345 /* Callback for for_each_rtx.  If *P is a hard reg or a subreg record the mode
12346    that the register is accessed in.  For non-TRULY_NOOP_TRUNCATION targets we
12347    might be able to turn a truncate into a subreg using this information.
12348    Return -1 if traversing *P is complete or 0 otherwise.  */
12349
12350 static int
12351 record_truncated_value (rtx *p, void *data ATTRIBUTE_UNUSED)
12352 {
12353   rtx x = *p;
12354   enum machine_mode truncated_mode;
12355   reg_stat_type *rsp;
12356
12357   if (GET_CODE (x) == SUBREG && REG_P (SUBREG_REG (x)))
12358     {
12359       enum machine_mode original_mode = GET_MODE (SUBREG_REG (x));
12360       truncated_mode = GET_MODE (x);
12361
12362       if (GET_MODE_SIZE (original_mode) <= GET_MODE_SIZE (truncated_mode))
12363         return -1;
12364
12365       if (TRULY_NOOP_TRUNCATION (GET_MODE_BITSIZE (truncated_mode),
12366                                  GET_MODE_BITSIZE (original_mode)))
12367         return -1;
12368
12369       x = SUBREG_REG (x);
12370     }
12371   /* ??? For hard-regs we now record everything.  We might be able to
12372      optimize this using last_set_mode.  */
12373   else if (REG_P (x) && REGNO (x) < FIRST_PSEUDO_REGISTER)
12374     truncated_mode = GET_MODE (x);
12375   else
12376     return 0;
12377
12378   rsp = VEC_index (reg_stat_type, reg_stat, REGNO (x));
12379   if (rsp->truncated_to_mode == 0
12380       || rsp->truncation_label < label_tick_ebb_start
12381       || (GET_MODE_SIZE (truncated_mode)
12382           < GET_MODE_SIZE (rsp->truncated_to_mode)))
12383     {
12384       rsp->truncated_to_mode = truncated_mode;
12385       rsp->truncation_label = label_tick;
12386     }
12387
12388   return -1;
12389 }
12390
12391 /* Callback for note_uses.  Find hardregs and subregs of pseudos and
12392    the modes they are used in.  This can help truning TRUNCATEs into
12393    SUBREGs.  */
12394
12395 static void
12396 record_truncated_values (rtx *x, void *data ATTRIBUTE_UNUSED)
12397 {
12398   for_each_rtx (x, record_truncated_value, NULL);
12399 }
12400
12401 /* Scan X for promoted SUBREGs.  For each one found,
12402    note what it implies to the registers used in it.  */
12403
12404 static void
12405 check_promoted_subreg (rtx insn, rtx x)
12406 {
12407   if (GET_CODE (x) == SUBREG
12408       && SUBREG_PROMOTED_VAR_P (x)
12409       && REG_P (SUBREG_REG (x)))
12410     record_promoted_value (insn, x);
12411   else
12412     {
12413       const char *format = GET_RTX_FORMAT (GET_CODE (x));
12414       int i, j;
12415
12416       for (i = 0; i < GET_RTX_LENGTH (GET_CODE (x)); i++)
12417         switch (format[i])
12418           {
12419           case 'e':
12420             check_promoted_subreg (insn, XEXP (x, i));
12421             break;
12422           case 'V':
12423           case 'E':
12424             if (XVEC (x, i) != 0)
12425               for (j = 0; j < XVECLEN (x, i); j++)
12426                 check_promoted_subreg (insn, XVECEXP (x, i, j));
12427             break;
12428           }
12429     }
12430 }
12431 \f
12432 /* Verify that all the registers and memory references mentioned in *LOC are
12433    still valid.  *LOC was part of a value set in INSN when label_tick was
12434    equal to TICK.  Return 0 if some are not.  If REPLACE is nonzero, replace
12435    the invalid references with (clobber (const_int 0)) and return 1.  This
12436    replacement is useful because we often can get useful information about
12437    the form of a value (e.g., if it was produced by a shift that always
12438    produces -1 or 0) even though we don't know exactly what registers it
12439    was produced from.  */
12440
12441 static int
12442 get_last_value_validate (rtx *loc, rtx insn, int tick, int replace)
12443 {
12444   rtx x = *loc;
12445   const char *fmt = GET_RTX_FORMAT (GET_CODE (x));
12446   int len = GET_RTX_LENGTH (GET_CODE (x));
12447   int i, j;
12448
12449   if (REG_P (x))
12450     {
12451       unsigned int regno = REGNO (x);
12452       unsigned int endregno = END_REGNO (x);
12453       unsigned int j;
12454
12455       for (j = regno; j < endregno; j++)
12456         {
12457           reg_stat_type *rsp = VEC_index (reg_stat_type, reg_stat, j);
12458           if (rsp->last_set_invalid
12459               /* If this is a pseudo-register that was only set once and not
12460                  live at the beginning of the function, it is always valid.  */
12461               || (! (regno >= FIRST_PSEUDO_REGISTER
12462                      && REG_N_SETS (regno) == 1
12463                      && (!REGNO_REG_SET_P
12464                          (DF_LR_IN (ENTRY_BLOCK_PTR->next_bb), regno)))
12465                   && rsp->last_set_label > tick))
12466           {
12467             if (replace)
12468               *loc = gen_rtx_CLOBBER (GET_MODE (x), const0_rtx);
12469             return replace;
12470           }
12471         }
12472
12473       return 1;
12474     }
12475   /* If this is a memory reference, make sure that there were no stores after
12476      it that might have clobbered the value.  We don't have alias info, so we
12477      assume any store invalidates it.  Moreover, we only have local UIDs, so
12478      we also assume that there were stores in the intervening basic blocks.  */
12479   else if (MEM_P (x) && !MEM_READONLY_P (x)
12480            && (tick != label_tick || DF_INSN_LUID (insn) <= mem_last_set))
12481     {
12482       if (replace)
12483         *loc = gen_rtx_CLOBBER (GET_MODE (x), const0_rtx);
12484       return replace;
12485     }
12486
12487   for (i = 0; i < len; i++)
12488     {
12489       if (fmt[i] == 'e')
12490         {
12491           /* Check for identical subexpressions.  If x contains
12492              identical subexpression we only have to traverse one of
12493              them.  */
12494           if (i == 1 && ARITHMETIC_P (x))
12495             {
12496               /* Note that at this point x0 has already been checked
12497                  and found valid.  */
12498               rtx x0 = XEXP (x, 0);
12499               rtx x1 = XEXP (x, 1);
12500
12501               /* If x0 and x1 are identical then x is also valid.  */
12502               if (x0 == x1)
12503                 return 1;
12504
12505               /* If x1 is identical to a subexpression of x0 then
12506                  while checking x0, x1 has already been checked.  Thus
12507                  it is valid and so as x.  */
12508               if (ARITHMETIC_P (x0)
12509                   && (x1 == XEXP (x0, 0) || x1 == XEXP (x0, 1)))
12510                 return 1;
12511
12512               /* If x0 is identical to a subexpression of x1 then x is
12513                  valid iff the rest of x1 is valid.  */
12514               if (ARITHMETIC_P (x1)
12515                   && (x0 == XEXP (x1, 0) || x0 == XEXP (x1, 1)))
12516                 return
12517                   get_last_value_validate (&XEXP (x1,
12518                                                   x0 == XEXP (x1, 0) ? 1 : 0),
12519                                            insn, tick, replace);
12520             }
12521
12522           if (get_last_value_validate (&XEXP (x, i), insn, tick,
12523                                        replace) == 0)
12524             return 0;
12525         }
12526       else if (fmt[i] == 'E')
12527         for (j = 0; j < XVECLEN (x, i); j++)
12528           if (get_last_value_validate (&XVECEXP (x, i, j),
12529                                        insn, tick, replace) == 0)
12530             return 0;
12531     }
12532
12533   /* If we haven't found a reason for it to be invalid, it is valid.  */
12534   return 1;
12535 }
12536
12537 /* Get the last value assigned to X, if known.  Some registers
12538    in the value may be replaced with (clobber (const_int 0)) if their value
12539    is known longer known reliably.  */
12540
12541 static rtx
12542 get_last_value (const_rtx x)
12543 {
12544   unsigned int regno;
12545   rtx value;
12546   reg_stat_type *rsp;
12547
12548   /* If this is a non-paradoxical SUBREG, get the value of its operand and
12549      then convert it to the desired mode.  If this is a paradoxical SUBREG,
12550      we cannot predict what values the "extra" bits might have.  */
12551   if (GET_CODE (x) == SUBREG
12552       && subreg_lowpart_p (x)
12553       && (GET_MODE_SIZE (GET_MODE (x))
12554           <= GET_MODE_SIZE (GET_MODE (SUBREG_REG (x))))
12555       && (value = get_last_value (SUBREG_REG (x))) != 0)
12556     return gen_lowpart (GET_MODE (x), value);
12557
12558   if (!REG_P (x))
12559     return 0;
12560
12561   regno = REGNO (x);
12562   rsp = VEC_index (reg_stat_type, reg_stat, regno);
12563   value = rsp->last_set_value;
12564
12565   /* If we don't have a value, or if it isn't for this basic block and
12566      it's either a hard register, set more than once, or it's a live
12567      at the beginning of the function, return 0.
12568
12569      Because if it's not live at the beginning of the function then the reg
12570      is always set before being used (is never used without being set).
12571      And, if it's set only once, and it's always set before use, then all
12572      uses must have the same last value, even if it's not from this basic
12573      block.  */
12574
12575   if (value == 0
12576       || (rsp->last_set_label < label_tick_ebb_start
12577           && (regno < FIRST_PSEUDO_REGISTER
12578               || REG_N_SETS (regno) != 1
12579               || REGNO_REG_SET_P
12580                  (DF_LR_IN (ENTRY_BLOCK_PTR->next_bb), regno))))
12581     return 0;
12582
12583   /* If the value was set in a later insn than the ones we are processing,
12584      we can't use it even if the register was only set once.  */
12585   if (rsp->last_set_label == label_tick
12586       && DF_INSN_LUID (rsp->last_set) >= subst_low_luid)
12587     return 0;
12588
12589   /* If the value has all its registers valid, return it.  */
12590   if (get_last_value_validate (&value, rsp->last_set, rsp->last_set_label, 0))
12591     return value;
12592
12593   /* Otherwise, make a copy and replace any invalid register with
12594      (clobber (const_int 0)).  If that fails for some reason, return 0.  */
12595
12596   value = copy_rtx (value);
12597   if (get_last_value_validate (&value, rsp->last_set, rsp->last_set_label, 1))
12598     return value;
12599
12600   return 0;
12601 }
12602 \f
12603 /* Return nonzero if expression X refers to a REG or to memory
12604    that is set in an instruction more recent than FROM_LUID.  */
12605
12606 static int
12607 use_crosses_set_p (const_rtx x, int from_luid)
12608 {
12609   const char *fmt;
12610   int i;
12611   enum rtx_code code = GET_CODE (x);
12612
12613   if (code == REG)
12614     {
12615       unsigned int regno = REGNO (x);
12616       unsigned endreg = END_REGNO (x);
12617
12618 #ifdef PUSH_ROUNDING
12619       /* Don't allow uses of the stack pointer to be moved,
12620          because we don't know whether the move crosses a push insn.  */
12621       if (regno == STACK_POINTER_REGNUM && PUSH_ARGS)
12622         return 1;
12623 #endif
12624       for (; regno < endreg; regno++)
12625         {
12626           reg_stat_type *rsp = VEC_index (reg_stat_type, reg_stat, regno);
12627           if (rsp->last_set
12628               && rsp->last_set_label == label_tick
12629               && DF_INSN_LUID (rsp->last_set) > from_luid)
12630             return 1;
12631         }
12632       return 0;
12633     }
12634
12635   if (code == MEM && mem_last_set > from_luid)
12636     return 1;
12637
12638   fmt = GET_RTX_FORMAT (code);
12639
12640   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
12641     {
12642       if (fmt[i] == 'E')
12643         {
12644           int j;
12645           for (j = XVECLEN (x, i) - 1; j >= 0; j--)
12646             if (use_crosses_set_p (XVECEXP (x, i, j), from_luid))
12647               return 1;
12648         }
12649       else if (fmt[i] == 'e'
12650                && use_crosses_set_p (XEXP (x, i), from_luid))
12651         return 1;
12652     }
12653   return 0;
12654 }
12655 \f
12656 /* Define three variables used for communication between the following
12657    routines.  */
12658
12659 static unsigned int reg_dead_regno, reg_dead_endregno;
12660 static int reg_dead_flag;
12661
12662 /* Function called via note_stores from reg_dead_at_p.
12663
12664    If DEST is within [reg_dead_regno, reg_dead_endregno), set
12665    reg_dead_flag to 1 if X is a CLOBBER and to -1 it is a SET.  */
12666
12667 static void
12668 reg_dead_at_p_1 (rtx dest, const_rtx x, void *data ATTRIBUTE_UNUSED)
12669 {
12670   unsigned int regno, endregno;
12671
12672   if (!REG_P (dest))
12673     return;
12674
12675   regno = REGNO (dest);
12676   endregno = END_REGNO (dest);
12677   if (reg_dead_endregno > regno && reg_dead_regno < endregno)
12678     reg_dead_flag = (GET_CODE (x) == CLOBBER) ? 1 : -1;
12679 }
12680
12681 /* Return nonzero if REG is known to be dead at INSN.
12682
12683    We scan backwards from INSN.  If we hit a REG_DEAD note or a CLOBBER
12684    referencing REG, it is dead.  If we hit a SET referencing REG, it is
12685    live.  Otherwise, see if it is live or dead at the start of the basic
12686    block we are in.  Hard regs marked as being live in NEWPAT_USED_REGS
12687    must be assumed to be always live.  */
12688
12689 static int
12690 reg_dead_at_p (rtx reg, rtx insn)
12691 {
12692   basic_block block;
12693   unsigned int i;
12694
12695   /* Set variables for reg_dead_at_p_1.  */
12696   reg_dead_regno = REGNO (reg);
12697   reg_dead_endregno = END_REGNO (reg);
12698
12699   reg_dead_flag = 0;
12700
12701   /* Check that reg isn't mentioned in NEWPAT_USED_REGS.  For fixed registers
12702      we allow the machine description to decide whether use-and-clobber
12703      patterns are OK.  */
12704   if (reg_dead_regno < FIRST_PSEUDO_REGISTER)
12705     {
12706       for (i = reg_dead_regno; i < reg_dead_endregno; i++)
12707         if (!fixed_regs[i] && TEST_HARD_REG_BIT (newpat_used_regs, i))
12708           return 0;
12709     }
12710
12711   /* Scan backwards until we find a REG_DEAD note, SET, CLOBBER, or
12712      beginning of basic block.  */
12713   block = BLOCK_FOR_INSN (insn);
12714   for (;;)
12715     {
12716       if (INSN_P (insn))
12717         {
12718           note_stores (PATTERN (insn), reg_dead_at_p_1, NULL);
12719           if (reg_dead_flag)
12720             return reg_dead_flag == 1 ? 1 : 0;
12721
12722           if (find_regno_note (insn, REG_DEAD, reg_dead_regno))
12723             return 1;
12724         }
12725
12726       if (insn == BB_HEAD (block))
12727         break;
12728
12729       insn = PREV_INSN (insn);
12730     }
12731
12732   /* Look at live-in sets for the basic block that we were in.  */
12733   for (i = reg_dead_regno; i < reg_dead_endregno; i++)
12734     if (REGNO_REG_SET_P (df_get_live_in (block), i))
12735       return 0;
12736
12737   return 1;
12738 }
12739 \f
12740 /* Note hard registers in X that are used.  */
12741
12742 static void
12743 mark_used_regs_combine (rtx x)
12744 {
12745   RTX_CODE code = GET_CODE (x);
12746   unsigned int regno;
12747   int i;
12748
12749   switch (code)
12750     {
12751     case LABEL_REF:
12752     case SYMBOL_REF:
12753     case CONST_INT:
12754     case CONST:
12755     case CONST_DOUBLE:
12756     case CONST_VECTOR:
12757     case PC:
12758     case ADDR_VEC:
12759     case ADDR_DIFF_VEC:
12760     case ASM_INPUT:
12761 #ifdef HAVE_cc0
12762     /* CC0 must die in the insn after it is set, so we don't need to take
12763        special note of it here.  */
12764     case CC0:
12765 #endif
12766       return;
12767
12768     case CLOBBER:
12769       /* If we are clobbering a MEM, mark any hard registers inside the
12770          address as used.  */
12771       if (MEM_P (XEXP (x, 0)))
12772         mark_used_regs_combine (XEXP (XEXP (x, 0), 0));
12773       return;
12774
12775     case REG:
12776       regno = REGNO (x);
12777       /* A hard reg in a wide mode may really be multiple registers.
12778          If so, mark all of them just like the first.  */
12779       if (regno < FIRST_PSEUDO_REGISTER)
12780         {
12781           /* None of this applies to the stack, frame or arg pointers.  */
12782           if (regno == STACK_POINTER_REGNUM
12783 #if !HARD_FRAME_POINTER_IS_FRAME_POINTER
12784               || regno == HARD_FRAME_POINTER_REGNUM
12785 #endif
12786 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
12787               || (regno == ARG_POINTER_REGNUM && fixed_regs[regno])
12788 #endif
12789               || regno == FRAME_POINTER_REGNUM)
12790             return;
12791
12792           add_to_hard_reg_set (&newpat_used_regs, GET_MODE (x), regno);
12793         }
12794       return;
12795
12796     case SET:
12797       {
12798         /* If setting a MEM, or a SUBREG of a MEM, then note any hard regs in
12799            the address.  */
12800         rtx testreg = SET_DEST (x);
12801
12802         while (GET_CODE (testreg) == SUBREG
12803                || GET_CODE (testreg) == ZERO_EXTRACT
12804                || GET_CODE (testreg) == STRICT_LOW_PART)
12805           testreg = XEXP (testreg, 0);
12806
12807         if (MEM_P (testreg))
12808           mark_used_regs_combine (XEXP (testreg, 0));
12809
12810         mark_used_regs_combine (SET_SRC (x));
12811       }
12812       return;
12813
12814     default:
12815       break;
12816     }
12817
12818   /* Recursively scan the operands of this expression.  */
12819
12820   {
12821     const char *fmt = GET_RTX_FORMAT (code);
12822
12823     for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
12824       {
12825         if (fmt[i] == 'e')
12826           mark_used_regs_combine (XEXP (x, i));
12827         else if (fmt[i] == 'E')
12828           {
12829             int j;
12830
12831             for (j = 0; j < XVECLEN (x, i); j++)
12832               mark_used_regs_combine (XVECEXP (x, i, j));
12833           }
12834       }
12835   }
12836 }
12837 \f
12838 /* Remove register number REGNO from the dead registers list of INSN.
12839
12840    Return the note used to record the death, if there was one.  */
12841
12842 rtx
12843 remove_death (unsigned int regno, rtx insn)
12844 {
12845   rtx note = find_regno_note (insn, REG_DEAD, regno);
12846
12847   if (note)
12848     remove_note (insn, note);
12849
12850   return note;
12851 }
12852
12853 /* For each register (hardware or pseudo) used within expression X, if its
12854    death is in an instruction with luid between FROM_LUID (inclusive) and
12855    TO_INSN (exclusive), put a REG_DEAD note for that register in the
12856    list headed by PNOTES.
12857
12858    That said, don't move registers killed by maybe_kill_insn.
12859
12860    This is done when X is being merged by combination into TO_INSN.  These
12861    notes will then be distributed as needed.  */
12862
12863 static void
12864 move_deaths (rtx x, rtx maybe_kill_insn, int from_luid, rtx to_insn,
12865              rtx *pnotes)
12866 {
12867   const char *fmt;
12868   int len, i;
12869   enum rtx_code code = GET_CODE (x);
12870
12871   if (code == REG)
12872     {
12873       unsigned int regno = REGNO (x);
12874       rtx where_dead = VEC_index (reg_stat_type, reg_stat, regno)->last_death;
12875
12876       /* Don't move the register if it gets killed in between from and to.  */
12877       if (maybe_kill_insn && reg_set_p (x, maybe_kill_insn)
12878           && ! reg_referenced_p (x, maybe_kill_insn))
12879         return;
12880
12881       if (where_dead
12882           && BLOCK_FOR_INSN (where_dead) == BLOCK_FOR_INSN (to_insn)
12883           && DF_INSN_LUID (where_dead) >= from_luid
12884           && DF_INSN_LUID (where_dead) < DF_INSN_LUID (to_insn))
12885         {
12886           rtx note = remove_death (regno, where_dead);
12887
12888           /* It is possible for the call above to return 0.  This can occur
12889              when last_death points to I2 or I1 that we combined with.
12890              In that case make a new note.
12891
12892              We must also check for the case where X is a hard register
12893              and NOTE is a death note for a range of hard registers
12894              including X.  In that case, we must put REG_DEAD notes for
12895              the remaining registers in place of NOTE.  */
12896
12897           if (note != 0 && regno < FIRST_PSEUDO_REGISTER
12898               && (GET_MODE_SIZE (GET_MODE (XEXP (note, 0)))
12899                   > GET_MODE_SIZE (GET_MODE (x))))
12900             {
12901               unsigned int deadregno = REGNO (XEXP (note, 0));
12902               unsigned int deadend = END_HARD_REGNO (XEXP (note, 0));
12903               unsigned int ourend = END_HARD_REGNO (x);
12904               unsigned int i;
12905
12906               for (i = deadregno; i < deadend; i++)
12907                 if (i < regno || i >= ourend)
12908                   add_reg_note (where_dead, REG_DEAD, regno_reg_rtx[i]);
12909             }
12910
12911           /* If we didn't find any note, or if we found a REG_DEAD note that
12912              covers only part of the given reg, and we have a multi-reg hard
12913              register, then to be safe we must check for REG_DEAD notes
12914              for each register other than the first.  They could have
12915              their own REG_DEAD notes lying around.  */
12916           else if ((note == 0
12917                     || (note != 0
12918                         && (GET_MODE_SIZE (GET_MODE (XEXP (note, 0)))
12919                             < GET_MODE_SIZE (GET_MODE (x)))))
12920                    && regno < FIRST_PSEUDO_REGISTER
12921                    && hard_regno_nregs[regno][GET_MODE (x)] > 1)
12922             {
12923               unsigned int ourend = END_HARD_REGNO (x);
12924               unsigned int i, offset;
12925               rtx oldnotes = 0;
12926
12927               if (note)
12928                 offset = hard_regno_nregs[regno][GET_MODE (XEXP (note, 0))];
12929               else
12930                 offset = 1;
12931
12932               for (i = regno + offset; i < ourend; i++)
12933                 move_deaths (regno_reg_rtx[i],
12934                              maybe_kill_insn, from_luid, to_insn, &oldnotes);
12935             }
12936
12937           if (note != 0 && GET_MODE (XEXP (note, 0)) == GET_MODE (x))
12938             {
12939               XEXP (note, 1) = *pnotes;
12940               *pnotes = note;
12941             }
12942           else
12943             *pnotes = alloc_reg_note (REG_DEAD, x, *pnotes);
12944         }
12945
12946       return;
12947     }
12948
12949   else if (GET_CODE (x) == SET)
12950     {
12951       rtx dest = SET_DEST (x);
12952
12953       move_deaths (SET_SRC (x), maybe_kill_insn, from_luid, to_insn, pnotes);
12954
12955       /* In the case of a ZERO_EXTRACT, a STRICT_LOW_PART, or a SUBREG
12956          that accesses one word of a multi-word item, some
12957          piece of everything register in the expression is used by
12958          this insn, so remove any old death.  */
12959       /* ??? So why do we test for equality of the sizes?  */
12960
12961       if (GET_CODE (dest) == ZERO_EXTRACT
12962           || GET_CODE (dest) == STRICT_LOW_PART
12963           || (GET_CODE (dest) == SUBREG
12964               && (((GET_MODE_SIZE (GET_MODE (dest))
12965                     + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
12966                   == ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest)))
12967                        + UNITS_PER_WORD - 1) / UNITS_PER_WORD))))
12968         {
12969           move_deaths (dest, maybe_kill_insn, from_luid, to_insn, pnotes);
12970           return;
12971         }
12972
12973       /* If this is some other SUBREG, we know it replaces the entire
12974          value, so use that as the destination.  */
12975       if (GET_CODE (dest) == SUBREG)
12976         dest = SUBREG_REG (dest);
12977
12978       /* If this is a MEM, adjust deaths of anything used in the address.
12979          For a REG (the only other possibility), the entire value is
12980          being replaced so the old value is not used in this insn.  */
12981
12982       if (MEM_P (dest))
12983         move_deaths (XEXP (dest, 0), maybe_kill_insn, from_luid,
12984                      to_insn, pnotes);
12985       return;
12986     }
12987
12988   else if (GET_CODE (x) == CLOBBER)
12989     return;
12990
12991   len = GET_RTX_LENGTH (code);
12992   fmt = GET_RTX_FORMAT (code);
12993
12994   for (i = 0; i < len; i++)
12995     {
12996       if (fmt[i] == 'E')
12997         {
12998           int j;
12999           for (j = XVECLEN (x, i) - 1; j >= 0; j--)
13000             move_deaths (XVECEXP (x, i, j), maybe_kill_insn, from_luid,
13001                          to_insn, pnotes);
13002         }
13003       else if (fmt[i] == 'e')
13004         move_deaths (XEXP (x, i), maybe_kill_insn, from_luid, to_insn, pnotes);
13005     }
13006 }
13007 \f
13008 /* Return 1 if X is the target of a bit-field assignment in BODY, the
13009    pattern of an insn.  X must be a REG.  */
13010
13011 static int
13012 reg_bitfield_target_p (rtx x, rtx body)
13013 {
13014   int i;
13015
13016   if (GET_CODE (body) == SET)
13017     {
13018       rtx dest = SET_DEST (body);
13019       rtx target;
13020       unsigned int regno, tregno, endregno, endtregno;
13021
13022       if (GET_CODE (dest) == ZERO_EXTRACT)
13023         target = XEXP (dest, 0);
13024       else if (GET_CODE (dest) == STRICT_LOW_PART)
13025         target = SUBREG_REG (XEXP (dest, 0));
13026       else
13027         return 0;
13028
13029       if (GET_CODE (target) == SUBREG)
13030         target = SUBREG_REG (target);
13031
13032       if (!REG_P (target))
13033         return 0;
13034
13035       tregno = REGNO (target), regno = REGNO (x);
13036       if (tregno >= FIRST_PSEUDO_REGISTER || regno >= FIRST_PSEUDO_REGISTER)
13037         return target == x;
13038
13039       endtregno = end_hard_regno (GET_MODE (target), tregno);
13040       endregno = end_hard_regno (GET_MODE (x), regno);
13041
13042       return endregno > tregno && regno < endtregno;
13043     }
13044
13045   else if (GET_CODE (body) == PARALLEL)
13046     for (i = XVECLEN (body, 0) - 1; i >= 0; i--)
13047       if (reg_bitfield_target_p (x, XVECEXP (body, 0, i)))
13048         return 1;
13049
13050   return 0;
13051 }
13052 \f
13053 /* Given a chain of REG_NOTES originally from FROM_INSN, try to place them
13054    as appropriate.  I3 and I2 are the insns resulting from the combination
13055    insns including FROM (I2 may be zero).
13056
13057    ELIM_I2 and ELIM_I1 are either zero or registers that we know will
13058    not need REG_DEAD notes because they are being substituted for.  This
13059    saves searching in the most common cases.
13060
13061    Each note in the list is either ignored or placed on some insns, depending
13062    on the type of note.  */
13063
13064 static void
13065 distribute_notes (rtx notes, rtx from_insn, rtx i3, rtx i2, rtx elim_i2,
13066                   rtx elim_i1, rtx elim_i0)
13067 {
13068   rtx note, next_note;
13069   rtx tem;
13070
13071   for (note = notes; note; note = next_note)
13072     {
13073       rtx place = 0, place2 = 0;
13074
13075       next_note = XEXP (note, 1);
13076       switch (REG_NOTE_KIND (note))
13077         {
13078         case REG_BR_PROB:
13079         case REG_BR_PRED:
13080           /* Doesn't matter much where we put this, as long as it's somewhere.
13081              It is preferable to keep these notes on branches, which is most
13082              likely to be i3.  */
13083           place = i3;
13084           break;
13085
13086         case REG_VALUE_PROFILE:
13087           /* Just get rid of this note, as it is unused later anyway.  */
13088           break;
13089
13090         case REG_NON_LOCAL_GOTO:
13091           if (JUMP_P (i3))
13092             place = i3;
13093           else
13094             {
13095               gcc_assert (i2 && JUMP_P (i2));
13096               place = i2;
13097             }
13098           break;
13099
13100         case REG_EH_REGION:
13101           /* These notes must remain with the call or trapping instruction.  */
13102           if (CALL_P (i3))
13103             place = i3;
13104           else if (i2 && CALL_P (i2))
13105             place = i2;
13106           else
13107             {
13108               gcc_assert (cfun->can_throw_non_call_exceptions);
13109               if (may_trap_p (i3))
13110                 place = i3;
13111               else if (i2 && may_trap_p (i2))
13112                 place = i2;
13113               /* ??? Otherwise assume we've combined things such that we
13114                  can now prove that the instructions can't trap.  Drop the
13115                  note in this case.  */
13116             }
13117           break;
13118
13119         case REG_NORETURN:
13120         case REG_SETJMP:
13121           /* These notes must remain with the call.  It should not be
13122              possible for both I2 and I3 to be a call.  */
13123           if (CALL_P (i3))
13124             place = i3;
13125           else
13126             {
13127               gcc_assert (i2 && CALL_P (i2));
13128               place = i2;
13129             }
13130           break;
13131
13132         case REG_UNUSED:
13133           /* Any clobbers for i3 may still exist, and so we must process
13134              REG_UNUSED notes from that insn.
13135
13136              Any clobbers from i2 or i1 can only exist if they were added by
13137              recog_for_combine.  In that case, recog_for_combine created the
13138              necessary REG_UNUSED notes.  Trying to keep any original
13139              REG_UNUSED notes from these insns can cause incorrect output
13140              if it is for the same register as the original i3 dest.
13141              In that case, we will notice that the register is set in i3,
13142              and then add a REG_UNUSED note for the destination of i3, which
13143              is wrong.  However, it is possible to have REG_UNUSED notes from
13144              i2 or i1 for register which were both used and clobbered, so
13145              we keep notes from i2 or i1 if they will turn into REG_DEAD
13146              notes.  */
13147
13148           /* If this register is set or clobbered in I3, put the note there
13149              unless there is one already.  */
13150           if (reg_set_p (XEXP (note, 0), PATTERN (i3)))
13151             {
13152               if (from_insn != i3)
13153                 break;
13154
13155               if (! (REG_P (XEXP (note, 0))
13156                      ? find_regno_note (i3, REG_UNUSED, REGNO (XEXP (note, 0)))
13157                      : find_reg_note (i3, REG_UNUSED, XEXP (note, 0))))
13158                 place = i3;
13159             }
13160           /* Otherwise, if this register is used by I3, then this register
13161              now dies here, so we must put a REG_DEAD note here unless there
13162              is one already.  */
13163           else if (reg_referenced_p (XEXP (note, 0), PATTERN (i3))
13164                    && ! (REG_P (XEXP (note, 0))
13165                          ? find_regno_note (i3, REG_DEAD,
13166                                             REGNO (XEXP (note, 0)))
13167                          : find_reg_note (i3, REG_DEAD, XEXP (note, 0))))
13168             {
13169               PUT_REG_NOTE_KIND (note, REG_DEAD);
13170               place = i3;
13171             }
13172           break;
13173
13174         case REG_EQUAL:
13175         case REG_EQUIV:
13176         case REG_NOALIAS:
13177           /* These notes say something about results of an insn.  We can
13178              only support them if they used to be on I3 in which case they
13179              remain on I3.  Otherwise they are ignored.
13180
13181              If the note refers to an expression that is not a constant, we
13182              must also ignore the note since we cannot tell whether the
13183              equivalence is still true.  It might be possible to do
13184              slightly better than this (we only have a problem if I2DEST
13185              or I1DEST is present in the expression), but it doesn't
13186              seem worth the trouble.  */
13187
13188           if (from_insn == i3
13189               && (XEXP (note, 0) == 0 || CONSTANT_P (XEXP (note, 0))))
13190             place = i3;
13191           break;
13192
13193         case REG_INC:
13194           /* These notes say something about how a register is used.  They must
13195              be present on any use of the register in I2 or I3.  */
13196           if (reg_mentioned_p (XEXP (note, 0), PATTERN (i3)))
13197             place = i3;
13198
13199           if (i2 && reg_mentioned_p (XEXP (note, 0), PATTERN (i2)))
13200             {
13201               if (place)
13202                 place2 = i2;
13203               else
13204                 place = i2;
13205             }
13206           break;
13207
13208         case REG_LABEL_TARGET:
13209         case REG_LABEL_OPERAND:
13210           /* This can show up in several ways -- either directly in the
13211              pattern, or hidden off in the constant pool with (or without?)
13212              a REG_EQUAL note.  */
13213           /* ??? Ignore the without-reg_equal-note problem for now.  */
13214           if (reg_mentioned_p (XEXP (note, 0), PATTERN (i3))
13215               || ((tem = find_reg_note (i3, REG_EQUAL, NULL_RTX))
13216                   && GET_CODE (XEXP (tem, 0)) == LABEL_REF
13217                   && XEXP (XEXP (tem, 0), 0) == XEXP (note, 0)))
13218             place = i3;
13219
13220           if (i2
13221               && (reg_mentioned_p (XEXP (note, 0), PATTERN (i2))
13222                   || ((tem = find_reg_note (i2, REG_EQUAL, NULL_RTX))
13223                       && GET_CODE (XEXP (tem, 0)) == LABEL_REF
13224                       && XEXP (XEXP (tem, 0), 0) == XEXP (note, 0))))
13225             {
13226               if (place)
13227                 place2 = i2;
13228               else
13229                 place = i2;
13230             }
13231
13232           /* For REG_LABEL_TARGET on a JUMP_P, we prefer to put the note
13233              as a JUMP_LABEL or decrement LABEL_NUSES if it's already
13234              there.  */
13235           if (place && JUMP_P (place)
13236               && REG_NOTE_KIND (note) == REG_LABEL_TARGET
13237               && (JUMP_LABEL (place) == NULL
13238                   || JUMP_LABEL (place) == XEXP (note, 0)))
13239             {
13240               rtx label = JUMP_LABEL (place);
13241
13242               if (!label)
13243                 JUMP_LABEL (place) = XEXP (note, 0);
13244               else if (LABEL_P (label))
13245                 LABEL_NUSES (label)--;
13246             }
13247
13248           if (place2 && JUMP_P (place2)
13249               && REG_NOTE_KIND (note) == REG_LABEL_TARGET
13250               && (JUMP_LABEL (place2) == NULL
13251                   || JUMP_LABEL (place2) == XEXP (note, 0)))
13252             {
13253               rtx label = JUMP_LABEL (place2);
13254
13255               if (!label)
13256                 JUMP_LABEL (place2) = XEXP (note, 0);
13257               else if (LABEL_P (label))
13258                 LABEL_NUSES (label)--;
13259               place2 = 0;
13260             }
13261           break;
13262
13263         case REG_NONNEG:
13264           /* This note says something about the value of a register prior
13265              to the execution of an insn.  It is too much trouble to see
13266              if the note is still correct in all situations.  It is better
13267              to simply delete it.  */
13268           break;
13269
13270         case REG_DEAD:
13271           /* If we replaced the right hand side of FROM_INSN with a
13272              REG_EQUAL note, the original use of the dying register
13273              will not have been combined into I3 and I2.  In such cases,
13274              FROM_INSN is guaranteed to be the first of the combined
13275              instructions, so we simply need to search back before
13276              FROM_INSN for the previous use or set of this register,
13277              then alter the notes there appropriately.
13278
13279              If the register is used as an input in I3, it dies there.
13280              Similarly for I2, if it is nonzero and adjacent to I3.
13281
13282              If the register is not used as an input in either I3 or I2
13283              and it is not one of the registers we were supposed to eliminate,
13284              there are two possibilities.  We might have a non-adjacent I2
13285              or we might have somehow eliminated an additional register
13286              from a computation.  For example, we might have had A & B where
13287              we discover that B will always be zero.  In this case we will
13288              eliminate the reference to A.
13289
13290              In both cases, we must search to see if we can find a previous
13291              use of A and put the death note there.  */
13292
13293           if (from_insn
13294               && from_insn == i2mod
13295               && !reg_overlap_mentioned_p (XEXP (note, 0), i2mod_new_rhs))
13296             tem = from_insn;
13297           else
13298             {
13299               if (from_insn
13300                   && CALL_P (from_insn)
13301                   && find_reg_fusage (from_insn, USE, XEXP (note, 0)))
13302                 place = from_insn;
13303               else if (reg_referenced_p (XEXP (note, 0), PATTERN (i3)))
13304                 place = i3;
13305               else if (i2 != 0 && next_nonnote_nondebug_insn (i2) == i3
13306                        && reg_referenced_p (XEXP (note, 0), PATTERN (i2)))
13307                 place = i2;
13308               else if ((rtx_equal_p (XEXP (note, 0), elim_i2)
13309                         && !(i2mod
13310                              && reg_overlap_mentioned_p (XEXP (note, 0),
13311                                                          i2mod_old_rhs)))
13312                        || rtx_equal_p (XEXP (note, 0), elim_i1)
13313                        || rtx_equal_p (XEXP (note, 0), elim_i0))
13314                 break;
13315               tem = i3;
13316             }
13317
13318           if (place == 0)
13319             {
13320               basic_block bb = this_basic_block;
13321
13322               for (tem = PREV_INSN (tem); place == 0; tem = PREV_INSN (tem))
13323                 {
13324                   if (!NONDEBUG_INSN_P (tem))
13325                     {
13326                       if (tem == BB_HEAD (bb))
13327                         break;
13328                       continue;
13329                     }
13330
13331                   /* If the register is being set at TEM, see if that is all
13332                      TEM is doing.  If so, delete TEM.  Otherwise, make this
13333                      into a REG_UNUSED note instead. Don't delete sets to
13334                      global register vars.  */
13335                   if ((REGNO (XEXP (note, 0)) >= FIRST_PSEUDO_REGISTER
13336                        || !global_regs[REGNO (XEXP (note, 0))])
13337                       && reg_set_p (XEXP (note, 0), PATTERN (tem)))
13338                     {
13339                       rtx set = single_set (tem);
13340                       rtx inner_dest = 0;
13341 #ifdef HAVE_cc0
13342                       rtx cc0_setter = NULL_RTX;
13343 #endif
13344
13345                       if (set != 0)
13346                         for (inner_dest = SET_DEST (set);
13347                              (GET_CODE (inner_dest) == STRICT_LOW_PART
13348                               || GET_CODE (inner_dest) == SUBREG
13349                               || GET_CODE (inner_dest) == ZERO_EXTRACT);
13350                              inner_dest = XEXP (inner_dest, 0))
13351                           ;
13352
13353                       /* Verify that it was the set, and not a clobber that
13354                          modified the register.
13355
13356                          CC0 targets must be careful to maintain setter/user
13357                          pairs.  If we cannot delete the setter due to side
13358                          effects, mark the user with an UNUSED note instead
13359                          of deleting it.  */
13360
13361                       if (set != 0 && ! side_effects_p (SET_SRC (set))
13362                           && rtx_equal_p (XEXP (note, 0), inner_dest)
13363 #ifdef HAVE_cc0
13364                           && (! reg_mentioned_p (cc0_rtx, SET_SRC (set))
13365                               || ((cc0_setter = prev_cc0_setter (tem)) != NULL
13366                                   && sets_cc0_p (PATTERN (cc0_setter)) > 0))
13367 #endif
13368                           )
13369                         {
13370                           /* Move the notes and links of TEM elsewhere.
13371                              This might delete other dead insns recursively.
13372                              First set the pattern to something that won't use
13373                              any register.  */
13374                           rtx old_notes = REG_NOTES (tem);
13375
13376                           PATTERN (tem) = pc_rtx;
13377                           REG_NOTES (tem) = NULL;
13378
13379                           distribute_notes (old_notes, tem, tem, NULL_RTX,
13380                                             NULL_RTX, NULL_RTX, NULL_RTX);
13381                           distribute_links (LOG_LINKS (tem));
13382
13383                           SET_INSN_DELETED (tem);
13384                           if (tem == i2)
13385                             i2 = NULL_RTX;
13386
13387 #ifdef HAVE_cc0
13388                           /* Delete the setter too.  */
13389                           if (cc0_setter)
13390                             {
13391                               PATTERN (cc0_setter) = pc_rtx;
13392                               old_notes = REG_NOTES (cc0_setter);
13393                               REG_NOTES (cc0_setter) = NULL;
13394
13395                               distribute_notes (old_notes, cc0_setter,
13396                                                 cc0_setter, NULL_RTX,
13397                                                 NULL_RTX, NULL_RTX, NULL_RTX);
13398                               distribute_links (LOG_LINKS (cc0_setter));
13399
13400                               SET_INSN_DELETED (cc0_setter);
13401                               if (cc0_setter == i2)
13402                                 i2 = NULL_RTX;
13403                             }
13404 #endif
13405                         }
13406                       else
13407                         {
13408                           PUT_REG_NOTE_KIND (note, REG_UNUSED);
13409
13410                           /*  If there isn't already a REG_UNUSED note, put one
13411                               here.  Do not place a REG_DEAD note, even if
13412                               the register is also used here; that would not
13413                               match the algorithm used in lifetime analysis
13414                               and can cause the consistency check in the
13415                               scheduler to fail.  */
13416                           if (! find_regno_note (tem, REG_UNUSED,
13417                                                  REGNO (XEXP (note, 0))))
13418                             place = tem;
13419                           break;
13420                         }
13421                     }
13422                   else if (reg_referenced_p (XEXP (note, 0), PATTERN (tem))
13423                            || (CALL_P (tem)
13424                                && find_reg_fusage (tem, USE, XEXP (note, 0))))
13425                     {
13426                       place = tem;
13427
13428                       /* If we are doing a 3->2 combination, and we have a
13429                          register which formerly died in i3 and was not used
13430                          by i2, which now no longer dies in i3 and is used in
13431                          i2 but does not die in i2, and place is between i2
13432                          and i3, then we may need to move a link from place to
13433                          i2.  */
13434                       if (i2 && DF_INSN_LUID (place) > DF_INSN_LUID (i2)
13435                           && from_insn
13436                           && DF_INSN_LUID (from_insn) > DF_INSN_LUID (i2)
13437                           && reg_referenced_p (XEXP (note, 0), PATTERN (i2)))
13438                         {
13439                           rtx links = LOG_LINKS (place);
13440                           LOG_LINKS (place) = 0;
13441                           distribute_links (links);
13442                         }
13443                       break;
13444                     }
13445
13446                   if (tem == BB_HEAD (bb))
13447                     break;
13448                 }
13449
13450             }
13451
13452           /* If the register is set or already dead at PLACE, we needn't do
13453              anything with this note if it is still a REG_DEAD note.
13454              We check here if it is set at all, not if is it totally replaced,
13455              which is what `dead_or_set_p' checks, so also check for it being
13456              set partially.  */
13457
13458           if (place && REG_NOTE_KIND (note) == REG_DEAD)
13459             {
13460               unsigned int regno = REGNO (XEXP (note, 0));
13461               reg_stat_type *rsp = VEC_index (reg_stat_type, reg_stat, regno);
13462
13463               if (dead_or_set_p (place, XEXP (note, 0))
13464                   || reg_bitfield_target_p (XEXP (note, 0), PATTERN (place)))
13465                 {
13466                   /* Unless the register previously died in PLACE, clear
13467                      last_death.  [I no longer understand why this is
13468                      being done.] */
13469                   if (rsp->last_death != place)
13470                     rsp->last_death = 0;
13471                   place = 0;
13472                 }
13473               else
13474                 rsp->last_death = place;
13475
13476               /* If this is a death note for a hard reg that is occupying
13477                  multiple registers, ensure that we are still using all
13478                  parts of the object.  If we find a piece of the object
13479                  that is unused, we must arrange for an appropriate REG_DEAD
13480                  note to be added for it.  However, we can't just emit a USE
13481                  and tag the note to it, since the register might actually
13482                  be dead; so we recourse, and the recursive call then finds
13483                  the previous insn that used this register.  */
13484
13485               if (place && regno < FIRST_PSEUDO_REGISTER
13486                   && hard_regno_nregs[regno][GET_MODE (XEXP (note, 0))] > 1)
13487                 {
13488                   unsigned int endregno = END_HARD_REGNO (XEXP (note, 0));
13489                   int all_used = 1;
13490                   unsigned int i;
13491
13492                   for (i = regno; i < endregno; i++)
13493                     if ((! refers_to_regno_p (i, i + 1, PATTERN (place), 0)
13494                          && ! find_regno_fusage (place, USE, i))
13495                         || dead_or_set_regno_p (place, i))
13496                       all_used = 0;
13497
13498                   if (! all_used)
13499                     {
13500                       /* Put only REG_DEAD notes for pieces that are
13501                          not already dead or set.  */
13502
13503                       for (i = regno; i < endregno;
13504                            i += hard_regno_nregs[i][reg_raw_mode[i]])
13505                         {
13506                           rtx piece = regno_reg_rtx[i];
13507                           basic_block bb = this_basic_block;
13508
13509                           if (! dead_or_set_p (place, piece)
13510                               && ! reg_bitfield_target_p (piece,
13511                                                           PATTERN (place)))
13512                             {
13513                               rtx new_note = alloc_reg_note (REG_DEAD, piece,
13514                                                              NULL_RTX);
13515
13516                               distribute_notes (new_note, place, place,
13517                                                 NULL_RTX, NULL_RTX, NULL_RTX,
13518                                                 NULL_RTX);
13519                             }
13520                           else if (! refers_to_regno_p (i, i + 1,
13521                                                         PATTERN (place), 0)
13522                                    && ! find_regno_fusage (place, USE, i))
13523                             for (tem = PREV_INSN (place); ;
13524                                  tem = PREV_INSN (tem))
13525                               {
13526                                 if (!NONDEBUG_INSN_P (tem))
13527                                   {
13528                                     if (tem == BB_HEAD (bb))
13529                                       break;
13530                                     continue;
13531                                   }
13532                                 if (dead_or_set_p (tem, piece)
13533                                     || reg_bitfield_target_p (piece,
13534                                                               PATTERN (tem)))
13535                                   {
13536                                     add_reg_note (tem, REG_UNUSED, piece);
13537                                     break;
13538                                   }
13539                               }
13540
13541                         }
13542
13543                       place = 0;
13544                     }
13545                 }
13546             }
13547           break;
13548
13549         default:
13550           /* Any other notes should not be present at this point in the
13551              compilation.  */
13552           gcc_unreachable ();
13553         }
13554
13555       if (place)
13556         {
13557           XEXP (note, 1) = REG_NOTES (place);
13558           REG_NOTES (place) = note;
13559         }
13560
13561       if (place2)
13562         add_reg_note (place2, REG_NOTE_KIND (note), XEXP (note, 0));
13563     }
13564 }
13565 \f
13566 /* Similarly to above, distribute the LOG_LINKS that used to be present on
13567    I3, I2, and I1 to new locations.  This is also called to add a link
13568    pointing at I3 when I3's destination is changed.  */
13569
13570 static void
13571 distribute_links (rtx links)
13572 {
13573   rtx link, next_link;
13574
13575   for (link = links; link; link = next_link)
13576     {
13577       rtx place = 0;
13578       rtx insn;
13579       rtx set, reg;
13580
13581       next_link = XEXP (link, 1);
13582
13583       /* If the insn that this link points to is a NOTE or isn't a single
13584          set, ignore it.  In the latter case, it isn't clear what we
13585          can do other than ignore the link, since we can't tell which
13586          register it was for.  Such links wouldn't be used by combine
13587          anyway.
13588
13589          It is not possible for the destination of the target of the link to
13590          have been changed by combine.  The only potential of this is if we
13591          replace I3, I2, and I1 by I3 and I2.  But in that case the
13592          destination of I2 also remains unchanged.  */
13593
13594       if (NOTE_P (XEXP (link, 0))
13595           || (set = single_set (XEXP (link, 0))) == 0)
13596         continue;
13597
13598       reg = SET_DEST (set);
13599       while (GET_CODE (reg) == SUBREG || GET_CODE (reg) == ZERO_EXTRACT
13600              || GET_CODE (reg) == STRICT_LOW_PART)
13601         reg = XEXP (reg, 0);
13602
13603       /* A LOG_LINK is defined as being placed on the first insn that uses
13604          a register and points to the insn that sets the register.  Start
13605          searching at the next insn after the target of the link and stop
13606          when we reach a set of the register or the end of the basic block.
13607
13608          Note that this correctly handles the link that used to point from
13609          I3 to I2.  Also note that not much searching is typically done here
13610          since most links don't point very far away.  */
13611
13612       for (insn = NEXT_INSN (XEXP (link, 0));
13613            (insn && (this_basic_block->next_bb == EXIT_BLOCK_PTR
13614                      || BB_HEAD (this_basic_block->next_bb) != insn));
13615            insn = NEXT_INSN (insn))
13616         if (DEBUG_INSN_P (insn))
13617           continue;
13618         else if (INSN_P (insn) && reg_overlap_mentioned_p (reg, PATTERN (insn)))
13619           {
13620             if (reg_referenced_p (reg, PATTERN (insn)))
13621               place = insn;
13622             break;
13623           }
13624         else if (CALL_P (insn)
13625                  && find_reg_fusage (insn, USE, reg))
13626           {
13627             place = insn;
13628             break;
13629           }
13630         else if (INSN_P (insn) && reg_set_p (reg, insn))
13631           break;
13632
13633       /* If we found a place to put the link, place it there unless there
13634          is already a link to the same insn as LINK at that point.  */
13635
13636       if (place)
13637         {
13638           rtx link2;
13639
13640           for (link2 = LOG_LINKS (place); link2; link2 = XEXP (link2, 1))
13641             if (XEXP (link2, 0) == XEXP (link, 0))
13642               break;
13643
13644           if (link2 == 0)
13645             {
13646               XEXP (link, 1) = LOG_LINKS (place);
13647               LOG_LINKS (place) = link;
13648
13649               /* Set added_links_insn to the earliest insn we added a
13650                  link to.  */
13651               if (added_links_insn == 0
13652                   || DF_INSN_LUID (added_links_insn) > DF_INSN_LUID (place))
13653                 added_links_insn = place;
13654             }
13655         }
13656     }
13657 }
13658 \f
13659 /* Subroutine of unmentioned_reg_p and callback from for_each_rtx.
13660    Check whether the expression pointer to by LOC is a register or
13661    memory, and if so return 1 if it isn't mentioned in the rtx EXPR.
13662    Otherwise return zero.  */
13663
13664 static int
13665 unmentioned_reg_p_1 (rtx *loc, void *expr)
13666 {
13667   rtx x = *loc;
13668
13669   if (x != NULL_RTX
13670       && (REG_P (x) || MEM_P (x))
13671       && ! reg_mentioned_p (x, (rtx) expr))
13672     return 1;
13673   return 0;
13674 }
13675
13676 /* Check for any register or memory mentioned in EQUIV that is not
13677    mentioned in EXPR.  This is used to restrict EQUIV to "specializations"
13678    of EXPR where some registers may have been replaced by constants.  */
13679
13680 static bool
13681 unmentioned_reg_p (rtx equiv, rtx expr)
13682 {
13683   return for_each_rtx (&equiv, unmentioned_reg_p_1, expr);
13684 }
13685 \f
13686 void
13687 dump_combine_stats (FILE *file)
13688 {
13689   fprintf
13690     (file,
13691      ";; Combiner statistics: %d attempts, %d substitutions (%d requiring new space),\n;; %d successes.\n\n",
13692      combine_attempts, combine_merges, combine_extras, combine_successes);
13693 }
13694
13695 void
13696 dump_combine_total_stats (FILE *file)
13697 {
13698   fprintf
13699     (file,
13700      "\n;; Combiner totals: %d attempts, %d substitutions (%d requiring new space),\n;; %d successes.\n",
13701      total_attempts, total_merges, total_extras, total_successes);
13702 }
13703 \f
13704 static bool
13705 gate_handle_combine (void)
13706 {
13707   return (optimize > 0);
13708 }
13709
13710 /* Try combining insns through substitution.  */
13711 static unsigned int
13712 rest_of_handle_combine (void)
13713 {
13714   int rebuild_jump_labels_after_combine;
13715
13716   df_set_flags (DF_LR_RUN_DCE + DF_DEFER_INSN_RESCAN);
13717   df_note_add_problem ();
13718   df_analyze ();
13719
13720   regstat_init_n_sets_and_refs ();
13721
13722   rebuild_jump_labels_after_combine
13723     = combine_instructions (get_insns (), max_reg_num ());
13724
13725   /* Combining insns may have turned an indirect jump into a
13726      direct jump.  Rebuild the JUMP_LABEL fields of jumping
13727      instructions.  */
13728   if (rebuild_jump_labels_after_combine)
13729     {
13730       timevar_push (TV_JUMP);
13731       rebuild_jump_labels (get_insns ());
13732       cleanup_cfg (0);
13733       timevar_pop (TV_JUMP);
13734     }
13735
13736   regstat_free_n_sets_and_refs ();
13737   return 0;
13738 }
13739
13740 struct rtl_opt_pass pass_combine =
13741 {
13742  {
13743   RTL_PASS,
13744   "combine",                            /* name */
13745   gate_handle_combine,                  /* gate */
13746   rest_of_handle_combine,               /* execute */
13747   NULL,                                 /* sub */
13748   NULL,                                 /* next */
13749   0,                                    /* static_pass_number */
13750   TV_COMBINE,                           /* tv_id */
13751   PROP_cfglayout,                       /* properties_required */
13752   0,                                    /* properties_provided */
13753   0,                                    /* properties_destroyed */
13754   0,                                    /* todo_flags_start */
13755   TODO_dump_func |
13756   TODO_df_finish | TODO_verify_rtl_sharing |
13757   TODO_ggc_collect,                     /* todo_flags_finish */
13758  }
13759 };